Python 数据类型--详细整理

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

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

a = None
print(a)  # 输出 None

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

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

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

3. 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

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

2.1.1 整数内置方法

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

• 全局方法：

1. abs(x)：返回 x 的绝对值。
2. divmod(x, y)：返回 x 除以 y 的商和余数，以元组 (q, r) 的形式返回，其中 q 是商，r 是余数。
3. pow(x, y[, z])：返回 x 的 y 次幂，如果给定了 z，则对结果取模后返回。
4. int(x[, base])：将一个字符串或数字转换为整数。如果指定了 base，则将字符串解析为该进制的整数。
5. bin(x)：将整数 x 转换为二进制字符串。
6. oct(x)：将整数 x 转换为八进制字符串。
7. 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. 浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的， 比如，1.23x109 和 12.3x108 是完全相等的。

2. 浮点数可以用数学写法，如 1.23，3.14，-9.01，等等。 但是对于很大或很小的浮点数，就必须用科学计数法表示，把 10 用 e 替代，1.23x109 就是 1.23e9， 或者 12.3e8，0.000012 可以写成 1.2e-5，等等。

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

2.2.1 浮点数内置方法

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

• 全局方法：

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

• math 方法：

6. math.sqrt(x)：返回浮点数 x 的平方根。
7. math.floor(x)：返回小于或等于浮点数 x 的最大整数。
8. 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 中与布尔值相关的内置函数有以下几个：

• 全局方法

1. bool()：用于将给定的值转换为布尔类型。如果值为假，返回 False，否则返回 True。
2. all()：用于判断给定的可迭代对象中所有元素是否都为真。如果是，则返回 True，否则返回 False。如果可迭代对象为空，也会返回 True。
3. 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 三种方式实现。

1. 使用 % 运算符

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

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

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

2. 使用 format() 方法

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

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

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

3. 使用 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 中一种常见的数据类型，它可以存储多个值，并且这些值之间可以有重复和顺序（位置）之分。

1. 创建列表

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

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

2. 访问和修改列表元素

可以使用索引（也就是位置）来访问和修改列表元素。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 表示倒数第二个项目，依此类推。

3. 列表切片

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

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']

4. 嵌套列表

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

>>> 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) 是一种不可变的序列，使用小括号 () 来表示。

• 元组可以包含任意类型的数据，包括数字、字符串、列表、元组等。

• 可以把字符串看作一种特殊的元组。

1. 定义元组

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

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

2. 访问元组元素

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

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

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

3. 元组的不可变性

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

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

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

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

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

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 元组相关的内置函数：

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

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

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

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

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

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

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

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

5. cmp()：比较两个元组。

   注意：在 Python 3 中，cmp() 函数已经被移除了。

   tup1 = (1, 2, 3)
   tup2 = (1, 2, 4)
   print(cmp(tup1, tup2))  # 输出 -1
   
   

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

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

7. 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

1. 访问元素

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

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

2. 获取长度

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---------------------------

题外话

当下这个大数据时代不掌握一门编程语言怎么跟的上时代呢？当下最火的编程语言Python前景一片光明！如果你也想跟上时代提升自己那么请看一下.

感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。


👉优快云大礼包🎁：全网最全《Python学习资料》免费赠送🆓！（安全链接，放心点击）

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

简历模板

👉优快云大礼包🎁：全网最全《Python学习资料》免费赠送🆓！（安全链接，放心点击）

若有侵权，请联系删除