Python--数据类型整理

数据类型整理
------------------------------------------------------------------------------------------------
   - int   整型
       -bit_length   使用方法:用一个int型例如int后的n   
                             n.bit_length()
       - to_bytes，  将数字转换成字节类型： 6表示用多少个人字节表示，little/big,用于指定生成字节的顺序
                result = val.to_bytes(6,'little')
                print(result)
       - from_bytes，将字节转换成数字
                result = b'\x02\x00\x00\x00\x00\x00'
                data = int.from_bytes(result,'little')
                print(data)
-------------------------------------------------------------------------------------------------
   - bool  布尔类型
       -True/False   False包括：0 {} [] () None
-------------------------------------------------------------------------------------------------
   -str    字符串
       -upper    将所有字母大写
                  使用方法：例如字符串变量  
                  n=abc  
                  n=n.upper()  
                  结果n=ABC
       -lower    将所有字母小写   
                 使用方法：例如字符串变量  
                 n=ABC  
                 n=n.upper()  
                 结果n=abc
       -strip    去掉数据的所有空格  
                 使用方法：例如字符串变量 
                 n='  ca  ' 
　　　　　　　　　　n=n.strip() 
　　　　　　　　　　结果n='ca'
       -split    分割    
　　　　　　　　　　使用方法：  例如字符串变量 
　　　　　　　　　　n=‘2+3'  
　　　　　　　　　　n=n.split('+')  
　　　　　　　　　　结果[2,3] 加在变量后，括号内字符串形式写分割依据
       -replace  替换    
　　　　　　　　　　使用方法：  例如字符串变量 
　　　　　　　　　　n='alex' 
　　　　　　　　　　n = n.replace('x','c')  
　　　　　　　　　　replace括号内前面字符串形式的被替换内容，后面是替换内容
       -join     迭代    
　　　　　　　　　　使用方法：  例如
　　　　　　　　　　li=['a','b','c'] 
　　　　　　　　　　v='+' n=li.split(v) 
　　　　　　　　　　结果a+b+c，v为要使用的迭代符放在split括号内，前面是迭代列表内容
       -capitalize 首字母大写  
　　　　　　　　　　使用方法： 例如字符串变量 
　　　　　　　　　　n=alex  
　　　　　　　　　　n=n.capitalize() 
　　　　　　　　　　结果n=Alex  首字母大写
       -starswith 是否以···为开头  
　　　　　　　　　　 使用方法：例如字符串变量
　　　　　　　　　　 n=alex  
　　　　　　　　　　 if n.starswith('a'): 
　　　　　　　　　　 print(True)  　
　　　　　　　　　　 else: print(False)  
 　　　　　　　　　　结果True  ,后面括号内是要确定是否是开头的数值
       -endswith  是否以···为结尾  
　　　　　　　　　　使用方法：上同，不过是结尾
       -isdecimal 判断是否是数字   
　　　　　　　　　　使用方法： 例如字符串变量
　　　　　　　　　　n=’9‘ 
　　　　　　　　　　if n.isdecimal():
　　　　　　　　　　print(True)
　　　　　　　　　　else:
　　　　　　　　　　print(False)
　　　　　　　　　　结果是True
       -encode('utf-8或utf-8') # 
　　　　　　　　　　使用方法：
　　　　　　　　　　n=’name‘ 
　　　　　　　　　　v=n.encode('utf-8')
　　　　　　　　　　把字符串转化成字节,括号内是转换的编码型
       -find     寻找      
　　　　　　　　　　使用方法：寻找索引例如
　　　　　　　　　　n='alex' 
　　　　　　　　　　v=n.find('e') 
　　　　　　　　　　print(v)
　　　　　　　　　　结果是2，寻找索引后面括号内要寻找的字符串，寻找不到输出-1
       -index    寻找      
　　　　　　　　　　使用方法同上，不过没寻找到报错
       -casefold 将所有字母最小写，同lower（）
　　　　　　　　　　使用方法，不过包含小语种  
　　　　　　　　　　lower（）只能英语
       -count    用于统计某个字符在字符串中出现的次数  
　　　　　　　　　　使用方法：
　　　　　　　　　　n='alel' 
　　　　　　　　　　v=n.count('l') 
　　　　　　　　　　print(v)
　　　　　　　　　　结果是2出现次数两次  除此外还可以规定范围
       　　　　　　　　规定范围方法  
　　　　　　　　　　n='alel' 
　　　　　　　　　　v=n.count('l',0,4)
　　　　　　　　　　print(v)
　　　　　　　　　　结果是2 如果是n='alel' v=count('l',2,4)print(v) 结果是1
       -center   数值在中间向两边填充
　　　　　　　　　　name = 'alEalax' 
　　　　　　　　　　val = name.center(20,'*') 
　　　　　　　　　　print(val) 
　　　　　　　　　　结果是******alEalax*******  括号内前面是加上数据的总长度后面是填充内容
       -ljust    数值在左向右填充  上同
       -rjust    数值在右向左填充  上同
       -expandtabs  使\t的数据对其  
　　　　　　　　　　使用方法：
　　　　　　　　　　name = 'IDIDIDID\tName\tPasswword\n1\talex\111\n2\teric\t888' 
　　　　　　　　　　val = name.expandtabs(50) print(val)括号内是对齐长度，算上数据本身
       -format    格式化有四种写法    还有用占位符
                     name = "我叫{0},年龄{1}-{0}-{0}"
                     val = name.format('海娇',45)
                     print(val)
                     其中{0}  format（）内第一个数据 可以重复使用  {1}是第二个  依次

                     name = "我叫{0},年龄{1}-{0}-{0}"
                     val = name.format(*['海角',45])
                     print(val)
                     列表要加*

                     name = "我叫{name},年龄{age}"
                     dic = {'name':'海角','age':18}
                     val = name.format(**dic)
                     print(val)   给定key 也可以重复使用，要用列表要有*一个不行就两个
       -format_map   可以不加*用列表字典
-----------------------------------------------------------------------------------------------------
   -list   列表
       -append   列表末尾添加新的对象 
　　　　　　　　　　使用方法：
　　　　　　　　　　name = [1,2,3,4]  
　　　　　　　　　　name.append(5) 
　　　　　　　　　　print(name) 
　　　　　　　　　　结果是[1,2,3,4,5] 括号内可以是字符串整数，也可以列表等
       -insert   向列表指定位置添加对象  
　　　　　　　　　　使用方法：
　　　　　　　　　　name = [1,2,3,4] 
　　　　　　　　　　name.insert[2,5] 
　　　　　　　　　　print(name) 
　　　　　　　　　　结果是[1,2,5,3,4]
       -reverse  列表反转   
　　　　　　　　　　使用方法 : 
　　　　　　　　　　name = [1,2,3] 
　　　　　　　　　　name.reverse()  
　　　　　　　　　　print(name)  
　　　　　　　　　　结果：[3,2,1]
       -count    列表中某个东西出现多少次  
　　　　　　　　　　使用方法:
　　　　　　　　　　name = [1,2,3]  
　　　　　　　　　　v = name.count(1)  
　　　　　　　　　　print(v)
　　　　　　　　　　结果是1
       -extend   扩展   将可迭代的放进去  相当于批量append  
       使用方法：name = [1,2]  name.extend('礼券') print(name) 结果是[1,2,'礼'，‘券']
               name = [1,2]  name.extend(5,6,7) print (name) 结果是[1,2,5,6,7]
       -index    找某个值索引位置  
　　　　　　　　　　使用方法:
　　　　　　　　　　name = [1,2,3]  
　　　　　　　　　　v = name.index(1)  
　　　　　　　　　　print(v)  结果是：0
       -pop         默认删除最后一个可以指定索引删除并且获取到值赋值给变量  
　　　　　　　　　　使用方法：
　　　　　　　　　　name = [1,2,3] 
　　　　　　　　　　v = name.pop(1) 
　　　　　　　　　　print(v)  
　　　　　　　　　　结果是：2 name为  [1,3]
       -remove   移除   
　　　　　　　　　　使用方法：同上，不过不获取移除的值，直接移除。可按照值移除，不按照索引移除。与pop不同，pop按索引，remove按值，重复只删第一个
       -sort     排序    
　　　　　　　　　　使用方法：
　　　　　　　　　　name = [3,2,1]  
　　　　　　　　　　name.sort()  
　　　　　　　　　　print(name)  
　　　　　　　　　　结果是：[1,2,3]  
　　　　　　　　　　默认括号内为（reverse=False），从小到大是（reverse=True）
       -copy     深浅拷贝  深拷贝拷贝所有层，浅拷贝只拷贝一层  使用方法：
　　　　　　　　　　name = [1,2,3]  
　　　　　　　　　　name.copy()  浅拷贝
       深拷贝：import copy
                li = [11,22]
                li2 = copy.deepcopy(li)
       -clear    清除      使用方法：name.clear()  列表内内容全部清除
-----------------------------------------------------------------------------------------------------
   -dict  字典
       -clear   上同列表
       -copy    上同列表
       -fromkeys 通过类就可以"."出来的功能，能生成字典
            # val = dict.fromkeys(['k1','k2','k3'],666)
            # print(val)
            # val['k1'] = 999
            结果：{'k1': 666, 'k2': 666, 'k3': 666}

            # val = dict.fromkeys(['k1','k2','k3'],[])
            # val['k1'].append(678)
            # val['k2'].append(999)
            # print(val)
            结果是：{'k1': [678, 999], 'k2': [678, 999], 'k3': [678, 999]}

            # val = dict.fromkeys(['k1','k2','k3'],[])
            # val['k1'].append(666)
            # val['k1'] = [1,2,3]
            # print(val)
            结果是：{'k1': [1, 2, 3], 'k2': [666], 'k3': [666]}

       -get     
 　　　　　　　　获取索引值   
　　　　　　　　　　使用方法：
　　　　　　　　　　name.get() 
　　　　　　　　　　括号内第一个可以索引值 ，第二个默认值
       -pop     同列表
       -items   所有键值对
       -keys    所有的key
       -popitem pop中指定了key  popitem出来的值是元素类型  也可以取两个值
       -setdefault  添加  列表中有的就不修改，没有就添加
       -update  更新
            # dic = {'k1':'v1','k2':'v2'} # dict类的一个对象
            # dic.update({'k4':'v4','k2':'v5'})
            # print(dic)
            结果：{'k1': 'v1', 'k2': 'v5', 'k4': 'v4'}
--------------------------------------------------------------------------------------------------
   -set（集合）
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # names.add('龙哥')
            # print(names)
            又加一次'龙哥'也不会出现，集合不可以重复
            #2. 差集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = ['小高','海娇','小狗']
            # val = names.difference(boys) # names中存在，boys中不存在数据
            # print(val)
            输出的val是boy中不存在的数据
            # val = boys.difference(names) # boys中存在，names中不存在数据
            # print(val)
            输出的val是names中不存在的数据
            # boys.difference_update(names) # boys中存在，names中不存在数据
            # print(boys)
            输出的boys中的names中不存在的数据
            # names.difference_update(boys) # boys中存在，boys中不存在数据
            # print(names)
            输出的names
            # 3. 对称差集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = {'小高','海娇','小狗'}
            # {'龙哥','海角','老狗','成绩','小江'}
            # {'海娇','小狗'}
            # {'海娇','小狗','龙哥','海角','老狗','成绩','小江'}
            # val = names.symmetric_difference(boys)
            # print(val)
             把同样的去掉，输出的是两个互相不相同的
            # names.symmetric_difference_update(boys)
            # print(names)
              同上
            # 4. 在集合中删除指定值
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # names.discard('龙哥')
            # print(names)
             集合中删除指定值的使用
            # 5. 求交集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = {'小高','海娇','小狗'}
            #
            # val = names.intersection(boys)
            # print(val)
            #求交集，输出两个都有的
            # names.intersection_update(boys)   更新了前面的，对name重新赋值了
            # print(names)
             同上
            # 6. 并集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = {'小高','海娇','小狗'}
            #
            # val = names.union(boys)
            # print(val)
            两个都有的都输出
            # 7.判断是否无交集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = {'海娇','小狗'}
            # # 有交集：False
            # # 无交集：True
            # val = names.isdisjoint(boys)
            # print(val)

            # 8. 子集父集
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = {'龙哥','老狗'}
            # # 是否是子集
            # val = boys.issubset(names)
            # print(val)
            # # 是否是父集
            # val = names.issuperset(boys)
            # print(val)

            # 9. 删除集合元素
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # v = names.pop()
            # print(v)

            # names.remove('老狗')
            # print(names)
            # names.discard('老狗1')
            # print(names)

            # 10. 更新
            # names = {'龙哥','海角','老狗','成绩','小江','小高'}
            # boys = ['龙哥1','老狗1']
            #
            # names.update(boys)
            # print(names)

            # 集合
                - 元素，不可变
            name = {1,'alex'}
            name = {1,'alex',[11,22,33]}
            name = {1,'alex',{''}}
            name = {1,'alex',()}
            name = {1,'alex',{'1','2'}}