python 基本数据类型以及内置方法（有这一篇就够了）
一、数据类型介绍
在 Python 中，数据类型是区分数据的种类和存储方式的标识符。它定义了数据的取值范围、占用空间大小、可操作特性等。Python 中常见的数据类型包括数字、字符串、列表、元组、集合和字典等。
数据类型在编程中的作用主要有以下几个方面：
- 内存空间的管理：不同的数据类型需要占用不同的内存空间，因此在内存空间的管理上，数据类型具有重要的作用。例如，在处理大量数据时，选择合适的数据类型可以有效地减少内存占用，提高程序的执行效率。
- 数据的表达和处理：数据类型定义了数据的表达方式和可操作性，使得程序能够对不同类型的数据进行有效的处理。例如，在处理数值型数据时，使用基本数据类型如 int 和 float 可以进行各种算术运算，而在处理字符串时，使用字符串类型 str 可以对字符串进行切片、连接、替换等操作。
- 代码的可读性和维护性：采用合适的数据类型可以使代码更加清晰、直观，并且易于维护和修改。例如，使用列表类型 list 来表示一组有序数据或使用字典类型 dict 来表示一组键值对数据，在代码中的语义更加明确和易于理解。
- 类型转换和数据校验：在 Python 中，不同的数据类型可以通过相应的内置方法或函数进行类型转换。例如，使用 int() 函数可以将一个字符串转换为整数类型，使用 str() 函数可以将一个数字或其他类型的数据转换为字符串类型。此外，数据类型还可以用于对输入或输出的数据进行校验和验证，以确保数据的正确性和有效性。
综上所述，数据类型在 Python 编程中具有重要的作用，合理地选择和使用数据类型可以提高代码的效率、可读性和可维护性，并确保数据的准确性和完整性。
1.数据类型的区分
Python 常见的数据类型可以分为以下几类：
- 数字型（Number）
- 数字型数据类型包括整型（int）、浮点型（float）、布尔型（bool）和复数型（complex）等。其中，整型用于表示整数，浮点型用于表示浮点数或科学计算中的实数，布尔型用于表示 True 和 False 两个值，复数型用于表示实部和虚部都为浮点数的复数。
- 序列型（Sequence）
- 序列型数据类型包括字符串型（str）、列表型（list）、元组型（tuple）等。其中，字符串型用于表示文本数据，列表型用于表示一组有序的数据，元组型也用于表示一组有序的数据，但是元组是不可变的。此外，还有字节数组（bytearray）和字节串（bytes）两种序列类型，这些序列类型在表示方式和操作方式上有所不同。
- 集合型（Set）
- 集合型数据类型用于表示一组无序的、独特的元素，常用的有集合（set）和不可变集合（frozenset）两种数据类型。
- 映射型（Mapping）
- 映射型数据类型用于表示一种键值对应关系的数据结构，它由键（key）和值（value）组成，常用的是字典（dict）数据类型。
- 可调用型（Callable）
- 可调用型数据类型包括函数和方法，它们可以被调用执行，并且可能会返回结果。
- 迭代器型（Iterator）
- 迭代器型数据类型是一种可迭代对象，并且可以通过 next() 方法遍历元素，常见的有生成器（generator）类型。
根据 Python 的定义，每个变量都有其自身的类型，而数据类型的区分则取决于其值和表现方式。在 Python 编程中，判断一个变量的数据类型可以使用** type() **函数来实现，例如：
x = 3
print(type(x)) # 输出 <class 'int'>
或者可以使用 isinstance() 函数来判断一个变量是否属于某个指定的数据类型，例如：
y = [1, 2, 3]
print(isinstance(y, list)) # 输出 True
综上所述，Python 中的数据类型根据其特点和表现形式进行分类，每个数据类型都有其独特的作用和功能，在编程过程中需要合理选择和使用不同的数据类型。
2.容器类型
在 Python 中，容器（Containers）是可以包含其他对象的对象，比如列表、元组、字典、集合等。以下是对这些常见容器类型的详细了解：
- 列表（List）：列表是 Python 中最常用且最基本的容器类型之一，可以通过中括号 [] 创建。列表中可以存储任意数据类型的元素，包括数字、字符串、列表、字典等。列表是有序的，可以根据索引值访问特定位置的元素，并且支持切片操作。
- 元组（Tuple）：元组与列表非常相似，也是有序的，但是元组创建后不能修改。元组可以通过小括号 () 或者逗号 , 创建。由于元组是不可变的，因此可以作为字典的键值或者集合的元素。
- 字典（Dictionary）：字典是一种无序的容器类型，由键值对（key-value pair）组成，每个键值对用冒号 : 分隔，不同的键值对用逗号 , 分隔，整个字典用大括号 {} 定义。字典中的键必须是唯一的，而值则可以是任意数据类型。
- 集合（Set）：集合是一种无序的容器类型，只能包含唯一的元素。集合可以通过花括号 {} 或者 set() 函数来创建。集合比较适合用来进行重复元素的过滤、集合运算（如交集、并集、差集等）。
二、数据类型共同操作方法
1. 索引取值(正向取，反向取)
在 Python 中，可以使用索引来访问与操作一些特定类型的数据，如字符串（str）、列表（list）、元组（tuple）等序列类型数据。
- 索引概述：索引是一种操作符，用于访问存储在某个数据类型中的元素。在 Python 中，索引从 0 开始，也就是说第一个元素的索引为 0，第二个元素的索引为 1，以此类推。除了正向索引外，Python 还支持负向索引，即从后往前数。例如，最后一个元素的索引为 -1，倒数第二个元素的索引为 -2，以此类推。
- 索引语法：可以使用类似于中括号的语法来进行索引操作，具体的语法格式为：data_type[index]。其中，data_type 是包含元素的数据类型，index 是需要访问或者操作的元素的索引。
- 1 字符串 str 支持索引取值
1.string字符串
str1 = 'hello python!'
正向取(从左往右) : print(str1[6]) # p
反向取(负号表示从右往左):print(str1[-4])# h
对于str来说，只能按照索引取值，不能改 : print(str1[0]='H') # 报错TypeError
2.List列表
正向取(从左往右)
my_friends=['tony','jason','tom',4,5]
my_friends[0] #tony
反向取(负号表示从右往左)
my_friends[-1] #5
对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
my_friends = ['tony','jack','jason',4,5]
my_friends[1] = 'martthow'
my_friends #['tony', 'martthow', 'jason', 4, 5]
# 通过索引取值实现列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]
小练习：names_list = ['kevin', 'jack', ['a', 'b', [1, 2, 'NB', ['AA', 'bb', 'LYNB']]]]
# 把LYNB取出来:列表取值就是一层一层的取出来
2.1. LYNB在大列表的第几个元素?第三个
l = names_list[2]
# print(l) #['a', 'b'，[1，2,'NB',['AA', 'bb', 'LYNB']]]
2.2.问:LYNB在大列表的第几个元素?
l1 = 1[2]
print(11) # [1,2,'NB',['AA', 'bb', 'LYNB']]
2.3.问:LYNB在大列表的第几个元素?
l2 = l1[3]
print(l2) # ['АА', 'bb', 'LYNB'J
2.4.问:LYNB在大列表的第几个元素?
l3 = l2[3]
print(l3) # LYNB
2.5.把以上4步合为一步
print(names_list[2][2][3][2])
3.tuple元组
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
(正向取+反向取)：只能取，不能改否则报错！
tuple1[0] #1
tuple1[-2] #22
tuple1[0] = 'hehe' # 报错：TypeError:
2. 切片(顾头不顾尾，步长)
在 Python 中，切片（slice）是指从一个序列中获取其中一部分的操作。这个序列可以是列表、元组、字符串等支持切片操作的对象。
str [ start : stop : step ]
- start 表示切片的起始位置（start如果不指定，则默认为序列的开头）
- stop 表示切片的结束位置（不包括结束位置的元素，如果不指定 stop，则默认为序列的结尾），
- step 表示切片的步长，默认为 1。（如果不指定 step，则默认为 1）【步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素】
s = 'Hello, World!'
print(s[0:5]) # 输出 'Hello'
print(s[7:]) # 输出 'World!'
print(s[:5]) # 输出 'Hello'
print(s[::2]) # 输出 'Hlo ol!'
print(s[::-1]) # 输出 '!dlroW ,olleH'
顾头不顾尾：取出索引为0到8的所有字符 : print(str1[0:9]) #hello pyt
步长：0:9:2,第三个参数2代表步长，会从0开始，每次跳两位取值，所以会取出索引0、2、4、6、8的字符:print(str1[0:9:2]) #hlopt
反向切片:
print(str1[:3]）#从左边开始切，切左边的三个
print(str1[ 3:] )#从左边开始切，除了左边的三个其他都打印
print(str1[::-1]) # ::代表反转将字符串翻过来 -1表示从右往左依次取值 run: !nohtyp olleh
列表
顾头不顾尾：取出索引为0到3的元素
lst = [1, 2, 3, 4, 5]
print(lst[1:3]) # 输出 [2, 3]
print(lst[::2]) # 输出 [1, 3, 5]
元组：
tup = (1, 2, 3, 4, 5)
print(tup[1:3]) # 输出 (2, 3)
print(tup[::2]) # 输出 (1, 3, 5)
需要注意的是，切片操作得到的是原序列的一个新副本，不会影响原序列。
3. len-长度
在 Python 中，len() 是内置函数，可以用于获取某些数据类型的长度或元素个数。下面是 Python 中支持 len() 函数的一些数据类型：
1.字符串（str）
s = "Hello, World!"
print(len(s)) # 输出 13
2.列表（list）
lst = [1, 2, 3, 'apple', 'orange']
print(len(lst)) # 输出 5
3.元组（tuple）
tup = (1, 2, 3, 'apple', 'orange')
print(len(tup)) # 输出 5
4.集合（set）
s = set([1, 2, 3, 4])
print(len(s)) # 输出 4
5.字典（dict）
d = {'name': 'John', 'age': 30, 'city': 'New York'}
print(len(d)) # 输出 3
6.其他类型
pythonCopy Codewith open('test.txt', 'r') as f:
print(len(f.readlines()))
4. 成员运算in和not in
Python 中的成员运算符 in 和 not in 用于判断某个元素是否存在于某个容器对象中，例如列表、元组、字典、集合和字符串等。
具体来说，对于支持成员运算符的数据类型，可以使用下列语句进行操作：
pythonCopy Code元素 in 容器对象 # 判断元素是否存在于容器对象中
元素 not in 容器对象 # 判断元素是否不在容器对象中
下面以常见的数据类型为例，详细说明成员运算符的用法：
1.列表（list）
lst = [1, 2, 3, 'apple', 'orange']
print(2 in lst) # 输出 True
print('banana' not in lst) # 输出 True
2.元组（tuple）
tup = (1, 2, 3, 'apple', 'orange')
print(3 in tup) # 输出 True
print('banana' not in tup) # 输出 True
3.字典（dict）
d = {'name': 'John', 'age': 30, 'city': 'New York'}
print('name' in d) # 输出 True
print(30 not in d) # 输出 True
字典暴露的就是 key 值所以只能判断字典的 key 值
4.集合（set）
s = set([1, 2, 3, 4])
print(2 in s) # 输出 True
print(5 not in s) # 输出 True
5.字符串（str）
s = "Hello, World!"
print('World' in s) # 输出 True
print('Python' not in s) # 输出 True
三、数值型(Number)类型
整型：int
在 Python 中，int（即 integer）是一种整数类型，用于表示整数值。Python 中的整数没有范围限制，可以表示任意大的整数。
与其它编程语言类似，整型变量在 Python 中可以直接进行算术运算，如加减乘除、取模、幂等操作。此外，int 类型还支持位运算（如按位与、按位或、异或等）和比较运算（如等于、不等于、大于、小于等）。
以下是一些常见的 Python 整数操作：
x = 123
a = 10
b = 3
c = a + b # 加法
d = a - b # 减法
e = a * b # 乘法
f = a / b # 除法（结果为浮点数）
g = a // b # 取整除法（结果为整数）
h = a % b # 取模（余数）
i = a ** b # 幂运算（a 的 b 次幂）
print(c, d, e, f, g, h, i) # 输出：13 7 30 3.3333333333333335 3 1 1000
pythonCopy Codea = 10
b = 20
print(a == b) # 判断 a 是否等于 b，输出 False
print(a != b) # 判断 a 是否不等于 b，输出 True
print(a > b) # 判断 a 是否大于 b，输出 False
print(a < b) # 判断 a 是否小于 b，输出 True
print(a >= b) # 判断 a 是否大于或等于 b，输出 False
print(a <= b) # 判断 a 是否小于或等于 b，输出 True
pythonCopy Codea = 0b1010 # 二进制数 1010（十进制数为 10）
b = 0b1100 # 二进制数 1100（十进制数为 12）
c = a & b # 按位与运算
d = a | b # 按位或运算
e = a ^ b # 按位异或运算
f = ~a # 按位取反运算
g = a >> 1 # 右移运算
h = b << 2 # 左移运算
print(bin(c), bin(d), bin(e), bin(f), bin(g), bin(h)) # 输出：0b1000 0b1110 0b0110 -0b1011 0b0101 0b110000
以下是 Python 整型支持的常见内置方法：
1.abs(x)：返回 x 的绝对值，整型输入、输出。
2.bit_length()：返回该整数二进制表示的长度，即二进制的位数。
3.divmod(a, b)：返回 a 和 b 元素相除的商和余数，以元组的形式输出。
4.pow(x, y[, z])：返回 x 的 y 次幂结果，如果提供了参数 z，则将结果对 z 取模。
5.round(x[, n])：将 x 四舍五入为 n 位小数（默认值为 0），返回一个浮点数。
6.to_bytes(length, byteorder, *, signed=False)：返回该整数的字节数组表示形式，其中 length 表示所需的字节数，byteorder 表示字节序（"big 或 little")。
7.from_bytes(bytes, byteorder, *, signed=False)：返回由给定字节数组表示的整数，byteorder 表示字节序（'big' 或 'little'）。
8.hex()：返回该整
[Something went wrong, please try again later.]
Python 中可以使用内置函数将 int 转换成其它类型。以下是一些常见的 int 类型转换示例：
1.转换为浮点数（float）：
x = 3
y = float(x)
print(y) # 输出结果为 3.0
2.转换为字符串（str）：
x = 123
y = str(x)
print(y) # 输出结果为 '123'
3.转换为布尔值（bool），0 转换为 False，非 0 转换为 True：
x = 0
y = bool(x)
print(y) # 输出结果为 False
4.转换为字节串（bytes）：
x = 123
y = bytes(x)
# 如果需要指定编码方式，可以使用如下代码：
# y = str(x).encode('utf-8')
print(y) # 输出结果为 b'{'
5.转换为十六进制字符串（hex）：
x = 255
y = hex(x)
print(y) # 输出结果为 '0xff'
6.转换为八进制字符串（oct）：
x = 255
y = oct(x)
print(y) # 输出结果为 '0o377'
7.转换为二进制字符串（bin）：
x = 255
y = bin(x)
print(y) # 输出结果为 '0b11111111'
0b代表二进制 0o代表八进制 0x代表十六进制
以上是 int 类型的常见转换方式，根据实际需求选择合适的转换方法。
以上是 Python int 类型的一些常见操作方法。需要注意的是，Python2.x 版本中的整数类型默认为 int（32 位），而 Python3.x 版本中的整数类型默认为 long（64 位）。但是在 Python3.x 中，可以自动将大于 32 位的整数转换为 long 类型，因此通常不需要进行特殊设置。
浮点型：float
在 Python 中，float 类型用于表示浮点数，即带有小数部分的数字。与 int 类型不同的是，float 类型使用的是 IEEE 754 标准表示法，可以精确地表示绝大部分实数，而且有更高的精度要求。
Python 中的浮点数可以通过直接赋值、算术运算或者强制类型转换等方式来创建。例如：
x = 3.14159 # 直接赋值
y = 1/3 # 除法运算
z = float("3.14") # 强制类型转换
与 int 类型一样， Python 中的 float 类型可以进行大多数的算术运算，如加减乘除、取模、幂等操作。此外，float 类型还支持比较运算（如等于、不等于、大于、小于等）。
以下是一些常见的 Python 浮点数操作：
x = 3.14159
y = 2.71828
a = x + y # 加法
b = x - y # 减法
c = x * y # 乘法
d = x / y # 除法
e = x % y # 取模（余数）
f = x ** y # 幂运算（x 的 y 次幂）
print(a, b, c, d, e, f) # 输出：5.85987 -0.57669 8.539743012 1.1557600354606984 0.42331087358525394 21.18741299459109
a = 3
b = 2.5
c = a + b # 整数会自动转换成浮点数
print(c) # 输出：5.5
a = 3.14159
b = 2.71828
print(a == b) # 判断 a 是否等于 b，输出 False
print(a != b) # 判断 a 是否不等于 b，输出 True
print(a > b) # 判断 a 是否大于 b，输出 True
print(a < b) # 判断 a 是否小于 b，输出 False
print(a >= b) # 判断 a 是否大于或等于 b，输出 True
print(a <= b) # 判断 a 是否小于或等于 b，输出 False
a = 3.14159
b = -2.71828
c = abs(b) # 取绝对值
d = round(a, 2) # 将浮点数四舍五入，保留两位小数
e = pow(a, b) # 计算 a 的 b 次幂
print(c, d, e) # 输出：2.71828 3.14 0.03230927256559649
下面是一些常用的 float 内置方法：
1.as_integer_ratio()
该方法返回一个元组 (n, d)，其中 n 和 d 分别是浮点数的分子和分母，表示浮点数的最简分数形式。例如：
x = 2.5
print(x.as_integer_ratio()) # 输出：(5, 2)
2.is_integer()
该方法返回一个布尔值，表示浮点数是否为整数。如果浮点数表示的值为整数，则返回 True，否则返回 False。例如：
x = 3.0
y = 3.14159
print(x.is_integer()) # 输出：True
print(y.is_integer()) # 输出：False
3.hex()
该方法返回一个字符串，表示浮点数的十六进制表示。字符串以 "0x" 开头，后面跟着一串十六进制数字，其中小数部分的二进制表示是以点号 "." 开始的。例如：
x = 10.5
print(x.hex()) # 输出：0x1.4000000000000p+3
4.fromhex(s)
该方法将一个十六进制字符串 s 转换为浮点数，并返回转换后的浮点数值。字符串中必须包含一个小数点，点号前后都可以有数字或空格。例如：
s = "0x1.5p+3"
x = float.fromhex(s)
print(x) # 输出：12.0
5.conjugate()
该方法返回浮点数的共轭复数。由于浮点数是实数或者虚数，因此其共轭复数就是其本身或者其相反数。例如：
x = 3.14
y = 2j
print(x.conjugate()) # 输出：3.14
print(y.conjugate()) # 输出：(-0-2j)
6.real 和 imag
real() 方法返回浮点数的实部（即其非虚部）；imag() 方法返回浮点数的虚部。对于实数，其虚部始终为 0。例如：
x = 3.14
y = 2j
print(x.real) # 输出：3.14
print(x.imag) # 输出：0.0
print(y.real) # 输出：0.0
print(y.imag) # 输出：2.0
需要注意的是，由于浮点数运算存在精度误差，因此在使用这些方法时可能需要特别小心，以避免误判。
需要注意的是，由于浮点数表示的是近似值，而不是精确值，因此在进行浮点数运算时可能会出现精度误差。这种误差通常不会对结果产生明显的影响，但在一些特殊的场合下可能需要进行特殊处理。
整型：int 与 浮点型：float 的区别：
数据类型
int 是整型数据类型，可以表示任意大的整数，没有小数部分。而 float 是浮点数数据类型，可以表示任意大或任意小的实数，包括有小数部分的数。
精度
由于计算机使用二进制来存储数值，在这种条件下，整数可以精确地表示，而浮点数只能近似地表示。因此，在计算机中，整数运算通常是精确的，而浮点数运算可能存在舍入误差。
例如：
python
x = 10
y = 3
z1 = x / y # 整数除以整数，结果为浮点数
z2 = x // y # 整数除以整数，结果为向下取整的整数
print(z1) # 输出：3.3333333333333335
print(z2) # 输出：3
在上面的例子中，x 和 y 都是整数，但通过除法运算得到的结果 z1 是一个浮点数，因为除法操作将两个整数转换为了浮点数。而使用整数除法运算符 // 得到的结果 z2 是一个整数。
内置方法
int 和 float 类型都有许多内置方法可供使用。但由于 int 和 float 的数据类型和特性不同，因此它们提供的方法也有所不同。例如，int 类型提供了 bit_length() 方法以获取二进制表示中所需的最少位数，而 float 类型则提供了 as_integer_ratio() 方法以获取其最简分数形式的分子和分母。
内存占用
在计算机内存中，整数通常占用更少的空间，而浮点数则需要更多的空间来存储。这是因为浮点数需要更多的位数来表示其小数部分和指数部分，以保证其精度。例如，在 Python 3.6 中，一个 int 类型变量通常需要 28 字节的内存，而一个 float 类型变量则需要 24 字节的内存。
综上所述，int 和 float 都是 Python 中常用的基本数据类型，它们各自具有不同的特性和应用场景。需要根据实际需求选择合适的数据类型来进行编程。
名字+括号的意思就是调用某个功能
四、字符串str以及内置方法
字符串是一种用来表示文本的数据类型，它是由符号或者数值组成的一个连续序列。
1、了解定义字符串:
在 Python 中，字符串是一种常见的数据类型，用于表示文本信息。一个字符串可以包含多个字符，在 Python 中使用单引号、双引号或三引号表示，例如：
s1 = 'Hello, World!' # 使用单引号表示字符串
s2 = "Python is great!" # 使用双引号表示字符串
s3 = '''This is a
multi-line
string.''' # 使用三引号表示多行字符串
在 Python 中，字符串是不可变（immutable）的，即不能修改字符串中的某个字符。但可以使用下标访问字符串中的单个字符，例如：
s = 'Python'
print(s[0]) # 输出 P
print(s[-1]) # 输出 n
可以使用加号（+）运算符将两个字符串合并成一个新的字符串，例如：
s1 = 'Hello'
s2 = 'World'
s3 = s1 + ', ' + s2 + '!'
print(s3) # 输出 Hello, World!
2、数据类型转换：
使用str()可以将任意数据类型转换成字符串类型
在 Python 中，str 是一种基本数据类型，表示字符串。有时候需要将其他类型的数据转换为字符串，或者将字符串转换为其他类型的数据。Python 提供了一些内置函数，可以实现这种类型转换。
1.str其他类型转换为 str
要将其他类型的数据转换为字符串，可以使用内置函数 str()，它可以接受任何类型的参数，并返回对应的字符串。
a = 123
b = 3.14
c = True
s1 = str(a)
s2 = str(b)
s3 = str(c)
print(s1, s2, s3) # 输出 "123 3.14 True"
对于复杂的数据结构，str() 函数会自动调用对象的 str() 方法，返回一个可读性较好的字符串表示。
2.str转换为 int 或 float
要将字符串转换为整数或浮点数，可以使用内置函数 int() 或 float()。
s1 = '123'
s2 = '3.14'
a = int(s1)
b = float(s2)
print(a, b) # 输出 123 3.14
需要注意的是，如果字符串不能被解析为有效的数字，则会抛出 ValueError 异常。
3.其他类型转换
除了上述常见类型外，还有一些其他类型的数据可以进行转换，例如 bool 类型、list 类型、tuple 类型等。可以通过直接或间接地调用相应的构造函数实现转换。
a = 0
b = ''
c = []
d = {}
e = ()
f = None
s1 = bool(a)
s2 = str(a)
s3 = list(e)
s4 = tuple(c)
s5 = dict(d)
i1 = int(s2)
print(s1, s2, s3, s4, s5, i1) # 输出 False "0" [] () {} 0
需要注意的是，一些类型之间的转换可能存在损失精度或改变数据结构的风险，需要根据实际需求谨慎选择。
3、转义符号：
转义字符是指使用反斜杠“”对一些特殊字符进行转义，即改变原有字符含义的特殊字符，在引号里面使用。
如果不让转义符号生效要用 r 或 R 来定义原始字符串
original = r"我是原始字符串\n"
print("original : ", original) #我是原始字符串\n
4、字符串的索引
字符串是一个由元素组成的序列，每个元素所处的位置是固定的， 并且对应着一个位置编号，编号从0开始，依次递增1，这个位置编号被称为索引或者下标。
⚠️注意
注意****1、Python 没有单独的字符类型，一个字符串的长度就是为 1
2、单引号与双引号可以嵌套使用，单引号表示的字符串中可以嵌套双引号的字符串， 但是单引号不允许嵌套单引号;
3、字符串可以用＋运算符拼接在一起，用＊运算符重复
4、Python中的字符串不能改变，可变的对象修改之后，前后地址不变，不可变对象修改地址之后，前后地址会变
正向索引：索引从 0 开始从左往右依次递增
反向索引：索引从- 1 开始从右到左依次递减
5、字符串的内置方法
Python 字符串的内置方法非常丰富，包括字符串查找、替换、分割、大小写转换、判断等等。
字符串查找
- str.find(sub[, start[, end]])：从左到右查找子字符串 sub 在 str 中的位置，返回第一个匹配项的索引位置。如果没有找到，则返回 -1。start 和 end 参数表示查找的范围，默认为整个字符串。
# 查找子字符串，返回索引位置
s = 'hello, world'
print(s.find('o')) # 4
print(s.find('o', 5)) # 8，从第 5 个位置开始查找
print(s.find('o', 5, 7)) # -1，查找范围为 [5, 7)
- str.rfind(sub[, start[, end]])：从右到左查找子字符串 sub 在 str 中的位置，返回最后一个匹配项的索引位置。如果没有找到，则返回 -1。start 和 end 参数表示查找的范围，默认为整个字符串。
# 从右到左查找子字符串，返回索引位置
s = 'hello, world'
print(s.rfind('o')) # 8
print(s.rfind('o', 0, -2)) # 4，查找范围为 [0, -2)
- str.index(sub[, start[, end]])：与 find() 方法类似，从左到右查找子字符串 sub 在 str 中的位置，返回第一个匹配项的索引位置。如果没有找到，则抛出 ValueError 异常。
# 查找子字符串，返回索引位置，没有找到则抛出异常
s = 'hello, world'
print(s.index('o')) # 4
print(s.index('o', 5)) # 8，从第 5 个位置开始查找
print(s.index('o', 5, 7)) # ValueError: substring not found
- str.rindex(sub[, start[, end]])：与 rfind() 方法类似，从右到左查找子字符串 sub 在 str 中的位置，返回最后一个匹配项的索引位置。如果没有找到，则抛出 ValueError 异常。
# 从右到左查找子字符串，返回索引位置，没有找到则抛出异常
s = 'hello, world'
print(s.rindex('o')) # 8
print(s.rindex('o', 0, -2)) # 4，查找范围为 [0, -2)
print(s.rindex('o', 5, 7)) # ValueError: substring not found
字符串替换
- str.replace(old, new[, count])：将 str 中的所有 old 子串替换为 new，返回新的字符串。如果指定了 count，则只替换前 count 个出现的子串。
# 替换子字符串
s = 'hello, world'
print(s.replace('o', 'O')) # hellO, wOrld
print(s.replace('o', 'O', 1)) # hellO, world，只替换第一个出现的子串
# 用新的字符替换字符串中旧的字符
str7 = 'my name is tony, my age is 18!' # 将tony的年龄由18岁改成73岁
str7 = str7.replace('18', '73') # 语法:replace('旧内容', '新内容') #my name is tony, my age is 73!
# 可以指定修改的个数
str7 = 'my name is tony, my age is 18!'
str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY #'MY name is tony, my age is 18!'
- str.maketrans(x[, y[, z]])：创建字符映射表，用于 translate() 方法的参数。x 是需要转换的字符，y 是转换后的字符，z 是需要删除的字符。
# 创建字符映射表
trans_table = str.maketrans('abc', '123')
print(trans_table) # {97: 49, 98: 50, 99: 51}
- str.translate(table)：根据字符映射表 table 对字符串进行转换。
# 根据字符映射表转换字符串
s = 'abc'
trans_table = str.maketrans('abc', '123')
print(s.translate(trans_table)) # 123
- expandtabs() 方法可以将字符串中的制表符
\t转换为空格，并根据指定的 tabsize 将连续的多个空格替换为一个制表符或若干个空格。
str.expandtabs(tabsize = 8)
其中，tabsize 为可选参数，默认值为 8。
示例代码：
str1 = 'a\tb\tc'
result = str1.expandtabs()
print(result) # 输出 'a b c'
str2 = 'a b c'
result = str2.expandtabs(4)
print(result) # 输出 'a b c'
字符串分割和连接
- str.split(sep=None, maxsplit=-1)：以 sep 为分隔符对 str 进行分割，返回一个列表。maxsplit 指定最多分割次数，默认为 -1，表示不限制。
# 分割字符串
s = 'hello, world'##可以使用解压赋值给切分出来赋一个变量,但是切多少块就给多少变量名
print(s.split()) # ['hello,', 'world']，默认以空格进行分割
print(s.split(',')) # ['hello', ' world']，以逗号进行分割
print(s.split(',', 1)) # ['hello', ' world']，最多分割一次
- str.rsplit(sep=None, maxsplit=-1)：与 split() 方法类似，但从右向左分割。
# 从右向左分割字符串
s = 'hello, world'
print(s.rsplit()) # ['hello,', 'world']
print(s.rsplit(',', 1)) # ['hello', ' world'] 可以指定切割次数,只有用切割次数才能看出来
- str.join(iterable)：将可迭代对象 iterable 中的字符串连接起来，返回一个新的字符串。
# 连接字符串
lst = ['hello', 'world']
print('｜'.join(lst)) # hello｜world
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
'%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
打印结果：'h%e%l%l%o'
'|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照|作为分隔符号进行拼接
打印结果：'tony|18|read'
字符串大小写转换
- str.capitalize()：将首字母变为大写，返回一个新的字符串。
# 首字母大写
s = 'hello, world'
print(s.capitalize()) # Hello, world
- str.title()：将每个单词的首字母变为大写，返回一个新的字符串。
# 每个单词首字母大写
s = 'hello, world'
print(s.title()) # Hello, World
- str.lower()：将所有字符变为小写，返回一个新的字符串。
# 所有字符变为小写
s = 'Hello, World'
print(s.lower()) # hello, world
- str.upper()：将所有字符变为大写，返回一个新的字符串。
# 所有字符变为大写
s = 'Hello, World'
print(s.upper()) # HELLO, WORLD
- str.swapcase()：将所有大写字母变为小写，所有小写字母变为大写，返回一个新的字符串。
# 大小写互换
s = 'Hello, World'
print(s.swapcase()) # hELLO, wORLD
字符串判断
- str.startswith(prefix[, start[, end]])：判断 str 是否以指定的前缀 prefix 开始。start 和 end 参数表示查找范围，默认为整个字符串。
# 判断字符串是否以指定前缀开始
s = 'hello, world'
print(s.startswith('h')) # True
print(s.startswith('o', 4)) # True，从第 4 个位置开始查找
print(s.startswith('w', 7)) # False，从第 7 个位置开始查找
- str.endswith(suffix[, start[, end]])：判断 str 是否以指定的后缀 suffix 结束。start 和 end 参数表示查找范围，默认为整个字符串。
# 判断字符串是否以指定后缀结束
s = 'hello, world'
print(s.endswith('d')) # True
print(s.endswith('l', 0, 3)) # True，查找范围为 [0, 3)
print(s.endswith('w', 0, 7)) # False，查找范围为 [0, 7)
- str.isalpha()：判断 str 是否只包含字母。
# 判断字符串是否只包含字母
s1 = 'hello'
s2 = 'hello!'
print(s1.isalpha()) # True
print(s2.isalpha()) # False，包含 '!'
- str.isdigit()：判断 str 是否只包含数字，是否为纯数字组成
# 判断字符串是否只包含数字
s1 = '123'
s2 = '123a'
print(s1.isdigit()) # True
print(s2.isdigit()) # False，包含 'a'
- str.isalnum()：判断 str 是否只包含字母和数字。
# 判断字符串是否只包含字母和数字
s1 = 'hello123'
s2 = 'hello, world'
print(s1.isalnum()) # True
print(s2.isalnum()) # False，包含 ','
- str.islower()：判断 str 是否全部为小写字母。
# 判断字符串是否全部为小写字母
s1 = 'hello'
s2 = 'Hello'
print(s1.islower()) # True
print(s2.islower()) # False，首字母为大写
- str.isupper()：判断 str 是否全部为大写字母。
# 判断字符串是否全部为大写字母
s1 = 'HELLO'
s2 = 'Hello'
print(s1.isupper()) # True
print(s2.isupper()) # False，包含小写字母
- str.isspace()：判断 str 是否只包含空白字符。
# 判断字符串是否只包含空白字符
s1 = ' \t\n'
s2 = ' hello '
print(s1.isspace()) # True
print(s2.isspace()) # False，包含字母
- isnumeric() 方法用于判断字符串中的字符是否都属于数字字符。其中，除了数字 0 ~ 9 之外，还包括罗马数字、汉字数字、全角数字等
str.isnumeric()
示例代码：
str1 = '123456'
print(str1.isnumeric()) # 输出 True
str2 = '①②③④⑤'
print(str2.isnumeric()) # 输出 True
str3 = '四百五十六'
print(str3.isnumeric()) # 输出 True
str4 = '12ab34'
print(str4.isnumeric()) # 输出 False
- isdecimal() 和 isnumeric() 非常相似，也是用来判断字符串中的字符是否都属于数字字符。不同之处在于，isdecimal() 方法只针对数字 0 ~ 9 进行判断，而不包括罗马数字、汉字数字、全角数字等
str.isdecimal()
示例代码：
str1 = '123456'
print(str1.isdecimal()) # 输出 True
str2 = '①②③④⑤'
print(str2.isdecimal()) # 输出 False
str3 = '四百五十六'
print(str3.isdecimal()) # 输出 False
str4 = '12ab34'
print(str4.isdecimal()) # 输出 False
- **isidentifier() **方法用于判断字符串是否是一个合法的标识符。标识符通常用来表示变量、函数、类等名称，它的命名规则和 Python 中变量命名的规则相同。具体而言，标识符只能由字母、下划线、数字组成，且不能以数字开头。
str.isidentifier()
示例代码：
str1 = 'hello'
print(str1.isidentifier()) # 输出 True
str2 = 'hello world'
print(str2.isidentifier()) # 输出 False
str3 = '_hello'
print(str3.isidentifier()) # 输出 True
str4 = '123hello'
print(str4.isidentifier()) # 输出 False
需要注意的是，Python 中有一些关键字是不能用作标识符的，例如 `if`、`while`、`for` 等。同时，Python 中的标识符是区分大小写的。
其他
- **count() **方法是用来返回指定元素在列表、字符串等对象中出现的次数。它的语法格式如下：
object.count(element)
"""其中，object 是需要检查的对象，element 是需要计数的元素。"""
1.列表中元素的计数
list1 = ['apple', 'banana', 'cherry', 'banana']
count = list1.count('banana')
print(count) # 输出 2
2.字符串中字符的计数
str1 = 'Hello, world!'
count = str1.count('o')
print(count) # 输出 2
3.检查子字符串的计数
str2 = 'To be or not to be, that is the question.'
count = str2.count('be')
print(count) # 输出 2
需要注意的是，count() 方法只能统计可哈希的对象类型（可作为字典的键），因此不能用于统计集合、字典等不可哈希的对象类型。同时，如果统计的元素不存在于对象中，count() 方法会返回 0。
**strip() 移除字符串首尾指定的字符(默认移除空格)
lstrip() 只移除左边的指定字符
rstrip() **只移除右边的指定字符
# 去除字符串首尾指定字符
s = ' hello, world '
print(s.strip()) # 'hello, world'，去除首尾的空格
print(s.lstrip()) # 'hello, world '，只去除左侧的空格
print(s.rstrip()) # ' hello, world'，只去除右侧的空格
# 去除字符串首尾指定字符，括号内不指定字符，默认以空格作为切分符号，括号内指定分隔字符，则按照括号内指定的字符切割字符串(空格、\n、\t)
s = '***hello, world***'
print(s.strip('*')) # 'hello, world'，去除首尾的'*'
print(s.lstrip('*')) # 'hello, world***'，只去除左侧的'*'
print(s.rstrip('*')) # '***hello, world'，只去除右侧的'*'
- **center() **方法是用来将字符串居中显示，并用指定的字符填充空白部分。它的语法格式如下：
string.center(width[, fillchar])
"""其中，string 是需要居中的字符串，width 是设置的总宽度（包括原字符串），fillchar 是可选参数，用来指定填充空白部分的字符。如果不指定，就用空格来填充。"""
1.居中显示并用空格填充
str1 = 'Hello'
result = str1.center(10)
print(result) # 输出 ' Hello '
2.居中显示并用指定字符填充
str2 = 'World'
result = str2.center(10, '*')
print(result) # 输出 '**World***'
"""
上面的示例中，第一个例子中的字符串 Hello 居中显示，总宽度是 10，因此需要在前后填充 2 个空格。在第二个例子中，字符串 World 居中显示，总宽度为 10，填充字符为 *，因此需要在前后各填充 2 个 *。
需要注意的是，如果指定的总宽度小于原字符串的长度，center() 方法并不会将字符串截断，而是直接返回原字符串。如果不指定填充字符，也不会把空白部分填充为其他字符，而是默认用空格填充。
"""
- **ljust()、rjust() 和 zfill() **方法都是用来对字符串进行填充的方法，它们的主要区别在于填充的方向和填充内容。
ljust()：将字符串左对齐，并用指定字符填充右侧空白部分。
rjust()：将字符串右对齐，并用指定字符填充左侧空白部分。
zfill()：在字符串左侧用 0 填充，使其达到指定长度。
1.ljust()
string.ljust(width[, fillchar])
其中，string 是需要左对齐的字符串，width 是设置的总宽度（包括原字符串），fillchar 是可选参数，用来指定填充空白部分的字符。如果不指定，就用空格来填充。例如：
# 左对齐并用空格填充
str1 = 'Hello'
result = str1.ljust(10)
print(result) # 输出 'Hello '
# 左对齐并用指定字符填充
str2 = 'World'
result = str2.ljust(10, '*')
print(result) # 输出 'World*****'
2.rjust()
string.rjust(width[, fillchar])
其中，string 是需要右对齐的字符串，width 是设置的总宽度（包括原字符串），fillchar 是可选参数，用来指定填充空白部分的字符。如果不指定，就用空格来填充。例如：
str1 = 'Hello'
result = str1.rjust(10, '*')
print(result) # 输出 '*****Hello'
3.zfill()
string.zfill(width)
其中，string 是需要左侧填充 0 的字符串，width 是设置的总宽度（包括原字符串）。例如：
str1 = '123'
result = str1.zfill(5)
print(result) # 输出 '00123'
需要注意的是，以上三种方法都是返回一个新的字符串，并不会改变原有字符串的值。如果指定的宽度小于原字符串长度，则不进行任何填充操作，直接返回原有字符串。
6.格式化输出
- **什么是格式化输出: **把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出。
- **为什么要格式化输出: **我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。
- Python 格式化输出的方式有三种：
1. 使用 % 运算符
在字符串中，可以使用 % 运算符实现格式化输出。
- %s 表示字符串占位符
- %d 表示整数占位符
- %f 表示浮点数占位符
- %X 表示十六进制整数占位符
- %x 表示十六进制整数占位符（小写）
- %o 表示八进制整数占位符
- %e 表示科学计数法占位符
1.字符串格式化输出
name = 'Alice'
age = 18
print('My name is %s, and I am %d years old.' % (name, age))
2.浮点数格式化输出
pi = 3.1415926
print('PI is %f.' % pi) # 默认保留小数点后 6 位
print('PI is %.2f.' % pi) # 保留小数点后 2 位
3.十六进制整数格式化输出
num = 255
print('Number in hex is %X' % num) # 大写字母
print('Number in hex is %x' % num) # 小写字母
4.八进制整数格式化输出
num = 64
print('Number in octal is %o' % num)
5.科学计数法格式化输出
num = 1.23456789e+09
print('Number in scientific notation is %e' % num) # 默认保留小数点后 6 位
print('Number in scientific notation is %.5e' % num) # 保留小数点后 5 位
6.输出结果：
Copy CodeMy name is Alice, and I am 18 years old.
PI is 3.141593.
PI is 3.14.
Number in hex is FF
Number in hex is ff
Number in octal is 100
Number in scientific notation is 1.234568e+09
Number in scientific notation is 1.23457e+09
ps:使用%s来做字符串的格式化输出操作,传值时，必须严格按照位置与%s一一对应
7.练习题：
练习：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式
------------ info of Tony -----------
Name : Tony
Age : 22
Sex : male
Job : Teacher
------------- end -----------------
Name = input('Name:')
Age = int(input('Age:'))
Sex = input('Sex:')
Job = input('Job:')
print('-' * 12, "info of %s" % Name, '-' * 11, '\n', 'Name:%s\n Age:%d\n Sex:%s\n Job:%s\n' % (Name, Age, Sex, Job),
'-' * 13, 'end', '-' * 17)
Name = input('Name:')
Age = int(input('Age:'))
Sex = input('Sex:')
Job = input('Job:')
print('-' * 12, "info of %s" % Name, '-' * 11, '\n', 'Name:{}\n Age:%d\n Sex:{}\n Job:{}\n'.format(Name, Age, Sex, Job),
'-' * 13, 'end', '-' * 17)
2. 使用 format() 方法
format() 方法使用一对花括号 {} 来表示占位符。大括号内可以包含数字、变量名或表达式等内容，用于指定替换的位置或值。如果只有一个参数，则不需要指定花括号中的数字。
1.字符串格式化输出
name = 'Bob'
age = 20
print('My name is {}, and I am {} years old.'.format(name, age))
2.指定占位符的位置
name = 'Charlie'
age = 22
print('My name is {0}, and I am {1} years old.'.format(name, age)) # 指定位置
c = '面包'
f = "{name}说：这个周六我们一起去吃{ss}吧".format(name='小狗', ss=c)
print(f)
3.指定占位符的名称
name = 'Dave'
age = 24
print('My name is {n}, and I am {a} years old.'.format(n=name, a=age)) # format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
4.格式化数值
pi = 3.1415926
print('PI is {:.2f}.'.format(pi)) # 保留小数点后 2 位
5.格式化十六进制整数
num = 255
print('Number in hex is {:X}'.format(num)) # 大写字母
print('Number in hex is {:x}'.format(num)) # 小写字母
6.格式化八进制整数
num = 64
print('Number in octal is {:o}'.format(num))
7.格式化科学计数法
num = 1.23456789e+09
print('Number in scientific notation is {:e}'.format(num)) # 默认保留小数点后 6 位
print('Number in scientific notation is {:.5e}'.format(num)) # 保留小数点后 5 位
8.输出结果：
Copy CodeMy name is Bob, and I am 20 years old.
My name is Charlie, and I am 22 years old.
My name is Dave, and I am 24 years old.
PI is 3.14.
Number in hex is FF
Number in hex is ff
Number in octal is 100
Number in scientific notation is 1.234568e+09
Number in scientific notation is 1.23457e+09
3. 使用 f-string
f-string 是 Python 3.6+ 新增的字符串格式化方法。使用 f-string 时，可以在花括号内直接写变量、表达式等内容作为占位符，更加简便。
1.字符串格式化输出
name = 'Eric'
age = 26
print(f'My name is {name}, and I am {age} years old.')
2.格式化数值
pi = 3.1415926
print(f'PI is {pi:.2f}.') # 保留小数点后 2 位
3.格式化十六进制整数
num = 255
print(f'Number in hex is {num:X}') # 大写字母
print(f'Number in hex is {num:x}') # 小写字母
4.格式化八进制整数
num = 64
print(f'Number in octal is {num:o}')
5.格式化科学计数法
num = 1.23456789e+09
print(f'Number in scientific notation is {num:e}') # 默认保留小数点后 6 位
print(f'Number in scientific notation is {num:.5e}') # 保留小数点后 5 位
6.输出结果：
Copy CodeMy name is Eric, and I am 26 years old.
PI is 3.14.
Number in hex is FF
Number in hex is ff
Number in octal is 100
Number in scientific notation is 1.234568e+09
Number in scientific notation is 1.23457e+09
五、列表list
1.说明
列表（list）是 Python 中一种常用的序列类型，与元组不同，列表中的元素是可以改变的，可以添加、删除和修改元素。列表使用方括号 [] 来表示，元素之间使用逗号分隔
说明
- 列表可以支持数字,字符串,和列表之间的嵌套
- 列表同样可以被索引和切片，可以使用＋操作符进行拼接, 列表被截取后返回一个包含所需元素的新列表。
- 列表截取的语法格式：变量［头下标：尾下标］；索引值以0为开始值，-1为从末尾的开始位置。
- 加号（＋）是列表连接运算符，星号（＊）是重复操作
- 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
2.操作列表
1.创建一个空列表
list1 = []
2.创建一个包含多个元素的列表
list2 = [1, 2, 3]
3.列表中可以包含不同类型的元素
list3 = [1, 'abc', True]
list = ['a', 'b', 'c']
print(list[0]) # 输出 'a'
print(list[-1]) # 输出 'c'
print(list[1:3]) # 输出 ['b', 'c']
3.列表内置方法
Python 中内置了丰富的列表方法，可以对列表进行排序、插入、删除、查找等操作。下面是列表常用的内置方法：
- list.append(obj)：在列表末尾添加一个元素。
- list.extend(iterable)：将可迭代对象中的所有元素添加到列表中。
- list.insert(index, obj)：在指定位置插入一个元素。
- list.remove(obj)：从列表中删除一个元素。
- list.pop([index])：删除列表中指定位置的元素，并返回该元素。
- list.index(obj)：返回列表中第一个与 obj 相等的元素的索引。
- list.count(obj)：返回列表中 obj 出现的次数。
- list.sort(key=None, reverse=False)：对列表进行排序，默认升序排序。
- list.reverse()：反转列表中的元素。
- list.copy()：返回列表的浅复制。
list1 = [1, 2, 3]
1.append()列表尾部追加元素
l1 = ['a','b','c']
l1.append('d')
print(l1) #['a', 'b', 'c', 'd']
extend()一次性在列表尾部添加多个元素
2.l1.extend(['a','b','c'])
print(l1) #['a', 'b', 'c', 'd', 'a', 'b', 'c']
list2 = [4, 5, 6]
list1.extend(list2) # 将另一个列表中的元素添加到当前列表中
print(list1) # 输出 [1, 2, 3, 4, 5, 6]
3.l1.insert(0,"first") # 0表示按索引位置插值
print(l1) #['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
list1.insert(2, 'abc') # 在指定位置插入一个元素
print(list1) # 输出 [1, 2, 'abc', 3, 4, 5, 6]
4.删除:del、pop、remove
l = [11,22,33,44]
del l[2] # 删除索引为2的元素
print(l) #[11,22,44]
pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
l = [11,22,33,22,44]
res=l.pop()
print(res) #44
res=l.pop(1)
res #22
remove()括号内指名道姓表示要删除哪个元素，没有返回值
l = [11,22,33,22,44]
res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
print(res) #None
5.列表比较大小
字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素
l1=[1,2,3]
l2=[2,]
l2 > l1 #True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
s1='abc'
s2='az'
s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立 run:True
# 所以我们也可以对下面这个列表排序
l = ['A','z','adjk','hello','hea']
l.sort()
l #['A', 'adjk', 'hea', 'hello','z']
6.index = list1.index(4) # 返回列表中第一个与 obj 相等的元素的索引
print(index) # 输出 2
7.count = list1.count(4) # 返回列表中 obj 出现的次数
print(count) # 输出 1
8.sort()给列表内所有元素排序
排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
l = [11,22,3,42,7,55]
l.sort()
print(l) #[3, 7, 11, 22, 42, 55] # 默认从小到大排序
l = [11,22,3,42,7,55]
l.sort(reverse=True) # reverse用来指定是否颠倒排序，默认为False
print(l ) #[55, 42, 22, 11, 7, 3]
9.list1.reverse() # 反转列表中的元素
print(list1) # 输出 [6, 5, 4, 2, 1]
10.new_list = list1.copy() # 返回列表的浅复制
print(new_list) # 输出 [6, 5, 4, 2, 1]
11.循环
# 循环遍历my_friends列表里面的值
for line in my_friends:
print(line)
'tony'
'jack'
'jason'
4
5
list1 = [1, 2, 3]
list1[1] = 'abc' # 直接修改列表中的元素
print(list1) # 输出 [1, 'abc', 3]
总之，列表是 Python 中常用的序列类型，具有可变性和可变结构的特点。使用丰富的内置方法，可以对列表进行排序、插入、删除、查找等操作，非常方便实用。
六、元组tuple
1.说明
作用:
- 元组（tuple）是一个不可变的序列类型，它的元素不能被修改，也不能添加或删除元素，与列表类似，不同之处在于元组一旦被创建，它的元素就不可更改了。
- 元组通常用于存储一组相关的数据，具有不可变性和不可变结构的特点。
- 在 Python 中，元组使用小括号 () 来表示，元素之间使用逗号 分隔。元组中的元素类型也可以不相同
- 元组与字符串类似，可以被索引且下，标索引从0开始，-1为从末尾开始的位置。
- 元组也可以被索引和切片（其实，可以把字符串看作一种特殊的元组）
- 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
- str、list和tuple都属于sequence（序列）
- 元组也可以使用+操作符进行拼接
- 元组内必须有值如果为空必须加一个逗号,否则()就只是包含的意思而非定义元组
- 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
2.操作元组
1.创建一个空元组
tup1 = (,)
2.创建一个包含多个元素的元组
tup2 = (1, 2, 3)
3.可以省略括号
tup3 = 1, 2, 3
4.访问元组中的元素：可以使用索引和切片来访问元组中的元素
tup = ('a', 'b', 'c')
print(tup[0]) # 输出 'a'
print(tup[-1]) # 输出 'c' 可以使用索引来访问元组中的数据，索引从0开始计数。
print(tup[1:3]) # 输出 ('b', 'c') 也可以使用切片操作来获取元组中的一个子集
5.元组的操作：元组不可修改，所以不能对元组中的数据进行增删改操作
tup[0] = 10 # TypeError: 'tuple' object does not support item assignment
6.但是可以对元组进行连接、重复等操作
tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
print(tup1 + tup2) # 输出 (1, 2, 3, 4, 5, 6)
print(tup1 * 2) # 输出 (1, 2, 3, 1, 2, 3)
3.元组内置方法
- len(tuple)：返回元组中元素的个数。
- max(tuple)：返回元组中最大的元素。
- min(tuple)：返回元组中最小的元素。
- tuple(seq)：将序列转换成元组。
- count() 方法：用于统计元组中某个元素出现的次数。
- index() 方法：用于返回元组中第一个匹配项的索引。
PS：需要注意的是，由于元组是不可变类型，因此不能对元素进行修改、添加或删除。如果需要对元组进行这些操作，可以先将元组转换成列表，在对列表进行修改，然后再将列表转换回元组。
tup = (1, 2, 3)
1.print(len(tup)) # 输出 3
2.print(max(tup)) # 输出 3
3.print(min(tup)) # 输出 1
list1 = [1, 2, 3]
4.tup1 = tuple(list1) # 转换成元组
print(tup1) # 输出 (1, 2, 3)
tup = (1, 2, 3, 4, 5, 1, 2, 1)
5.print(tup.count(1)) # 输出 3，1出现3次
tup = (1, 2, 3, 4, 5, 1, 2, 1)
6.print(tup.index(2)) # 输出 1，2在元组中的索引为1
7.循环
for line in tuple1:
... print(line)
1
hhaha
15000.0
11
22
33
七、字典
1.说明
Python 中的字典（dict）是一种无序、可变的数据类型。它是由键（key）和值（value）组成的键值对集合，每个键对应唯一的值。
说明：a. 字典的键可以是任意的不可变类型
b. 成员资格查找时查找的是键而不是值
c. 即使键起初不存在也可以为它直接赋值，字典会自动添加新的项
d. 字典是不可修改的
2.操作字典
创建字典
使用大括号 {} 来创建一个空字典，或者使用花括号 {key: value} 来创建带有初始键值对的字典。
字典的键必须是不可变类型，如字符串、数字或元组等，而键对应的值可以是任何数据类型。其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能
empty_dict = {}
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
访问字典中的值（字典取值）
通过键来访问字典中的值。如果键不存在，则会抛出 KeyError 异常，可以使用 get() 方法来避免这种情况。
print(fruit_dict['apple']) # 输出 1
print(fruit_dict.get('watermelon', 0)) # 输出 0，因为 watermelon 键不存在
1.按key存取值：可存可取
# 1.1 取
dic = {
'name': 'xxx',
'age': 18,
'hobbies': ['play game', 'basketball']
}
print（dic['name']）#'xxx'
print（dic['hobbies'][1]）#'basketball'
1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
dic['gender'] = 'male'
print（dic）#{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic['name'] = 'tony'
print（dic）#{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}
小练习:取出最后一个字典 f 的值
info = {
'username': 'kevin',
'addr': ['a', 'b', {'aa': 1, 'bb': 2, 'hobby': ['xijio', 'tangtou', 'hejiu', {'c': 1, 'd': 2, 'f': 'LYNB'}]}]
}
ll = info['addr'][2]['hobby'][3]['f']
print(ll)
更新字典
通过键来更新字典中的值，或者使用 update() 方法来更新多个键值对。
fruit_dict['apple'] = 4 # 将 apple 的值更新为 4
fruit_dict.update({'banana': 5, 'watermelon': 6}) # 更新多个键值对
删除字典
可以使用 del 关键字删除字典中的键值对，或使用 clear() 方法清空整个字典。
del fruit_dict['apple'] # 删除键为 'apple' 的键值对
fruit_dict.clear() # 删除字典中的所有键值对
循环（遍历）字典
可以使用 for 循环来遍历字典中的键值对。使用 keys() 方法来获取所有的键，使用 values() 方法来获取所有的值，使用 items() 方法来获取所有的键值对。
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
1.循环
6.1 默认遍历的是字典的key
for key in dic:
print(key)
"""执行结果：
age
hobbies
name
"""
6.2 只遍历key
for key in dic.keys():
print(key)
"""执行结果：
age
hobbies
name"""
6.3 只遍历value
for key in dic.values():
print(key)
"""执行结果：
18
['play game', 'basketball']
xxx"""
6.4 遍历key与value
for key in dic.items():
print(key)
"""执行结果：
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')"""
类型转换
转换1:
info=dict([['name','tony'],('age',18)])
print（info）#{'age': 18, 'name': 'tony'}
转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
{}.fromkeys(('name','age','sex'),None) #{'age': None, 'sex': None, 'name': None}
字典内置方法
1.clear(): 用于删除字典中的所有元素。
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
fruit_dict.clear()
print(fruit_dict) # 输出 {}
2.copy(): 返回一个字典的浅拷贝（shallow copy）。
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
copy_fruit_dict = fruit_dict.copy()
print(copy_fruit_dict) # 输出 {'apple': 1, 'banana': 2, 'orange': 3}
3.fromkeys(seq[, value]): 用于创建一个新字典，其中包含序列 seq 中每个元素作为键，而所有的值都设置为value。
seq = ('apple', 'banana', 'orange')
fruit_dict = dict.fromkeys(seq, 0)
print(fruit_dict) # 输出 {'apple': 0, 'banana': 0, 'orange': 0}
4.get(key[, default]): 返回指定键的值，如果键不存在则返回默认值。
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
print(fruit_dict.get('apple', 0)) # 输出 1
print(fruit_dict.get('watermelon', 0)) # 输出 0
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
dic.get('k1') #'jason' # key存在，则获取key对应的value值
res=dic.get('xxx') # key不存在，不会报错而是默认返回None
print(res) #None
res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
print(res) #666
# ps:字典取值建议使用get方法
5.items(): 返回一个包含所有（键，值）元组的列表。获取字典所有的键值对
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
print(fruit_dict.items()) # 输出 dict_items([('apple', 1), ('banana', 2), ('orange', 3)])
6.keys(): 返回一个包含所有键的列表。获取字典所有的key
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
print(fruit_dict.keys()) # 输出 dict_keys(['apple', 'banana', 'orange'])
7.pop(key[, default]): 删除指定键，并返回对应的值。如果键不存在，则返回默认值（如果提供了）或引发 KeyError 错误。
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
v = dic.pop('k2') # 删除指定的key对应的键值对,并返回值
print（dic）#{'k1': 'jason', 'kk2': 'JY'}
print（v）#'Tony'
8.popitem(): 随机删除并返回一个（键，值）对元组。
dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem() # 随机删除一组键值对,并将删除的键值放到元组内返回
print（dic）#{'k3': 'JY', 'k2': 'Tony'}
print（item）#('k1', 'jason')
9.setdefault(key[, default]): 如果键存在，则返回其值，否则将键插入字典并返回默认值（如果提供了）或 None。
1.key不存在则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222}
res=dic.setdefault('k3',333)
print（res）# 333
print（dic） # 字典中新增了键值对 #{'k1': 111, 'k3': 333, 'k2': 222}
2.key存在则不做任何修改，并返回已存在key对应的value值
dic={'k1':111,'k2':222}
res=dic.setdefault('k1',666)
print（res）#111
dic # 字典不变 #{'k1': 111, 'k2': 222}
10.update([other]): 更新字典，以其他字典或键-值对序列（iterable）中的键值覆盖当前字典中的相应值。
fruit_dict = {'apple': 1, 'banana': 2}
fruit_dict.update({'orange': 3, 'watermelon': 4})# 用新字典更新旧字典，有则修改，无则添加
print(fruit_dict) # 输出 {'apple': 1, 'banana': 2, 'orange': 3, 'watermelon': 4}
11.values(): 返回一个包含所有值的列表。获取字典所有的value
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
print(fruit_dict.values()) # 输出 dict_values([1, 2, 3])
八、集合set
1.集合介绍以及使用
在Python中，集合（Set）是一种无序的容器类型，只能包含唯一的元素。集合可以通过花括号 {} 或者 set() 函数来创建。
说明
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
s = {1,2,3,4} # 本质 s = set({1,2,3,4})
注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。
注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({'name':'jason',})
s3 = set('egon')
print（s,s1,s2,s3）# {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
1.1.创建set集合
1.使用花括号创建set集合
a = {1, 2, 3, 4}
2.使用set()函数创建set集合
b = set([1, 2, 3, 4])
1.2集合运算
两个集合的关系如下图所示定义两个集合friends与friends2来分别存放两个人的好友名字
friends1 = {"zero","kevin","ly","qq"} friends1 的好友们
friends2 = {"Jy","ricky","ly","qq"} friends2 的好友们
1.交集(&)运算符
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2
print(s3) # 输出结果：{2, 3}
2.并集(|)运算符
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2
print(s3) # 输出结果：{1, 2, 3, 4}
3.差集(-)运算符
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 - s2
print(s3) # 输出结果：{1}
4.对称差集(^)运算符
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2
print(s3) # 输出结果：{1, 4}
5.子集(<)和超集(>)运算符
s1 = {1, 2}
s2 = {1, 2, 3}
result = s1 < s2
print(result) # 输出结果：True
s1 = {1, 2, 3}
s2 = {1, 2}
result = s1 > s2
print(result) # 输出结果：True
1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'ly', 'Jy', 'qq'}
2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'ly', 'qq'}
3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
5.值是否相等(==)
>>> friends1 == friends2
False
6.父集：一个集合是否包含另外一个集合
6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
1.3集合的内置方法
1.add()方法
s = set([1, 2, 3])
s.add(4)
print(s) # 输出结果：{1, 2, 3, 4}
2.clear()方法
s = set([1, 2, 3])
s.clear()
print(s) # 输出结果：set()
3.copy()方法
s1 = set([1, 2, 3])
s2 = s1.copy()
print(s2) # 输出结果：{1, 2, 3}
4.difference()方法
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.difference(s2)
print(s3) # 输出结果：{1}
5.discard()方法
s = set([1, 2, 3])
s.discard(2)
print(s) # 输出结果：{1, 3}
6.intersection()方法
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.intersection(s2)
print(s3) # 输出结果：{2, 3}
7.isdisjoint()方法
s1 = set([1, 2, 3])
s2 = set([4, 5, 6])
print(s1.isdisjoint(s2)) # 输出结果：True
s3 = set([2, 3, 4])
print(s1.isdisjoint(s3)) # 输出结果：False
8.issubset()方法
s1 = set([1, 2, 3])
s2 = set([1, 2, 3, 4])
print(s1.issubset(s2)) # 输出结果：True
s3 = set([2, 3, 4])
print(s1.issubset(s3)) # 输出结果：False
9.issuperset()方法
s1 = set([1, 2, 3])
s2 = set([1, 2])
print(s1.issuperset(s2)) # 输出结果：True
s3 = set([2, 3, 4])
print(s1.issuperset(s3)) # 输出结果：False
10.pop()方法
s = set([1, 2, 3])
x = s.pop()
print(x) # 输出结果：1
print(s) # 输出结果：{2, 3}
11.remove()方法
s = set([1, 2, 3])
s.remove(2)
print(s) # 输出结果：{1, 3}
12.symmetric_difference()方法
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.symmetric_difference(s2)
print(s3) # 输出结果：{1, 4}
13.union()方法
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.union(s2)
print(s3) # 输出结果：{1, 2, 3, 4}
14.update()方法
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1.update(s2)
print(s1) # 输出结果：{1, 2, 3, 4}
1.4去重
集合去重复有局限性1. 只能针对不可变类型
2. 集合本身是无序的，去重之后无法保留原来的顺序
l=['a','b',1,'a','a']
s=set(l)
print（s） # 将列表转成了集合 {'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print（l_new）#['b', 'a', 1] # 去除了重复，但是打乱了顺序
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print（new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
{'age': 18, 'sex': 'male', 'name': 'lili'},
{'age': 73, 'sex': 'male', 'name': 'jack'},
{'age': 20, 'sex': 'female', 'name': 'tom'}
]
"""
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'ly','qq','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
pythons & linuxs
# 求出所有报名的学生名字集合
pythons | linuxs
# 求出只报名python课程的学员名字
pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
pythons ^ linuxs
九、 布尔bool
布尔只有两种状态，True 或 False
在 Python 中布尔的首字母要大写，其他语言是小写
用来记录真假这两种状态
is_ok = True
is_ok = False
使用
通常用来当作判断的条件，我们将在if判断中用到它
在python中什么是真?什么是假?什么是假：0 , " " ，None , { } , [ ] , ... 空的内容都是假的 , 其余都是真的
十、可变类型与不可变类型
可变数据类型和不可变数据类型可变和不可变都是基于内存地址来说的
可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值
不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值
总结：不可变数据类型更改后地址发生改变，可变数据类型更改地址不发生改变
数值型（不可变数据类型）```python
A = 1
print(id(A),type(A))
140710074386096 <class 'int'>
A = 100
print(id(A),type(A))
140710074389264 <class 'int'>
可以发现,变量的内存地址发生了改变，说明整型是不可变数据类型，浮点型也一样，那数值类型就是不可变数据类型。
**字符串（**不可变数据类型**）**```python
>>> x = "Jy"
>>> id(x)
938809263920
>>> x = "Ricky"
>>> id(x)
938809264088
# 内存地址改变了，说明字符串是不可变数据类型
列表（可变数据类型）```python
list1 = ['tom','jack','egon']
id(list1)
486316639176
list1[2] = 'kevin'
id(list1)
486316639176
list1.append('lili')
id(list1)
486316639176
对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型
元组（不可变的数据类型）```python
>>> t1 = ("tom","jack",[1,2])
>>> t1[0]='TOM' # 报错：TypeError
>>> t1.append('lili') # 报错：TypeError
# 元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改
>>> t1 = ("tom","jack",[1,2])
>>> id(t1[0]),id(t1[1]),id(t1[2])
(4327403152, 4327403072, 4327422472)
>>> t1[2][0]=111 # 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
>>> t1
('tom', 'jack', [111, 2])
>>> id(t1[0]),id(t1[1]),id(t1[2]) # 查看id仍然不变
(4327403152, 4327403072, 4327422472)
字典（可变数据类型）（set 也是可变数据类型）```python
dic = {'name':'egon','sex':'male','age':18}
id(dic)
4327423112
dic['age']=19
dic
{'age': 19, 'sex': 'male', 'name': 'egon'}
id(dic)
4327423112
对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型
<a name="REZCg"></a>
# 十一、数据类型以及内置方法总结
<a name="OGwzr"></a>
# 十二、队列和栈
Python 中的队列和栈都是常见的数据结构，它们主要用于存储和操作一系列数据。队列和栈的实现方式略有不同，下面分别介绍它们的基本概念和相关操作。
<a name="C408M"></a>
## 1.队列
队列（Queue）是一种先进先出（First-In-First-Out，FIFO）的数据结构，类似于排队买东西或者排队上车。在 Python 中，可以通过使用 queue 模块中的 Queue 类来创建一个队列对象。
<a name="zzjJK"></a>
### 1.1 创建队列对象
```python
import queue
q = queue.Queue() # 创建一个空队列
1.2基本操作
以下是对队列进行基本操作的方法：
- q.put(item[, block[, timeout]]): 将 item 放入队列，如果 block=True 则等待直到队列非空，timeout 表示超时时间；
- q.get([block[, timeout]]): 获取并移除队列头部元素，如果 block=True 则等待直到队列非空，timeout 表示超时时间；
- q.qsize(): 返回队列中当前元素数量；
- q.empty(): 如果队列为空返回 True，否则返回 False；
- q.full(): 如果队列已满返回 True，否则返回 False。
1.3示例
下面是对队列进行操作的示例代码。
import queue
q = queue.Queue()
q.put(1)
q.put(2)
q.put(3)
print(q.qsize()) # 输出 3
item = q.get()
print(item) # 输出 1
item = q.get()
print(item) # 输出 2
print(q.empty()) # 输出 False
item = q.get()
print(item) # 输出 3
print(q.empty()) # 输出 True
这段代码用 Python 自带的 queue 模块实现了队列（Queue）的基本操作，具体实现方式如下：
导入 queue 模块，然后通过 queue.Queue() 创建一个空队列对象 q，即 q = queue.Queue()。
1.使用 q.put() 方法向队列中依次添加元素 1、2 和 3，即 q.put(1)、q.put(2) 和 q.put(3)。
2.使用 q.qsize() 方法获取当前队列对象 q 中的元素数量，即队列中元素的数量。由于此时队列中已经有 3 个元素，因此输出值为 3。
3.使用 q.get() 方法获取并移除队列头部元素，即队列中第一个元素 1，将其赋值给变量 item。第一次执行 item = q.get() 时，item 的值为 1。
4.再次使用 q.get() 方法获取并移除队列头部元素，即队列中第二个元素 2，同样将其赋值给变量 item。此时 item 的值为 2。
5.使用 q.empty() 方法判断当前队列是否为空，如果队列不为空则返回 False，否则返回 True。由于队列中还有一个元素 3，因此输出值为 False。
6.再次使用 q.get() 方法获取并移除队列头部元素，即队列中最后一个元素 3，将其赋值给变量 item。此时 item 的值为 3。
7.再次使用 q.empty() 方法判断当前队列是否为空，由于队列已经为空，因此输出值为 True。
总之，这段代码展示了在 Python 中如何使用 queue 模块实现队列的基本操作，包括入队（put）和出队（get）。需要注意的是，在操作队列时，需要遵循先进先出（FIFO）原则。
2.栈
栈（Stack）是一种先进后出（Last-In-First-Out，LIFO）的数据结构，类似于餐厅里洗碗碟子的场景，后洗的碟子先放在桶里面。在 Python 中，可以通过使用 list 类型来实现一个栈。
2.1创建栈对象
s = [] # 创建一个空栈
2.2基本操作
以下是对栈进行基本操作的方法:
2.3示例
s = []
s.append(1)
s.append(2)
s.append(3)
print(len(s)) # 输出 3
item = s.pop()
print(item) # 输出 3
item = s.pop()
print(item) # 输出 2
print(len(s)) # 输出 1
item = s[-1]
print(item) # 输出 1
在 Python 中使用列表（List）来实现栈的基本操作，具体实现方式如下：
1.创建一个空的列表 s，即 s = []。
2.将元素 1、2、3 依次添加到列表末尾，即 s.append(1)、s.append(2) 和 s.append(3)。
3.使用 len(s) 获取当前列表 s 的长度，即栈中元素的数量。
4.使用 s.pop() 方法移除并返回列表 s 的最后一个元素，也就是栈顶元素。第一次执行 item = s.pop() 时，item 取得的值为 3，此时栈中仅剩两个元素。
5.再次使用 s.pop() 移除并返回栈顶元素，此时取得的值为 2。
6.使用 len(s) 获取当前列表 s 的长度，此时栈中仅剩一个元素。
7.使用 s[-1] 获取列表 s 的最后一个元素，即栈顶元素。此时取得的值为 1。
总之，这段代码展示了在 Python 中如何使用列表实现栈的基本操作，包括入栈（append）和出栈（pop）。需要注意的是，在使用列表实现栈时，需要遵循栈的后进先出（LIFO）原则。
总之，队列和栈是两种常用的数据结构，在 Python 中可以使用 queue 模块和 list 类型来实现。需要根据具体的场景选择合适的数据结构进行操作。
