pythonc成长之旅4

---恢复内容开始---

一、整形“魔法”（理论水平不够，不知道该叫什么，应该是整形数据库重点一种功能吧）

(1).至少用几位二进制来表示

age = 5

#1     1
#2     10
#3    11
#4    100
#5     101    


r = age.bit_length()
print(r)
 

（2）.将字符串转化为数字

# name = "123"
# print(type(name),name)
# v = int(name)
# print(v)

#输出结果

<class 'str'> 123
<class 'int'> 123

#字符串已经转化为整形

num = "0011" num必须用机器码  
v = int(num,base=10)  #将num转化为几进制
print(type(v),v)

二、字符串函数（魔法）

    一、B.capitalize()
            Return a copy of B with only its first character capitalized 
            (ASCII)and the rest lower-cased.
            #字符串首字母大写，对字母有效，对数字无效。

name = "counrse"
old = "five years"
v = name.capitalize()                输出结果：    Counrse
                                                Five years    
t = old.capitalize()
print(v)
print(t)   

    二、B.casefold()
            B.casefold() -> str
            Return a version of S suitable for caseless comparisons.
            #将字符串中大写字母变成小写字母。
name = "CouNrse"
v = name.casefold()                    输出结果：counrse
print(v)

    三、center(self, width, fillchar=None)
            Return S centered in a string of length width. Padding is
            done using the specified fill character (default is a space)
            #自定义一个长度，将字符串置于中间，其他位置填充你输入的字符。
            #如果不输入，系统默认为填充空格。
name = "counrse"
v = name.center(20,'*')                输出结果：******counrse*******    
print(v)
    
    四、count(self, sub, start=None, end=None)
            Return the number of non-overlapping occurrences of substring sub in
            string S[start:end].  Optional arguments start and end are
            interpreted as in slice notation.
            #设置一个开始位置，一个结束位置，然后查找该字符串中的子序列。
            #如果不输入，系统默认为从第一个开始，最后一个结束。
name = "counrse"
v = name.count('un', 1, 6)            输出结果：1
print(v)

    五、encode(self, encoding: str = ..., errors: str = ...) -> bytes（编码）
    
str = "我从初中就一直喜欢你喜欢你";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")

print(str)
print("UTF-8 编码：", str_utf8)
print("GBK 编码：", str_gbk)

print("UTF-8 解码：", str_utf8.decode('UTF-8','strict'))
print("GBK 解码：", str_gbk.decode('GBK','strict'))
        
                                    输出结果；    我从初中就一直喜欢你
                                                UTF-8 编码： b'xe5x85xb6xe5xaex9exe6x88x91xe4xbbx8exe5x88x9dxe4xb8xadxe5xb0xb1xe4xb8x80xe7x9bxb4xe5x96x9cxe6xacxa2xe4xbdxa0'
                                                GBK 编码：  b'xc6xe4xcaxb5xcexd2xb4xd3xb3xf5xd6xd0xbexcdxd2xbbxd6xb1xcfxb2xbbxb6xc4xe3'
                                                UTF-8 解码： 我从初中就一直喜欢你
                                                GBK 解码： 我从初中就一直喜欢你
                                                Process finished with exit code 0

    六、endswith(self, suffix, start=None, end=None)
            Return True if S ends with the specified suffix, False otherwise.
            With optional start, test S beginning at that position.
            With optional end, stop comparing S at that position.
            suffix can also be a tuple of strings to try.
            #输入一个字母，该函数判断是否以该字母结束，可以设定起始位置和结束位置。输出结果为bool.
            #有endswith  则有startswith(),用法与endswith相同。
        
name = "counrse"
v = name.endswith('s',1,3)           输出结果；False
print(v)
        
    七、expandtabs(self, tabsize=8)
            Return a copy of S where all tab characters are expanded using spaces.
            If tabsize is not given, a tab size of 8 characters is assumed.
            #自己去设置字节长度，如果为设置，系统默认为8个字节长度。遇到	补充为剩余字节长度。
            #补充：
  	可以用来制作表格。

name = "counrs123456	789"
v = name.expandtabs()                输出结果：counrs123456    789 19
print(v,len(v))

    八、find(self, sub, start=None, end=None)
            Return the lowest index in S where substring sub is found,
            such that sub is contained within S[start:end].  Optional
            arguments start and end are interpreted as in slice notation.
        
            '''Return -1 on failure.'''
            #查找子序列在该字符串的那个位子，可设置开始和最后的查找位置。
name = "counrse"
v = name.find('n')                  输出结果：3
print(v)
            
    九、format(self, *args, **kwargs)
            Return a formatted version of S, using substitutions from args and kwargs.
            The substitutions are identified by braces ('{' and '}').
            #格式化，将一个字符串中的占位符替换为指定的值。
            #('{' and '}').只能替换这些占位符。如果不指定，即遵循从左到右的顺序。
name = "I like {sky},numbe {a}"
print(name)
v = name.format(sky='sex',a=0 )        输出结果；    I like {sky},numbe {a}
                                                I like sex,numbe 0
print(v)

            


    十、format_map(self, mapping)
            Return a formatted version of S, using substitutions from mapping.
            The substitutions are identified by braces ('{' and '}').
            #格式化，传入的值如{"hero":'le'}
name = "counrse is {hero}"
v = name.format_map({"hero":'le'})    输出结果：    counrse is le

print(v)
    
    十一、index(self, sub, start=None, end=None)
            Return the lowest index in S where substring sub is found, 
            such that sub is contained within S[start:end].  Optional
            arguments start and end are interpreted as in slice notation.
        
            #Raises ValueError when the substring is not found.
            #同found,找不到会报错，所以一般情况用found。
            
    十二、isalnum(self)
            Return True if all characters in S are alphanumeric
            and there is at least one character in S, False otherwise.
            #该字符串全是字母数字返回ture，有其他的返回false.
name = "counrse-=-"
v = name.isalnum()                    输出结果：False
print(v)

    
name = "counrse"
v = name.isalnum()                    输出结果：True
print(v)
    
    十三、isalpha(self)
            Return True if all characters in B are alphabetic
            and there is at least one character in B, False otherwise.
            #该字符串全是字母返回ture,否则返回false.
name = "cournse123=-"
v = name.isalpha()                    输出结果：False
print(v)
    
name = "cournse123=-"
v = name.isalpha()                    输出结果:True
print(v)
    
    十四、isdigit(self)
            Return True if all characters in B are digits
            and there is at least one character in B, False otherwise.
            #数字返回Ture，否则返回Flase
            
    十五、islower(self)
            Return True if all cased characters in B are lowercase and there is
            at least one cased character in B, False otherwise.
            #判断是否全是小写。lower将字符串全部小写化。
            #判断全部是否是大写以及大写化。isupper()/upper().
    
    十六、isdecimal(self)、isdigit(self)、isnumeric(self)
            #都是判断字符串是否是数字
            #第一种支持数字
            #第二种支持数字、特殊数字，如②
            #第三种支持数字、特殊数字、中文数字、如二
            
    十七、isprintable（self）
    
            #判断是否存在不可显示的字符，如	,
.
    
    十八、isspace(self)
            
            #判断是否全为空格。
            
    十九、istitle(self)、title(self)
    
            #第一个判断是否为英文标题。
            #第二个转化为英文标题。

a = "Return True if all characters in B are whitespace"
v1 = a.istitle()
v2 = a.title()                        输出结果：    False
                                                Return True If All Characters In B Are Whitespace
print(v1)
print(v2)
    
        ***二十、join（self, *args, **kwargs）
                #进行指定字符串拼接，每一个字符都与你所指定的字符拼接。
        
title = "快过来被我亲"
print(title)
t = ' --  '                            输出结果：    快过来被我亲
v = t.join(title)                                快 --  过 --  来 --  被 --  我 --  亲
print(v)

        二十一、ljust(self, width, fillchar=None)
                rjust(self, width, fillchar=None)
                Return B left justified in a string of length width. Padding is
                done using the specified fill character (default is a space).
                #同center、把填充字符放左边（），第二个把填充字符放在右边。
                
        二十二、.isidentifier()
                #判断是否是标识符（数字、下划线、字母）

name = "_1Cadfkjafhkj"
v = name.isidentifier()                输出结果：True
print(v)
    

    
name = "1Cadfkjafhkj"
v = name.isidentifier()                输出结果：False
print(v)
        
        二十三、lstrip(),rstrip(),strip()
                #分别是处理左边空格、
、	.和右边空格、
、	.，以及两边空格、
、	的。
                #指定内容，便去掉指定内容。*如果你输入的字符串不是原字符串子序列，然而你输入的字符串有
                #原字符串的子序列，则函数自动去匹配。
name = " SDKJHKSHGKJSKGSK"
v = name.rstrip('186GSK')            输出结果： SDKJHKSHGKJ
print(v)
                
        二十四、translate(self, *args, **kwargs)、 maketrans(*args, **kwargs)
                #指定对应关系，并替换。
                
name = " SDKJH32544552KSHGKJSKGSK"
m = str.maketrans("HKG", "我爱你")    输出结果： SD爱J我32544552爱S我你爱JS爱你S爱
new_name = name.translate(m)

print(new_name)

        二十五、partition()、rpartition()、 rsplit（）、split（）、splitlines（）
        #以你指定的字符分割，p~和rp~分割出来有你指定的字符，而s~和rs~分割出来没有你指定的字符。
        #另外，正则表达式，有你设定如何分割。
        #splitlines主要以
为分割点。
        
        
name = "cosurses"        
new_name = "cosu
rse	s"
v = name.partition('s')
v1 = name.rpartition('s')
v2 = name.split('s')
v3 = name.rsplit('s')
v4 = new_name.splitlines()            输出结果：         ('co', 's', 'urses')
print(v)                                            ('cosurse', 's', '')
print(v1)                                            ['co', 'ur', 'e', '']
print(v2)                                            ['co', 'ur', 'e', '']
print(v3)                                            ['cosu', 'rse	s']
print(v4)


        二十六、swapcase(self)
                    Return a copy of B with uppercase ASCII characters converted
                    to lowercase ASCII and vice versa.
                #将大写转化为小写，将小写转化为大写。
                
name = "c678679696ouAAAAnre141414s"
v = name.swapcase()                    输出结果：C678679696OUaaaaNRE141414S
print(v)