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'>
题外话
当下这个大数据时代不掌握一门编程语言怎么跟的上时代呢?当下最火的编程语言Python前景一片光明!如果你也想跟上时代提升自己那么请看一下.
感兴趣的小伙伴,赠送全套Python学习资料,包含面试题、简历资料等具体看下方。
👉CSDN大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)
一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照下面的知识点去找对应的学习资源,保证自己学得较为全面。
二、Python必备开发工具
工具都帮大家整理好了,安装就可直接上手!
三、最新Python学习笔记
当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。
四、Python视频合集
观看全面零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
五、实战案例
纸上得来终觉浅,要学会跟着视频一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。
六、面试宝典
简历模板
👉CSDN大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)
若有侵权,请联系删除