代码收藏家 Python 数据类型必知知识点
1.整数数据类型（int）
整数，没有小数点的部分，包括正整数、负整数、0这些。
在Python中，存储整数的数据类型只有一种，那就是整数数据类型。
Python中的整型的取值范围是无限的！也就是说，整数具有无限的精度。
1.1 不同进制的表示
（1）使用十进制形式的整数时，不能以 0 （数字零）作为开头，除非这个数字本身就是 0
运行结果：
（2）八进制形式，由 0~7 共八个数字组成，以0o或0O开头（注意，第一个符号是数字 0，第二个符号是小写字母 o 或大写字母 O）
运行结果：
（3）二进制形式，由 0 和 1 两个数字组成，书写时以0b或0B开头（注意，第一个符号是数字 0，第二个符号是小写字母 b 或大写字母 B）
运行结果：
（4）十六进制形式，由 0-9 十个数字以及 A-F（或 a~f）六个字母组成，书写时以0x或0X开头（注意，第一个符号是数字 0，第二个符号是小写字母 x 或大写字母 X）
运行结果：
1.2 不同进制间的转换
二进制：bin()
八进制：oct()
十六进制：hex()
只需在对应括号内写入要转换的值即可，例：
运行结果：
1.3 数字分隔符
数字分隔符，在 Python 中使用下划线_作为数字的分隔符，可以提高数字的可读性，且不会影响数字本身的值
运行结果：
2.浮点数据类型（flaot）
浮点类型必须带有小数部分
2.1 十进制表示形式
x = 12.0
y = 12.12.2 指数表示形式
Python 小数的指数表示形式，如下所示：
mEe 或 mee 等价于 m x Base^e说明：
m 为尾数（Mantissa）部分，是一个十进制数；
e (最后那个 e )为指数（Exponent）部分，是一个十进制整数；
E 或 e （中间的 E 或 e）是固定的字符，可以是大写的或者小写的，用于分割尾数部分和指数部分。整个表达式等价于 a×10^n。
Base 为基，Base 等于10。
实例如下所示：
22.1E1 = 22.1 x 10^1 # 其中 22.1 是尾数，1 是指数。
44E-2 = 44 x 10^-2 # 44 是尾数，-2 是指数 注意事项：
只要写成指数的形式，就是小数。 即使最终值看起来像一个整数。如下所示：
>>> type(44E2)
<class 'float'>3.字符串类型（str）
字符串是由 Unicode 码位构成的不可变序列。
简单理解，若干个字符（可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字）的集合就是一个字符串。
字符串字面值有多种不同的写法，如下所示：
单引号: '允许包含有 "双" 引号'。
双引号: "允许包含有 '单' 引号"。
三重引号: '''三重单引号'''，"""三重双引号"""。使用三重引号的字符串可以跨越多行，其中所有的空白字符都将包含在该字符串字面值中。
3.1 字符串的定义
字符串是 Python 中最常用的数据类型。
我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
str1 = 'hello world'
str2 = "hello world"
str3 = '''hello world'''
str4 = """hello world"""
print(str1) # <class 'str'>
print(str2) # <class 'str'>
print(str3) # <class 'str'>
print(str4) # <class 'str'>运行结果：
使用单引号情况
str1 = 'I'm Yixiao'运行结果：
说明：
字符串的定义代码出现了语法错误（SyntaxError）。
单引号在字符串定义中必须成对出现，而且Python解析器在解析代码时，会自动认为第一个单引号和最近的一个单引号是一对！
如果一定要在单引号中在放入一个单引号，必须使用反斜杠进行转义：
str1 = 'I\'m Yixiao'
print(str1)或使用双引号：
print('_'*20)
str2 = "I'm Yixiao"
print(str2)运行结果：
建议：在Python中，如果存在多个引号
① 单引号放在双引号中；
② 双引号放在单引号中。
3.2 字符串输入
在Python代码中，我们可以使用input()方法来接收用户的输入信息。
注意：在Python中，input()方法返回的结果是一个字符串类型的数据。
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')
print(name, age, address)
说明：
input()可以阻断当前正在执行的代码，让系统处于等待状态，直到用户输入完成。
input()方法接收到的所有数据，返回的数据类型都是字符串。
3.3 字符串的输出
3.3.1 普通输出
print(变量名称)
print(变量名称1, 变量名称2, 变量名称3)3.3.2 格式化输出
（1） 百分号
name = input('请输入您的姓名：')
age = int(input('请输入您的年龄：'))
address = input('请输入您的住址：')
print('我的名字是%s，今年%d岁了，家里住在%s...' % (name, age, address))（2）format方法
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')
print('我的名字是{}，今年{}岁了，家里住在{}...'.format(name, age, address))（3）f形式
name = input('请输入您的姓名：')
age = input('请输入您的年龄：')
address = input('请输入您的住址：')
print(f'我的名字是{name}，今年{age}岁了，家里住在{address}...')延伸：
name = input('请输入您购买商品的名称：')
price = float(input('请输入您购买商品的价格：')) # 18.5
print(f'购买商品名称：{name}，商品价格：{price:.2f}')在Python的f-string中，:.2f是一种格式化指令，用于控制浮点数的输出格式。
.后面的数字2表示保留两位小数。f表示浮点数。
因此，:.2f将把浮点数格式化为保留两位小数的形式。
3.4 长字符串
由三个双引号"""或者三个单引号'''包围的字符串，被称为 Python 长字符串。
简单理解，长字符串，就是可以直接换行（不用加反斜杠\）书写的字符串。
当程序中有大段文本内容需要写成字符串时，建议使用长字符串形式，因为长字符串形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。
语法格式如下所示：
"""长字符串内容"""
'''长字符串内容'''在讲 Python 注释时有讲到可以使用三个单引号或者三个双引号对多行内容进行注释，这其实就是 Python 的长字符串。
如果长字符串没有赋值给任何变量，那么这个长字符串就不会起到任何作用，和一段普通的文本无异，相当于注释（注意：Python 解释器并不会忽略长字符串，同样会按照语法解析，只不过长字符串没有实际作用）。
3.5 原始字符串
在普通字符串或者长字符串的开头加上 r 前缀，就变成了原始字符串。
在原始字符串中，反斜杠 \ 不会被当作转义字符，所有的内容都会保持原来的样子。
在Python中，如果你想让一个字符串被解析为原始字符串，可以在字符串前加上一个小写的'r'。
这样，字符串内的所有字符就会被视为字面意义，而不会被转义。
这对于需要避免转义字符（如换行符\n，制表符\t等）的字符串非常有用。
语法格式如下所示：
str1 = r'原始字符串内容'
str2 = r"""原始字符串内容"""举例如下所示：
str_demo = 'D:\Data\Tools\Python382\python.exe'
print(str_demo)报错：SyntaxWarning: invalid escape sequence '\D'（无效转义序列 '\D'）。
在Python字符串中，反斜杠\是一个特殊字符，被用作转义字符。这意味着它被用来引入特殊字符序列。例如，\n代表一个新行，\t代表一个制表符等。
在你的代码中，你试图将一个包含文件路径的字符串赋值给str_demo。这个字符串中的反斜杠\被Python解释为转义字符，但\D并不是一个有效的转义序列。
解决这个问题的方法有两种：
方法一：使用原始字符串。在字符串前面加上r前缀，可以使得反斜杠被视为普通的字符而不是转义字符。这是代码示例：
str_demo = r'D:\Data\Tools\Python382\python.exe'
print(str_demo)运行结果：
D:\Data\Tools\Python382\python.exe方法二：使用双反斜杠。在每个反斜杠前再加一个反斜杠，可以使得它被视为一个普通的字符。这是代码示例：
str_demo = 'D:\\Data\\Tools\\Python382\\python.exe'两种方法都可以解决你的问题，你可以选择你觉得更方便的那种。
· 处理原始字符串中的引号问题
普通格式的原始字符串中如果出现了引号，是需要对引号进行转义的。否则 Python 照样无法对字符串的引号精确配对。
但是，又和普通字符串有所不同，此时用于转义的反斜杠会变成字符串内容的一部分。
注意：Python 原始字符串中的反斜杠仍然会对引号进行转义，因此原始字符串的结尾处不能有反斜杠，否则字符串结尾处的引号会被转义，导致字符串不能正确结束。
举例如下所示：
str_demo = r'I\'m CodeFarmer'
print(str_demo)运行结果：
以上问题有两种解决办法：
第一种：用长字符串或不同引号，不要使用原始字符串。
第二种：单独书写反斜杠。
举例如下所示：
# 打印 D:\Data\Tools\Python382\
str_demo = r'D:\Data\Tools\Python382''\\' # 字符串拼接
print(str_demo)运行结果：
3.6 字符串切片
所谓的切片是指对操作的对象截取其中一部分的操作。
字符串、列表、元组都支持切片操作。
字符串切片基本语法：
口诀：顾头不顾尾。
序列名称[开始位置下标:结束位置下标:步长(步阶)]
numstr = '0123456789'
numstr[0:3:1] # 012 => range方法非常类似，步长：每次前进1步
numstr[0:3:2] # 02 => 每次前进2步说明：
步长可以为负数，正数代表从左向右截取，负数代表从右向左截取
不包含结束位置下标对应的数据， 正负整数均可；
步长是选取间隔，正负整数均可，正数从左向右，负数从右向左。默认步长为1。
字符串切片小口诀：切片其实很简单，只顾头来尾不管，步长为正正向移，步长为负逆向移。
3.7 字符串中的查找方法
所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
基本语法格式：
字符串.find(要查找的字符或者子串)
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | find() | 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。 |
| 2 | index() | 检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。 |
3.7.1 find()方法
作用：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。
# 定义一个字符串
str1 = 'hello world hello linux hello python'
# 查找linux子串是否出现在字符串中
print(str1.find('linux'))
# 在str1中查找不存在的子串
print(str1.find('and'))案例：使用input方法输入任意一个文件名称，求点号的索引下标。
filename = input('请输入您要上传文件的名称：')
# 获取点号的索引下标
index = filename.find('.')
print(index)
# 求文件名称
print(filename[:index])
# 求文件后缀
print(filename[index:])3.7.2 index()方法
index()方法其功能与find()方法完全一致，唯一的区别在于当要查找的子串没有出现在字符串中时，find()方法返回-1，而index()方法则直接报错。
str1 = 'apple, banana, orange'
# 判断apple是否出现在字符串str1中
print(str1.index('apple'))
print(str1.index('pineapple'))运行结果：
3.8 字符串的修改方法
所谓修改字符串，指的就是通过函数（方法）的形式修改字符串中的数据。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | replace() | 返回替换后的字符串 |
| 2 | split() | 返回切割后的列表序列 |
| 3 | title() | 所有单词首字母大写 |
| 4 | upper()与lower() | 返回全部大写或小写的字符串 |
3.8.1 replace()方法
基本语法：
字符串.replace(要替换的内容, 替换后的内容, 替换的次数-可以省略)
案例：编写一个字符串，然后把字符串中的linux替换为python
str1 = 'hello linux and hello linux'
# 把字符串中所有linux字符替换为python
print(str1.replace('linux', 'python'))
# 把字符串中的第一个linux进行替换为python
print(str1.replace('linux', 'python', 1))
# 把and字符串替换为&&
print(str1.replace('and', '&&'))replace主要用于实现关键字替换或过滤功能。
3.8.2 split()方法
作用：对字符串进行切割操作，返回一个list()列表类型的数据。
str1 = 'apple-banana-orange'
print(str1.split('-'))3.8.3 join()方法
作用：和split()方法正好相反，其主要功能是把序列拼接为字符串。
字符串.join(数据序列)
案例：把水果列表['apple', 'banana', 'orange']拼接成'apple-banana-orange'。
list1 = ['apple', 'banana', 'orange']
print('-'.join(list1))3.8.4 upper()与lower() 方法
upper()：把字符串全部转换为大写形式
lower()：把字符串全部转换为小写形式
# 用户名以及密码验证案例
username = input('请输入您的账号：')
password = input('请输入您的密码：')
# 把username和password全部转换为大写或小写
print(username.lower())
print(password.upper())3.9 字符串的判断方法
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | startswith() | 检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。 |
| 2 | endswith() | 检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。 |
3.9.1 startswith()
作用：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
str1 = 'python program'
print(str1.startswith('python'))3.9.2 endswith()
作用：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
str2 = 'avatar.png'
print(str2.endswith('.png'))
if str2.endswith('.png') or str2.endswith('.jpg') or str2.endswith('.gif'):
print('是一张图片格式的图片')
else:
print('您上传的文件格式异常')4.布尔类型（bool）
Python 布尔类型，在 Python 中用 bool表示。
bool 类是 int 类的子类。
布尔类型提供了两个布尔值来表示真（对）或假（错），在 Python 中分别用 True（真或对）或False（假或错）来表示。
True 和 False 是 Python 的关键字，在使用时，一定要注意首字母要大写，否则解释器会报错。
如下代码所示： 例一，
print(True) # True 首字母要大写
print(False) # False 首字母要大写
print(type(True)) # 查看 True 的类型
print(type(False)) # 查看 False 的类型
运行结果：
例二，
print(true) # True 首字母小写，会报错运行结果：
4.1 注意事项
bool 类是 int 类的子类，其他类不能继承它，它只有 False 和 True 两个实例。
在 Python 中，任何对象都可以进行真假值的判断。如下例一所示。
布尔类型的布尔值可以当做整数对待，但在日常开发中是不建议这么用的，实属不妥。 布尔值可以当做整数来对待，即 True 相当于整数值 1，False 相当于整数值 0。如例二所示：
例一，
print(4 > 3)
print(2 > 4)运行结果：
例二，
print(True + 2)
print(True - 2)
print(False + 2)运行结果：
5.列表类型（list）
列表是可变序列，通常用于存放同类项目的集合（其中精确的相似程度将根据应用而变化）。
列表将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，element1 ~ elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。
列表可以存储整数、小数（浮点数）、布尔值、复数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。
列表数据类型，在 Python 中用list表示，可以用type()函数查看。
列表的语法格式：
listname = [element1 , element2 , element3 , ... , elementn] # 包含多个元素的列表
emptylist = [] # 一个元素都没有的列表，称为空列表对以上格式说明：
listname ：变量名。创建完列表后，通常会把列表赋值给一个变量，便于调用列表。
element1 ~ elementn： 表示列表的元素。
使用 [] 直接创建列表：
list1 = ['apple', 'banana', 'pineapple']
# list列表类型支持直接打印
print(list1)
# 打印列表的数据类型
print(type(list1)) # <class 'list'>5.1 创建列表的其他方式
使用 list() 内置函数创建列表，其实就是将其它数据类型转换为列表类型。
# 将字符串转换成列表
list_demo1 = list('你好！')
print(list_demo1)
# 将元组转换成列表
tuple_demo1 = ('python', 'java', 'php', 'c')
list_demo2 = list(tuple_demo1)
print(list_demo2)
# 创建空列表
list_demo3 = list()
print(list_demo3)运行结果
5.2 访问列表元素
5.2.1 使用索引访问列表元素
语法格式如下所示：
listname[index]对以上格式说明，
listname：表示列表名字。
index：表示索引值。Python 支持正索引和负索引。
举例如下所示：
list_demo4 = ['1234567', 'abcdefg', 'HELLO']
print('list_demo4[0] =', list_demo4[0])
print('list_demo4[1] =', list_demo4[1])
print('list_demo4[2] =', list_demo4[2])
print('list_demo4[-1] =', list_demo4[-1])
print('list_demo4[-2] =', list_demo4[-2])
print('list_demo4[-3] =', list_demo4[-3])运行结果：
5.2.1 使用切片访问列表元素
格式如下所示：
listname[start: end: step]对以上格式说明，
lsitname：表示列表名字。
start：表示开始索引。
end：表示结束索引。
step：表示步长。
各个参数的使用比较灵活，详情 举例如下所示：
list_demo5 = [1, 2, 3, 4, 5, 6]
print('list_demo5[::] =', list_demo5[::]) # 三个参数都不写
print('list_demo5[:2:2] =', list_demo5[:2:2]) # 不写 start 参数
print('list_demo5[1::2] =', list_demo5[1::2]) # 不写 end 参数
print('list_demo5[1:2:] =', list_demo5[1:2:]) # 不写 step 参数
print('list_demo5[1:4:2] =', list_demo5[1:4:2])
print('list_demo5[1:4:3] =', list_demo5[1:4:3])
print('list_demo5[1:2] =', list_demo5[1:2]) # 不要 step 参数
# 不要 step 参数
print('list_demo5[:] =', list_demo5[:])
print('list_demo5[1:] =', list_demo5[1:])
print('list_demo5[2:] =', list_demo5[2:])
print('list_demo5[:1] =', list_demo5[:1])
print('list_demo5[:2] =', list_demo5[:2])
print('list_demo5[1:3] =', list_demo5[1:3])
运行结果：
5.3 列表基本操作
5.3.1 增（添加列表元素）
列表，元组，字符串，数字都可以添加到列表中，列表与列表间可以使用“+”合并。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | append() | 增加指定数据到列表中 |
| 2 | extend() | 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表 |
| 3 | insert() | 指定位置新增数据 |
append()方法
格式如下所示：
listname.append(obj)对以上格式说明，
append()： append()方法会在列表中添加元素，要注意的是：append()添加的元素在列表的末尾。
listname：表示要添加元素的列表。
obj：表示要添加到列表末尾的数据。obj如果是列表或元组，会将列表或元组当做一个整体作为要添加元素列表的一个元素，形成一个包含列表或元组的“新列表”（“新列表”指的是列表内存地址没变，元素更新了）。
注意：列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。
extend()方法
格式如下所示：
listname.extend(obj)对以上格式说明，
extend()：extend()会在列表中添加元素，要注意的是extend()添加的元素在列表的末尾。这一点跟append()方法一致。
listname：要添加元素的列表。
obj：obj表示要添加到列表末尾的数据。要注意的是：会与append()方法不同，append()方法会将字符串、列表或元组当做一个整体作为要添加元素列表的一个元素，形成一个包含字符串、列表或元组的“新列表”（“新列表”指的是列表内存地址没变，元素更新了）；而extend()方法会将它们包含的元素逐个添加到列表中，不会将它们视为一个整体哦。
insert()方法
格式如下所示：
listname.insert(index , obj)对以上格式说明，
insert()：insert()方法可以在列表中间某个（指定位置）位置插入元素。append()、extend()方法只能在列表末尾插入元素。
listname：表示要插入元素的列表。
index：表示指定位置的索引值。
obj：要插入列表的数据。如果插入的数据是列表或元组，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，在这一点上和 append()方法是一样的。
5.3.2 删（删除列表元素）
Python 自带的有垃圾回收机制，对于创建好的列表，如果不再使用，Python 会自动将其回收。
当然，也可以手动进行删除。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | del 列表[索引] | 删除列表中的某个元素 |
| 2 | pop() | 删除指定下标的数据(默认为最后一个)，并返回该数据 |
| 3 | remove() | 移除列表中某个数据的第一个匹配项。 |
| 4 | clear() | 清空列表，删除列表中的所有元素，返回空列表。 |
del方法
使用格式如下所示：
del listname[index] # 删除列表中的单个元素
del listname[start : end] # 删除列表中某段连续的元素，del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。 对以上格式说明，
listname表示要删除元素的列表。
index表示要删除元素的索引值。
start表示起始索引值。
end表示结束索引值。
pop()方法
使用格式如下所示：
listname.pop(index)对以上格式说明，
listname表示要删除元素的列表。
index表示要删除元素的索引值。如果不写 index 参数，默认会删除列表中的最后一个元素。
remove()方法
使用格式如下所示：
listname.remove(element)对以上语法格式说明：
remove()：remove()方法会根据元素本身的值进行删除。要注意的是：①该方法只会删除遇见的第一个指定元素，如果列表中还有相同的元素是不会被删除的；②必须保证要删除的元素在列表中是存在的，否则会报错。
listname：要删除元素的列表。
element：要删除的元素。
clear()方法
使用格式如下所示：
listname.clear()对以上格式说明，
clear()： clear()方法会删除列表中的所有元素。
listname：要删除所有元素的列表。
5.3.3 改（修改列表元素）
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 列表[索引] = 修改后的值 | 修改列表中的某个元素 |
| 2 | reverse() | 反转列表中的元素顺序 |
| 3 | sort() | 升序排序(从小到大) |
列表[索引]
格式如下所示：
listname[index] = element对以上格式说明，
listname：要修改元素的列表。
index：要修改元素对应的索引值。
element：新元素值。
reverse()方法
格式如下所示：
listname.reverse()对以上格式说明，
reverse()： reverse()方法会反转列表中的所有元素。
listname：要反转所有元素的列表。
sort()
使用格式如下所示：
listname.sort(*, key=None, reverse=False)对以上格式说明，
sort()：sort()方法会对列表进行原地排序，即修改原列表。
sort()方法接受两个仅限以关键字形式传入的参数。
key：指定带有一个参数的函数，用于从每个列表元素中提取比较键 (例如 key=str.lower)。 对应于列表中每一项的键会被计算一次，然后在整个排序过程中使用。 默认值 None 表示直接对列表项排序而不计算一个单独的键值。
reverse：reverse 为一个布尔值。默认为False，表示升序排序。 如果设为 True，则每个列表元素将按反向顺序（降序）比较进行排序。
5..3.4 查（查找列表元素）
列表在计算机中的底层存储形式，列表和字符串一样，在计算机内存中都占用一段连续的内存地址，我们向访问列表中的每个元素，都可以通过"索引下标"的方式进行获取。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | index() | 指定数据所在位置的下标 |
| 2 | count() | 统计指定数据在当前列表中出现的次数 |
| 3 | in | 判断指定数据在某个列表序列，如果在返回True，否则返回False |
| 4 | not in | 判断指定数据不在某个列表序列，如果不在返回True，否则返回False |
index()方法
使用格式如下所示：
listname.index(obj, start, end)对以上格式说明，
返回值：index()方法返回某个元素在列表中出现的位置（索引）。如果查找的元素不存在，会报错。
listname：表示列表名称。
obj：表示要查找的元素。
start：表示起始位置。可以不写，表示检索从开头到end（不包括end）的元素。
end：表示结束位置。可以不写，表示检索从start到末尾的元素。
start和end可以都不写，表示检索整个列表；都写，表示检索start和end（不包括end）之间的元素。
count()方法
使用格式如下所示：
listname.count(obj)对以上格式说明，
count()方法的返回值：count()方法返回某个元素在列表中出现的次数。如果返回 0，表示列表中不存在该元素。
listname：表示列表名。
obj：表示要统计的元素。
in方法
list_1 = ['张三','李四']
if '张三' in list_1:
print('张三在')
else：
print('张三不在')not in 与in方法是相反的，使用方式一样
6.元组类型（tuple）
元组是由一系列按特定顺序排序的元素组成的序列结构。
元组的所有元素都放在一对小括号( )（小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组）中，相邻元素之间用逗号,分隔（通常还会在逗号后加一个空格），可以存储数字、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同，元素的个数没有限制。
通常情况下，元组用于储存异构数据的多项集（例如：由 enumerate() 内置函数所产生的二元组）。 元组也被用于需要同构数据的不可变序列的情况（例如：允许存储到 set 或 dict 的实例）。简单理解，元组用于保存无需修改的内容。
注意：如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型。
基本语法：
# 多个数据元组
tuplename = (element1, element2, ..., elementn)
# 单个数据元组
tuple2 = (element,)
# 空元组
tuplename1 = () 对以上格式说明，
tuplename：变量名（元组名称）。创建好元组后，通常会将元组赋值给一个变量，便于后面的再次使用。
element1 ~ elementn：表示元组的元素。
元组的所有元素都放在一对小括号( )中，但是，小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。
如果创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。
请注意：决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。
6.1 创建元组的其他方式
使用 tuple() 内置函数创建元组，其实就是将其它数据类型转换为元组类型。
使用格式如下所示：
tuple(data)
对以上格式说明，
tuple()：tuple() 内置函数可以将其它数据类型转换为元组类型。
data：表示可以转化为元组的数据（字符串、元组、range 对象等）。
举例如下所示：
str_demo = '欢迎来到一笑的博客' # 字符串
list_demo = [1, 2, 3, 4, 5] # 列表
range_demo = range(1, 7) # range 区间
print(tuple(str_demo)) # 将字符串转换为元组
print(tuple(list_demo)) # 将列表转换为元组
print(tuple(range_demo)) # 将 range 区间转换为元组
print(tuple()) # 空元组 运行结果：
6.2 元组的基本操作
6.2.1 查（查找元组元素）
由于元组中的数据不允许直接修改，所以其操作方法大部分为查询方法。
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | 元组[索引] | 根据索引下标查找元素 |
| 2 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同 |
| 3 | count() | 统计某个数据在当前元组出现的次数 |
| 4 | len() | 统计元组中数据的个数 |
元组[索引]
使用索引访问元组元素的格式为：
tuplename[index]对以上格式说明，
tuplename：表示元组名字。
index：表示索引值。可以是正数，也可以是负数。
tuplename[index]：得到的是一个元素的值。
使用切片访问元组元素的格式为：
tuplename[start : end : step]对以上格式说明，
tuplename：表示元组名字。
start：表示起始索引。可以是正数，也可以是负数。
end：表示结束索引。可以是正数，也可以是负数。
step：表示步长。可以不写步长，默认值为 1 。
tuplename[start : end : step]：得到的是一个新的子元组。
index()方法
格式：
列表名.index(列表元素)count()方法
格式：
列表名.count(列表元素)len()方法
格式：
len(列表名)6.2.2 改（修改元组）
替换法
替换法修改元组，指的是创建一个新的元组去替代旧的元组。因为元组是不可变序列，元组中的元素不能被修改。
举例如下所示：
tuple_demo = (1, 2, 3, 4, 5, 6, 7, 8)
print('修改前 tuple_demo =', tuple_demo)
print('修改前 tuple_demo 元组 id:', id(tuple_demo)) # id()函数返回值为内存地址的唯一标识
tuple_demo = ('hello', ',', 'word!')# 修改元组，即对元组变量进行重新赋值
print('修改后 tuple_demo =', tuple_demo)
print('修改后 tuple_demo 元组 id:', id(tuple_demo))运行结果：
从 id 标识可以看出（id 不同），修改后与修改前不是同一个元组。
拼接法
拼接法修改元组，指的是通过连接多个元组，使用+加法运算符拼接元组的方式向元组中添加新元素。
举例如下所示：
tuple_demo1 = (1, 2, 3)
tuple_demo2 = (6, 7, 8)
tuple_demo3 = tuple_demo1 + tuple_demo2 # 使用 + 加法运算符拼接元组
print('修改前 tuple_demo1 =', tuple_demo1)
print('修改前 tuple_demo2 =', tuple_demo2)
print('修改前 tuple_demo1 元组 id:', id(tuple_demo1))
print('修改前 tuple_demo2 元组 id:', id(tuple_demo2))
print('-----------------------------------------')
print('拼接后 tuple_demo3 =', tuple_demo3)
print('拼接后 tuple_demo3 id 为：', id(tuple_demo3))运行结果：
从 id 标识可以看出（id 不同），使用+拼接元组以后， 生成的是一个新的元组。
6.2.3 删（删除元组）
Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 关键字来手动删除。
手动删除不用的元组，举例如下所示：
tuple_demo = (1, 2, 3, 4, 5, 6, 7, 8)
print('删除前 tuple_demo =', tuple_demo)
del tuple_demo # 使用 del 关键字删除元组
print('删除后 tuple_demo =', tuple_demo)运行结果：
因为成功删除了元组tuple_demo，所以在输出删除后会报错。
7.字典类型（dict）
mapping 对象会将 hashable 值映射到任意对象。 映射属于可变对象。
目前仅有一种标准映射类型字典。
Python 字典（dict）是一种无序的、可变的序列，元素以“键值对（key-value）”的形式存储。
字典的键“几乎”可以是任何值。 非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键。 数字类型用作键时遵循数字比较的一般规则：如果两个数值相等 (例如 1 和 1.0) 则两者可以被用来索引同一字典条目。 （注意：由于计算机对于浮点数存储的只是近似值，因此将其用作字典键是不明智的。） 字典中的键必须唯一，不支持同一个键出现多次，否则只会保留最后一个键值对。
特点：
① 符号为大括号（花括号） => {}。
② 数据为键值对形式出现 =>{key:value}，key：键名，value：值，在同一个字典中，key必须是唯一（类似于索引下标）。
③ 各个键值对之间用逗号（英文）隔开。
使用{ } 创建字典的语法格式如下所示：
dict_demo1 = {} # 直接使用 {} 创建空字典
dict_demo2 = dict() # 使用 dict() 内置函数创建空字典dictname = {'key1': 'value1', 'key2': 'value2', ..., 'keyn': 'valuen'}对以上格式说明，
dictname： 表示字典变量名。
keyn: valuen： 表示各个元素的键值对。注意：同一字典中的各个键必须唯一，不能重复，否则只会保留最后一个键值对。
字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
7.1 创建字典的其他方式
7.1.1 通过 fromkeys() 方法创建字典
dict 对象提供 fromkeys(list，value=None) 方法创建带有默认值的字典。 通常用于初始化字典（设置 value 的默认值）。
使用格式如下所示：
dictname = dict.fromkeys(list，value=None)对以上格式说明，
dictname：fromkeys() 方法的返回值（创建好的字典）会赋值给变量 dictname。
list：list 参数表示要创建的字典中所有键组成的列表。
value：value 参数表示要创建的字典的元素的值的默认值，所有元素的值都为这个默认值；如果不写，则为空值 None。
list1 = ['Q', 'W', 'E', 'R']
dict_demo1 = dict.fromkeys(list1) # 不写 value 参数，则为空值 `None`
dict_demo2 = dict.fromkeys(list1,'1')
print(dict_demo1)
print(dict_demo2)运行结果：
7.1.2 通过 dict() 映射函数创建字典
举例如下所示：
# 字符串类型的 键 不能带引号，否则会报错
dict1 = dict(Q='1', W='2', E='3', R="4")
print('dict1 =', dict1)
# 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。
dict2 = dict([('Q', '1'), ('W', '2'), ('E', '3'), ('R', '4')])
print('dict2 =', dict2)
# 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。
keys = ['Q', 'W', 'E', 'R']
values = ['1', '2', '3', '4']
dict3 = dict(zip(keys, values))
print('dict3 =', dict3)运行结果：
7.2 字典基本操作
7.2.1 增
向 Python 字典添加键值对，直接给不存在的 key 赋值即可。
使用语法格式如下所示：
dictname[key] = value对以上格式说明：
dictname： 表示字典名称。
key： 表示新的键。
value： 表示新的值，只要是 Python 支持的数据类型都可以。
7.2.2 删
删除整个字典
dict_demo = dict(Q='1', W='2', E='3', R="4")
print('删除前 dict_demo =', dict_demo)
del dict_demo # 删除字典操作
print('删除后 dict_demo =', dict_demo)运行结果：
del 字典名称[key]：删除指定元素
dict_demo = dict(Q='1', W='2', E='3', R="4")
print('删除前 dict_demo =', dict_demo)
del dict_demo['Q'] # 删除字典中Q元素
print('删除后 dict_demo =', dict_demo)运行结果：
clear()方法：清空字典
dict_demo = dict(Q='1', W='2', E='3', R="4")
print('删除前 dict_demo =', dict_demo)
dict_demo.clear() # 清空字典
print('删除后 dict_demo =', dict_demo)运行结果：
7.2.3 改
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。
基本语法格式：
字典名称[key] = value
注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。7.2.4 查
使用具体的某个key查询数据，如果未找到，则直接报错。
字典名[key]查询方法
| 编号 | 函数 | 作用 |
|---|---|---|
| 1 | get(key, 默认值) | 根据字典的key获取对应的value值，如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None |
| 2 | keys() | 以列表返回一个字典所有的键 |
| 3 | values() | 以列表返回字典中的所有值 |
| 4 | items() | 以列表返回可遍历的(键, 值) 元组数组 |
通过键（key）来查询对应的值
使用格式如下所示：
dictname[key]对以上格式说明，
dictname：表示被访问字典的变量名。
key：表示键名。注意：键必须是存在的，否则会抛出异常。
通过 dict 对象提供的 get() 方法访问指定键对应的值
Python 更推荐使用 dict 对象提供的 get() 方法来获取指定键对应的值。
使用格式如下所示：
dictname.get(key[,default])对以上格式说明，
dictname：被访问字典的变量名。
key：表示指定的键。当指定的键不存在时，get() 方法不会抛出异常。
default：用于指定要查询的键不存在时，返回的默认值；如果不手动指定，会返回 None。
keys()提取字典中的所有key
字典名.keys()values()提取字典中的所有value值
字典名.value()使用items()方法提取数据
dict_demo = dict(Q='1', W='2', E='3', R="4")
# 结合for循环对字典中的数据进行遍历
for key, value in dict_demo.items():
print(f'{key}：{value}')运行结果：
判断键值对是否存在
判断字典中是否存在指定键值对：
首先，判断字典中是否有对应的键；
然后，如果键存在，再通过访问字典的方法可以轻易的获取对应的值。
判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符（都是基于 key 来判断的）
dict_demo = dict(Q='1', W='2', E='3', R="4")
print('R' in dict_demo) # 判断字典中是否存在键 'R'
print('R' not in dict_demo) # 判断字典中是否不存在键 'R'运行结果：
8.集合类型（set）
目前有两种内置集合类型，set 和 frozenset。
set 类型：是可变的，其内容可以使用 add() 和 remove() 这样的方法来改变。 由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。
frozenset 类型：是不可变并且为 hashable ，其内容在被创建后不能再改变； 因此它可以被用作字典的键或其他集合的元素。
Python 中的 set 集合，将所有元素放在一对大括号 {} 中，相邻元素之间用 , 分隔。
set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同。
set 集合中的元素都是唯一的，互不相同。并且元素个数没有限制。
在同一集合中，只能存储不可变的数据类型，包括数字、字符串、元组；无法存储列表、set 集合、字典这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
直接使用 {} 创建 set 集合，并把创建好的 set 集合赋值给一个变量，便于以后的使用。
语法格式如下所示：
set_demo1 = {} #直接用{}创建空集合
set_demo2 = set() #使用内置函数set（）创建一个空集合setname = {element1, element2, ..., elementn}对以上格式说明，
set：表示集合的名称。起名时既要符合 Python 命名规范，也要避免与 Python 内置函数重名。同时要“见名知其意”。
element1 - elementn：表示 set 集合元素，个数没有限制。
8.1 创建集合的其他方式
使用 Python 的内置函数 set()创建集合。
其实是将字符串、列表、元组、range 对象等可迭代对象转换成 set 集合。
注意：如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {} 创建 set 集合，Python 解释器会将其视为一个空字典。
使用语法格式如下所示：
setname = set(iteration)对以上格式说明，
iteration：表示字符串、列表、元组、range 对象等可迭代对象。
8.2 集合基本操作
8.2.1 增
add() 方法实现
向 set 集合中添加元素，可以使用 set 类型提供的 add() 方法实现。
注意：使用 add() 方法添加的元素，只能是不可变数据，包含数字、字符串、元组；不能添加列表、集合、字典这类可变的数据，否则 Python 解释器会报 TypeError 错误。
使用语法格式如下所示：
setname.add(element)对以上格式说明，
setname：表示要添加元素的 set 集合。
element：表示要添加到 set 集合中的元素。
update()方法实现
向集合中增加序列类型的数据（字符串、列表、元组、集合、字典）
students = set()
list1 = ['张三', '李四']
students.update(list1)
print(students)运行结果：
students = set()
students.add('张三')
students.add('李四')
# 使用update新增元素
students.update('王五')
print(students)运行结果：
8.2.2 删
del 关键字删除集合
del 集合名remove() 方法删除 set 集合中的指定元素
删除 set 集合中的指定元素，可以使用 remove() 方法。
注意：如果要删除的元素不在集合中，则此方法会抛出 KeyError 错误。此时，可以使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别在于当删除集合中元素失败时，此方法不会抛出任何错误。
使用语法格式如下所示：
setname.remove(element)
对以上格式说明，
setname：要删除元素的 set 集合。
element：表示要删除的元素。
discard() 方法删除
集合名.discard(元素) #删除一个不存在的元素不会报错pop()方法删除
pop()方法：随机删除集合中的某个数据，并返回这个数据。
执行原理：系统自动对集合中的数据进行排序，排序后，pop()方法自动删除第一个元素。
集合名.pop()8.2.3 改
如果需要修改集合中的元素，您需要将其从集合中删除，然后插入新值。
my_set = {1, 2, 3}
my_set.remove(2)
my_set.add(4)
print(my_set) # 输出: {1, 3, 4}8.2.4 查
set 集合中的元素是无序的，因此无法使用索引（下标）访问元素。
in判断某个元素是否在集合中，如果在，则返回True，否则返回False。
not in 判断某个元素不在集合中，如果不在，则返回True，否则返回False。
# 定义一个set集合
s1 = {'张三', '李四'}
# 判断张三是否在s1集合中
if '张三' in s1:
print('张三在s1集合中')
else:
print('张三没有出现在s1集合中')8.3 集合之间的运算
8.3.1 交集运算
set 集合间的交集运算：取两集合公共的元素。 运算符位：&。
案例如下所示：
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
print(A & B)运行结果:
8.3.2 并集运算
set 集合间的并集运算：取两集合全部的元素。 运算符位：|。
举例如下所示：
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
print(A | B)运行结果：
8.3.3 差集运算
set 集合间的差集运算：取一个集合（被减数集合）中另一个集合没有的元素。 运算符位：-。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print('set1 - set2 =', set1 - set2)
print('set2 - set1 =', set2 - set1)运行结果：
8.3.4 对称差集运算
set 集合间的对称差集运算：取集合 A 和 B 中不属于 A&B 的元素。 运算符为：^。
举例如下所示：
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)运行结果：
9.总结
-
列表 (List):
- 特征：有序的可变序列。
- 定义：用方括号
[]表示，元素之间用逗号,分隔。 - 示例：
[1, 2, 3, 'a', 'b', 'c'] - 主要特点：允许重复元素，支持索引访问和切片操作，可以动态增加或删除元素。
-
元组 (Tuple):
- 特征：有序的不可变序列。
- 定义：用圆括号
()表示，元素之间用逗号,分隔。 - 示例：
(1, 2, 3, 'a', 'b', 'c') - 主要特点：允许重复元素，支持索引访问和切片操作，一旦创建便无法修改（immutable）。
-
集合 (Set):
- 特征：无序的可变集合，不包含重复元素。
- 定义：用大括号
{}表示，元素之间用逗号,分隔。 - 示例：
{1, 2, 3, 'a', 'b', 'c'} - 主要特点：不允许重复元素，不支持索引访问和切片操作，可以动态增加或删除元素。集合中的元素是无序的，因此不能通过索引访问。
-
字典 (Dictionary):
- 特征：无序的键值对集合，键必须是唯一的。
- 定义：用大括号
{}表示，每个键值对用冒号:分隔，键与值之间用逗号,分隔。 - 示例：
{'a': 1, 'b': 2, 'c': 3} - 主要特点：键必须是唯一的且不可变（通常是字符串或数值），值可以是任意类型的对象。支持通过键访问值，可以动态增加或删除键值对。
小结：
作者：ઈ一笑ഒ
