每一种计算机语言都有自己的数据类型，但大多数计算机语言的数据类型都基本一致，下来我们来看看python中的数据类型
int数字，运算
就是用来计算的，定义方式就是 ：变量名 = 数值
方法也不多，就记住 bit_length() 当十进制用二进制表示时，最少使用的位数
v = 9 #定义一种整型的数据类型
data = v.bit_length() #判断该数值转化为二进制需要的最小位数
print(data)
布尔值bool，判断
布尔值就两种：True，False。就是判断条件的正确与否，其实所有的计算机语言都有bool值，基本一致。
真 1 True。
假 0 False。
str字符串，存储少量的信息数据，操作简单，便于传输
在python里，""(双引号)’’(单引号)都是用来标识字符串的， 字符串就是由字母数字，下划线，其他字符组成的，用引号引起来的就是字符串，需要注意的是：字符串是有序的，从前往后是0开始，从后往前是从-1开始。
我们：我们来看一下字符串的具体用法：
字符串的索引与切片。
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。 字符串是有序的，从前往后是0开始，从后往前是从-1开始， 首个切片从0开始，即0可以省略，如果是想取到整个字符串，则可以写为s[:]，单 个空格也是一个字符，只要是对字符串进行了操作，就会产生一个新的字符串
步长，步长为一定的数值，是有规律的取出
[起始索引: 截至索引 :步长]会有三个参数，前两个是你取的字符串，最后一个参数，就是你每隔几个字符串再去一个字符串
如果你想要反向取出字符串，即需要添加步长，步长为负值
s = 'Nice to meet you 999!'
print(s[2])
print(s[6])
print(s[7])
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（但是切片的区间是半开区间，左闭右开）。
s = 'Nice to meet you 999!'
print(s[3:9])
print(s[0:-1]) #默认到最后
print(s[0:10:2]) # 反向步长
print(s[11:0:-2]) #反向加步长
print(a[0:]) #默认到最后
字符串常用方法：
关于字母的大小写转换
s = 'nice* to* meet you 999!'
print(s.capitalize()) #首字母大写 Nice* to* meet you 999!
print(s.swapcase()) #大小写翻转 NICE* TO* MEET YOU 999!
print(s.title()) #每个单词的首字母大写 Nice* To* Meet You 999!
print(s.upper()) #NICE* TO* MEET YOU 999! 全部小写转大写
print(s.lower()) #nice* to* meet you 999! 全部大写转小写
内同居中，总长度，空白处填充
s1 = 'aaa'
print(s1.center(20, '*')) #********aaa*********
统计字符串中的元素出现的个数
s = '*nice* to* meet you 999!*'
print(s.count('e', 0, -1)) #统计字符串中的元素出现的个数。 3
去掉字符串中的特殊字符，分割
split分割,默认以空格进行分割，分割后的结果是一个列表,也可以规定以什么进行分割，也可以设置分割几次
s = '*nice* to* meet you 999!*'
print(s.split("*")) #结果变为了列表 ['nice', ' to', ' meet you 999!']
print(s.lstrip("*")) #nice* to* meet you 999!* #去掉左边
print(s.rstrip("*")) #*nice* to* meet you 999! #去掉右边
print(s.strip()) #nice to meet you 999! #都去
判断开头结尾，返回结果布尔值
s = '*nice* to* meet you 999!*'
print(s.startswith('k', 0, -1)) #False
print(s.endswith('9', 0, -1)) #True
寻找字符串中的元素是否存在
s = '*nice* to* meet you 999!*'
print(s.index('you', 0, -1)) # 返回的找到的元素的索引，找不到报错。15
print(s.find('you', 0, -1)) # 15 返回的找到的元素的索引，如果找不到返回-1
replace替换
从头开始进行替换，（字符串原有的字符串，新的替换的字符串，替换的次数）
s = '*nice* to* meet you 999!*'
print(s.replace("999", "too")) #nice* to* meet you too!
is系列
s = '*nice* to* meet you 999!*'
print(s.isdigit()) #False
print(s.isalpha()) #False
print(s.isalnum()) #False
默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，
如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
s = '*nice* to* meet you 999!*'
print(s.expandtabs())
join加入，形成新的字符串
print('*'.join('meet')) #m*e*e*t
tuple元组，只读列表，不能更改数据
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。以（）进行定义
list列表，存放大量数据，存储不同类型的数据，大量数据放在列表中便于操作
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
列表是可变数据类型，所以可以进行增删改查
增
l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]
l.append('too') #增加到最后
print(l) #['I', 'like', 'you', '*', 999, ['dear', 'love'], 'too']
l.insert(5, 'me') #按照索引去增加
print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too']
l.extend('abc') #迭代的去增，将里面的元素分开（里面的元素是以逗号进行分割，列表，是#将列表的每一个元素分别以一个元素进行添加）
print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too', 'a', 'b', 'c']
删
l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]
#删 li.pop() 按照索引删除,默认删除最后一个，返回的删除的内容
l.pop(2)
print(l) #['I', 'like', '*', 999, ['dear', 'love']]
#remove 删除某部分内容,默认删除一个相对应的元素
l.remove('*')
print(l) #['I', 'like', 999, ['dear', 'love']]
#del也可以进行切片删除
del l[1:3]
print(l)#['I', ['dear', 'love']]
#clear清空内容，但是列表还是存在的
l.clear()
print(l)#[]
#del删除列表，即把列表全部删除，列表也将不存在
del l
print(l) #NameError: name 'l' is not defined
改
# 改 按照索引修改,即只是把该索引的位置重新赋值，覆盖之前的数据
l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]
l[1] = 'love'
print(l) #['I', 'love', 'you', '*', 999, ['dear', 'love']]
#按照切片修改
l[:3] = 'w'#但是这个方式，只是把第一个索引的位置修改
print(l) #['w', '*', 999, ['dear', 'love']]
l[:3] = ['I','very', 'love', 'you']#这样就可以把这些索引的位置可以修改了
print(l) #['I', 'very', 'love', 'you', ['dear', 'love']]
查
l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]
#循环去查。
for i in l :
print(i)
#切片去查
print(l[0])
print(l[2:3])
print(l[1:9:2]) #['like', '*', ['dear', 'love']]
print(l[9:0:-2]) #[['dear', 'love'], '*', 'like']
其他操作
count（数）（方法统计某个元素在列表中出现的次数）
l = ['I', 'like', 'you', '*']
print(l.count('you'))
index（方法用于从列表中找出某个值第一个匹配项的索引位置）
l = ['I', 'like', 'you', '*']
print(l.index('like'))
sort （方法用于在原位置对列表进行排序），这个只是字符串类型，里面不能有列表或整形。
l = ['I', 'like', 'you', '*']
l.sort()
print(l)
reverse （方法将列表中的元素反向存放），这个只是字符串类型，里面不能有列表或整形。
l = ['I', 'like', 'you', '*']
l.reverse()
print(l)
len长度，这个列表的长度
l = ['I', 'like', 'you', '*']
print(len(l))
dict字典，存储关系型数据，以键值对的方式存在，查询数据非常快，以二分法进行查找以{}进行定义
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。字典的值可以是任意数据类型，哈希：每一个数据都有唯一的对应的哈希值。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典的顺序：
3.5之前，字典是无序的
3.6开始，字典在创建的时候是有序的，按照一定的顺序创建，看起来是有序的
增
dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}
dic['dream'] = 'haapy'
print(dic) #以覆盖的形式，有则覆盖 ，无则添加
# setdefault,但默认添加的键所对应的值是none,无则添加，有则不变
dic.setdefault('like', 'mmd')
print(dic)
dic.setdefault('like', 'dear')
print(dic)
删
dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}
dic.pop('hobby') #pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
print(dic)
dic.popitem() #随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
print(dic)
dic.clear() #清空字典
print(dic)
del dic
改
dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}
dic1 = {'addr': '海边'}
dic.update(dic1) #{'hobby': 'fish', 'age': 2, 'name': 'cat', 'addr': '海边'}
查
dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}
print(dic['name']) #如果没有该键，则会报错
print(dic.get('name'))#如果没有该键的话，就会返回none
for key in dic:
print(key + dic[key])
for k, v in dic.items():
print(k, v)
print(dic.items())
其他操作
dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}
item = dic.items()
print(item,type(item))
#这个类型就是dict_items类型，可迭代的，
# dict_items([('name', 'cat'), ('age', '2'), ('hobby', 'fish')]) <class 'dict_items'>
keys = dic.keys()
print(keys, type(keys))
# dict_keys(['name', 'age', 'hobby']) <class 'dict_keys'>
values = dic.values()
print(values, type(values))
#dict_values(['cat', '2', 'fish']) <class 'dict_values'>
for，enumerate，range
for循环：用户按照顺序循环可迭代对象的内容。for循环就是来迭代那些可迭代的对象的，无论是列表，字典，还是字符串都可以实现for循环来查看
enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['haha','cat','女神','happy','男神'']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
range：指定范围，生成指定数字。
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)
复制代码
集合
集合中的数据是无序，不重复的数据集合，有点像我们数学中学到的集合，但是一定要注意，无序，它里面的元素也是可哈希的（不可变 的数据类型），但是集合的本身不可哈希。集合最大的特点就是可以帮助你去重，而且是自动去重哦，还有一点就是它可以像数学的集合一样，进行交差并补的运算，同时他也可以进行增删的操作
集合的创建
set1 = set({1, 3, 'like'})
print(set1)
集合的增
集合的增有两种方式：add，单独增加一个元素，update，迭代增加
add
set1 = set({1, 3, 'like'})
set1.add('love')
print(set1)
update
set1 = set({1, 3, 'like'})
set1.update([8,7,9])
print(set1) #{1, 3, 7, 'like', 9, 8}
集合的删
集合的删也有四个方法
pop（）
set1 = set({1, 3, 'like'})
set1.remove(1) # 删除一个元素
set1.pop() # 随机删除一个元素
set1.clear() # 清空集合
del set1 # 删除集合
集合的交 （& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
集合的差 （- 或者 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}
集合的并 （| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
集合的补 （反交集） ^ 或者 symmetric_difference
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
如果将列表转换为集合，就可以直接实现去重
l = [1,2,3,4,5,1,2,3,4,5]
set1 = set(l)
print(set1) #{1, 2, 3, 4, 5}
基础数据类型的总结
按照可变不可变分类：
可变：列表，字典
不可变：数字，字符串，元组，布尔值
按照访问顺序：
直接访问：数字
顺序访问：字符串，列表，元组
映射访问，字典
按照存值的个数
简单的数据：数字，字符串
容器类（大量数据）：列表，元组，字典
按有序无序分类
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改