python数据类型

数据类型的作用

如果说：程序是用来处理数据的，那么变量就是用来存储并快速找到数据的，而数据类型就是为了更充分的利用内存空间及更有效率的分类管理数据。

数据类型的分类

python数据类型特点

• 不用特意指定，赋值时其会自动检测值得数据类型。

按数字分类

在 Python 中，大部分 非数字型变量 都支持以下特点：

• 都是一个 序列 sequence，也可以理解为 容器
• 根据索引取值 [] 和 切片 （字典靠key取值，不能切片）
• 遍历 for _ in 序列:
• 计算长度、最大/最小值、比较、删除
• 拼接 + 相同类型序列 和 重复 * （字典和集合不能拼接和重复）

按可变不可变分类

容器型数据的循环遍历

本人另一篇博客： python 循环语句

str 字符串类型

凡是用一对或三对引号（双引号或单引号，但不可混用）引起来的内容皆称为字符串。

str1 = "我叫'狗蛋'，" \ 
       "今年8岁。"        # 一个引号的字符串回车后的样子
str2 = 'I\'m,kangkang.'
str3 = """我叫'狗蛋'，
今年8岁。"""              # 三个引号的字符串回车后的样子
str4 = '''我叫'狗蛋'，
今年8岁。'''

执行结果：  |我叫'狗蛋'，今年8岁。
		   |I'm,kangkang.
		   |我叫'狗蛋'，
		   |今年8岁。
		   |我叫'狗蛋'，
		   |今年8岁。
		   |我叫'狗蛋'，
		   |今年8岁。

由执行结果可以看出：

• 使用一个引号标识字符串时，若其中还需要使用引号，则必须使用另一种引号或使用转义字符（\’ 或\"）。在字符串中使用回车时，打印时仅会一行显示（不会换行显示，即与不打回车一致）。
• 使用三个引号标识字符串时，若其中还需要使用引号，则什么引号皆可使用。在字符串中使用回车时，打印时会两行显示（会换行显示，即与使用 “\n” 一致）。

字符串常用方法

索引和切片

所谓“下标”，就是编号，通过这个编号就能找到相应的存储空间，取出其中的数据。
字符串实际上就是字符的数组，如字符串name = ‘hello word’，在内存中的实际存储如下:

红色数字便是下标也称为索引值，索引计数从0开始。其可以用于索引和切片。

索引为根据一个下标，取出一个数据，并将其生成一个字符串输出。

• 格式为：字符串[下标]
• 下标可为负，表示从右往左数第几个

切片为根据一个下标范围，取出多个数据，并将其生成一个字符串输出。

• 格式为：字符串[开始下标：结束下标：步长] ，步长表示选取间隔
• 其中下标和步长可正可负。 下标为负，表示从右往左数第几个；步长为负表示从右往左取值。
• 切片规则：包括开始下标数据，不包括结束下标数据并且 开始到结束的方向需要与步长的方向一致，否则取值为空
• 切片顺序：先取开始下标的数据作为第一个数据，然后再根据步长取其他值，而非根据开始下标加上步长后再取第一个数据。
• 省略开始下标表示从0开始取值，省略结束下标表示取到最后，省略步长时最后一个冒号也可省，表示从左到右依次取值
• 注意：当开始下标或结束下标越界后不会报错，仅会取得有的那部分乃至空字符串

name = "hello word"
print(name[3])
print(name[-3])
print(name[2:8:2])
print(name[-2:-8:-2])

执行结果为：|'l'
		   |'o'
		   |'low'
		   |'rwo'

查找

序号	方法	说明
1	.find（）	由数据从左到右查 找索引， 无则返回-1
1	.rfind（）	由数据从右到左查找索引， 无则返回-1
2	.index（）	由数据从左到右查找索引 ，无则报错
2	.rindex（）	由数据从右到左查找索引，无则报错
3	.count（）	由数据查出现次数
4	len（）	由字符串数据查字符串长度
5	max（）	在同类型数据中查找到最大值 （“啊”>“A”>“a”>“1”）
5	min（）	在同类型数据中查找到最小值

1. find() 更常用 由数据查找索引

• 格式为：字符串A.find(要查询的字符串B, start=开始下标, end=结束下表)
• 检测要查询的字符串B是否包含在 字符串A的指定范围(开始下标和结束下标之间，不包含结束下标)
• 若在指定范围内，则 返回首次查询到的字符串B在字符串A首位索引值，不在则返回 -1
• 开始下标和结束下标可以省略，表示搜索全文
• find()表示从左往右查找，rfind()表示从右往左查找
• 无论find()还是rfind()，其开始到结束的方向必须是从左到右，否则查不到

name = "hello word"
print(name.find("ll", 1, 8))
print(name.rfind("ll", -1, 1))

执行结果为：|2
   		   |-1

2. index() 由数据查找索引

• 格式为：字符串A.index(要查询的字符串B, start=开始下标, end=结束下表)
• 与find用法一致，不同在于index指定范围查询不到则报错，而find返回-1

name = "hello word"
print(name.index("ll", 1, 8))
print(name.rindex("ll", -1, 1))

执行结果为：|2
   		   |ValueError: substring not found

3. count() 由数据查找出现次数

格式为：字符串A.count(要查找的字符串B, start=开始下标, end=结束下标)

• 检测要查询的字符串B在 字符串A的指定范围(包含开始下标，不包含结束下标)中出现了几次
• 开始下标和结束下标都省略，表示搜索全文，省略一位表示省略结束下标
• 若在指定范围内，则 返回出现的次数，不在则返回0

name = "hello word"
print(name.count("l", 1, 8))
print(name.count("q"))
print(name.count("o", 5))

执行结果为：|2
   		   |0
   		   |1

4. len() 查字符串长度

格式为：len(要查找的字符串B)

• 检测要查询的字符串B的长度，返回int型

name = "hello word"
print(len(name))

执行结果为：|10

修改

因为字符串是不可变类型，所以使用其修改方法时必须用变量接收，若不接受，执行后不会报错，但不会修改任何数据，即不起任何效果。

序号	方法	说明
1	.replace（）	将字符串中的旧子字符串修改成新子字符串
2	.split（）	从左侧开始根据分隔符多次分割；每次分隔成两部分；且每部分都不包含分割字符，返回列表
2	.rsplit（）	从右侧开始根据分隔符多次分割；每次分隔成两部分；且每部分都不包含分割字符，返回列表
3	.splitlines（）	根据\n多次分割成两部分，返回列表
4	.partition（）	从左侧开始根据分隔符分割一次成三部分（分隔字符串自占一部分），返回元祖
4	.rpartition（）	从右侧根据分隔符分割一次成三部分（分隔字符串自占一部分），返回元祖
5	.join()	将全字符串的序列按拼接符拼接成新字符串
6	.strip()	删除首尾空白字符，也可删指定字符
6	.lstrip()	仅删除首部空白字符，也可删指定字符
6	.rstrip()	仅删除尾部空白字符，也可删指定字符
7	.ljust()	使⽤指定字符 (默认空格)填充⾄指定⻓度，左对齐返回
7	.rjust()	使⽤指定字符(默认空格)填充⾄指定⻓度，右对齐返回
7	.center()	使⽤指定字符(默认空格)填充⾄指定⻓度，居中对齐返回
8	.capitalize()	将字符串第⼀个字符转换成⼤写
9	.title()	将字符串每个单词首字母转换成⼤写
10	.lower()	将字符串所有字母转换成小写
11	.upper()	将字符串所有字母转换成大写

1 .replace() 将字符串中的旧子字符串修改成新子字符串

• 格式为：字符串A.replace(旧子字符串, 新子字符串, 修改次数)
• 含义：将字符串A中的N个旧子字符串修改成新子字符串，N为修改次数。
• 若字符串A中不包含旧子字符串，不会修改也不会报错。
• 若省略修改次数或修改次数超过旧子字符串出现次数，则会将旧子字符串全部修改为新字符串。不会报错

name = "hello word"
print(name.replace("o", "oo", 1))  
print(name.replace("o", "oo", 8))
print(name.replace("oo","www"))

执行结果为：|'helloo word'
   		   |'helloo woord'
   		   |'hello word'

第二行执行结果不是6个o 是因为字符串为不可变类型，并且没有用变量重新接收

2 .split() 根据分隔符多次分割；每次分隔成两部分；且每部分都不包含分割字符，返回列表

• 格式为：字符串.replace("分割子串", 分割次数)
• 当字符串中存在分割子串时，会返回一个列表，其中包含根据分割子串前后各生成的新字符串；当字符串中不包含分割字串时，不会报错，只是不会有任何分割
• 省略分割次数 或 分割次数大于分割子串出现的次数，则会将所有分割子串全部分割
• rsplit()表示从右侧开始分割

name = "hello word"
print(name.rsplit("o"))
print(name.rsplit("o", 8))
print(name.split("oo"))

执行结果为：|['hell', ' w', 'rd']
   		   |['hell', ' w', 'rd']
   		   |['hello word']

3 .splitlines() 根据\n多次分割成两部分，返回列表

• 格式为：字符串.splitlines()
• 没有任何参数
• 按照\n分隔 ，返回一个 列表，其中包含多个\n前和\n后形成的字符串
• 若不存在\n，则会返回一个仅包含原字符串的列表

name = "hel\nlo \nword"
name1 = "hello wo\trd"
print(name.splitlines())
print(name1.splitlines())

执行结果为：|['hel', 'lo ', 'word']
   		   |['hello wo\trd']

4 .partition() 根据分隔符分割一次成三部分（分隔字符串自占一部分），返回元祖

• 格式为：字符串.partition("分割子串")
• 若字符串中存在分割子串，则会返回一个元祖其中包括以分割子串将字符串分割成的三个字符串：分割子串前、分割子串和分割子串后
• 若字符串中不存在分割子串，不会报错，会返回一个元祖其中包括原字符串和两个空字符串''

name = "hello word"
print(name.partition("ll"))
print(name.rpartition("oo"))

执行结果为：|('he', 'll', 'o word')
   		   |('hello word', '', '')

5 .join() 将全字符串的序列按拼接符拼接成新字符串

• 格式为：拼接符.join(全字符串序列)
• 全字符串序列包括 字符串、列表、元祖、字典、集合。若为字典则只拼接键
• 若序列不是全为字符串或拼接符不是字符串会报错

s1 = '过年好'
list1 = ['恭', '喜', '发', '财']
t1 = ('红', '包', '拿', '来')
tuple1 = {"name": "xiao", "age": 13}
print('！'.join(s1))
print('$'.join(list1))
print('￥'.join(t1))
print("%%".join(tuple1))

执行结果为：|'过！年！好'
		   |'恭$喜$发$财'
		   |'红￥包￥拿￥来'
		   |'name%%age'

6 .strip() 删除首尾指定字符

• 格式为： 字符串.strip("指定字符")
• 若不指定字符，则默认删除空白字符（\t、\n、空格）
• 若指定字符，则会删除首尾的指定字符
• 若首位没有要删除的字符，不会报错
• lstrip()表示删除首部的空白字符，rstrip()表示删除尾部的空白字符

name = "  \t  eeeelel  \t  hello word    \n"
name1 = "eeeelel  \t  hello word    \n"
print(name.strip())
print(name.strip("e"))
print(name1.strip("e"))

执行结果为：|'eeeelel  \t  hello word'
   		   |'  \t  eeeelel  \t  hello word    \n'
   		   |'lel  \t  hello word    \n'

7 .ljust() 使⽤指定字符填充⾄指定⻓度，左对齐返回

• 格式为： 字符串.ljust(指定长度, "指定填充字符")
• 若不指定填充字符，则默认使用空格填充，若指定，则使用指定字符填充
• 不可不指定长度，若指定长的小于原字符串长度，不会报错，仅会返回原字符串
• rjust（）表示右对齐
• center（）表示居中对齐，若需填充的字符为奇数，居中对齐时左侧会多一个

name = "hello word"
print(name.ljust(15, "-"))
print(name.rjust(15))
print(name.rjust(5, "-"))
print(name.center(15, "-"))

执行结果为：|'hello word-----'
   		   |'     hello word'
   		   |'hello word'
   		   |'---hello word--'

判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False

序号	方法	说明
1	.startswith('指定子串')	检查字符串是否是以指定⼦串开头，可指定范围检测
2	.endswith('指定子串')	检查字符串是否是以指定⼦串结尾，可指定范围检测
3	.isalpha()	判断字符串有且只有字⺟
4	.isdigit()	判断字符串有且只有数字
5	.isalnum()	判断字符串有且只有字⺟或数字
6	.isspace()	如果字符串中有且只有空⽩字符（\t、\n、空格）

list 列表类型

• 格式为：变量名=[2, 2.2, True, "字符串", [列表], (元祖), {字典}]
• 凡是用一对中括号[]引起来的内容皆称为列表，为可变类型
• 列表嵌套：变量名=[[], [], []]， 定义空列表：变量名=[]
• 列表可以⼀次性存储多个不同数据，但为了方便循环遍历处理数据，一般放置相同类型的数据

列表的常⽤操作

列表为可变类型

• 用列表自带方法修改数据，其前后id（数据储存地址）不变
• 修改后不需要使用原变量名接收改变后的数据，进行重新赋值
• 如果重新赋值，则表示新建一列表然后赋值，其id（数据储存地址）会发生变化

查

序号	方法	说明
1	列表[下标]	索引：根据一个下标，取出一个数据
1	列表[下标范围]	切片：根据一个下标范围，取出多个数据
2	.index（）	由数据找索引 ，无则报错
3	.count（）	由数据查出现次数
4	len（）	由列表数据查字符串长度
5	max（）	在同类型数据中查找到最大值 （“啊”>“A”>“a”>“1”）
5	min（）	在同类型数据中查找到最小值
6	数据 in 列表	判断数据是否在列表中，在返回Ture ；非列表内置方法，而是成员运算符，所有序列皆可使用
6	数据 not in 列表	判断数据是否在列表中，在返回False

1 索引和切片

索引为根据一个下标，取出一个数据，并将以数据原类型输出。

• 格式为：列表[下标]
• 下标若不小于列表长度，否则会报错（下标越界）
• 下标可为负，表示从右往左数第几个

切片为根据一个下标范围，取出多个数据，并将其生成一个新列表输出。

• 格式为：列表[开始下标：结束下标：步长] ，步长表示选取间隔
• 其中下标和步长可正可负。 下标为负，表示从右往左数第几个；步长为负表示从右往左取值。
• 切片规则：包括开始下标数据，不包括结束下标数据并且 开始到结束的方向需要与步长的方向一致，否则取值为空
• 切片顺序：先取开始下标的数据作为第一个数据，然后再根据步长取其他值，而非根据开始下标加上步长后再取第一个数据。
• 省略开始下标表示从0开始取值，省略结束下标表示取到最后，省略步长时最后一个冒号也可省，表示从左到右依次取值
• 注意：当开始下标或结束下标越界后不会报错，仅会取得有的那部分乃至空列表

  name_list = ['a', "b", "A", "N", "12", "啊", "2"]
  print(name_list[2], type(name_list[2]))
  print(name_list[-2::-2])
  
  执行结果为：|A <class 'str'>
  		   |['啊', 'N', 'b']
  

2 .index() 由数据查找索引

• 格式为：列表.index(要查询数据, start=开始下标, stop=结束下表)
• 检测要查询的数据是否包含在 列表的指定范围(包含开始下标数据，不包含结束下标数据)
• 若在指定范围内，则 返回第一次查询到列表索引值，不在则报错
• 开始下标和结束下标可以省略，表示搜索全文，若填写一个下标表示从下标开始搜索直至结束，而不是从开始搜索至下标位置
• 列表没有 .find() 方法

name_list = ['a', "b", "A", "N", "12", "啊", "2"]
print(name_list.index("A", 1))

执行结果为：|2

3 .count() 由数据查找出现次数

格式为：列表.count(要查找数据)

• 检测要查询的数据是否包含在 列表中，若在指定范围内，则 返回出现的次数，不在则返回0
• 注意：与字符串不同，列表不能指定范围

name_list = ['a', "b", "A", "N", "12", "啊", "2", "a"]
print(name_list.count("a"))
print(name_list.count("1"))

执行结果为：|2
   		   |0

4 .len() 查字符串长度

格式为：len(要查找的列表)

• 检测要查询的列表的长度，返回int型

name_list = ['a', "b", "A", "N", "12", "啊", "2"]
print(len(name_list), type(len(name_list)))

执行结果为：|7 <class 'int'>

增

序号	方法	说明
1	.append()	将数据以一个整体追加到列表结尾
2	.extend()	将序列遍历式逐一追加到列表结尾
2	+=	将序列遍历式逐一追加到列表结尾，要求与效果以extend()完全一致
3	.insert()	将要追加的数据整体插入到指定位置

1 .append()：将数据以一个整体追加到列表结尾

• 格式为：列表.append(要追加的数据)
• 含义：将要追加的数据以一个整体追加到列表末尾
• 如果追加的数据是⼀个序列，则将整个序列追加到列表末尾

name_list = ['张三', '李四', '王五']
name_list.append(['赵六', '钱七'])
print(name_list)

执行结果为：|['张三', '李四', '王五', ['赵六', '钱七']]

2 .extend()：将序列遍历式逐一追加到列表结尾

• 格式为：列表.append(要追加的序列)
• 含义：将要追加的序列遍历式逐一追加到列表末尾
• 追加的数据必须是⼀个序列，若不是序列会报错
• 若追加的是字符串，则会将字符串拆开逐一追加，可套一列表追加整体

  name_list = ['张三', '李四', '王五']
  name_list.extend(['赵六', '钱七'])
  name_list.extend('赵六')
  name_list.extend(['钱七'])
  print(name_list)
  
  执行结果为：|['张三', '李四', '王五', '赵六', '钱七', '赵', '六', '钱七']
  

2 += ：将序列遍历式逐一追加到列表结尾

• 格式为：列表+=要追加的序列

• 其与expend()方法要求和效果完全一致，也是在列表的原数据上进行遍历式追加列表结尾

  name_list = ['张三', '李四', '王五']
  name_list += ['赵六', '钱七']
  name_list += '赵六'
  name_list += ['钱七']
  print(name_list)
  
  执行结果为：|['张三', '李四', '王五', '赵六', '钱七', '赵', '六', '钱七']
  

3 .insert()：将要追加的数据 整体插入到指定下标位置

• 格式为：列表.insert(下标，要追加的数据)
• 含义：将要追加的数据以一个整体插入到列表指定下标位置，原位置及之后的数据往后移
• 追加的数据必须是⼀个序列若不是序列会报错

  name_list = ['张三', '李四', '王五']
  name_list.expend(1, ['赵六', '钱七'])
  print(name_list)
  
  执行结果为：|['张三', ['赵六', '钱七'], '李四', '王五']
  

删除

序号	方法	说明
1	del 列表[下标]或del (列表[下标])	带下标删列表指定位置数据，不带下标删列表
2	.pop()	删除指定下标的数据(默认为最后⼀个)，并返回删除的数据
3	.remove(制定数据)	移除列表中指定数据的第⼀个匹配项
4	.clear()	清空列表所有数据，返回空列表

1. del 带下标删列表指定位置数据，不带下标删列表

分函数和关键字两种删除方式，效果一致

1. 关键字形式（常用）
   格式为：del 列表索引或切片 或 del 列表 前者为删除列表指定下标位置数据，后者为删除整个列表

2. 函数形式
   格式为：del（列表索引或切片） 或 del（列表） 前者为删除列表指定下标位置数据，后者为删除整个列表

name_list = ['张三', '李四', '王五']
del name_list[1]  # del(name_list[1])
print(name_list)
del name_list[:]  # del(name_list[:])
print(name_list)
del name_list     # del(name_list)
print(name_list)

执行结果为：|['张三', '王五']
		   |[]
		   |NameError: name 'name_list' is not defined

2 .pop()：删除指定下标的数据(默认为最后⼀个)，并返回删除的数据

• 格式为：列表.pop(指定下标)
• 有返回值（删除掉的数据），需要有变量接受，否则得不到删掉的数据
• 若不指定下标，默认删除最后一个数据

name_list = ['张三', '李四', '王五']
name = name_list.pop(2)
print(name)

执行结果为：|王五

3 .remove()：移除列表中指定数据的第⼀个匹配项

• 格式为：列表.remove(指定数据)
• 删除列表中指定数据的第一个匹配项
• 若列表不包含指定数据，则报错

name_list = ['张三', "王五", '李四', '王五']
name_list.remove("王五")
print(name_list)
name_list.remove("wangwu")
print(name_list)

执行结果为：|['张三', '李四', '王五']
   		   |ValueError: list.remove(x): x not in list

4 .clear()： 清空列表所有数据

修改

序号	方法	说明
1	列表[下标] = 值	修改指定下标数据，不修改内存地址
2	列表 = 值	表示重新赋值，修改内存地址
3	.reverse()	将列表中的数据逆置处理，即顺序颠倒
4	.sort(reverse=Fales)	将整个列表进行以升序（默认）或 降序（Ture）重新排列

1. 列表[下标] = 值；修改指定下标数据，不修改内存地址

根据列表索引进行索引所在位置值的重新赋值

• 格式为：列表[下标] = 值

name_list = ['张三', "王五", '李四', '王五']
print(id(name_list), name_list)
name_list[1] = "马六"
print(id(name_list), name_list)

执行结果为：|1873320599816 ['张三', "王五", '李四', '王五']
  		   |1873320599816 ['张三', '马六', '李四', '王五']

2. 列表 = 值；列表重新赋值，修改内存地址

对整个列表进行重新赋值

• 格式为：列表 = 值

name_list = ['张三', "王五", '李四', '王五']
print(id(name_list), name_list)
name_list = ["马六", "田七"]
print(id(name_list), name_list)

执行结果为： |1336607760648 ['张三', '王五', '李四', '王五']
  			|1336607760712 ['马六', '田七']

3. reverse() 将整个列表进行逆置，数据顺序颠倒

• 格式为：列表.reverse()

name_list = ['张三', "王五", '李四', 1, '王五']
name_list.reverse()
print(name_list)

执行结果为： |['王五', 1,  '李四', '王五', '张三']

4. sort() 将整个列表进行以升序或降序重新排列

• 格式为：列表.sort(reverse=False)
• 其中列表中的数据必须为同类型数据，否则报错
• reverse为默认参数，默认为False（升序），改为True表示降序排列
• “啊”>“A”>“a”>“1”

name_list = ['a', "b", "A", "N", "12", "啊", "2"]
name_list.sort()
print(name_list)
name_list.sort(reverse=True)
print(name_list)
print()
a = [1, 4, 2, 3, "1"]
a.sort()
print(a)

执行结果为： |['12', '2', 'A', 'N', 'a', 'b', '啊']
  			|['啊', 'b', 'a', 'N', 'A', '2', '12']
   	  		|
   			|TypeError: '<' not supported between instances of 'str' and 'int'

列表推导式

指的轻量级循环创建列表

• 格式为：变量名 = [ 要输出成列表的项 for 临时变量 in 序列 for嵌套 if判断]

print([i+1 for i in range(4)])          # for循环结合range
print([i for i in (1, 2, 3, 4)])        # for循环结合元组
print([i+"!" for i in "hello word"])    # for循环结合字符串
print(["@"+i for i in {"a", "b", "c"}]) # for循环结合集合
print([i for i in {"name": "小明", "age": 12}.items()])  # for循环结合字典及其内置所有键值对函数
print([i for i in range(2, 9) if i % 3 == 0])   # for循环结合if判断
print([(i, j) for i in range(1, 4) for j in range(2, 4)])   # for嵌套结合range
my_list = ({"name": "李四", "age": 20}, {"name": "王五", "age": 22})
print([u for u in my_list if u["age"] > 20])   # for循环结合if判断和字典

执行结果为： |[1, 2, 3, 4]
   			|[1, 2, 3, 4]
   			|['h!', 'e!', 'l!', 'l!', 'o!', ' !', 'w!', 'o!', 'r!', 'd!']
   			|['@b', '@c', '@a']
   			|[('name', '小明'), ('age', 12)]
   			|[3, 6]
   			|[(1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3)]
   			|[{'name': '王五', 'age': 22}]

tuple 元组类型

• 格式为：变量名=（2, 2.2, True, "字符串", [列表], (元祖), {字典}）
• 元组可以⼀次性存储多个不同数据，但为了方便循环遍历处理数据，一般放置相同类型的数据
• 凡是用一对小括号（）引起来的内容皆称为元组，为不可变类型
• 若 括号中只有一个数据，数据类型为数据的数据类型，不一定为元组，若想要是元祖类型需要在数据后面加一个逗号
• 列表嵌套：变量名 = ((), (),())， 定义空元祖：变量名 = ()，一个元素的元组：变量名 = (数据,)

元组的常⽤操作

元组为不可变类型，只能重新赋值不可修改，常将列表型数据转化为元组，从而进行数据保存。因此元组除了查询没有其他操作

注意：元组的第一层数据是不可修改的，但如果其中有可变类型，还是可以修改可变类型中的数据的。但一般定义元组就表示数据不可改，所以不要轻易修改元组中的可变类型

查询

序号	方法	说明
1	列表[下标]	索引为根据一个下标，取出一个数据
1	列表[下标范围]	切片为根据一个下标范围，取出多个数据
2	.index（）	由数据找索引 ，无则报错
3	.count（）	由数据查出现次数 ，不能指定范围
4	len（）	由列表数据查字符串长度
5	max（）	在同类型数据中查找到最大值 （“啊”>“A”>“a”>“1”）
5	min（）	在同类型数据中查找到最小值
6	数据 in 元组	判断数据是否在元组中，在返回Ture
6	数据 not in 元组	判断数据是否在元组中，在返回False

dict 字典类型

• 格式为：变量名 = {键1: 值1, 键2: 值2}

• 凡是用一对小括号{}引起来的键值对形式数据皆称为字典，为可变类型

• 字典以键值对的形式存储的数据，键是唯一的，若增加数据时键已存在，则会将原有的值覆v盖

• 定义空字典：变量名 = {} 或 变量名 = dict（）

• 字典一般是储存描述性信息，增加代码的可读性。如：每个学生学号、姓名、年龄等信息

• 字典在python 3.6之前为无序的，在3.6以后方才改为有序字典

• 因字典之前为无序的，因此无法使用下标进行索引和切片，只能通过key对其索引

字典的常⽤操作

字典为可变类型，使用以下常用操作内存地址不会发生变化

序号	方法	说明
获取数据	字典[键]	根据指定键获取对应值，若键不存在报错
获取数据	.get(键, 默认值)	根据指定键获取对应值，若键不存在，返回默认值
添加和修改元素	字典[键] = 值	键不存在为增加，存在为修改
删除	del或del ()	带下标删字典指定键数据，不带下标删字典
删除	.pop()	删除指定下标的数据(默认为最后⼀个)，并返回删除的数据
清空	.clear()	清空字典所有数据，返回空列表
查长度	len()	测量字典中，键值对的个数
所有键	.keys()	返回一个包含字典所有键的列表
所有值	.values()	返回一个包含字典所有值的列表
所有键值对	.items()	返回一个包含字典所有键值对（元组形式表示） 的列表
合并字典	字典1.update(字典2)	将字典2中的键值对更新到字典1中（键无则添加，有则更新值）
由值排序	sorted	sorted(字典.items()，key = lambda x:x[1])

获取数据

1.键索引

• 格式：字典[键]
• 索引存在的键，返回键值对中的值
• 索引存不在的键，会发生异常

2 .get()

• 在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值
• 格式：字典.get(键, 默认值)
• 索引存在的键，无论是否有默认值，都返回原字典中键值对中的值
• 索引不存在的键和默认值，获取到None，不会出现异常
• 索引不存在的键，但有默认值，会返回默认值

info = {'name': '周瑜', 'age': 18}
print(info['name']) 
print(info['sex'])  
print(info.get('age', 20)) 
print(info.get('sex'))
print(info.get('sex', "男")) 

执行结果为：|周瑜
		   |KeyError: 'sex'
		   |18
		   |None
		   |男

添加和修改元素

• 格式：字典[键] = 值 添加后的格式键：值
• 当新增的键不存在时，表示增加数据（键值对）
• 当新增的键存在是，则表示修改原字典的相同键的值。（因为字典中的键是唯一的）

info = {'name': '周瑜', 'age': 18}
info["sex"] = "男"  # 键"sex"原字典中不存在，为添加数据
info["age"] = 22   # 键"age"原字典中存在，为添加数据
print(info)

执行结果为：|{'name': '周瑜', 'age': 22, 'sex': '男'}

update() 字典合并

• 格式：字典1.update(字典2)
• 将字典2中的键值对更新到字典1中（字典2中不重复键的键值对添加到字典1中，重复键的值更新到字典1中）

info1 = {'name': '周瑜', 'age': 18}
info2 = {"sex": "男", 'age': 22}
info1.update(info2)
print(info)

执行结果为：|{'name': '周瑜', 'age': 22, 'sex': '男'}

删除

1. del 带下标删字典指定键数据，不带下标删字典

分为函数和关键字两种删除方式
1.关键字形式（常用）

• 格式为：del 字典[键] 或 del 字典 前者为删除字典指定下标位置数据，后者为删除整个字典

2.函数形式

• 格式为：del（字典[键]） 或 del（字典） 前者为删除字典指定下标位置数据，后者为删除整个字典

name_dict = {"name": "小明", "age": 20, "sex": "男"}
del name_dict["sex"]  # del(name_dict["sex"])
print(name_dict)
del name_dict     # del(name_dict), 删除后不能访问
print(name_dict)

执行结果为：|{'name': '小明', 'age': 20}
		   |NameError: name 'name_dict' is not defined

2. pop()：删除指定下标的数据(默认为最后⼀个)，并返回删除的数据

• 格式为：变量 = 字典.pop(指定键)
• 有返回值（指定键对应的值），需要有变量接受，否则得不到删掉的数据
• 必须指定一个存在的键，后则会报错

name_dict = {"name": "小明", "age": 20, "sex": "男"}
deldata = name_dict.pop("sex")
print(deldata)
print(name_dict)

执行结果为：|男
   	   	   |{'name': '小明', 'age': 20}

set 集合数据

• 格式为：变量名 = {值1, 值2}
• 集合为可变类型，但不可承载可变类型，其中只能承载数字型数据、字符串、元祖。
• 其中数据不能重复，若其它类型（列表、元祖）转变时会去重。
• 不能通过下标取值和切片
• 凡是用一对小括号{}引起来的非键值对数据皆称为集合
• 定义空集合：变量名 = set() 而非 变量名 = {}
• 一般用于列表数据的去重和两个序列的交并总差

# 1. 快速去重
list1 = [1, 2, 3, 7, 2, 1]
print(list(set(list1)))
执行结果为：|[1, 2, 3, 7]

# 2. 取交集：共有的部分
a = {11,22,33,44,55}
b = {22,44,55,66,77}
print(a&b)
执行结果为：|{22, 44, 55}

# 3. 取并集：总共的部分
print(a|b)
执行结果为：|{11, 22, 33, 44, 55, 66, 77}

# 4. 差集：另一个集合中没有的部分
print(a-b)               # a - b
执行结果为：|{11, 33}     # {66, 77}  

# 5. 取不同，即对称差集(在 a 或 b 中，但不会同时出现在二者中) 
print(a ^ b)
执行结果为：|{11, 33, 66, 77}

数据类型转换

函数	说明	要求
int(x)	将x转换为一个十进制整数	只含整数的字符串、float型（只留下整数部分，舍弃小数部分）和bool型
float(x)	将x转换为一个浮点数	只含数的字符串、float型和bool型
str(x)	将对象 x 转换为字符串	all
tuple(s)	将序列 s 转换为一个元组	str型（会将其按顺序展开）、list型、set型（无序去重记录）、dict型（按顺序记录键，不记录值）
list(s)	将序列 s 转换为一个列表	str型（会将其按顺序展开）、tuple型、set型（无序去重记录）、dict型（按顺序记录键，不记录值）
eval(str)	计算字符串中有效Python表达式	包含有效表达式的字符串， 返回值为一个对象
repr(x)	将对象 x 转换为表达式字符串
chr(x)	将整数x转换为Unicode字符
ord(x)	将字符x转换为它的ASCII整数值
hex(x)	将整数x转换为十六进制字符串
oct(x)	将整数x转换为八进制字符串
bin(x)	将整数x转换为二进制字符串