Python 数据类型--详细整理_type(3j)-优快云博客

本文链接：https://blog.youkuaiyun.com/Saki_Python/article/details/134006637

Python 数据类型

类型	具体类型
数值类型	`int` 整数, `float` 浮点数, `complex` 复数, `bool` 布尔值
文本类型	`str` 字符串
序列类型	`list` 列表, `tuple` 元组, `range` 范围
集合类型	`set` 集合, `frozenset`
映射类型	`dict` 字典
二进制类型	`bytes`, `bytearray`, `memoryview`

数据类型	特点	示例
`int` 整数	不可变	`100`
`float` 浮点数	不可变	`12.2`
`complex` 复数	不可变	`2+3j` (只有 `j` 可以，其他字母不可以)
`bool` 布尔值	不可变	`True`、`False` (大写大写)
`str` 字符串	不可变	`'abcd'`
`range` 范围	不可变	`range(1,10,2)`
`list` 列表	可变、可重复、有序	`['abcd', 786]`
`tuple` 元组	不可变、可重复、有序	`('abcd', 2.23, 'runoob', 70.2)`
`set` 集合	可变、不可重复、无序	`{'f', 'g', 'e', 'e'}`
`dict` 字典	可变、无序、键值对的数据集合	`{'name': 'run', 'code':1, 'site': 'www'}`

获取数据类型：
- type(xxx) 返回数据类型，不会认为子类是一种父类类型
- isinstance(xxx, yyy)返回布尔值，会认为子类是一种父类类型

type(100)                        # <class 'int'>
type(10.1)                       # <class 'float'>
type(2+3j)                       # <class 'complex'>
type(True)                       # <class 'bool'>
type('abcd')                     # <class 'str'>
type([2, '1'])                   # <class 'list'>
type((2, '1'))                   # <class 'tuple'>
type(range(1,9))                 # <class 'range'>
type({1,3,4})                    # <class 'set'>
type({'name': 'Ann', 'age': 3})  # <class 'dict'>

python 的 bool 是数值类型吗

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
print(isinstance(a, int))
# 输出
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
True

设置数据类型
- 在 Python 中，当为变量赋值时，会自动设置数据类型
- 如果希望指定数据类型，可以使用构造函数

1 空值

空值是 Python 里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

>>> type(None)
<class 'NoneType'>

在 Python 中，空值用 None 表示。None 是一个特殊的对象，表示一个空的或不存在的值。

可以将 None 赋值给任何变量，但它并不等同于零、空字符串或 False。

在比较时，None 只与自身相等。例如：

x = None
if x is None:
    print("x is None")
else:
    print("x is not None")

输出结果为：

x is None

None：表示空值，可以用于初始化变量或作为函数返回值。

a = None
print(a)  # 输出 None

is运算符：用于判断两个变量是否指向同一个对象，如果是，则返回 True，否则返回 False。

这里使用了 is 运算符来比较 x 是否为 None。注意，不能使用 == 运算符来比较 None，因为它可以与许多其他值相等，例如空字符串、空列表等。

a = None
b = None
c = 0
print(a is b)  # 输出 True
print(a is c)  # 输出 False

is not运算符：用于判断两个变量是否指向不同的对象，如果是，则返回 True，否则返回 False。

a = None
b = None
c = 0
print(a is not b)  # 输出 False
print(a is not c)  # 输出 True

注意，None 是一个对象，而不是一个常量。因此，当使用 is 进行比较时，需要注意对象的身份。

2 数值类型

Python3 支持 int、float、bool、complex（复数）。
Python3 只有一种整数类型 int 长整型，没有 python2 中的 Long。
Python3 中 bool 是 int 的子类，True 和 False 可以和数字相加

>>> issubclass(bool, int)  # True
>>> True==1                # True
>>> False==0               # True
>>> True+1                 # 2
>>> False+1                # 1
>>> 1 is True              # False
>>> 0 is False             # False

运算：在混合计算时，Python 会把整型转换成为浮点数

>>> 5 + 4  # 加法 9
>>> 4.3 - 2 # 减法 2.3
>>> 3 * 7  # 乘法 21
>>> 2 / 4  # 除法，得到一个浮点数 0.5
>>> 2 // 4 # 除法，得到一个整数 0
>>> 17 % 3 # 取余 2
>>> 2 ** 5 # 乘方 32

2.1 整数 int

正、负整数、0: 8080、-8080、0
十六进制表示整数：十六进制用 0x 前缀和 0-9，a-f 表示，例如：0xff00，0xa5b4c3d2，等等。
在数字中间以_分隔: 10_000_000_000 和 10000000000 是一样的。十六进制数也可以写成 0xa1b2_c3d4。

2.1.1 整数内置方法

Python 中有很多内置函数可以用于处理整数，以下是整数相关常用的函数：

全局方法：

abs(x)：返回 x 的绝对值。
divmod(x, y)：返回 x 除以 y 的商和余数，以元组 (q, r) 的形式返回，其中 q 是商，r 是余数。
pow(x, y[, z])：返回 x 的 y 次幂，如果给定了 z，则对结果取模后返回。
int(x[, base])：将一个字符串或数字转换为整数。如果指定了 base，则将字符串解析为该进制的整数。
bin(x)：将整数 x 转换为二进制字符串。
oct(x)：将整数 x 转换为八进制字符串。
hex(x)：将整数 x 转换为十六进制字符串。

下面是一些使用这些函数的例子：

# abs(x)
print(abs(-3))  # 输出：3

# divmod(x, y)
print(divmod(10, 3))  # 输出：(3, 1)

# pow(x, y[, z])
print(pow(2, 3))  # 输出：8
print(pow(2, 3, 5))  # 输出：3

# int(x[, base])
print(int('1010', 2))  # 输出：10

# bin(x)
print(bin(10))  # 输出：0b1010

# oct(x)
print(oct(10))  # 输出：0o12

# hex(x)
print(hex(10))  # 输出：0xa

还有一些其他的函数，例如 max(iterable) 可以返回一个迭代器中的最大值，min(iterable) 可以返回最小值。注意，这些函数都只适用于整数或可以转换为整数的数据类型。

2.2 浮点数 float

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109 和 12.3x108 是完全相等的。
浮点数可以用数学写法，如 1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把 10 用 e 替代，1.23x109 就是 1.23e9，或者 12.3e8，0.000012 可以写成 1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

2.2.1 浮点数内置方法

Python 中有很多内置函数可以用于处理浮点数，以下是其中一些常用的函数：

全局方法：

round(x, n)：将浮点数 x 四舍五入到 n 位小数（默认为 0）。
abs(x)：返回浮点数 x 的绝对值。
min(x1, x2, ..., xn)：返回一组浮点数中的最小值。
max(x1, x2, ..., xn)：返回一组浮点数中的最大值。
pow(x, y) 或 x ** y：返回 x 的 y 次幂。

math 方法：

math.sqrt(x)：返回浮点数 x 的平方根。
math.floor(x)：返回小于或等于浮点数 x 的最大整数。
math.ceil(x)：返回大于或等于浮点数 x 的最小整数。

下面是一些使用这些函数的例子：

# 四舍五入
print(round(3.14159))  # 输出：3
print(round(3.14159, 2))  # 输出：3.14

# 取绝对值
print(abs(-5.6))  # 输出：5.6

# 求最大值和最小值
print(min(-1, 0, 1))  # 输出：-1
print(max(-1, 0, 1))  # 输出：1

# 幂运算
print(pow(2, 3))  # 输出：8
print(2 ** 3)  # 输出：8

# 平方根
import math
print(math.sqrt(9))  # 输出：3.0

# 向下取整和向上取整
print(math.floor(3.8))  # 输出：3
print(math.ceil(3.2))  # 输出：4

注意，在进行浮点数计算时，由于浮点数的精度问题，可能会出现一些意外的结果，例如：

print(0.1 + 0.2)  # 输出：0.30000000000000004

这是因为在计算机中，浮点数是以二进制的形式存储的，而在某些情况下，二进制无法精确表示某些十进制小数，从而导致精度问题。因此，在进行浮点数计算时，需要特别注意精度问题。

2.3 复数 complex

在 Python 中，复数是由实部和虚部组成的数。它们可以用 a + bj 的形式表示，其中 a 是实部，b 是虚部，j 是虚数单位，满足 j^2 = -1。

在 Python 中，可以用 complex() 函数来创建一个复数对象。例如，complex(1, 2) 将返回一个实部为 1，虚部为 2 的复数对象。可以使用 +、-、* 和 / 等运算符对复数进行加、减、乘和除的运算。

# 创建一个复数对象
z = complex(1, 2)

# 输出复数的实部和虚部
print("Real part:", z.real) # Real part: 1.0
print("Imaginary part:", z.imag) # Imaginary part: 2.0

# 输出复数的模
print("Magnitude:", abs(z)) # Magnitude: 2.23606797749979

# 对复数进行加减乘除运算
w = complex(3, 4)
print("z + w =", z + w) # z + w = (4+6j)
print("z - w =", z - w) # z - w = (-2-2j)
print("z * w =", z * w) # z * w = (-5+10j)
print("z / w =", z / w) # z / w = (0.44+0.08j)

2.3.1 复数内置方法

Python 中有一些内置方法可以用于处理复数：

全局方法：
- complex(real, imag)：创建一个复数，其中 real 是实部，imag 是虚部。
- abs(z)：返回复数 z 的模长。
复数实例属性
- z.real：返回复数 z 的实部。
- z.imag：返回复数 z 的虚部。
复数实例方法
- z.conjugate()：返回复数 z 的共轭复数。

下面是一些使用这些函数的例子：

# 创建一个复数
z = complex(3, 4)
print(z)  # 输出：(3+4j)

# 获取复数的实部和虚部
print(z.real)  # 输出：3.0
print(z.imag)  # 输出：4.0

# 获取复数的模长和共轭复数
print(abs(z))  # 输出：5.0
print(z.conjugate())  # 输出：(3-4j)

还有一些其他的函数，例如 cmath.phase(z) 可以返回复数 z 的相位角，cmath.rect(r, phi) 可以根据极坐标形式创建一个复数。

注意，这些函数都来自于 cmath 模块，而不是 math 模块。

2.4 布尔值 bool

在 Python 中，布尔类型有两个值：True 和 False。

这两个值都是关键字，表示真和假。可以使用布尔类型来进行条件判断、循环控制等操作。

在 Python 中，还可以将其他类型的值转换为布尔类型。

所有非零数、非空字符串、非空列表、非空元组、非空字典等都被视为 True，
只有空值 None 和 False 被视为 False。

可以使用 bool() 函数将其他类型的值转换为布尔类型。例如：

print(bool(0))        # False
print(bool(1))        # True
print(bool(""))       # False
print(bool("hello"))  # True
print(bool([]))       # False
print(bool([1, 2]))   # True
print(bool(()))       # False
print(bool((1, 2)))   # True
print(bool({}))       # False
print(bool({"a": 1})) # True
print(bool(None))     # False

注意，布尔类型也可以进行逻辑运算，包括与、或、非三种运算。与运算用 and 表示，或运算用 or 表示，非运算用 not 表示。例如：

print(True and False) # False
print(True or False)  # True
print(not True)       # False

2.4.1 布尔值内置方法

Python 中与布尔值相关的内置函数有以下几个：

全局方法

bool()：用于将给定的值转换为布尔类型。如果值为假，返回 False，否则返回 True。
all()：用于判断给定的可迭代对象中所有元素是否都为真。如果是，则返回 True，否则返回 False。如果可迭代对象为空，也会返回 True。
any()：用于判断给定的可迭代对象中是否有任意一个元素为真。如果是，则返回 True，否则返回 False。如果可迭代对象为空，也会返回 False。

3 文本类型 – 字符串 str

Python 中的字符串是一种不可变的数据类型，表示一串字符序列。

3.1 字符串表示

3.1.1 基本表示

字符串可以由单引号、双引号或三引号（三个单引号或三个双引号）表示，例如：

string1 = 'Hello, world!'
string2 = "I'm a Python developer."
string3 = """This is a multi-line string.
You can use it to write long paragraphs."""

三个双引号表示，可以用于跨多行的字符串。

3.1.2 复杂表示

Python 中的字符串支持许多操作，例如：

字符串拼接：可以使用 + 运算符将两个字符串拼接起来，例如："Hello" + " " + "world"。
字符串复制：可以使用 * 运算符将一个字符串复制多次，例如："Hello" * 3。
字符串索引：可以使用方括号 [] 和索引值获取字符串中的某个字符，例如："Hello"[0] 返回 'H'。
字符串切片：可以使用方括号和索引值获取字符串中的子串，例如："Hello"[1:3] 返回 'el'。

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

str = 'abcdefg'
# 冒号左边的包括，冒号右边的不包括
str[0:-1]    # 第一个到倒数第二个的所有字符
str[2:5]     # 从第三个开始到第五个的字符
str[2:]      # 从第三个开始的后的所有字符
str * 2      # 字符串两次，也可以写成 2 * str

3.1.3 转义字符

反斜杠 \ 转义特殊字符，不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

3.1.4 字符串格式化

Python 中的字符串格式化可以使用 % 运算符、format() 方法和 f-string 三种方式实现。

使用 % 运算符

使用 % 运算符可以将一个字符串中的占位符替换为指定的值。例如：

name = "Alice"
age = 25
print("My name is %s and I'm %d years old." % (name, age))

上述代码中，%s 和 %d 分别表示字符串和整数类型的占位符，% 运算符后面的括号中依次为占位符指定了具体的值。

使用 format() 方法

使用 format() 方法可以将一个字符串中的占位符替换为指定的值。例如：

name = "Bob"
age = 30
print("My name is {} and I'm {} years old.".format(name, age))

上述代码中，{} 表示占位符，format() 方法中依次为占位符指定了具体的值。

使用 f-string

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

f-string 是 Python 3.6 引入的一种字符串格式化方式，可以将一个字符串中的占位符替换为指定的值。例如：

name = "Charlie"
age = 35
print(f"My name is {name} and I'm {age} years old.")

上述代码中，在字符串前面加上 f，并在占位符中使用 {} 括起来需要替换的变量名即可。

以上三种字符串格式化方式都可以实现相同的效果，具体使用哪种方式取决于个人喜好和项目需求。

3.2 字符串方法

字符串长度：可以使用 len() 函数获取字符串的长度，例如：len("Hello") 返回 5。

以下所有字符串方法都返回新值。它们不会更改原始字符串。

详情见 👉w3school 字符串方法，这里不一一展开，要用的时候详细看看，多用才能记住

示例：

>>> txt = "welcome to China"
>>> txt.split()
['welcome', 'to', 'China']

方法	描述
`capitalize()`	把首字符转换为大写。
`casefold()`	把字符串转换为小写。
`center()`	返回居中的字符串。
`count()`	返回指定值在字符串中出现的次数。
`encode()`	返回字符串的编码版本。
`endswith()`	如果字符串以指定值结尾，则返回 true。
`expandtabs()`	设置字符串的 tab 尺寸。
`find()`	在字符串中搜索指定的值并返回它被找到的位置。
`format()`	格式化字符串中的指定值。
`format_map()`	格式化字符串中的指定值。
`index()`	在字符串中搜索指定的值并返回它被找到的位置。
`isalnum()`	如果字符串中的所有字符都是字母数字，则返回 True。
`isalpha()`	如果字符串中的所有字符都在字母表中，则返回 True。
`isdecimal()`	如果字符串中的所有字符都是小数，则返回 True。
`isdigit()`	如果字符串中的所有字符都是数字，则返回 True。
`isidentifier()`	如果字符串是标识符，则返回 True。
`islower()`	如果字符串中的所有字符都是小写，则返回 True。
`isnumeric()`	如果字符串中的所有字符都是数，则返回 True。
`isprintable()`	如果字符串中的所有字符都是可打印的，则返回 True。
`isspace()`	如果字符串中的所有字符都是空白字符，则返回 True。
`istitle()`	如果字符串遵循标题规则，则返回 True。
`isupper()`	如果字符串中的所有字符都是大写，则返回 True。
`join()`	把可迭代对象的元素连接到字符串的末尾。
`ljust()`	返回字符串的左对齐版本。
`lower()`	把字符串转换为小写。
`lstrip()`	返回字符串的左修剪版本。
`maketrans()`	返回在转换中使用的转换表。
`partition()`	返回元组，其中的字符串被分为三部分。
`replace()`	返回字符串，其中指定的值被替换为指定的值。
`rfind()`	在字符串中搜索指定的值，并返回它被找到的最后位置。
`rindex()`	在字符串中搜索指定的值，并返回它被找到的最后位置。
`rjust()`	返回字符串的右对齐版本。
`rpartition()`	返回元组，其中字符串分为三部分。
`rsplit()`	在指定的分隔符处拆分字符串，并返回列表。
`rstrip()`	返回字符串的右边修剪版本。
`split()`	在指定的分隔符处拆分字符串，并返回列表。
`splitlines()`	在换行符处拆分字符串并返回列表。
`startswith()`	如果以指定值开头的字符串，则返回 true。
`strip()`	返回字符串的剪裁版本。
`swapcase()`	切换大小写，小写成为大写，反之亦然。
`title()`	把每个单词的首字符转换为大写。
`translate()`	返回被转换的字符串。
`upper()`	把字符串转换为大写。
`zfill()`	在字符串的开头填充指定数量的 0 值。

4 序列类型 – 列表 list

列表(list)是 Python 中一种常见的数据类型，它可以存储多个值，并且这些值之间可以有重复和顺序（位置）之分。

创建列表

可以使用方括号 “[]” 来创建一个空列表，也可以在方括号中加入元素来创建一个有值的列表，例如：

my_list = []  # 创建一个空列表
my_list = [1, 2, 'apple', 'banana', True]  # 创建一个有值的列表

访问和修改列表元素

可以使用索引（也就是位置）来访问和修改列表元素。Python 中的索引从 0 开始，例如：

my_list = [1, 2, 'apple', 'banana', True]

print(my_list[0]) # 访问列表第一个元素 # 输出: 1

my_list[2] = 'orange' # 修改列表第三个元素
print(my_list)  # 输出: [1, 2, 'orange', 'banana', True]

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

列表切片

可以使用切片语法来获取列表的一个子集，例如：

my_list = [1, 2, 'apple', 'banana', True]

print(my_list[:3])  # 获取前三个元素 # 输出: [1, 2, 'apple']
print(my_list[-2:]) # 获取后两个元素 # 输出: [True, 'banana']
print(my_list[1:4]) # 获取第二个到第四个元素 # 输出: [2, 'apple', 'banana']

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

4.1 列表方法

详情 👉Python 列表/数组方法

Python 中，列表(list)是一种常见的数据类型。除了使用索引来访问和修改列表元素之外，还有很多列表相关的函数可用于操作列表。下面介绍一些常用的列表函数。

1. len( ) 函数

len() 函数可以返回列表中元素的个数。

my_list = [1, 2, 'apple', 'banana', True]
print(len(my_list))  # 输出: 5

2. append( ) 函数

append() 函数可以在列表末尾添加一个新元素。

my_list = [1, 2, 'apple', 'banana', True]
my_list.append('grape')
print(my_list)  # 输出: [1, 2, 'apple', 'banana', True, 'grape']

3. insert( ) 函数

insert() 函数可以在列表的指定索引处插入一个新元素。

my_list = [1, 2, 'apple', 'banana', True]
my_list.insert(2, 'orange')
print(my_list)  # 输出: [1, 2, 'orange', 'apple', 'banana', True]

4. remove( ) 函数

remove() 函数可以删除列表中的指定元素。

my_list = [1, 2, 'apple', 'banana', True]
my_list.remove('banana')
print(my_list)  # 输出: [1, 2, 'apple', True]

5. pop( ) 函数

pop() 函数可以删除列表中指定索引处的元素，并返回该元素的值。

my_list = [1, 2, 'apple', 'banana', True]
x = my_list.pop(3)
print(my_list)  # 输出: [1, 2, 'apple', True]
print(x)  # 输出: banana

6. sort( ) 函数

sort() 函数可以对列表进行排序，默认是按照升序排列，也可以通过设置 reverse=True 参数来实现降序排列。

my_list = [3, 7, 2, 1, 5]
my_list.sort()
print(my_list)  # 输出: [1, 2, 3, 5, 7]

my_list = [3, 7, 2, 1, 5]
my_list.sort(reverse=True)
print(my_list)  # 输出: [7, 5, 3, 2, 1]

7. count( ) 函数

count() 函数可以返回指定元素在列表中出现的次数。

my_list = [1, 2, 'apple', 'banana', True, 'banana', 'banana']
print(my_list.count('banana'))  # 输出: 3

以上是 Python 中一些常用的列表函数，还有其他许多函数可用于操作列表。

4.1.1 将列表当做堆栈使用

在 Python 中，可以将列表(list)当做堆栈(stack)使用。堆栈是一种后进先出(LIFO)的数据结构，也就是说最后入栈的元素最先出栈。

下面介绍如何使用列表作为堆栈来存储和操作数据。

1. 将元素入栈

使用列表的 append() 方法将新元素添加到列表末尾即可实现入栈操作。

stack = []

# 元素入栈
stack.append(1)
stack.append(2)
stack.append(3)

print(stack)  # 输出: [1, 2, 3]

2. 将元素出栈

使用列表的 pop() 方法从列表末尾删除一个元素即可实现出栈操作，并返回被删除的元素值。

stack = [1, 2, 3]

# 元素出栈
x = stack.pop()
print(x)  # 输出: 3
print(stack)  # 输出: [1, 2]

3. 查看栈顶元素

使用列表的索引操作来查看栈顶元素。

stack = [1, 2, 3]

# 查看栈顶元素
top_element = stack[-1]
print(top_element)  # 输出: 3

注意，虽然列表可以模拟堆栈的行为，但并不是所有情况下都适用于列表，对于一些复杂的数据结构，推荐使用标准库中的相应数据类型来实现。

4.1.2 将列表当作队列使用

在 Python 中，可以将列表(list)当作队列(queue)使用。队列是一种先进先出(FIFO)的数据结构，也就是说最先入队的元素最先出队。

下面介绍如何使用列表作为队列来存储和操作数据。

1. 将元素入队

使用列表的 append() 方法将新元素添加到列表末尾即可实现入队操作。

queue = []

# 元素入队
queue.append(1)
queue.append(2)
queue.append(3)

print(queue)  # 输出: [1, 2, 3]

2. 将元素出队

使用列表的 pop(0) 方法从列表开头删除一个元素即可实现出队操作，并返回被删除的元素值。

queue = [1, 2, 3]

# 元素出队
x = queue.pop(0)
print(x)  # 输出: 1
print(queue)  # 输出: [2, 3]

注意，使用 pop(0) 方法可能会导致性能问题，因为这个方法会移动队列中其他所有元素的位置。如果对性能有要求，推荐使用 collections 模块中的 deque 类型来实现队列，该类型既可以在两端进行添加或删除操作，也支持高效的 popleft() 操作。

from collections import deque

queue = deque()

# 元素入队
queue.append(1)
queue.append(2)
queue.append(3)

# 元素出队
x = queue.popleft()
print(x)  # 输出: 1
print(queue)  # 输出: deque([2, 3])

注意，虽然列表可以模拟队列的行为，但并不是所有情况下都适用于列表，对于一些复杂的数据结构，推荐使用标准库中的相应数据类型来实现。

4.2 列表遍历

Python 中列表(list)是一种常见的数据类型。在处理列表时，遍历每个元素是一个很常见的操作。下面介绍 Python 中列表遍历的所有办法。

1. for 循环遍历

使用 for 循环可以遍历整个列表，并对其中的每个元素进行操作。

my_list = [1, 2, 'apple', 'banana', True]

for element in my_list:
    print(element)
# 1
# 2
# apple
# banana
# True

2. while 循环遍历

使用 while 循环也可以遍历整个列表，需要设置一个变量来记录当前遍历到的元素的索引。

my_list = [1, 2, 'apple', 'banana', True]

i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1
# 1
# 2
# apple
# banana
# True

3. 列表推导式

列表推导式是一种语法糖，可以通过一行代码生成一个新的列表，同时遍历原始列表中的每个元素。

my_list = [1, 2, 3, 4, 5]

new_list = [x * 2 for x in my_list]

print(new_list)  # 输出: [2, 4, 6, 8, 10]

4. enumerate() 函数

enumerate() 函数可以同时遍历列表中的索引和元素。

my_list = [1, 2, 'apple', 'banana', True]

for i, element in enumerate(my_list):
    print(i, element)

# 0 1
# 1 2
# 2 apple
# 3 banana
# 4 True

5. zip() 函数

zip() 函数可以将多个列表中的元素一一配对，然后遍历它们。

numbers = [1, 2, 3]
fruits = ['apple', 'banana', 'cherry']

for number, fruit in zip(numbers, fruits):
    print(number, fruit)

# 1 apple
# 2 banana
# 3 cherry

5 序列类型 – 元组 tuple

当我们需要表示一组不可变的数据时，可以使用 Python 中的元组。元组和列表类似，其不同之处在于元组是不可变的，因此我们不能对元组中的元素进行添加、修改和删除操作。

Python 中的元组 (tuple) 是一种不可变的序列，使用小括号 () 来表示。
元组可以包含任意类型的数据，包括数字、字符串、列表、元组等。
可以把字符串看作一种特殊的元组。

定义元组

元组是一种有序、不可变的序列类型（不可变指的是元组一旦创建，就不能像列表那样进行修改，例如增删改）。Python 中定义元组使用小括号 ()，元素之间用逗号分隔。

tup1 = ()        # 定义一个空元组
tup2 = (1,)      # 定义一个元素的元组
tup3 = ('abcd', 786 , 2.23, 'runoob', [1, 2, 3]) # 定义多个元素的元组

访问元组元素

元组中的元素存储方式和列表相同，可以使用索引（从 0 开始）来访问元组中的元素，也可以使用切片来访问一部分元素。

tup = (1, 2, 3, 4, 5)

print(tup[1])    # 访问索引为1的元素，即第二个元素
print(tup[1:4])  # 切片访问元素，输出为：(2, 3, 4)

元组的不可变性

元组是不可变的，它一旦被创建就无法修改元素。元组中的元素可以是任意类型的对象，如数字、字符串、列表、元组等。虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表

tup = (1, 2, [3, 4])

tup[2][0] = 5 # 尝试修改索引为2的元素

print(tup) # 输出为：(1, 2, [5, 4])

由于元组中的元素不可变，对于可变类型的对象如列表，它们内部的元素是可以修改的。

元组相关操作

元组支持多种操作，如合并多个元组、重复元组、判断元素是否存在、获取元素个数等。

tup1 = (1, 2, 3)
tup2 = (4, 5, 6)

print(tup1 + tup2) # 合并元组
print(tup1 * 2)    # 重复元组
print(2 in tup1)   # 判断元素是否存在
print(len(tup1))   # 获取元素个数

以上是 Python 元组的基本知识，如果您想深入学习可以了解更高级的用途，如元组拆包、命名元组等。

5.1 元组拆包

元组拆包是一种 Python 独有的特性，它允许我们将一个元组或其他序列类型的值赋给一组变量。例如：

a, b, c = (1, 2, 3)
print(a)  # 输出 1
print(b)  # 输出 2
print(c)  # 输出 3

可以看到，上面这段代码中，我们将一个元组 (1,2,3) 赋值给三个变量 a、b、c，因此 a=1、b=2、c=3。

5.2 命名元组

有时候，我们需要用到一种数据类型，它具有元组的不可变性，同时还拥有类的属性，这就是命名元组。

命名元组可以看作是一种更加方便的元组形式，在一些特定场景下使用起来更加方便。

将元组转换成命名元组，我们需要使用 Python 标准库中的 collections 模块中的 namedtuple 函数。例如：

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)

print(p.x)  # 输出 1
print(p.y)  # 输出 2

以上代码中，我们将 namedtuple 函数用来定义了一个名叫 Point 的命名元组类型，该类型包含两个属性：x 和 y。然后，我们使用该类型创建了一个名叫 p 的点，它的 x 坐标为 1， y 坐标为 2。

总体来说，元组是 Python 中非常常见的数据类型之一，掌握了元组的相关知识可以让我们快速有效地处理不可变数据。

5.3 元组方法

详情 👉Python 元组方法

以下是 Python 元组相关的内置函数：

len()：返回元组中元素的个数。

tup = (1, 2, 3, 4, 5)
print(len(tup))  # 输出 5

max()：返回元组中最大的元素。

tup = (1, 2, 3, 4, 5)
print(max(tup))  # 输出 5

min()：返回元组中最小的元素。

tup = (1, 2, 3, 4, 5)
print(min(tup))  # 输出 1

tuple()：将列表转换为元组。

lst = [1, 2, 3, 4, 5]
tup = tuple(lst)
print(tup)  # 输出 (1, 2, 3, 4, 5)

cmp()：比较两个元组。

注意：在 Python 3 中，cmp() 函数已经被移除了。
```
tup1 = (1, 2, 3)
tup2 = (1, 2, 4)
print(cmp(tup1, tup2))  # 输出 -1
```

count()：返回元组中指定元素出现的次数。

tup = (1, 2, 2, 3, 3, 3, 4, 4, 4, 4)
print(tup.count(3))  # 输出 3

index()：返回元组中指定元素的索引位置。

tup = (1, 2, 3, 4, 5)
print(tup.index(3))  # 输出 2

6 序列类型 – 范围 Range

range() 函数返回的是一个 range 类型的对象，它表示一个不可修改的序列。range 类型的对象具有以下特点：

仅包含整数。
使用时才会计算序列中的值，而不是提前生成所有元素。
只有在需要时才占用内存空间。

在 Python 3.x 中，range() 函数返回的是一个类似列表的对象，但实际上是一个可迭代对象（iterable）。

range() 函数返回的是一个不可修改、按需计算、仅包含整数的序列对象。虽然它看起来类似于列表类型，但实际上是一个独立的数据类型，用于表示整数序列。使用 range 类型可以帮助我们更高效地处理大量的整数序列数据。

x = range(1,10,2)
print(x)           # range(1, 10, 2)
print(type(x))     # <class 'range'>
print(x[0],x[1],x[2],x[3],x[4])  # 1 3 5 7 9

访问元素

range 类型支持使用索引访问元素，例如获取第三个元素的值：

r = range(10)
print(r[3])

获取长度

range 类型支持使用 len() 函数获取其长度（即序列中元素的个数）。

r = range(10)
print(len(r))

6.1 范围遍历

与列表类型一样，我们可以使用 for 循环或者其他可迭代对象的方式遍历 range 类型的对象。

for i in range(10):
    print(i)

# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

7 集合类型 – 集合 set

在 Python 中，集合（set）是一种无序、不重复的数据类型。它可以用于去除重复元素、检查成员资格等场景。

集合（set）是 Python 中一种无序且不重复的数据类型，常用于去除重复元素和检查成员资格等场景。

基本功能是进行成员关系测试和删除重复元素

7.1 创建集合

可以使用花括号 {} 或者 set() 函数来创建集合。

创建非空集合：set() 或{...} 创建空集合：set()

# 使用花括号创建集合
s1 = {1, 2, 3}
print(s1)  # {1, 2, 3}

# 使用 set() 函数创建集合
s2 = set([2, 3, 4])
print(s2)  # {2, 3, 4}

注意，如果要创建空集合，必须使用 set() 函数，而不能使用 {}，因为 {} 表示一个空字典。

empty_set = set()
print(empty_set)  # set()

sites1 = {'a', 'b', 'c', 'd', 'e', 'e'}
sites2 = {'f', 'g', 'h', 'd', 'e', 'e'}
sites3 = {'abcdee'}
sites4 = set('12')
sites5 = set()

print(sites1)  # {'d', 'e', 'a', 'b', 'c'}
print(sites2)  # {'e', 'f', 'd', 'g', 'h'}
print(sites3)  # {'abcdee'}
print(sites4)  # {'1', '2'}
print(sites5)  # set()

print(sites1 - sites2)     # 差集 {'a', 'b', 'c'}
print(sites1 | sites2)     # 并集 {'d', 'a', 'g', 'h', 'c', 'e', 'f', 'b'}
print(sites1 & sites2)     # 交集 {'d', 'e'}
print(sites1 ^ sites2)     # 不同时存在的元素 {'f', 'g', 'b', 'h', 'c', 'a'}

7.2 集合方法

详情 👉Python 集合方法

7.2.1 添加元素

可以使用 add() 方法向集合中添加一个元素，或者使用 update() 方法向集合中添加多个元素。

s = {1, 2, 3}
s.add(4)        # 添加单个元素
s.update({5, 6})    # 添加多个元素
print(s) # {1, 2, 3, 4, 5, 6}

7.2.2 删除元素

可以使用 remove() 或者 discard() 方法删除集合中的元素。

s = {1, 2, 3, 4, 5}
s.remove(3)     # 删除元素 3
s.discard(6)    # 如果元素不存在，不会报错
print(s) # {1, 2, 4, 5}

7.2.3 集合运算

集合支持并集、交集、差集等运算。可以使用 union()、intersection()、difference() 等方法进行运算。

s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1.union(s2))         # 并集 {1, 2, 3, 4}
print(s1.intersection(s2))  # 交集 {2, 3}
print(s1.difference(s2))    # 差集 {1}

7.2.4 其他操作

集合还支持判断子集、超集等操作，可以使用 issubset()、issuperset() 方法进行操作。

s1 = {1, 2, 3}
s2 = {1, 2}
print(s2.issubset(s1))       # 判断 s2 是否是 s1 的子集
print(s1.issuperset(s2))     # 判断 s1 是否是 s2 的超集

输出结果分别为 True 和 True。

8 集合类型 – 字典 dict

在 Python 中，字典（dictionary）是一种无序的、可变的数据类型，用于存储键值对。字典中的键必须是唯一的，而值则不必

字典当中的元素是通过键来存取的，而不是通过偏移存取。

key 不可变，唯一，可以用数字，字符串或元组充当，而用列表就不行。

8.1 创建字典

可以使用花括号 {} 或者 dict() 函数来创建字典。

# 使用花括号创建字典
d1 = {'name': 'Alice', 'age': 20}
print(d1)  # {'name': 'Alice', 'age': 20}

# 使用 dict() 函数创建字典
d2 = dict([('name', 'Bob'), ('age', 21)])
print(d2)  # {'name': 'Bob', 'age': 21}

注意，如果要创建空字典，必须使用 dict() 函数，而不能使用 {}。

empty_dict = dict()
print(empty_dict)  # {}

dict = {}
dict['one'] = "111"
dict[2]     = "222"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值 111
print (dict[2])           # 输出键为 2 的值 222
print (tinydict)          # 输出完整的字典 {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 输出所有键 ['name', 'code', 'site']
print (tinydict.values()) # 输出所有值 ['runoob', 1, 'www.runoob.com']

dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])  # {'Runoob': 1, 'Google': 2, 'Taobao': 3}
{x: x**2 for x in (2, 4, 6)}  # {2: 4, 4: 16, 6: 36}
dict(Runoob=1, Google=2, Taobao=3) # {'Runoob': 1, 'Google': 2, 'Taobao': 3}

8.2 字典方法

详情 👉Python 字典方法

8.2.1 访问元素

可以通过键来访问字典中的元素。

d = {'name': 'Alice', 'age': 20}
print(d['name']) # Alice

如果要访问不存在的键，则会抛出 KeyError 异常。可以使用 get() 方法来避免该异常。

d = {'name': 'Alice', 'age': 20}
print(d.get('gender'))      # None
print(d.get('gender', '-')) # 如果键不存在，返回默认值 '-'

8.2.2 修改元素

可以通过键来修改字典中的元素。如果键不存在，则会添加新的键值对。

d = {'name': 'Alice', 'age': 20}
d['age'] = 21   # 修改元素
d['gender'] = 'female'  # 添加新元素
print(d) # {'name': 'Alice', 'age': 21, 'gender': 'female'}

8.2.3 删除元素

可以使用 del 关键字或者 pop() 方法删除字典中的元素。

d = {'name': 'Alice', 'age': 20}
del d['age']        # 删除元素
print(d)  # {'name': 'Alice'}

age = d.pop('age', None)    # 删除元素，如果键不存在，返回默认值 None
print(age) # None

8.2.4 遍历字典

可以使用 for 循环遍历字典中的键值对。

d = {'name': 'Alice', 'age': 20}
for key in d:
    print(key, d[key])
# name Alice
# age 20

也可以使用 items() 方法获取键值对，然后进行遍历。

d = {'name': 'Alice', 'age': 20}
for key, value in d.items():
    print(key, value)

# name Alice
# age 20

8.2.5 其他操作

字典还支持 len()、in 等操作，例如判断键是否存在。

d = {'name': 'Alice', 'age': 20}
print(len(d))               # 获取字典元素个数
print('age' in d)           # 判断键是否存在
print('gender' not in d)    # 判断键是否不存在

输出结果为 2、True 和 True。

8.3 字典遍历

在 Python 中，字典（dictionary）是一种无序的、可变的数据类型，用于存储键值对。可以使用多种方式遍历字典。

8.3.1 遍历键值对

使用 for 循环遍历字典中的键值对，可以使用 items() 方法获取键值对，然后进行遍历。

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}
for key, value in d.items():
    print(key, value)
# name Alice
# age 20
# gender female

8.3.2 遍历键

如果只需要遍历字典中的键，可以使用 keys() 方法。

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}
for key in d.keys():
    print(key)
# name
# age
# gender

也可以直接使用 for 循环遍历字典，此时默认遍历字典中的键。

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}
for key in d:
    print(key)

输出结果同上。

8.3.3 遍历值

如果只需要遍历字典中的值，可以使用 values() 方法。

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}
for value in d.values():
    print(value)

# Alice
# 20
# female

8.3.4 排序遍历

使用 sorted() 函数对字典中的键进行排序，然后遍历。

d = {'b': 2, 'a': 1, 'c': 3}
for key in sorted(d):
    print(key, d[key])
# a 1
# b 2
# c 3

8.3.5 列表推导式

使用列表推导式可以将字典中的键、值或者键值对转化成一个列表。

d = {'name': 'Alice', 'age': 20, 'gender': 'female'}
key_list = [key for key in d]
value_list = [value for value in d.values()]
kv_list = [(key, value) for key, value in d.items()]

print(key_list)   # ['name', 'age', 'gender']
print(value_list) # ['Alice', 20, 'female']
print(kv_list)    # [('name', 'Alice'), ('age', 20), ('gender', 'female')]

9 数据类型转换

一般只需要将数据类型作为函数名即可。

隐式类型转换 - 自动完成
显式类型转换 - 需要使用类型函数来转换

在 Python 中，可以使用内置的函数进行数据类型转换。常用的数据类型转换包括整数、浮点数、字符串、列表、元组、集合、字典等。

9.1 整数转换

将其他数据类型转换成整数可以使用 int() 函数。

a = '123'
b = 3.5
c = True
print(int(a)) # 123
print(int(b)) # 3
print(int(c)) # 1

注意，如果要将浮点数转换成整数，会截取整数部分。同时，True 被转换成了 1，False 被转换成了 0。

9.2 浮点数转换

将其他数据类型转换成浮点数可以使用 float() 函数。

a = '3.14'
b = 123
c = True
print(float(a)) # 3.14
print(float(b)) # 123.0
print(float(c)) # 1.0

注意，True 被转换成了 1.0，False 被转换成了 0.0。

9.3 字符串转换

将其他数据类型转换成字符串可以使用 str() 函数。

a = 123
b = 3.14
c = [1, 2, 3]
print(str(a)) # 123
print(str(b)) # 3.14
print(str(c)) # [1, 2, 3]

9.4 列表转换

将其他数据类型转换成列表可以使用 list() 函数。

a = '123'
b = (1, 2, 3)
c = {1, 2, 3}
d = {'name': 'Alice', 'age': 20}
print(list(a))  # ['1', '2', '3']
print(list(b))  # [1, 2, 3]
print(list(c))  # [1, 2, 3]
print(list(d))  # ['name', 'age']

注意，字典被转换成了只包含键的列表。

9.5 元组转换

将其他数据类型转换成元组可以使用 tuple() 函数。

a = '123'
b = [1, 2, 3]
c = {1, 2, 3}
d = {'name': 'Alice', 'age': 20}
print(tuple(a)) # ('1', '2', '3')
print(tuple(b)) # (1, 2, 3)
print(tuple(c)) # (1, 2, 3)
print(tuple(d)) # ('name', 'age')

注意，字典被转换成了只包含键的元组。

9.6 集合转换

将其他数据类型转换成集合可以使用 set() 函数。

a = '123'
b = [1, 2, 3]
c = (1, 2, 3)
d = {'name', 'age'}
e = {'name': 'Alice', 'age': 20}
print(set(a)) # {'3', '2', '1'}
print(set(b)) # {1, 2, 3}
print(set(c)) # {1, 2, 3}
print(set(d)) # {'name', 'age'}
print(set(e)) # {'name', 'age'}

注意，字典被转换成了只包含键的集合。

9.7 字典转换

将其他数据类型转换成字典可以使用 dict() 函数。

a = [('name', 'Alice'), ('age', 20)]
b = {'name': 'Alice', 'age': 20}
print(dict(a)) # {'name': 'Alice', 'age': 20}
print(dict(b)) # {'name': 'Alice', 'age': 20}

注意，元组列表和字典本身都可以直接转换成字典。

10 推导式

在 Python 中，推导式是一种简洁的语法，可以通过一个表达式快速构建出一个新的序列。Python 支持列表推导式、字典推导式和集合推导式。

10.1 列表推导式

syntax：[expression for element in iterable if condition]

其中，expression 是要应用于 iterable 中每个元素的操作；element 是 iterable 中的元素；condition 是可选的过滤条件，只有符合条件的元素才会被包含在推导式生成的列表中。

例如，我们可以通过以下代码生成一个由 1 到 10 的平方组成的列表：

squares = [x**2 for x in range(1, 11)]
print(squares)

10.2 字典推导式

syntax：{key_expression: value_expression for element in iterable if condition}

其中，key_expression 和 value_expression 分别是要应用于 iterable 中每个元素的操作，element 是 iterable 中的元素，condition 是可选的过滤条件，只有符合条件的元素才会被包含在推导式生成的字典中。

例如，我们可以通过以下代码生成一个由数字和它们的平方组成的字典：

square_dict = {x:x**2 for x in range(1, 6)}
print(square_dict)

10.3 集合推导式

syntax：{expression for element in iterable if condition}

其中，expression 是要应用于 iterable 中每个元素的操作，element 是 iterable 中的元素，condition 是可选的过滤条件，只有符合条件的元素才会被包含在推导式生成的集合中。

例如，我们可以通过以下代码得到 1 到 10 中所有能够被 2 整除的数字，以集合的形式表示：

even_nums = {x for x in range(1, 11) if x % 2 == 0}
print(even_nums)

元组(tuple)推导式：(表达式 for 变量 in 序列 if 条件 )
列表(list)推导式：[表达式 for 变量 in 序列 if 条件]
集合(set)推导式：{ 表达式 for 变量 in 序列 if 条件 }
字典(dict)推导式：{ key的表达式: value的表达式 for 变量 in 序列 if 条件 }
变量：自己另取的变量名
序列：已知给出的
条件：可有可无，提供的序列中满足 if 条件的
表达式：关于变量的变化（变成大写、平方等等）
key 的表达式：这个关于变量的变化作为 key
value 的表达式：这个关于变量的变化作为 value

str = 'abcd'
tuple = ( 'abcd', 'runoob')
list = [ 'abcd', 'runoob']
ran = range(1,10,2)
sites = {'f', 'g', 'e', 'e'}
dict = {'name': 'run', 'code':1, 'site': 'www'}

x1 = [name.upper() for name in str]
x2 = [name.upper() for name in tuple]
x3 = [name.upper() for name in list]
x4 = [name for name in ran]
x5 = [name.upper() for name in sites]
x6 = [name.upper() for name in dict]
print(x1, x2, x3, x4, x5, x6)
print(type(x1), type(x2), type(x3), type(x4), type(x5), type(x6))

# 结果
['A', 'B', 'C', 'D'] ['ABCD', 'RUNOOB'] ['ABCD', 'RUNOOB'] [1, 3, 5, 7, 9] ['G',
'E', 'F'] ['NAME', 'CODE', 'SITE']
<class 'list'> <class 'list'> <class 'list'> <class 'list'> <class 'list'> <class 'list'>

---------------------------END---------------------------