数据类型和变量
1.1 Python 数字
Python 中有三种数字类型:
- int
- float
- complex
如需验证 Python 中任何对象的类型,请使用 type() 函数:
x=123 y='一,二,三' z=1.0 print(type(x)) print(type(y)) print(type(z)) #输出结果: <class 'int'> <class 'str'> <class 'float'>
1.1.1 Int
Int 或整数是完整的数字,正数或负数,没有小数,长度不限。
1.1.2 Float
浮动或“浮点数”是包含小数的正数或负数。浮点数也可以是带有“e”的科学数字,表示 10 的幂,例:
x = 27e4 y = 15E2 z = -49.8e100
1.1.3 复数
复数用 "j" 作为虚部编写:
x = 2+3j y = 7j z = -7j #输出结果: print(type(x)) print(type(y)) print(type(z))
1.1.4 小数
因为计算机硬件特点,浮点数不能执行精确运算
示例代码如下。
print(0.3+0.3+0.3+0.1) #输出结果: 0.9999999999999999 #计算结果并不是1.0
print(0.3-0.1-0.1-0.1) #输出结果: -2.7755575615628914e-17 #计算结果并不是0
-2.7755575615628914e-17
Python 2.4开始引入了一种新的数字类型:小数对象。
1.1.4.1 创建和使用小数对象
小数对象使用decimal模块中的Decimal()函数创建
示例代码如下:
from decimal import Decimal #从模块导入函数 sum=Decimal('0.3')+Decimal('0.3')+Decimal('0.3')+Decimal('0.1') print(sum) #输出结果: 1.0
1.1.4.1 小数的全局精度
全局精度指作用于当前程序的小数的有效位数设置,默认全局精度为28位有效数字。
可使用decimal模块中的上下文对象来设置小数的全局精度。
首先,调用decimal模块的getcontext()函数获得当前的上下文对象
再通过上下文对象的prec属性设置全局精度。
from decimal import Decimal, getcontext #或者使用 from decimal import * con=getcontext() con.prec=3 consult=Decimal('1')/Decimal('3') print(consult) #输出结果: 0.333
1.1.4.2 小数的临时精度
临时精度在with模块中使用。
首先,调用decimal模块的localcontext ()函数返回本地上下文对象
再通过本地上下文对象的prec属性设置临时精度,例:
from decimal import * with localcontext() as local: local.prec=2 consult=Decimal('1')/Decimal('3') print(consult) #输出结果: 0.33
1.1.5 分数
分数是Python 2.6和3.0版本引入的新类型。
分数对象明确地拥有一个分子和分母,分子和分母保持最简。
使用分数可以避免浮点数的不精确性。
分数使用fractions模块中的Fraction()函数来创建,其基本语法格式如下。
x = Fraction(a,b)
其中,a为分子,b为分母,python自动计算为最简分数,例:
from fractions import Fraction f=Fraction(100,2) print(f) #输出结果: 50
1.1.6 类型转换
您可以使用 int()、float() 和 complex() 方法从一种类型转换为另一种类型,
从一种类型转换为另一种类型,例:
x = 10 # int y = 6.3 # float z = 1j # complex # 把整数转换为浮点数 a = float(x) # 把浮点数转换为整数 b = int(y) # 把整数转换为复数: c = complex(x) print(a) print(b) print(c) print(type(a)) print(type(b)) print(type(c))
注意:您无法将复数转换为其他数字类型。
可以使用Fraction.from_float()函数将浮点数转换为分数,例:
from fractions import Fraction a=1.25 r=Fraction.from_float(a) print(r) #输出结果: 5/4
1.1.7 随机数
Python 没有 random() 函数来创建随机数,但 Python 有一个名为 random 的内置模块,可用于生成随机数:
导入 random 模块,并显示 1 到 9 之间的随机数,例:
import random print(random.randrange(1,10)) #输出结果: 1-9随机,不包含10
1.1.8数字运算
1.1.8.1 数字运算操作符
操作符 | 说明 | 举例 |
** | 幂运算 | 2**3 |
~ | 按位取反 | ~5 |
- | 负号 | -5 |
*、%、/、// | 乘法、求余数、真除法、floor除法 | 2*3、3%2、5/2、5//2 |
+、- | 加法、减法 | 2+3、2-3 |
<<、>> | 向左移位、向右移位 | 3<<2、12>>2 |
& | 按位与 | 5&2 |
^ | 按位异或 | 5^2 |
| | 按位或 | 5|2 |
<、<=、>、>=、==、!= | 小于、小于等于、大于、 大于等于、相等、不等 | 2<3、2<=3、2>3、 2>=3、2==3、2!=3 |
not | 逻辑非 | not True、not 2<3 |
and | 逻辑与 | x>5 and x<100 |
or | 逻辑或 | x<5 or x>100 |
3-1
1.1.8.2 计算的优先级
表3-1中操作符的运算优先级按从上到下的顺序依次降低。可以用括号(括号优先级最高)改变计算顺序,例:
print(2*5+10) print(2*(5+10)) #输出结果: 20 30
1.1.8.3 计算中的自动数据类型转换
在运算过程中遇到不同类型的数字参数时,Python总是将简单的类型转换为复杂的类型,例:
print(type(2+1.5)) #输出结果: <class 'float'> print(type(2+(2+6j))) #输出结果: <class 'complex'>
Python中的类型复杂度为:布尔型比整型简单、整型比浮点数简单、浮点数比复数简单。
1.1.8.4 求余数
' x % y'计算x除以y的余数,余数符号与y一致,例:
a=5%2 print(a) b=5%-2 #当y位上的值为负数时,结果也为负 print(b) #输出结果: 1 -1
若存在一个操作数为浮点数,则结果为浮点数,否则为整数,例:
a=5.0%2 print(a) #任意一个操作数为浮点数,则结果为浮点数 #输出结果: 1.0
1.1.8.5 真除法和floor除法
真除法
“/”运算称为真除法,这是为了与传统除法进行区别。
在Python 3.0之前的版本中,“/”运算在两个操作数都是整数时,计算结果只保留整数部分(称为截断除法);如果有一个操作数是浮点数,则计算结果为浮点数,保留小数部分。
在Python 3中,“/”运算执行真除法,即无论操作数是否为整数,计算结果都是浮点数,保留小数部分,例:
print(10/2) #输出结果: 5.0
floor除法
“//”运算称为floor除法。
“x // y”计算结果为不大于x除以y的(向下取整)最大整数。
当两个操作数都是整数时,结果为int类型,否则为float类型 ,例:
print(5//2) print(5//2.0) #输出结果: 2 #操作数都是int类型,结果为int类型 2.0 #操作数中一个是float类型,结果为float类型
1.1.8.6 位运算
位运算:~、&、^、|、<<、>>,按操作数的二进制位进行操作。
(1)按位取反“~”
操作数的二进制位中,1取反为0,0取反为1,符号也取反。
~5 #5的8位二进制形式为00000101,按位取反为11111010,即-6
按位与“&”
将两个操作数按其相同位置的数执行“与”操作,两个位上都是1时,与的结果为1,否则为0,例:
print(4 & 5) #4的二进制形式为00000100,5为00000101,所以结果为00000100 #输出结果: 4
print(-4 & 5) #-4的二进制形式为11111100,5为00000101,所以结果为00000100 #输出结果: 4
1.2 Python 字符串
python 中的字符串字面量由单引号或双引号括起。
'hello' 等同于 "hello"。
您可以使用 print() 函数显示字符串字面量,例:
print("Hello") print('Hello') #输出结果: Hello Hello
1.2.1 多行字符串
您可以使用三个引号或三个单引号将多行字符串赋值给变量,例:
s=''' 岁月里,总有秀丽暗香浮动,生命有热烈也有平淡,有欢喜也有忧伤, 记忆的花瓣总要找一个灵魂的支点。时光的角落里,总会隐藏着惊喜,也许就在下一个巷口, 完美的懂得便会如约而至。 ''' print(s) #输出结果: 岁月里,总有秀丽暗香浮动,生命有热烈也有平淡,有欢喜也有忧伤, 记忆的花瓣总要找一个灵魂的支点。时光的角落里,总会隐藏着惊喜,也许就在下一个巷口, 完美的懂得便会如约而至。
1.2.2 字符串是数组
Python 中的字符串是表示 unicode 字符的字节数组。
方括号可用于访问字符串的元素:
获取位置 1 处的字符(请记住第一个字符的位置为 0),例:
a = "Hello, World!" print(a[1]) #输出结果: e
1.2.3 裁切(相当于java中的分割)
指定开始索引和结束索引,冒号分隔,返回字符串的一部分:
获取从位置 2 到位置 5(不包括)的字符,例:
b = "Hello, World!" print(b[2:5]) #输出结果: llo
1.2.4 负的索引
使用负索引从字符串末尾开始切片:
获取从位置 5 到位置 1 的字符,从字符串末尾开始计数,例:
b = "Hello, World!" print(b[-5:-2]) #输出结果: orl
1.2.5 字符串长度
如需获取字符串的长度,请使用 len() 函数。
len() 函数返回字符串的长度,例:
a = "Hello, World!" print(len(a)) #输出结果: 13
1.2.6 字符串方法
Python 有一组可用于字符串的内置方法。
strip() 方法删除开头和结尾的空白字符,例:
a = " Hello, World! " print(a.strip()) #输出结果: Hello, World!
lower() 返回小写的字符串,例:
a = "Hello, World!" print(a.lower()) #输出结果: hello, world!
upper() 方法返回大写的字符串,例:
a = "Hello, World!" print(a.upper()) #输出结果:
replace() 用另一段字符串来替换字符串,例:
a = "Hello, World!" print(a.replace("World", "Kitty")) #输出结果: Hello, Kitty!
split() 方法在找到分隔符的实例时将字符串拆分为子字符串,例:
a = "Hello, World!" print(a.split(",")) #输出结果: ['Hello', ' World!']
如需检查字符串中是否存在特定短语或字符,我们可以使用 in 或 not in 关键字,检查以下文本中是否存在短语 "ina",例:
txt = "China is a great country" x = "ina" in txt print(x) #输出结果: True
1.2.7 字符串级联(串联)
如需串联或组合两个字符串,您可以使用 + 运算符。
将变量 a 与变量 b 合并到变量 c 中,例:
a = "Hello" b = "World" c = a + b print(c) #输出结果: HelloWorld
在它们之间添加一个空格,例:
a = "Hello" b = "World" c = a + " " + b print(c) #输出结果: Hello World
1.2.8 字符串格式
正如在 Python 变量一章中所学到的,我们不能像这样组合字符串和数字,例:
(错误示例)
age = 63 txt = "My name is Bill, I am " + age print(txt)
但是我们可以使用 format() 方法组合字符串和数字!
format() 方法接受传递的参数,格式化它们,并将它们放在占位符 {} 所在的字符串中:
使用 format() 方法将数字插入字符串,例:
age = 63 txt = "My name is Bill, and I am {}" print(txt.format(age)) #输出结果: My name is Bill, and I am 63
format() 方法接受不限数量的参数,并放在各自的占位符中,例:
quantity = 3 itemno = 567 price = 49.95 myorder = "I want {} pieces of item {} for {} dollars." print(myorder.format(quantity, itemno, price)) #输出结果: I want 3 pieces of item 567 for 49.95 dollars.
您可以使用索引号 {0} 来确保参数被放在正确的占位符中,例:
quantity = 3 itemno = 567 price = 49.95 myorder = "I want to pay {2} dollars for {0} pieces of item {1}." print(myorder.format(quantity, itemno, price)) #输出结果: I want to pay 49.95 dollars for 3 pieces of item 567.
1.2.9 字符串方法总结
Python 有一组可以在字符串上使用的内建方法。
注释:所有字符串方法都返回新值。它们不会更改原始字符串。
方法 | 描述 |
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 值。 |
注释:所有字符串方法都返回新值。它们不会更改原始字符串。
1.3 布尔
1.3.1 布尔表示两值之一
True 或 False。
print(8 > 7) print(8 == 7) print(8 > 7) #输出结果: True False True
1.4 Python 集合(数组)
Python 编程语言中有四种集合数据类型:
- 列表(List)是一种有序和可更改的集合。允许重复的成员。
- 元组(Tuple)是一种有序且不可更改的集合。允许重复的成员。
- 集合(Set)是一个无序和无索引的集合。没有重复的成员。
- 词典(Dictionary)是一个无序,可变和有索引的集合。没有重复的成员。
1.4.1 列表(List)
列表是一个有序且可更改的集合。在 Python 中,列表用方括号编写。
1.4.1.1 创建列表:
使用'[ ]'创建列表,例:
thislist = ["apple", "banana", "cherry"] print(thislist) #输出结果: ['apple', 'banana', 'cherry']
1.4.1.2 访问列表
您可以通过引用索引号来访问列表项,从0开始
打印列表的第二项,例:
thislist = ["apple", "banana", "cherry"] print(thislist[1]) #输出结果: banana
1.4.1.2 负的索引
负索引表示从末尾开始,-1 表示最后一个项目,-2 表示倒数第二个项目,依此类推。
打印列表的最后一项,例:
thislist = ["apple", "banana", "cherry"] print(thislist[-1]) #输出结果: cherry
1.4.1.3 索引范围
您可以通过指定范围的起点和终点来指定索引范围。
指定范围后,返回值将是包含指定项目的新列表。
返回第2、第3、4项(按下标),例:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"] print(thislist[2:5]) #输出结果: ['cherry', 'orange', 'kiwi']
注释:搜索将从索引 2(包括)开始,到索引 5(不包括)结束。
请记住,第一项的索引为 0。
负索引的范围
如果要从列表末尾开始搜索,请指定负索引:
实例
此例将返回从索引 -4(包括)到索引 -1(排除)的项目:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"] print(thislist[-4:-1]) #输出结果: ['orange', 'kiwi', 'melon']
1.4.1.4 更改项目值
如需更改特定项目的值,请引用索引号:
更改第二项,例:
thislist = ["apple", "banana", "cherry"] thislist[1] = "mango" print(thislist) #输出结果: ['apple', 'mango', 'cherry']
1.4.1.5 遍历列表
可以使用 for 循环遍历列表项:
逐个打印列表中的所有项目,例:
thislist = ["apple", "banana", "cherry"] for x in thislist: print(x) #输出结果 apple banana cherry
for 循环正式学习暂放后面。
1.4.1.6 检查项目是否存在
如需确定列表中是否存在指定的项,请使用 in 关键字:
检查列表中是否存在 “apple”,例:
thislist = ["apple", "banana", "cherry"] if "apple" in thislist: print("Yes, 'apple' is in the fruits list") #输出结果 Yes, 'apple' is in the fruits list
1.4.1.7 列表长度
如需确定列表中有多少项,请使用 len() 方法:
打印列表中的项目数,例:
thislist = ["apple", "banana", "cherry"] print(len(thislist)) #输出结果: 3
1.4.1.8 添加项目
如需将项目添加到列表的末尾,请使用 append() 方法:
使用 append() 方法追加项目,例:
thislist = ["apple", "banana", "cherry"] thislist.append("orange") print(thislist) #输出结果 ['apple', 'banana', 'cherry', 'orange']
要在指定的索引处添加项目,请使用 insert() 方法:
插入项目作为第二个位置,例:
thislist = ["apple", "banana", "cherry"] thislist.insert(1, "orange") print(thislist) #输出结果: ['apple', 'orange', 'banana', 'cherry']
1.4.1.9 删除项目
有几种方法可以从列表中删除项目:
remove() 方法删除指定的项目,例:
thislist = ["apple", "banana", "cherry"] thislist.remove("banana") print(thislist) #输出结果: ['apple', 'cherry']
pop() 方法删除指定的索引(如果未指定索引,则删除最后一项),例:
thislist = ["apple", "banana", "cherry"] print(thislist.pop()) print(thislist) #输出结果: cherry #能够返回删除 值 ['apple', 'banana']
del 关键字删除指定的索引,例:
thislist = ["apple", "banana", "cherry"] del thislist[0] print(thislist) #输出结果: ['banana', 'cherry']
del 关键字也能完整地删除列表,例:
thislist = ["apple", "banana", "cherry"] del thislist
clear() 方法清空列表,例:
thislist = ["apple", "banana", "cherry"] thislist.clear() print(thislist) #输出结果 []
1.4.1.10 复制列表
只能通过键入 list2 = list1 来复制列表,因为:list2 将只是对 list1 的引用,list1 中所做的更改也将自动在 list2 中进行,例:
thislist=["apple", "banana", "cherry"] thislist1=thislist thislist.remove("apple") print(thislist1) #输出结果: ['banana', 'cherry'] #thislist发生改变后thislist1也发生了改变
有一些其他方法可以进行复制,复制后,被复制对象发生改变后不影响新列表,一种方法是使用内置的 List 方法 copy()。
使用 copy() 方法来复制列表,例:
thislist=["apple", "banana", "cherry"] thislist1=thislist.copy() thislist.append('orange') print(thislist1) #输出结果: ['apple', 'banana', 'cherry'] #thislist发生改变后thislist1没有发生改变
制作副本的另一种方法是使用内建的方法 list()。
使用 list() 方法复制列表,例:
thislist = ["apple", "banana", "cherry"] mylist = list(thislist) thislist.append('orange') print(mylist) #输出结果: ['apple', 'banana', 'cherry'] #thislist发生改变后mylist没有发生改变
1.4.1.11 合并两个列表
在 Python 中,有几种方法可以连接或串联两个或多个列表。
最简单的方法之一是使用 + 运算符。
合并两个列表,例:
list1 = ["a", "b" , "c"] list2 = [1, 2, 3] list3 = list1 + list2 print(list3) #输出结果: ['a', 'b', 'c', 1, 2, 3]
连接两个列表的另一种方法是将 list2 中的所有项一个接一个地追加到 list1 中:
把 list2 追加到 list1 中,例:
list1 = ["a", "b" , "c"] list2 = [1, 2, 3] for x in list2: list1.append(x) print(list1) #输出结果: ['a', 'b', 'c', 1, 2, 3]
或者,您可以使用 extend() 方法,其目的是将一个列表中的元素添加到另一列表中:
使用 extend() 方法将 list2 添加到 list1 的末尾,例:
list1 = ["a", "b" , "c"] list2 = [1, 2, 3] list1.extend(list2) print(list1) #输出结果: ['a', 'b', 'c', 1, 2, 3]
list() 构造函数
也可以使用 list() 构造函数创建一个新列表。
使用 list() 构造函数创建列表,例:
thislist = list(("apple", "banana", "cherry")) # 请注意双括号 print(thislist) #输出结果 ['apple', 'banana', 'cherry']
列表方法
Python 有一组可以在列表上使用的内建方法。
方法 | 描述 |
append() | 在列表的末尾添加一个元素 |
clear() | 删除列表中的所有元素 |
copy() | 返回列表的副本 |
count() | 返回具有指定值的元素数量。 |
extend() | 将列表元素(或任何可迭代的元素)添加到当前列表的末尾 |
index() | 返回具有指定值的第一个元素的索引 |
insert() | 在指定位置添加元素 |
pop() | 删除指定位置的元素 |
remove() | 删除具有指定值的项目 |
reverse() | 颠倒列表的顺序 |
sort() | 对列表进行排序 |
1.4.2 元组(Tuple)
元组是有序且不可更改的集合。在 Python 中,元组是用圆括号编写的。
1.4.2.1 创建元组:
使用'( )'创建元组,例:
thistuple = ("apple", "banana", "cherry") print(thistuple) #输出结果: ('apple', 'banana', 'cherry')
1.4.2.2 访问元组项目
可以通过引用方括号内的索引号来访问元组项目:
打印元组中的第二个项目,例:
thistuple = ("apple", "banana", "cherry") print(thistuple[1]) #输出结果: banana
1.4.2.3 负索引
负索引表示从末尾开始,-1 表示最后一个项目,-2 表示倒数第二个项目,依此类推。
打印元组的最后一个项目,例:
thistuple = ("apple", "banana", "cherry") print(thistuple[-1]) #输出结果: cherry
1.4.2.4 索引范围
您可以通过指定范围的起点和终点来指定索引范围。
指定范围后,返回值将是带有指定项目的新元组。
返回第三、第四、第五个项目,例:
thistuple = ("apple", "banana", "cherry", "orange") print(thistuple[1:3]) #输出结果: ('banana', 'cherry')
注释:搜索将从索引 1(包括)开始,到索引 3(不包括)结束(包头不包尾)。
第一项的索引为 0。
1.4.2.5 负索引范围
如果要从元组的末尾开始搜索,请指定负索引:
此例将返回从索引 -4(包括)到索引 -1(排除)的项目(包头不包尾),例:
thistuple = ("apple", "banana", "cherry", "orange") print(thistuple[-3:-1]) #输出结果: ('banana', 'cherry')
1.4.2.6 更改元组值
创建元组后,您将无法更改其值。元组是不可变的,或者也称为恒定的。
但是有一种解决方法。您可以将元组转换为列表,更改列表,然后将列表转换回元组。
把元组转换为列表即可进行更改,例:
x = ("apple", "banana", "cherry") y = list(x) y[1] = "kiwi" x = tuple(y) print(x) #输出结果: ('apple', 'kiwi', 'cherry')
1.4.2.7 遍历元组
您可以使用 for 循环遍历元组项目。
遍历项目并打印值,例:
thistuple = ("apple", "banana", "cherry") for x in thistuple: print(x) #输出结果: apple banana cherry
1.4.2.8 检查项目是否存在
要确定元组中是否存在指定的项,请使用 in 关键字:
检查元组中是否存在 "apple",例:
thistuple = ("apple", "banana", "cherry") if "apple" in thistuple: print("Yes, 'apple' is in the fruits tuple") #输出结果: Yes, 'apple' is in the fruits tuple
1.4.2.9 元组长度
要确定元组有多少项,请使用 len() 方法:
打印元组中的项目数量,例:
thistuple = ("apple", "banana", "cherry") print(len(thistuple)) #输出结果: 3
1.4.2.10 添加项目
元组一旦创建,您就无法向其添加项目。元组是不可改变的。
您无法向元组添加项目,错误示例,例:
thistuple = ("apple", "banana", "cherry") thistuple[0] = "orange" # 会引发错误 print(thistuple)
1.4.2.11 创建有一个项目的元组
如需创建仅包含一个项目的元组,您必须在该项目后添加一个逗号,否则 Python 无法将变量识别为元组。
单项元组,别忘了逗号,例:
thistuple = ("apple",) print(type(thistuple)) #输出结果: <class 'tuple'> #不是元组 thistuple = ("apple") print(type(thistuple)) #输出结果: <class 'str'>
1.4.2.12 删除项目
注释:您无法删除元组中的项目。
元组是不可更改的,因此您无法从中删除项目,但您可以完全删除元组:
del 关键字可以完全删除元组,例:
thistuple = ("apple", "banana", "cherry") del thistuple print(thistuple) # 这会引发错误,因为元组已不存在。
1.4.2.13 合并两个元组
如需连接两个或多个元组,您可以使用 + 运算符:
合并这个元组,例:
tuple1 = ("a", "b" , "c") tuple2 = (1, 2, 3) tuple3 = tuple1 + tuple2 print(tuple3) #输出结果: ('a', 'b', 'c', 1, 2, 3)
1.4.2.14 tuple() 构造函数
也可以使用 tuple() 构造函数来创建元组。
使用 tuple() 方法来创建元组,例:
thistuple = tuple(("apple", "banana", "cherry")) # 请注意双括号 print(thistuple) #输出结果: ('apple', 'banana', 'cherry')
1.4.2.15 元组方法
Python 提供两个可以在元组上使用的内建方法。
方法 | 描述 |
count() | 返回元组中指定值出现的次数。 |
index() | 在元组中搜索指定的值并返回它被找到的位置。 |
1.4.3 集合(Set)
集合是无序和无索引的集合。在 Python 中,集合用花括号编写。
创建集合,例:
thisset = {"apple", "banana", "cherry"} print(thisset) #输出结果: {'cherry', 'banana', 'apple'} 注释:集合是无序的,因此您无法确定项目的显示顺序。
1.4.3.1 访问项目
您无法通过引用索引来访问 set 中的项目,因为 set 是无序的,项目没有索引。
但是您可以使用 for 循环遍历 set 项目,或者使用 in 关键字查询集合中是否存在指定值。
遍历集合,并打印值,例:
thisset = {"apple", "banana", "cherry"} for x in thisset: print(x)
检查 set 中是否存在 “banana”,例:
thisset = {"apple", "banana", "cherry"} print("banana" in thisset)
1.4.3.2 更改项目(添加项目)
集合一旦创建,您就无法更改项目,但是您可以添加新项目。
添加项目
要将一个项添加到集合,请使用 add() 方法。
要向集合中添加多个项目,请使用 update() 方法。
使用 add() 方法向 set 添加项目,例:
thisset = {"apple", "banana", "cherry"} thisset.add("orange") print(thisset) #输出结果: {'banana', 'orange', 'apple', 'cherry'}
使用 update() 方法将多个项添加到集合中,例:
thisset = {"apple", "banana", "cherry"} thisset.update(["orange", "mango", "grapes"]) print(thisset) #输出结果: {'orange', 'banana', 'cherry', 'grapes', 'mango', 'apple'}
1.4.3.3 获取 Set 的长度
要确定集合中有多少项,请使用 len() 方法。
获取集合中的项目,例:
thisset = {"apple", "banana", "cherry"} print(len(thisset)) #输出结果: 3
1.4.3.4 删除项目
要删除集合中的项目,请使用 remove() 或 discard() 方法。
使用 remove() 方法来删除 “banana”,例:
thisset = {"apple", "banana", "cherry"} thisset.remove("banana") print(thisset) #输出结果: {'apple', 'cherry'}
注释:如果要删除的项目不存在,则 remove() 将引发错误。
使用 discard() 方法来删除 “banana”,例:
thisset = {"apple", "banana", "cherry"} thisset.discard("banana") print(thisset) #输出结果: {'cherry', 'apple'}
注释:如果要删除的项目不存在,则 discard() 将引发错误。
您还可以使用 pop() 方法删除项目,但此方法将删除最后一项。请记住,set 是无序的,因此您不会知道被删除的是什么项目。
pop() 方法的返回值是被删除的项目。
使用 pop() 方法删除最后一项,例:
thisset = {"apple", "banana", "cherry"} x = thisset.pop() print(x) print(thisset) #输出结果: apple #被移除的数据 {'cherry', 'banana'} #移除元素
注释:集合是无序的,因此在使用 pop() 方法时,您不会知道删除的是哪个项目。clear() 方法清空集合,例:
thisset = {"apple", "banana", "cherry"} thisset.clear() print(thisset) #输出结果: set()
del 彻底删除集合,例:
thisset = {"apple", "banana", "cherry"} del thisset print(thisset)
1.4.3.5 合并两个集合
在 Python 中,有几种方法可以连接两个或多个集合。
您可以使用 union() 方法返回包含两个集合中所有项目的新集合,也可以使用 update() 方法将一个集合中的所有项目插入另一个集合中:
实例
union() 方法返回一个新集合,其中包含两个集合中的所有项目:
set1 = {"a", "b" , "c"} set2 = {1, 2, 3} set3 = set1.union(set2) print(set3) #输出结果 {'a', 1, 2, 3, 'c', 'b'}
update() 方法将 set2 中的项目插入 set1 中,例:
set1 = {"a", "b" , "c"} set2 = {1, 2, 3} set1.update(set2) print(set1) #输出结果 {1, 2, 'b', 3, 'a', 'c'}
注释:union() 和 update() 都将排除任何重复项。
还有其他方法将两个集合连接起来,并且仅保留重复项,或者永远不保留重复项,请查看此页面底部的集合方法完整列表。
set() 构造函数
也可以使用 set() 构造函数来创建集合。
使用 set() 构造函数来创建集合,例:
thisset = set(("apple", "banana", "cherry")) # 请留意这个双括号 print(thisset) #输出结果 {'apple', 'banana', 'cherry'}
Set 方法
Python 拥有一套能够在集合(set)上使用的内建方法。
方法 | 描述 |
add() | 向集合添加元素。 |
clear() | 删除集合中的所有元素。 |
copy() | 返回集合的副本。 |
difference() | 返回包含两个或更多集合之间差异的集合。 |
difference_update() | 删除此集合中也包含在另一个指定集合中的项目。 |
discard() | 删除指定项目。 |
intersection() | 返回为两个其他集合的交集的集合。 |
intersection_update() | 删除此集合中不存在于其他指定集合中的项目。 |
isdisjoint() | 返回两个集合是否有交集。 |
issubset() | 返回另一个集合是否包含此集合。 |
issuperset() | 返回此集合是否包含另一个集合。 |
pop() | 从集合中删除一个元素。 |
remove() | 删除指定元素。 |
symmetric_difference() | 返回具有两组集合的对称差集的集合。 |
symmetric_difference_update() | 插入此集合和另一个集合的对称差集。 |
union() | 返回包含集合并集的集合。 |
用此集合和其他集合的并集来更新集合。 |
1.4.4 字典(Dictionary)
字典是一个无序、可变和有索引的集合。在 Python 中,字典用花括号编写,拥有键和值。
1.4.4.1 创建字典
使用'{ }'创建字典,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } print(thisdict) #输出结果: {'brand': 'Porsche', 'model': '911', 'year': 1963}
1.4.4.2 访问项目
您可以通过在方括号内引用其键名来访问字典的项目:
获取 "model" 键的值,例:
x = thisdict["model"]
还有一个名为 get() 的方法会给你相同的结果:
获取 "model" 键的值,例:
x = thisdict.get("model")
1.4.4.3 更改值
您可以通过引用其键名来更改特定项的值:
把 "year" 改为 2019,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } thisdict["year"] = 2019 print(thisdict) #输出结果 {'brand': 'Porsche', 'model': '911', 'year': 2019}
1.4.4.4 遍历字典
您可以使用 for 循环遍历字典。
循环遍历字典时,返回值是字典的键,但也有返回值的方法。
逐个打印字典中的所有键名,例:
for x in thisdict: print(x)
逐个打印字典中的所有值,例:
for x in thisdict: print(thisdict[x])
您还可以使用 values() 函数返回字典的值,例:
for x in thisdict.values(): print(x)
通过使用 items() 函数遍历键和值,例:
for x, y in thisdict.items(): print(x, y)
1.4.4.5 检查键是否存在
要确定字典中是否存在指定的键,请使用 in 关键字:
检查字典中是否存在 "model",例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } if "model" in thisdict: print("Yes, 'model' is one of the keys in the thisdict dictionary")
1.4.4.6 字典长度
要确定字典有多少项目(键值对),请使用 len() 方法。
打印字典中的项目数,例:
print(len(thisdict))
1.4.4.7 添加项目
通过使用新的索引键并为其赋值,可以将项目添加到字典中,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } thisdict["color"] = "red" print(thisdict)
1.4.4.8 删除项目
有几种方法可以从字典中删除项目:
pop() 方法删除具有指定键名的项,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } thisdict.pop("model") print(thisdict)
popitem() 方法删除最后插入的项目(在 3.7 之前的版本中,删除随机项目),例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } thisdict.popitem() print(thisdict)
del 关键字删除具有指定键名的项目,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } del thisdict["model"] print(thisdict)
del 关键字也可以完全删除字典,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } del thisdict print(thisdict) #this 会导致错误,因为 "thisdict" 不再存在。
clear() 关键字清空字典,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } thisdict.clear() print(thisdict)
1.4.4.9 复制字典
您不能通过键入 dict2 = dict1 来复制字典,因为:dict2 只是对 dict1 的引用,而 dict1 中的更改也将自动在 dict2 中进行。
有一些方法可以进行复制,一种方法是使用内建的字典方法 copy()。
使用 copy() 方法来复制字典,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } mydict = thisdict.copy() print(mydict)
制作副本的另一种方法是使用内建方法 dict()。
使用 dict() 方法创建字典的副本,例:
thisdict = { "brand": "Porsche", "model": "911", "year": 1963 } mydict = dict(thisdict) print(mydict)
1.4.4.10 嵌套字典
词典也可以包含许多词典,这被称为嵌套词典。
创建包含三个字典的字典,例:
myfamily = { "child1" : { "name" : "Phoebe Adele", "year" : 2002 }, "child2" : { "name" : "Jennifer Katharine", "year" : 1996 }, "child3" : { "name" : "Rory John", "year" : 1999 } }
或者,如果您想嵌套三个已经作为字典存在的字典:
创建三个字典,然后创建一个包含其他三个字典的字典,例:
child1 = { "name" : "Phoebe Adele", "year" : 2002 } child2 = { "name" : "Jennifer Katharine", "year" : 1996 } child3 = { "name" : "Rory John", "year" : 1999 } myfamily = { "child1" : child1, "child2" : child2, "child3" : child3 }
1.4.4.11 dict() 构造函数
也可以使用 dict() 构造函数创建新的字典,例:
thisdict = dict(brand="Porsche", model="911", year=1963) # 请注意,关键字不是字符串字面量 # 请注意,使用了等号而不是冒号来赋值 print(thisdict) #输出结果: {'brand': 'Porsche', 'model': '911', 'year': 1963}
1.4.4.12 字典方法
Python 提供一组可以在字典上使用的内建方法。
方法 | 描述 |
clear() | 删除字典中的所有元素 |
copy() | 返回字典的副本 |
fromkeys() | 返回拥有指定键和值的字典 |
get() | 返回指定键的值 |
items() | 返回包含每个键值对的元组的列表 |
keys() | 返回包含字典键的列表 |
pop() | 删除拥有指定键的元素 |
popitem() | 删除最后插入的键值对 |
setdefault() | 返回指定键的值。如果该键不存在,则插入具有指定值的键。 |
update() | 使用指定的键值对字典进行更新 |
values() | 返回字典中所有值的列表 |