数据类型

按照以下几个点展开数据类型的学习

1 2 3 4 5 6 7 8 9 10 11 12 13

#======================================基本使用====================================== #1、用途   #2、定义方式   #3、常用操作+内置的方法   #======================================该类型总结==================================== #存一个值or存多个值       #有序or无序   #可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

一、数字（int,float）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

""" 整型int 　　作用：年纪，等级，身份证号，qq号等整型数字相关 　　定义： 　　　　age=10 #本质age=int(10)   浮点型float 　　作用：薪资，身高，体重，体质参数等浮点数相关      定义：      salary=9999.9 #本质salary=float(9999.9) """ age = '18' print ( type ( int (age))) # <class 'int'> salary = '123.8' print ( type ( float (salary))) # <class 'float'>   print ( bin ( 16 ))  #0b10000 二进制 print ( oct ( 17 ))  #0o21 八进制 print ( hex ( 18 )) #0x12 十六进制

二、字符串（str）

"""字符串【有序不可变】　　作用：名字，性别，国籍，地址等描述信息　　定义：　　　　name='tom' #本质 name = str('tom')"""# stripname = '*tom**'print(name.strip('*'))  # tomprint(name.lstrip('*'))  # tom**print(name.rstrip('*'))  # *tom# lower,uppername = 'tom'print(name.lower())  # tomprint(name.upper())  # TOM# startswith,endswithname = 'tom_en'print(name.endswith('en'))  # Trueprint(name.startswith('tom'))  # True# format的三种玩法res = '{} {} {}'.format('egon', 18, 'male')res = '{1} {0} {1}'.format('egon', 18, 'male')res = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)# splitname = 'root:x:0:0::/root:/bin/bash'print(name.split(':'))  # 默认分隔符为空格  ['root', 'x', '0', '0', '', '/root', '/bin/bash']name = 'C:/a/b/c/d.txt'print(name.split('/', 1))  # 只想拿到顶级目录 ['C:', 'a/b/c/d.txt']name = 'a|b|c'print(name.rsplit('|', 1))  # 从右开始切分['a|b', 'c']# jointag = ' 'print(tag.join(['tom', 'say', 'hello', 'world']))  # 可迭代对象必须都是字符串 tom say hello worldprint('_'.join('abcd'))  # a_b_c_d# replacename = 'tom say hello world,tom say bye'print(name.replace('tom', 'rose', 1))  # rose say hello world,tom say bye# findname = 'tom say hello world,tom say bye'print(name.find('jack', 0, len(name)))  # -1 (找不到返回-1)查找子串第一次在母串中出现的位置，可以自己指定位置范围来搜查# countname = 'tom say hello world,tom say bye'print(name.count('tom', 0, len(name)))  # 2 计算出子串 'tom'在母串中出现的次数，默认是在整个母串中查找，# isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法age = input('>>: ')print(age.isdigit())print('1'.isdecimal())  # Trueprint('1'.isdigit())  # Trueprint('1'.isnumeric())  # Trueprint('②'.isdecimal())  # Falseprint('②'.isdigit())  # Trueprint('②'.isnumeric())  # Trueprint('二'.isdecimal())  # Falseprint('二'.isdigit())  # Falseprint('二'.isnumeric())  # Trueprint('Ⅳ'.isdecimal())  # Falseprint('Ⅳ'.isdigit())  # Falseprint('Ⅳ'.isnumeric())  # True #罗马数字print(b'1'.isdigit())  # True# print(b'1'.isdecimal())#报错# print(b'1'.isnumeric())#True #报错print('4.3'.isdigit())  # Falseprint('4.3'.isdecimal())  # Falseprint('4.3'.isnumeric())  # Falseprint('-4'.isdigit())     # Falseprint('-4'.isdecimal())   # Falseprint('-4'.isnumeric())   # Falsenum = '-10'if (num.startswith('-') and num[1:] or num).isdigit():    print('num是整数')else:    print('num不是整数')num = '-4.5'import reif re.match(r'^-?(\.\d+|\d+(\.\d+)?)', num):    print('num是整数')else:    print('num不是整数')num = '-10'if num.lstrip('-').isdigit():    print('num是整数')else:    print('num不是整数')'''总结:    最常用的是isdigit,可以判断bytes类型,这也是最常见的数字应用场景    如果要判断中文数字或罗马数字,则需要用到isnumeric '''

def capitalize(self) 首字母大写def casefold(self) 所有变小写，casefold更强，很多未知的也会相应变小写def center(self, width, fillchar=None)设置宽度，并将内容居中def count(self, sub, start=None, end=None)去字符串中寻找子序列的出现次数def encode(self, encoding='utf-8', errors='strict')def endswith(self, suffix, start=None, end=None)以什么什么结尾def expandtabs(self, tabsize=8) 断句tabsize的长度def find(self, sub, start=None, end=None)从开始往后找，找到第一个之后，获取其索引def format(self, *args, **kwargs)格式化，将一个字符串中的占位符替换为指定的值def format_map(self, mapping)格式化，传入的值 {
     "name": 'alex', "a": 19}def index(self, sub, start=None, end=None)找不到，报错def isalnum(self)字符串中是否只包含 字母和数字def isalpha(self)是否是字母，汉字def isdecimal(self)当前输入是否是数字 2def isdigit(self)②，2def isidentifier(self)def islower(self)def isnumeric(self)②，2，二def isprintable(self)def isspace(self)def istitle(self)def isupper(self)def join(self, iterable)def ljust(self, width, fillchar=None)def lower(self)def lstrip(self, chars=None)def maketrans(self, *args, **kwargs)def partition(self, sep)分割为三部分def replace(self, old, new, count=None)将指定字符串替换为指定字符串def rfind(self, sub, start=None, end=None)def rindex(self, sub, start=None, end=None)def rjust(self, width, fillchar=None)def rpartition(self, sep)def rsplit(self, sep=None, maxsplit=-1)def rstrip(self, chars=None)def split(self, sep=None, maxsplit=-1)def splitlines(self, keepends=None)def startswith(self, prefix, start=None, end=None)def strip(self, chars=None)def swapcase(self)def title(self)def translate(self, table)def upper(self)def zfill(self, width) # m = str.maketrans("aeiou", "12345")# new_v = v.translate(m)

三、列表（list）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

""" 列表【有序可变】 　　作用：多个装备，多个爱好，多门课程，多本书籍等 　　定义： 　　　　[]内可以有多个任意类型的值，逗号分隔 """ # 创建 li = [ 'a' , 'b' , 'cc' , 4 ]  # 定义一个列表一般用这种就可以 # li = list(['a','b','cc',4]) # 定义一个列表   # #增加 li.append( 5 )  # #在列表末尾 添加一个元素,li=['a', 'b', 'cc', 4, 5] li.insert( 0 , 'g' )  # #在列表末尾 添加一个元素,li=['g', 'a', 'b', 'cc', 4] li.extend([ 'gg' , 'kk' ])  # 添加一个列表['gg','kk'], li=['a', 'b', 'cc', 4, 'gg', 'kk']   # # 删除 aa = li.pop() #******pop 删除的时候要保障元素存在，不然会报错******， print (li,aa)  # 从尾部删除一个元素,并返回删除的元素 ['a', 'b', 'cc'] 4 aa = li.pop( 2 )  # 删除索引为2的元素,并返回删除的元素['a', 'b', 4] cc   aa = li.remove( 'a' )  # 从列表中移除，无返回值 'a',['b', 'cc', 4] None li.clear()  # 清空列表[] del li[-1]  # 删除最后一个   # # 修改 li[ 0 ] = 'A'  # ['A', 'b', 'cc', 4]   # # 查找 print (li.index( 'a' ))  # 运行结果0 # 获取该元素，在列表中的索引,（如果列表中有多个相同的元素，只会取找到的第一个元素的索引。 # 当然也可获取某段范围的索引print(liist1.index('d',2,5))） # 找不到会报错 print (li.count( 'a' ))  # 运行结果1  统计列表中有几个a（元素）   # # 其他 li.reverse()  # 反转一个列表,li=[4, 'cc', 'b', 'a']   for i in li:  # 循环输出列表元素      print (i)   list1 = [ "a" , "c" , "b" , "e" , "d" ] list1.sort()  # 排序 print (list1)  # ['a', 'b', 'c', 'd', 'e'] # # python3.x系列的数据类型排序，字符串类型和数字类型不能一起进行排序

四、元组（tuple）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

""" 元组【有序不可变】 　　作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 　　定义： 　　　　与列表类型比，只不过[]换成() """   t = ( 'a' ,)  # 元祖只有一个元素时，需要加逗号, 和字符串区分开 t = ( 'a' , 'b' , 'b' , 'c' )  # 定义一个元组 t = tuple (( 'a' , 'b' , 'b' , 'c' ))   print (t.index( 'b' ))  # 索引出元素第一次出现的位置，还可以指定在某一范围里查找，这里默认在整个元组里查找输出1 print (t.count( 'b' ))  # 计算元素出现的次数，这里输出2 print ( len (t))  # 输出远组的长度，这里输出4 print (t[ 1 : 3 ])  # 切片 输出('b','b') for i in t:      print (i)  # 循环打印出元组数据

五、字典（dict）

"""字典【无序可变】　　作用：存多个值,key-value存取，取值速度快　　定义：　　　　key必须唯一，必须是不可变类型，value可以是任意类型"""# 创建：info = {"name": "tom", "age": 18, "gender": "male"}  # 本质info=dict({"name":"tom","age":18})# info=dict(name='tom',age=18,gender='male')# info=dict([['name','tom'],('age',18)])# info={}.fromkeys(('name','age','gender'),None) #{'name': None, 'gender': None, 'age': None}# 增加info['salary'] = 50000  # {'name': 'tom', 'age': 18, 'salary': 50000, 'gender': 'male'}# 删除info.pop('age')  # 根据键删除某一元素 d={'Michael': 95, 'Tracy': 85}info.popitem()  # 随机删除info.clear()  # {}# 修改info['age'] = '25'  # 如果没有该key，则在字典创建新的的的key-value# 查询info.get('age')  # 根据key获取values，如果不存在返回None，这里输出75'''setdefault的功能1：key存在，则不赋值，key不存在则设置默认值2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值'''print(info.setdefault('age', 50000))  # 18print(info.setdefault('salary', 50000))  # 50000print(info)  # {'age': 18, 'name': 'tom', 'salary': 50000, 'gender': 'male'}# 其他print(len(info))  # 输出字典长度print('age' in info)  # python3 中移除了 has_key,要判断键是否存在用infor i in info:    print(i)  # 循环默认按键输出for i in info.values():  # 循环按值输出    print(i)for k, v in info.items():  # 循环按键值输出    print(k, v)seq = ('Google', 'Runoob', 'Taobao')seq2 = ('1', '2', '3')d1 = dict.fromkeys(seq)d2 = dict.fromkeys(seq,seq2)print(d1) # {'Google': None, 'Taobao': None, 'Runoob': None}print(d2) # {'Taobao': ('1', '2', '3'), 'Google': ('1', '2', '3'), 'Runoob': ('1', '2', '3')}

def clear(self)def copy(self)@staticmethod # known casedef fromkeys(*args, **kwargs)def get(self, k, d=None)def items(self)def keys(self)def pop(self, k, d=None)def popitem(self)def setdefault(self, k, d=None)def update(self, E=None, **F)def values(self)

六、集合（set）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

""" 集合【无序可变】 　　作用：去重，关系运算 　　定义： 　　　　 1：每个元素必须是不可变类型(可hash，可作为字典的key)           2:没有重复的元素           3：无序           4：可以包含多个元素，用逗号分割， """ a = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 } b = { 1 , 3 , 9 , 10 , 11 }   a.add( 10 )  # 添加一个元素   a.discard( 1 )  # 删除元素1，不存在的话不报错 a.remove( 1 )  # 删除元素1，不存在的话报错 a.pop()  # 随机删除   a.update([ 1 , 8 , 34 ])  # 更新，没有就添加，有就不添加   # 并集 a.union(b) a | b # 返回一个新的集合包含a和b的所有元素   # 交集 a.intersection(b) a & b # 返回一个新的集合包含a和b的公共元素   # 差集 a.difference(b) a - b # 返回一个新的集合，包含a中的元素，但是没有b中的元素   # 对称差集 a.symmetric_difference(b) print (a ^ b) # 返回一个新的集合包含 a和b中不重复的元素

数据类型总结

• 【有序】: 列表，元组
• 【无序】: 字典，集合
• 【可变】:列表，字典，集合
• 【不可变】：数字，字符串，元组
• 【存单值】:数字，字符串
• 【存多值】:列表，元组，字典

其他

一、格式化

1 2 3 4 5 6 7 8 9 10 11 12 13

res1 = '{} {} {}' . format ( 'tom' , 18 , 'male' ) res2 = '{1} {0} {1}' . format ( 'tom' , 18 , 'male' ) res3 = '{name} {age} {gender}' . format (gender = 'male' ,name = 'tom' ,age = 18 ) res4 = '{name} {age} {gender}' . format ( * * { "name" : "tom" , "age" : 18 , "gender" : "male" }) print (res1) #tom 18 male print (res2) #18 egon 18 print (res3) #tom 18 male print (res4) #tom 18 male   msg = 'i am %s my hobby is %s' % ( 'seven' , 'paly' ) tpl = "%(name)s age %(age)d" % { "name" : "tom" , "age" : 18 } print (msg) #i am seven my hobby is paly print (tpl) #tom age 18

二、切片

1 2 3 4 5 6 7 8 9 10 11 12

s = 'abcdefghigk' print (s[ 0 : 3 ]) #截取第一位到第三位的字符  #abc print (s[:] ) #截取字符串的全部字符 #abcdefghigk print (s[ 6 :]) #截取第七个字符到结尾 #ghigk print (s[: - 3 ] ) #截取从头开始到倒数第三个字符之前 #abcdefgh print (s[ 2 ]) #截取第三个字符 #c print (s[ - 1 ] ) #截取倒数第一个字符 #k print (s[:: - 1 ]) #创造一个与原字符串顺序相反的字符串 #kgihgfedcba print (s[ - 3 : - 1 ] ) #截取倒数第三位与倒数第一位之前的字符 #ig print (s[ - 3 :]) #截取倒数第三位到结尾 #igk print (s[ 0 : 10 : 2 ]) #每隔一个，取一个值 #acegi print (s[ 0 : 10 : 3 ]) #每隔2个，取一个值 #adgg

三 、enumerate

　　为一个可迭代的对象添加序号，可迭代的对象你可以理解成能用for循环的就是可迭代的。默认是编号是从0开始，可以设置从1开始

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

user = [ 'tom' , 'rose' , 'jack' ] for k,v in enumerate (user):      print (k,v) """ tom rose jack """   user = [ 'tom' , 'rose' , 'jack' ] for k,v in enumerate (user, 25 ):      print (k,v) """ tom rose jack """

四 、三目运算

　　三目运算符可以简化条件语句的缩写，可以使代码看起来更加简洁，三目可以简单的理解为有三个变量，它的形式是这样的 name= k1 if 条件 else k2 ，如果条件成立，则 name=k1，否则name=k2，下面从代码里面来加深一下理解，从下面的代码明显可以看出三目运算符可以使代码更加简洁。

1 2 3 4 5 6 7 8

a = 1 b = 2 if a<b:                     #一般条件语句的写法      k = a else :      k = b       c = a if a<b else b      　　 #三目运算符的写法

五、浅copy和深copy

对于字典、列表等数据结构，深拷贝和浅拷贝有区别，从字面上来说，可以看出深拷贝可以完全拷贝，浅拷贝则没有完全拷贝。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

#字典只有顶级对象(源变了，深浅copy没变) import copy  #导入copy模块 info = { 'name' : 'tom' , 'age' : 18 }  #原始字典 info_copy = copy.copy(info) #浅拷贝 info_deep = copy.deepcopy(info) #深拷贝 print (info) print (info_copy) print (info_deep) id (info); id (info_copy); id (info_deep)  #3个不同的对象,id不一样 info[ 'age' ] = 19  #源变了，深浅copy没变   #字典嵌套可变对象 （源和浅copy变了，深copy没变） import copy  #导入copy模块 info = { 'name' : 'tom' , 'age' : 18 , 'job' :[ 'it' , 'design' ]}  #原始字典 info_copy = copy.copy(info) #浅拷贝 info_deep = copy.deepcopy(info) #深拷贝   id (info); id (info_copy); id (info_deep)  #3个不同的对象,id不一样 info[ 'job' ][ 0 ] = 'boss'  #源和浅copy变了，深copy没变 print (info) #{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'} print (info_copy) #{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'} print (info_deep) #{'age': 18, 'job': ['it', 'design'], 'name': 'tom'}   '''   深浅copy都是对源对象的复制，占用不同的内存空间。 如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象 如果对象不止一级目录，源做任何改动，都要影响浅拷贝，但不影响深 拷贝 '''

"""小数据池：为了快在python中，默认会把数字，字符串，布尔值进行缓存控制台的时候，代码块与代码块之间的规则：    对于数字：-5～256是会被加到小数据池中的，每次使用都是同一个对象    对于字符串：    1.如果字符串的长度是0或者1都会默认进行缓存    2.字符串长度大于1，但是字符串中只包含字母，数字，下划线时才会缓存    3.用乘法得到的字符串        3.1乘数为1，仅包含数字，字母，下划线时会被缓存，如果包含其他字符，而长度<=1也会被驻存        3.2乘数大于1，仅包含数字，字母，下划线这个时候会被缓存，但乘完后字符串长度不能大于20    4.指定驻留，可以通过sys模块中的intern()函数来指定要驻留的内容        对于布尔值pycharm中：py文件里，一个代码块内部，也有自己的小数据池，缓存的范围会比外面的代码块的数据池要大    数字：基本都会缓存，运算结果不缓存 （-5～256会缓存）    字符串：默认都缓存，如果有乘法依然遵循上方的结论    布尔值：默认缓存"""from sys import interna=intern('bubu@qq.com')b=intern('bubu@qq.com')print(a is b)a=1000b=1000print(a is b)# 在py文件中，得到的结果时True，但是在command中就不是了。"""在代码块内的缓存机制是不一样的，在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以文件执行时（同一个代码块）会把a,b两个变量指向同一个对象。如果是不同的代码块，他就会看这两个变量是否是满足小数据池的数据，如果是满足小数据池的数据则会指向同一个地址。所以a，b的赋值语句分别被当作两个代码块执行，但是他们不满足小数据池的数据所以得到两个不同的对象，因而is判断返回False"""