一.什么是数据类型？
什么是数据类型？
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：
整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
二.基础数据类型。
2.1数字int。
数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：
#bit_length() 当十进制用二进制表示时，最少使用的位数 a = 32 data = a.bit_length() print(data)
2.2布尔值bool。
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
2.3字符串str。
2.3.1、字符串的索引与切片。
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
msg = ‘ab cde132‘ print(msg[:]) print(msg[0:2]) print(msg[0:3]) print(msg[::2]) print(msg[-1:0:-1]) print(msg[::-1])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
2.3.2、字符串常用方法。
msg = ‘ajb kKTA kerk‘ print(msg.capitalize())#首字母大写 print(msg.swapcase())#大小写翻转 print(msg.title())#非字母隔开的单词的每个首字母大写
msg = ‘skj‘ a = msg.center(50, ‘*‘)#将字符串居中，可以设置总长度和填充物 print(a)
msg = ‘abcdKHGRE‘ print(msg.upper())#将字符串全部大写 print(msg.lower())#将字符串全部小写
msg = ‘abcdkGKJU‘ s1 = msg.startswith(‘ab‘) s2 = msg.startswith(‘ab‘, 2, 6)#判断是否以。。。开头，可切片（顾头不顾尾） s3 = msg.startswith(‘G‘, 5) a1 = msg.endswith(‘U‘) a2 = msg.endswith(‘J‘, 0, -1)#判断是否以。。。结尾，可切片（顾头不顾尾） print(s1, s2, s3, a1, a2)
msg = ‘abc d a acaUYcR‘ print(msg.find(‘a‘, 2, 10))#可切片返回所找字符索引，找不到返回-1 print(msg.find(‘c‘)) print(msg.index(‘c‘))#可切片返回所找字符的索引，找不到报错
msg = ‘a+bk =23+kk+jsi:fjs:rt‘ s1 = msg.split(‘+‘) s2 = msg.split(‘:‘) s3 = msg.split(‘+‘, 1)#最多对1个“+”进行分割 s4 = msg.split(‘+‘, 2)#最多对2个“+”进行分割 print(s1, s2, s3, s4)
msg = ‘ ****cab***c d k13355 77kk ‘ print(msg.strip()) msg2 = msg.strip() print(msg2.strip(‘*‘)) msg3 = msg2.strip(‘*‘)#去除字符串前后两端的指定字符，特别注意是前后两端 print(msg3.strip(‘c‘))
li = [‘panky‘, ‘is‘, ‘neverous‘] s = ‘_‘.join(li)#连接符 print(s)
note = ‘panky say he has a coin in his home, he also called panky‘ print(note.replace(‘panky‘, ‘SB‘, 1))#替换1次 print(note.replace(‘panky‘, ‘SB‘, 2))#替换2次
#format的三种形式的格式化输出 s1 = ‘I am {}, like play {}, my gender is {}‘.format(‘panky‘, ‘mobile games‘, ‘male‘) s2 = ‘I an {0} like play{1} my nickname also is {0}‘.format(‘panky‘, ‘mobile games‘, ‘male‘) s3 = ‘I am {name}, like play {sp}, my gender is {ge}‘.format(sp = ‘mobile games‘, name = ‘panky‘, ge = ‘male‘) print(s1) print(s2) print(s3)
name = ‘panky123‘ print(name.isalnum())#字符串由字母或数字构成，返回bool print(name.isalpha())#字符串由字母构成，返回bool print(name.isdigit())#字符串由数字构成，返回bool
msg = ‘ank sjh iea sd dd;39977a777a63‘ print(msg.count(‘a‘))#计算字符串中某个字符出现的次数 print(msg.count(‘ ‘)) print(msg.count(‘a‘, 2, -1))#切片
#公共方法（内置函数） s = ‘ks kkk jkk 1949940‘ print(len(s))#测量字符串字符的个数
2.4元组tuple。
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
2.5列表list。
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
2.5.1、增
# li = [1, ‘a‘, ‘b‘, 2, 3, ‘a‘] # li.insert(0, 55) #按照索引去增加 # print(li)
# li = [‘a‘, ‘b‘, 1, 5, (‘a‘, ‘b‘, ‘t‘)] # li.insert(3, ‘pan ky‘)#按照索引去增加 # print(li)
# li = [1, 12, ‘abc‘, ‘sk‘] # li.append(‘xyz‘)#增加到最后 # li.append(‘abc‘)#增加到最后 # print(li)
# li = [‘a‘, ‘b‘, 1, 5, (‘a‘, ‘b‘, ‘t‘)] # li.extend(‘q,a,w‘)#迭代的去增（增加到最后） # print(li) # li.extend([‘q,w‘, ‘aaa‘]) # print(li) # li.extend(‘abc‘) # print(li) # li.extend(‘a, b ,c‘) # print(li)
总共3种方式
li.insert() li.append() li.extend()
2.5.2、删。
# li = [‘a‘, ‘b‘, 1, 5, (‘a‘, ‘b‘, ‘t‘)]
# li1 = li.pop(1)#按照位置去删除，有返回值
# li.pop(1)
# print(li, li1)#[‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] b
# li = [‘a‘, ‘b‘, 1, 5, (‘a‘, ‘b‘, ‘t‘)] # del li[1:3]#按照位置去删除，可切片，顾头不顾尾，没有返回值 # print(li)
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # li.remove(‘a‘)#按照元素去删除，删掉第一个即停止 # li.remove(‘a‘) # print(li)
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # li.clear()#清空列表 # print(li)
#按照位置去删li.pop() del li[] #按照元素去删li.remove() #清空列表li.clear()
2.5.3、改。
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # li[1] = ‘panky‘#按照位置去改 # print(li) # li[1:3] = [‘hello‘, ‘panda‘]#切片去改 # print(li)
2.5.4、查。
切片去查，或者循环去查。
2.5.5、其他操作。
count（数）（方法统计某个元素在列表中出现的次数）。
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # print(li.count(‘a‘))#找出元素的索引 # print(li.index(‘a‘,1))#找出元素的索引，可切片
index（方法用于从列表中找出某个值第一个匹配项的索引位置）
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # print(li.count(‘a‘))#找出元素的索引 # print(li.index(‘a‘,1))#找出元素的索引，可切片
sort （方法用于在原位置对列表进行排序）。
reverse （方法将列表中的元素反向存放）。
# li = [‘a‘, ‘b‘, 1, ‘a‘, ‘a‘, 5, (‘a‘, ‘b‘, ‘t‘)] # li.reverse()#将元素反向存放 # print(li) # a = [1, 2, 5, 4, 9] # a.sort()#对列表进行排序 # print(li)
2.6字典dict。
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
# dic = {‘james‘: 98, ‘job‘: 78}#字典使用key-values方式， # print(dic[‘job‘])#78 # 也就是建--值的方式 # for key in dic: # print(key)#james job#取出字典中的key值 # for values in dic: # print(values)#james job#说明迭代的不是值是键
2.6.1、增。
字典的增：dic[] = xx 和 dic.setdefault()
# dic1 = {‘name‘: ‘shu ai‘, ‘age‘: 19, ‘sex‘: ‘man‘} # dic1[‘height‘] = 185#没有键值对，添加 # print(dic1)#{‘name‘: ‘shu ai‘, ‘age‘: 19, ‘sex‘: ‘man‘, ‘height‘: 185} # dic1[‘age‘] = 16#有这个键就覆盖 # print(dic1)#{‘name‘: ‘shu ai‘, ‘age‘: 16, ‘sex‘: ‘man‘, ‘height‘: 185} # dic1.setdefault(‘weight‘, 150)#有键值对，不做任何改变，没有才添加 # print(dic1)#{‘name‘: ‘shu ai‘, ‘age‘: 16, ‘sex‘: ‘man‘, ‘height‘: 185, ‘weight‘: 150}
# dic = {‘a‘: ‘b‘, ‘panky‘: 5} # dic[‘li‘] = [‘a‘, ‘b‘, ‘c‘] # print(dic)#{‘a‘: ‘b‘, ‘panky‘: 5, ‘li‘: [‘a‘, ‘b‘, ‘c‘]} # dic[‘a‘] = [‘k‘, ‘y‘] # print(dic) #此种方式，没有键值对添加，有这个键就覆盖
dic = {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘}
# dic.setdefault(‘k‘, ‘v‘)
# print(dic)#{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘}
# dic.setdefault(‘sir‘)#只有键
# print(dic)#{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘, ‘sir‘: None}
# dic.setdefault(‘k‘, ‘45‘)
# print(dic)#{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘, ‘sir‘: None}
# dic.setdefault(‘k‘)
# print(dic)#{‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘, ‘sir‘: None}
# #此种方式在字典添加键值对时，如果只有键，那对应的
# #值是键+none，但是如果原字典中存在设置的键值对时，
# #则他不会更改或者覆盖
2.6.2、删。
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘}
# dic_pop = dic.pop(‘age‘)
# print(dic_pop)#25#返回25，即键“age”所对应的值
# print(dic)#{‘name‘: ‘pan ky‘, ‘gender‘: ‘male‘}
# dic_pop2 = dic.pop(‘kk‘, ‘无key默认返回值‘)
# print(dic_pop2)#无key默认返回值
# print(dic)#{‘name‘: ‘pan ky‘, ‘gender‘: ‘male‘}
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘} # dic_pop = dic.popitem()#随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回 # print(dic_pop)#(‘gender‘, ‘male‘) # print(dic)#{‘name‘: ‘pan ky‘, ‘age‘: ‘25‘}
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘} # dic_clear = dic.clear()#清空字典 # print(dic, dic_clear)#{} None
2.6.3、改。
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘} # dic2 = {‘name‘: ‘alex‘, ‘weight‘: ‘108kg‘} # dic2.update(dic)#将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中 # print(dic2)#{‘name‘: ‘pan ky‘, ‘weight‘: ‘108kg‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘}
2.6.4、查。
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘} # value1 = dic[‘name‘]#返回值 # value2 = dic[‘nickname‘]#没有报错 # print(value1， value2)
# dic = {‘name‘: ‘pan ky‘, ‘age‘: ‘25‘, ‘gender‘: ‘male‘} # value1 = dic.get(‘ab dj dk‘, ‘默认返回值‘) # value2 = dic.get(‘age‘) # print(value1)#默认返回值 # print(value2)#25
2.6.5、其他操作。
# dic = {‘name‘: ‘pan ky‘, ‘age‘: 25, ‘gender‘: ‘male‘} # item = dic.items() # print(item, type(item))#dict_items([(‘name‘, ‘pan ky‘), (‘age‘, 25), (‘gender‘, ‘male‘)]) # # <class ‘dict_items‘> # print(dic)#{‘name‘: ‘pan ky‘, ‘age‘: 25, ‘gender‘: ‘male‘} #这个类型就是dict_items类型，可迭代的
# dic = {‘name‘: ‘pan ky‘, ‘age‘: 25, ‘gender‘: ‘male‘} # keys = dic.keys() # print(keys, type(keys))#dict_keys([‘name‘, ‘age‘, ‘gender‘]) <class ‘dict_keys‘>
# dic = {‘name‘: ‘pan ky‘, ‘age‘: 25, ‘gender‘: ‘male‘} # values = dic.values() # print(values, type(values))#dict_values([‘pan ky‘, 25, ‘male‘]) <class ‘dict_values‘>
字典的循环。
2.7集合set。
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1，集合的创建。
# set1 = set({1, 2, ‘cookie‘}) # set2 = {1, 2, ‘cookie‘} # print(set1, set2)#{1, 2, ‘cookie‘} {1, 2, ‘cookie‘}
2，集合的增。
3，集合的删。
4，集合的其他操作：
4.1 交集。（& 或者 intersection）
# & 或者 intersection # set1 = {1, 2, 3, 4, 5} # set2 = {4, 5, 6, 7, 8} # print(set1 & set2)#{4, 5} # print(set1.intersection(set2))#{4, 5}
4.2 并集。（| 或者 union）
# | 或者 union # set1 = {1, 2, 3, 4, 5} # set2 = {4, 5, 6, 7, 8} # print(set1 | set2) # print(set2.union(set1))
4.3 差集。（- 或者 difference）
# - 或者 difference # set1 = {1, 2, 3, 4, 5} # set2 = {4, 5, 6, 7, 8} # print(set1 - set2)#{1, 2, 3} # print(set1.difference(set2))#{1, 2, 3}
4.4反交集。 （^ 或者 symmetric_difference）
# ^ 或者 symmetric_difference # set1 = {1, 2, 3, 4, 5} # set2 = {4, 5, 6, 7, 8} # print(set1 ^ set2) # print(set1.symmetric_difference(set2))
4.5子集与超集
5，frozenset不可变集合，让集合变成不可变类型。
# s = frozenset(‘barry‘) # print(s, type(s))#frozenset({‘a‘, ‘b‘, ‘y‘, ‘r‘}) <class ‘frozenset‘> # b = frozenset(‘panky‘) # print(b)#frozenset({‘n‘, ‘y‘, ‘a‘, ‘p‘, ‘k‘})
三.基础数据类型的总结
按存储空间的占用分（从低到高）
数字 字符串 集合：无序，即无序存索引相关信息 元组：有序，需要存索引相关信息，不可变 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
按可变不可变区分
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组，布尔值 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
四.其他（for，enumerate，range）。
for循环：用户按照顺序循环可迭代对象的内容。
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
range：指定范围，生成指定数字。