2020-08-18

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()	返回包含集合并集的集合。
update()	用此集合和其他集合的并集来更新集合。

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()	返回字典中所有值的列表

貂蝉戏的卢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2020-08-18

数据类型和变量1.1 Python 数字1.1.1 Int1.1.2 Float1.1.3 复数1.1.4 小数1.1.4.1 创建和使用小数对象1.1.4.1 小数的全局精度1.1.4.2 小数的临时精度1.1.5 分数1.1.6 类型转换1.1.7 随机数1.1.8数字运算1.1.8.1 数字运算操作符1.1.8.2 计算的优先级1.1.8.3 计算中的自动数据类型转换1.2 Python 字符串1.2.1 多行字符串1.2.2 字
复制链接

扫一扫

2020-08-18

“相关推荐”对你有帮助么？