在标准的Python数据类型中，有些是可变的，有些是不可变的，不可变就意味着你不能对它进行操作，只能读取。

不可变数据：Number数字、String（字符串）、Tuple（元组）

可变数据：List（列表）、Dictionary（字典）、Set（集合）

可以使用type()函数查看数据的类型

可以使用isinstance()函数来判断数据是不是指定的 类型

isinstance(123,int)

判断123是不是整型值

返回True

1.数字

Python的数字类型可以存储数学中的 各种数字，包括常见的自然数、负数中的虚数、无穷大数、正负数、带小数点的数、不同进制的数等。

1 #int 整形

1.2 #float 浮点

1j #complex 复数

a = 10
b = 21
# 数值计算
a + b # 31
a - b # -11
a * b # 210
b / a # 2.1
a ** b # 表示10的21次幂
b % a # 1 （取余）
# 地板除，相除后只保留整数部分，即向下取整
# 但如果其中一个操作数为负数，则取负无穷大方向距离结果最近的整数
9//2 # 4
9.0//2.0 # 4.0
-11//3 # -4
-11.0//3 # -4.0

2.字符串

字符串可以使一条或多条文本信息，可以对字符串进行切片访问（同时适用于字符、列表、元组等），字符串从左向右，索引值从0开始，要是从右往左，索引值则是从-1开始，可以取字符串中的片段，切片索引按左闭右开原则

var = 'Hello World!'
# 按索引取部分内容，索引从0开始, 左必须小于右
# 支持字符、列表、元组
var[0] # 'H'
# 从右往左，索引从-1开始
var[-1] # '!'
var[-3:-1] # 'ld'
var[1:7] # 'ello W'（有个空格，不包含最后一位索引7）
var[6:] # 'World!' （只指定开头，包含后面所有的字符）
var[:] # 'Hello World!'（相当于复制）
var[0:5:2] # 'Hlo'（2为步长，按2的倍数取）
var[1:7:3] # 'ello W' -> 'eo'
var[::-1] # '!dlroW olleH'（实现反转字符功能）

一些最常用的字符串操作：

len('good') #4  返回字符串的长度

'good'.replace('g','f')     #food   将字符串中的g替换为f

'风-光-无-限'.split('-')  #['风', '光', '无', '限']   指定字符串中的某个字符作为分隔符，
# 如果指定的字符不存在，那么该字符串就不会被分割，如果参数留空，则默认按照空格对字符串对象进行分割操作
'风-光-无-限'.split('风')  #['', '-光-无-限']

'-'.join(['山','水','风','雨'])   #山-水-风-雨    指定分隔符将一个可迭代项目中的元素拼接成一个新的字符串
'和'.join(['诗','远方'])  #诗和远方

'good'.upper()    #GOOD   将字符串中的英文字母全部转换成大写
'FOOD'.lower()    #food       将字符串中的英文字幕全部转换成小写
'Good Bye'.swapcase()     #gOOD bYE   将字符串中的英文字母大小写互换
'good'.capitalize() #Good 将字符串的首字母转换成大写
'good古德'.islower()  #True   #字符串中的英文字母是否全部为小写，可以包含其他字符，只要没出现大写字母都返回True
'GOOD古德'.isupper()    #True，字符串中的英文字母是否均为大写
'字符串'.zfill(6)    #000字符串 将字符串调整为指定长度，如果长度不够，则填充0，如果字符串本身长度超过指定的值，那就不做修改

3.布尔型

在计算机世界中，0和1是基本元素，代表关和开或假和真两种状态。

在Python中，True和False分别代表真和假，它们都属于布尔型

检测变量时，以下情况会得到假，其他情况都为真

False：

None、False

数值中的0、0.0、0j（虚数）、Decimal(0)、Fraction(0,1)

空字符串”、空元祖()、空列表[]

空字典{}、空集合set()

对象默认为True，除非它有bool()方法且返回False，或有len()方法且返回0

以下是一些典型的布尔运算：

a = 0
b = 1
c = 2
a and b # 0（a为假，返回假的值）
b and a # 0（b为真，返回a的值）
a or b # 2 （a为假，返回b的值）
a and b or c # 2
a and (b or c) # 0 （用类似数学中的括号提高运算优先级）

# not的注意事项
not a # True
not a == b # True
not (a == b) # True（逻辑同上）
a == not b # 这条有语法错误, 正确的如下：
a == (not b) # True

# and的优先级高于or。首先，'a'为真，'a' and 'b'返回'b';然后，'' or 'b'返回'b'
'' or 'a' and 'b' # 'b'

4.列表

列表是用方括号[]组织起来的，每个元素用英文逗号隔开，里面每个具体元素可以是任意类型的内容。

通常元素的类型是相同的，但也可以不相同，比如：

x = [] # 空列表
x = [1, 2, 3, 4, 5]
x = ['a', 'b', 'c']
x = ['a', 1.5, True, [2, 3, 4]] # 各种类型混杂
type(x) # list 类型检测

列表和字符串一样支持切片访问，可以将字符串中的一个字符当成是列表中的一个元素，以下是一些常用的列表操作：

len() 返回列表元素个数
max() 返回列表中的最大值
min() 返回列表中的最小值
sum() 求和
列表.index(索引值) 返回列表元素指定索引值位置的元素
列表.count(元素） 统计指定元素在列表中出现的次数
for i in 列表:print(i) #迭代列表中的元素
sorted(列表) 在列表中元素都是数字的情况下，默认将列表中的元素按从小到大进行排序并返回，但并不会对原列表进行修改
any(列表) 列表中是否存在可以表示为真True的元素，如果有一个元素为真就返回True，否则（全是假）返回False
all(列表) 判断该列表是否所有的元素都为真，如果所有的元素都为真则返回True，否则返回false
列表.append(元素) 将指定元素增加至列表末尾
列表.pop() 每执行一次，都会返回列表中最后一个元素，并将该元素从列表中删除
列表.extend([列表]) 将两张列表中的元素合并成一个新的列表
列表.insert(索引值,元素) 在指定索引值的位置，插入一个新的元素
列表.remove(元素) #删除列表中第一个出现的指定元素
列表.clear() 清空列表中的所有元素，列表会变成[]

另外，需要熟练掌握列表的推导式，可以由可迭代对象快速生成一个列表。

推导式就是用for循环结合if表达式生成一个列表，这是一个非常紧凑地定义列表的方式，可以大大减少代码量

# 将一个可迭代的对象展开，形成一个列表
列表=[i for i in range(10)]
print(列表)   #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#可将结果进行处理
列表=['第'+str(i) for i in range(10)]
print(列表)   #['第0', '第1', '第2', '第3', '第4', '第5', '第6', '第7', '第8', '第9']

#可以进行条件筛选，实现取偶数
列表=[i for i in range(10) if i%2==0]
print(列表)   #[0, 2, 4, 6, 8]

#提取列表中每一字符，过滤空格，并转换成大写，生成一个新列表
列表=[i.upper() for i in 'Hello world' if i !='']
print(列表)   #['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']

5.元组

元组（tuple）与列表（list）非常相似，但区别是，元组不可变，而列表则可以修改，元组使用圆括号()表示，列表使用方括号[]表示。

元组的索引机制与列表相同，修改元组中的元素时会报错，但是可以修改混杂类型里的列表数据类型。

了解了元组的解包操作就可以更灵活地赋值、定义函数、传参

元组=(1,2,3,4,5,6,7,8,9)
a,*b=元组     #a获得元组中第一个元素，剩余的所有元素作为一个列表装入b
print(a)    #1
print(b)    #[2, 3, 4, 5, 6, 7, 8, 9]

元组=(1,2,3,4,5,6,7,8,9)
a,*b,c=元组
print(a)    #1
print(b)    #[2, 3, 4, 5, 6, 7, 8, 9]
print(c)    #9
#a获得列表中第一个元素，c获得最后一个元素，中间的所有元素作为一个列表装入b

6.字典

字典是Python中的重要数据结构，由键值对组成。

在客观世界中，所有的事件都有它的属性和属性对应的值，比如某种花的颜色是红色，有6个花瓣，其中花瓣的颜色与数量可以看成是属性，红色与6可以看成是对应属性的值。

属性（key）与值（value）组成了字典中的键值对

字典中还可以嵌套字典，也就是其中某个键的值是一个字典

字典={}   #定义空字典
字典=dict()   #定义空字典
字典={'键':'值','键':'值','键':'值',}   #自定义字典，如果其中的键有重复，重复是取最后一个
d={'a':1,'b':{'c':3}}        #字典中还可以嵌套字典，也就是其中某个键的值是一个字典
字典={'a':[1,2,3],'b':[6,6,6]}    #字典中嵌套列表

# 以下均可定义如下结果
# {'name': 'Tom', 'age': 18, 'height': 180}
d = dict(name='Tom', age=18, height=180)
d = dict([('name', 'Tom'), ('age', 18), ('height', 180)])
d = dict(zip(['name', 'age', 'height'], ['Tom', 18, 180]))

访问字典的方法如下：

字典[‘键’] #返回指定键对应的值
字典[‘键’]=值 #修改指定键对应的值
字典[‘新的键’]=值 #增加一对键值
字典.get(键) #返回字典中指定键的值
嵌套取值
d = {‘a’: {‘name’: ‘Tom’, ‘age’:23}, ‘b’: [4,5,6]}
d[‘b’][1] #5
d[‘a’][‘age’] #23

常用的字典操作方法如下：字典.pop(‘键’) #删除指定的键并返回该键对应的值
字典.popitem() #随机删除字典中某一个键，并返回该键对应的值
del 字典[‘键’] #删除字典中某一个键
字典.clear() #清空字典
按类型访问，可迭代
字典.keys() #列出字典中所有的键，返回结果dict_keys([键的列表’])
字典.values() #列出字典中所有键对应的值，返回格式为dict_values([所有的值])
字典.items() #返回字典中所有的键值对元组，返回的格式为dict_items([(键, 值), (键,,值)])
字典常用操作
字典.setdefault(键,值) #插入一个键并指定它的值，如不指定，则指默认为None
字典1.update(字典2) #将字典2的键值对添加到字典1，如果键已经存在，则会替换掉字典1中原有的值，该方法不返回任何值，None?
字典.get(要查找的键,如果键不存在返回什么值) #参数2，如果不存在返回什么值可不填，默认为None
字典2=字典1.copy() #深拷贝，修改字典1不影响字典2
max(字典) #返回字典中最大的键
min(字典) #返回字典中最小的键
len(字典) #返回字典的长度，也就是键的个数
str(字典) #将字典内容以字符串形式返回
any(字典) #是否存在可以代表True的键，只要有一个键为True则返回True
all(字典) #是否字典中所有的键都是True，如果都是那就返回True，否则返回False
sorted(字典) #返回经过排序后的字典的键的列表

7.集合

集合（set）是存放无顺序、无索引内容的容器，用花括号{}来表示，可以包含布尔值、数字、字符串等各种类型的元素

可以通过集合来消除重复的元素，也可以用它作交、叉、并、补等数学运算

集合的定义方法：

集合=set() #创建一个空集合

集合={‘元素’,’元素’} #创建一个自定义的集合

集合=set(列表) #将列表转换成集合

集合没有顺序，没有索引，所以无法通过指定位置去访问，但可以用for遍历的方式读取

一些集合的常用操作：

元素 in 集合 #判断集合中是否有某个元素

集合.add(元素) #向集合中添加元素

集合1.update(集合2/列表2) 将集合2或列表2中的元素装入集合1，重复的元素只会存在一个，也就是计算得出一个集合与另一个集合/列表的并集

集合.remove(元素) #删除集合中的指定元素，如果删除不存在的元素会报错

集合.discard(元素) #删除一个元素，无则忽略，不会报错

集合.clear() #清空集合内的内容

集合的数学运算如下，返回结果都是集合：

集合1&集合2 #取2个集合的交集，也就是共同都有的元素
集合1.intersection(集合2) #取交集
集合1.intersection_update(集合2) #取交集，并且会覆盖掉集合1

集合1 | 集合2 #返回2个集合的并集，相当于合并两个集合，重复的元素只保留1个
集合1.union(集合2) #返回2个集合的并集

集合1.difference(集合2) #返回2个集合的差集，返回集合1拥有但集合2没有的元素，返回结果是集合
集合1.difference(集合2) #返回2个集合的差集，并且会覆盖掉集合1

集合1.symmetric_difference(集合2) #返回2个集合之间没有重复的元素，集合1有但集合2没有，以及集合2有但集合1没有的元素，也就是交集之外的元素

集合1.isdisjoint(集合2) #两个集合是否没有交集，也就是两个集合所有用的元素完全不相同，没有重复，如果没有交集就返回True，如果有相同的元素则返回False
集合1.issubset(集合2) #集合1是否是集合2的子集，也就是集合2是否包含集合1的所有元素，如果集合1的所有元素在集合2中都能找到，也就是集合2包含集合1的所有元素，那么集合1就可以看成是集合2的子集
集合1.issuperset(集合2) #集合1是否是集合2的超集，集合1是否包含集合1中的所有元素