1.Python3 基本数据类型简介
1.1 变量赋值
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
#!/usr/bin/python3 counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "lizexiong" # 字符串 print (counter) print (miles) print (name) 执行以上程序会输出如下结果： 100 1000.0 lizexiong
1.2 多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "lizexiong"
以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "lizexiong" 分配给变量 c。
1.3 标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
1.4 Number（数字）
Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
>>> a, b, c, d = 20, 5.5, True, 4+3j >>> print(type(a), type(b), type(c), type(d)) <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
此外还可以用 isinstance 来判断：
>>> a = 111
>>> isinstance(a, int)
True
>>>
isinstance 和 type 的区别在于：
- type()不会认为子类是一种父类类型。
- isinstance()会认为子类是一种父类类型。
>>> class A: ... pass ... >>> class B(A): ... pass ... >>> isinstance(A(), A) True >>> type(A()) == A True >>> isinstance(B(), A) True >>> type(B()) == A False
注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。 >>> issubclass(bool, int) True >>> True==1 True >>> False==0 True >>> True+1 2 >>> False+1 1 >>> 1 is True False >>> 0 is False False 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象。例如：
del var del var_a, var_b
1.4.1 数值运算
>>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32
注意：
- Python可以同时为多个变量赋值，如a, b = 1, 2。
- 一个变量可以通过赋值指向不同类型的对象。
- 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
- 在混合计算时，Python会把整型转换成为浮点数。
1.4.2 数值类型实例
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
1.5 String（字符串）
Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：
#!/usr/bin/python3 #根据菜鸟教程学习,这里Runoob替换本人测试字符 str = 'Lizexiong' print (str) # 输出字符串 print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次，也可以写成 print (2 * str) print (str + "TEST") # 连接字符串 执行以上程序会输出如下结果： Lizexiong Lizexion L zex zexiong LizexiongLizexiong LizexiongTEST
Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
>>> print ('Li\nzexiong') Li zexiong >>> print (r'li\nzexiong') li\nzexiong
另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。
>>> word = 'Python' >>> print(word[0], word[5]) P n >>> print(word[-1], word[-6]) n P
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
注意：
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
- 字符串可以用+运算符连接在一起，用*运算符重复。
- Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
- Python中的字符串不能改变。
1.6 List（列表）
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
#!/usr/bin/python3 list = [ 'abcd', 786 , 2.23, 'Lizexiong', 70.2 ] tinylist = [123, 'Lizexiong'] print (list) # 输出完整列表 print (list[0]) # 输出列表第一个元素 print (list[1:3]) # 从第二个开始输出到第三个元素 print (list[2:]) # 输出从第三个元素开始的所有元素 print (tinylist * 2) # 输出两次列表 print (list + tinylist) # 连接列表 以上实例输出结果： ['abcd', 786, 2.23, 'Lizexiong', 70.2] abcd [786, 2.23] [2.23, 'Lizexiong', 70.2] [123, 'Lizexiong', 123, 'Lizexiong'] ['abcd', 786, 2.23, 'Lizexiong', 70.2, 123, 'Lizexiong']
与Python字符串不一样的是，列表中的元素是可以改变的：
>>> a = [1, 2, 3, 4, 5, 6] >>> a[0] = 9 >>> a[2:5] = [13, 14, 15] >>> a [9, 2, 13, 14, 15, 6] >>> a[2:5] = [] # 将对应的元素值设置为 [] >>> a [9, 2, 6]
List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。
注意：
- List写在方括号之间，元素用逗号隔开。
- 和字符串一样，list可以被索引和切片。
- List可以使用+操作符进行拼接。
- List中的元素是可以改变的。
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：
def reverseWords(input): # 通过空格将字符串分隔符，把各个单词分隔为列表 inputWords = input.split(" ") # 翻转字符串 # 假设列表 list = [1,2,3,4], # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) # inputWords[-1::-1] 有三个参数 # 第一个参数 -1 表示最后一个元素 # 第二个参数为空，表示移动到列表末尾 # 第三个参数为步长，-1 表示逆向 inputWords=inputWords[-1::-1] # 重新组合字符串 output = ' '.join(inputWords) return output if __name__ == "__main__": input = 'I like lizexiong' rw = reverseWords(input) print(rw) 输出结果为： Lizexiong like I
1.7 Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：
#!/usr/bin/python3 tuple = ( 'abcd', 786 , 2.23, 'lizexiong', 70.2 ) tinytuple = (123, 'lizexiong') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 print (tuple + tinytuple) # 连接元组 以上实例输出结果: ('abcd', 786, 2.23, 'lizexiong', 70.2) abcd (786, 2.23) (2.23, 'lizexiong', 70.2) (123, 'lizexiong', 123, 'lizexiong') ('abcd', 786, 2.23, 'lizexiong', 70.2, 123, 'lizexiong')
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组。
>>> tup = (1, 2, 3, 4, 5, 6) >>> print(tup[0]) 1 >>> print(tup[1:5]) (2, 3, 4, 5) >>> tup[0] = 11 # 修改元组元素的操作是非法的 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
string、list 和 tuple 都属于 sequence（序列）。
注意：
- 与字符串一样，元组的元素不能修改。
- 元组也可以被索引和切片，方法一样。
- 注意构造包含 0 或 1 个元素的元组的特殊语法规则。
- 元组也可以使用+操作符进行拼接。
1.8 Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
#!/usr/bin/python3 dict = {} dict['one'] = "1 - 华为" dict[2] = "2 - 三星" tinydict = {'name': 'lizexiong','code':1, 'site': 'www.lizexiong.com'} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值 结果输出如下: 1 - 华为 2 - 三星 {'name': 'lizexiong', 'code': 1, 'site': 'www.lizexiong.com'} dict_keys(['name', 'code', 'site']) dict_values(['lizexiong', 1, 'www.lizexiong.com'])
构造函数 dict() 可以直接从键值对序列中构建字典如下：
>>> dict([('Lizexiong', 1), ('Google', 2), ('Taobao', 3)]) {'Lizexiong': 1, 'Google': 2, 'Taobao': 3} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> dict(Lizexiong=1, Google=2, Taobao=3) {'Lizexiong': 1, 'Google': 2, 'Taobao': 3}
{x: x**2 for x in (2, 4, 6)} 该代码使用的是字典推导式，更多推导式内容可以参考：Python 推导式章节
另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。
注意：
- 字典是一种映射类型，它的元素是键值对。
- 字典的关键字必须为不可变类型，且不能重复。
- 创建空字典使用 { }。
1.9 Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
#!/usr/bin/python3 sites = {'Google', 'Taobao', 'Lizexiong', 'Facebook', 'Zhihu', 'Baidu'} print(sites) # 输出集合，重复的元素被自动去掉 # 成员测试 if 'Lizexiong' in sites : print('Lizexiong 在集合中') else : print('Lizexiong 不在集合中') # set可以进行集合运算 a = set('abracadabra') b = set('alacazam') print(a) print(a - b) # a 和 b 的差集 print(a | b) # a 和 b 的并集 print(a & b) # a 和 b 的交集 print(a ^ b) # a 和 b 中不同时存在的元素 输出为以下: {'Facebook', 'Google', 'Lizexiong', 'Zhihu', 'Baidu', 'Taobao'} Lizexiong 在集合中 {'c', 'r', 'b', 'd', 'a'} {'b', 'r', 'd'} {'l', 'c', 'z', 'r', 'b', 'm', 'd', 'a'} {'c', 'a'} {'l', 'z', 'd', 'r', 'b', 'm'}
2.Python3数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，一般情况下你只需要将数据类型作为函数名即可。
Python 数据类型转换可以分为两种：
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
2.1 隐式类型转换
在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。
以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。
num_int = 123 num_flo = 1.23 num_new = num_int + num_flo print("datatype of num_int:",type(num_int)) print("datatype of num_flo:",type(num_flo)) print("Value of num_new:",num_new) print("datatype of num_new:",type(num_new)) 以上实例输出结果为： num_int 数据类型为: <class 'int'> num_flo 数据类型为: <class 'float'> num_new: 值为: 124.23 num_new 数据类型为: <class 'float'>
代码解析：
- 实例中我们对两个不同数据类型的变量 num_int 和 num_flo 进行相加运算，并存储在变量 num_new 中。
- 然后查看三个变量的数据类型。
- 在输出结果中，我们看到 num_int 是 整型（integer） ， num_flo 是 浮点型（float）。
- 同样，新的变量 num_new 是 浮点型（float），这是因为 Python 会将较小的数据类型转换为较大的数据类型，以避免数据丢失。
我们再看一个实例，整型数据与字符串类型的数据进行相加：
num_int = 123 num_str = "456" print("Data type of num_int:",type(num_int)) print("Data type of num_str:",type(num_str)) print(num_int+num_str) 以上实例输出结果为： num_int 数据类型为: <class 'int'> num_str 数据类型为: <class 'str'> Traceback (most recent call last): File "/test/test.py", line 7, in <module> print(num_int+num_str) TypeError: unsupported operand type(s) for +: 'int' and 'str'
从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。
但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。
2.2 显式类型转换
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。
int() 强制转换为整型：
x = int(1) # x 输出结果为 1 y = int(2.8) # y 输出结果为 2 z = int("3") # z 输出结果为 3
float() 强制转换为浮点型：
x = float(1) # x 输出结果为 1.0 y = float(2.8) # y 输出结果为 2.8 z = float("3") # z 输出结果为 3.0 w = float("4.2") # w 输出结果为 4.2
str() 强制转换为字符串类型：
x = str("s1") # x 输出结果为 's1' y = str(2) # y 输出结果为 '2' z = str(3.0) # z 输出结果为 '3.0'
整型和字符串类型进行运算，就可以用强制类型转换来完成：
num_int = 123 num_str = "456" print("num_int 数据类型为:",type(num_int)) print("类型转换前，num_str 数据类型为:",type(num_str)) num_str = int(num_str) # 强制转换为整型 print("类型转换后，num_str 数据类型为:",type(num_str)) num_sum = num_int + num_str print("num_int 与 num_str 相加结果为:",num_sum) print("sum 数据类型为:",type(num_sum)) 以上实例输出结果为： num_int 数据类型为: <class 'int'> 类型转换前，num_str 数据类型为: <class 'str'> 类型转换后，num_str 数据类型为: <class 'int'> num_int 与 num_str 相加结果为: 579 sum 数据类型为: <class 'int'>
2.3 内置的函数
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
- int(x [,base])
描述
int() 函数用于将一个字符串或数字转换为整型。
语法
以下是 int() 方法的语法:
class int(x, base=10)
参数
x -- 字符串或数字。
base -- 进制数，默认十进制。
返回值
返回整型数据。
实例
以下展示了使用 int() 方法的实例：
>>>int() # 不传入参数时，得到结果0 0 >>> int(3) 3 >>> int(3.6) 3 >>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18 >>> int('0xa',16) 10 >>> int('10',8) 8
- float() 函数
描述
float() 函数用于将整数和字符串转换成浮点数。
语法
float()方法语法：
class float([x])
参数
x -- 整数或字符串
返回值
返回浮点数。
实例
以下实例展示了 float() 的使用方法：
>>>float(1) 1.0 >>> float(112) 112.0 >>> float(-123.6) -123.6 >>> float('123') # 字符串 123.0
- complex() 函数
描述
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
语法
complex 语法：
class complex([real[, imag]])
参数说明：
real -- int, long, float或字符串；
imag -- int, long, float；
返回值
返回一个复数。
实例
以下实例展示了 complex 的使用方法：
>>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 >>> complex("1+2j") (1 + 2j)
- str() 函数
描述
str() 函数将对象转化为适于人阅读的形式。
语法
以下是 str() 方法的语法:
class str(object='')
参数
object -- 对象。
返回值
返回一个对象的string格式。
实例
以下展示了使用 str() 方法的实例：
>>>s = 'LIZEXIONG' >>> str(s) 'LIZEXIONG' >>> dict = {'lizexiong': 'lizexiong.com', 'google': 'google.com'}; >>> str(dict) "{'google': 'google.com', 'lizexiong': 'lizexiong.com'}" >>>
- repr() 函数
描述
repr() 函数将对象转化为供解释器读取的形式。
语法
以下是 repr() 方法的语法:
repr(object)
参数
object -- 对象。
返回值
返回一个对象的 string 格式。
实例
以下展示了使用 repr() 方法的实例：
>>> s = 'LIZEXIONG' >>> repr(s) "'LIZEXIONG'" >>>dict = {'lizexiong': 'lizexiong.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'lizexiong': 'lizexiong.com'}" >>> 示例2 s="物品\t单价\t数量\n包子\t1\t2" print(s) print(repr(s)) 运行结果： 物品 单价 数量 包子 1 2 '物品\t单价\t数量\n包子\t1\t2'
- eval() 函数
描述
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法
以下是 eval() 方法的语法:
eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
实例
以下展示了使用 eval() 方法的实例：
>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85
- tuple()方法
描述
tuple 函数将可迭代系列（如列表）转换为元组。
语法
tuple()方法语法：
tuple( iterable )
参数
iterable -- 要转换为元组的可迭代序列。
返回值
返回元组。
实例
以下实例展示了 tuple()函数的使用方法：
>>>list1= ['Google', 'Taobao', 'Lizexiong', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Lizexiong', 'Baidu')
- list()方法
描述
list() 方法用于将元组或字符串转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法
list()方法语法：
list( seq )
参数
seq --要转换为列表的元组或字符串。
返回值
返回列表。
实例
以下实例展示了 list() 函数的使用方法：
#!/usr/bin/python3 aTuple = (123, 'Google', 'Lizexiong', 'Taobao') list1 = list(aTuple) print ("列表元素 : ", list1) str="Hello World" list2=list(str) print ("列表元素 : ", list2) 以上实例输出结果如下： 列表元素 : [123, 'Google', 'Lizexiong', 'Taobao'] 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
- set() 函数
描述
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
语法
set 语法：
class set([iterable])
参数说明：
iterable -- 可迭代对象对象；
返回值
返回新的集合对象。
实例
以下实例展示了 set 的使用方法：
交集 & : x&y，返回一个新的集合，包括同时在集合 x 和y中的共同元素。 并集 | : x|y，返回一个新的集合，包括集合 x 和 y 中所有元素。 差集 - : x-y，返回一个新的集合,包括在集合 x 中但不在集合 y 中的元素。 补集 ^ : x^y，返回一个新的集合，包括集合 x 和 y 的非共同元素。 >>> x = set('lizexiong') >>> y = set('google') >>> x,y ({'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'}, {'e', 'l', 'o', 'g'}) # 重复的被删除 >>> x & y # 交集 {'e', 'l', 'o', 'g'} >>> set(['o']) {'o'} >>> x | y # 并集 {'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'} >>> x - y # 差集 {'n', 'z', 'x', 'i'} >>>
- dict() 函数
描述
dict() 函数用于创建一个字典。
语法
dict 语法：
class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
参数说明：
**kwargs -- 关键字。
mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
iterable -- 可迭代对象。
返回值
返回一个字典。
实例
以下实例展示了 dict 的使用方法：
>>>dict() # 创建空字典 {} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>>
只使用关键字参数创建字典
numbers = dict(x=5, y=0) print('numbers =', numbers) print(type(numbers)) empty = dict() print('empty =', empty) print(type(empty)) 以上实例输出结果为： numbers = {'y': 0, 'x': 5} <class 'dict'> empty = {} <class 'dict'>
使用可迭代对象创建字典
# 没有设置关键字参数 numbers1 = dict([('x', 5), ('y', -5)]) print('numbers1 =',numbers1) # 设置关键字参数 numbers2 = dict([('x', 5), ('y', -5)], z=8) print('numbers2 =',numbers2) # zip() 创建可迭代对象 numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3]))) print('numbers3 =',numbers3) 以上实例输出结果为： numbers1 = {'y': -5, 'x': 5} numbers2 = {'z': 8, 'y': -5, 'x': 5} numbers3 = {'z': 3, 'y': 2, 'x': 1}
使用映射来创建字典
映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
numbers1 = dict({'x': 4, 'y': 5})
print('numbers1 =',numbers1)
# 以下代码不需要使用 dict()
numbers2 = {'x': 4, 'y': 5}
print('numbers2 =',numbers2)
# 关键字参数会被传递
numbers3 = dict({'x': 4, 'y': 5}, z=8)
print('numbers3 =',numbers3)
以上实例输出结果为：
numbers1 = {'x': 4, 'y': 5}
numbers2 = {'x': 4, 'y': 5}
numbers3 = {'x': 4, 'z': 8, 'y': 5}
- frozenset() 函数
描述
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法
frozenset() 函数语法：
class frozenset([iterable])
参数
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
实例
以下实例展示了 frozenset() 的使用方法：
>>>a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> b = frozenset('lizexiong') >>> b frozenset({'l', 'o', 'g', 'z', 'x', 'n', 'e', 'i'}) # 创建不可变集合 >>>
为什么需要冻结的集合（即不可变的集合）呢？因为在集合的关系中，有集合的中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，那么它的实例就不能放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。
- chr() 函数
描述
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
语法
以下是 chr() 方法的语法:
chr(i)
参数
i -- 可以是10进制也可以是16进制的形式的数字。
返回值
返回值是当前整数对应的 ASCII 字符。
实例
以下展示了使用 chr() 方法的实例：
>>>print (chr(0x30), chr(0x31), chr(0x61)) # 十六进制 0 1 a >>> print (chr(48), chr(49), chr(97)) # 十进制 0 1 a
- hex() 函数
描述
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
语法
hex 语法：
hex(x)
参数说明：
x -- 10进制整数
返回值
返回16进制数，以字符串形式表示。
实例
以下实例展示了 hex 的使用方法：
>>>hex(255) '0xff' >>> hex(-42) '-0x2a' >>> hex(1L) '0x1L' >>> hex(12) '0xc' >>> type(hex(12)) <class 'str'> # 字符串
- oct() 函数
描述
oct() 函数将一个整数转换成 8 进制字符串。
-
- Python2.x 版本的 8 进制以 0 作为前缀表示。
- Python3.x 版本的 8 进制以 0o 作为前缀表示。
语法
oct 语法：
oct(x)
参数说明：
x -- 整数。
返回值
返回 8 进制字符串。
实例
以下实例展示了 oct 的使用方法：
实例(Python 2.0+) >>> oct(10) '012' >>> oct(20) '024' >>> oct(15) '017' 实例(Python 3.0+) >>> oct(10) '0o12' >>> oct(20) '0o24' >>> oct(15) '0o17'
3.Python3 Number(数字)
Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些数字对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用，例如：
del var del var_a, var_b
Python 支持三种不同的数值类型：
- 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
我们可以使用十六进制和八进制来代表整数：
>>> number = 0xA0F # 十六进制 >>> number 2575 >>> number=0o37 # 八进制 >>> number 31
- Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
3.1 Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
- int(x) 将x转换为一个整数。
- float(x) 将x转换到一个浮点数。
- complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
以下实例将浮点数变量 a 转换为整数：
>>> a = 1.0
>>> int(a)
1
3.2 Python 数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：
>>> 2 + 2 4 >>> 50 - 5*6 20 >>> (50 - 5*6) / 4 5.0 >>> 8 / 5 # 总是返回一个浮点数 1.6
注意：在不同的机器上浮点运算的结果可能会不一样。
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：
>>> 17 / 3 # 整数除法返回浮点型 5.666666666666667 >>> >>> 17 // 3 # 整数除法返回向下取整后的结果 5 >>> 17 % 3 # ％操作符返回除法的余数 2 >>> 5 * 3 + 2 17
注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
>>> 7//2 3 >>> 7.0//2 3.0 >>> 7//2.0 3.0 >>>
等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。
>>> width = 20
>>> height = 5*9
>>> width * height
900
Python 可以使用 ** 操作来进行幂运算：
>>> 5 ** 2 # 5 的平方 25 >>> 2 ** 7 # 2的7次方 128
变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：
>>> n # 尝试访问一个未定义的变量 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'n' is not defined
不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：
>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round(_, 2) 113.06
此处， _变量应被用户视为只读变量。
3.3 数学函数
- abs() 函数
描述
abs() 函数返回数字的绝对值。
语法
以下是 abs() 方法的语法:
abs( x )
参数
x -- 数值表达式，可以是整数，浮点数，复数。
返回值
函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小。
实例
以下展示了使用 abs() 方法的实例：
#!/usr/bin/python3 print ("abs(-40) : ", abs(-40)) print ("abs(100.10) : ", abs(100.10)) 以上实例运行后输出结果为： abs(-40) : 40 abs(100.10) : 100.1
- ceil() 函数
描述
ceil(x) 函数返回一个大于或等于 x 的的最小整数。
语法
以下是 ceil() 方法的语法:
import math math.ceil( x )
注意：ceil()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
函数返回一个大于或等于 x 的的最小整数。
实例
以下展示了使用 ceil() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.ceil(-45.17) : ", math.ceil(-45.17)) print ("math.ceil(100.12) : ", math.ceil(100.12)) print ("math.ceil(100.72) : ", math.ceil(100.72)) print ("math.ceil(math.pi) : ", math.ceil(math.pi)) 以上实例运行后输出结果为： math.ceil(-45.17) : -45 math.ceil(100.12) : 101 math.ceil(100.72) : 101 math.ceil(math.pi) : 4
- exp() 函数
描述
exp() 方法返回x的指数,ex。
语法
以下是 exp() 方法的语法:
import math math.exp( x )
math.exp( x )
注意：exp()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回x的指数,ex。
实例
以下展示了使用 exp() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.exp(-45.17) : ", math.exp(-45.17)) print ("math.exp(100.12) : ", math.exp(100.12)) print ("math.exp(100.72) : ", math.exp(100.72)) print ("math.exp(math.pi) : ", math.exp(math.pi)) 以上实例运行后输出结果为： math.exp(-45.17) : 2.4150062132629406e-20 math.exp(100.12) : 3.0308436140742566e+43 math.exp(100.72) : 5.522557130248187e+43 math.exp(math.pi) : 23.140692632779267
- fabs() 函数
描述
fabs() 方法返回数字的绝对值，如math.fabs(-10) 返回10.0。
fabs() 函数类似于 abs() 函数，但是他有两点区别:
-
- abs() 是内置函数。 fabs() 函数在 math 模块中定义。
- fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。
语法
以下是 fabs() 方法的语法:
import math math.fabs( x )
注意：fabs()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回数字的绝对值。
实例
以下展示了使用 fabs() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.fabs(-45.17) : ", math.fabs(-45.17)) print ("math.fabs(100.12) : ", math.fabs(100.12)) print ("math.fabs(100.72) : ", math.fabs(100.72)) print ("math.fabs(math.pi) : ", math.fabs(math.pi)) 以上实例运行后输出结果为： math.fabs(-45.17) : 45.17 math.fabs(100.12) : 100.12 math.fabs(100.72) : 100.72 math.fabs(math.pi) : 3.141592653589793
- floor() 函数
描述
floor(x) 返回数字的下舍整数，小于或等于 x。
语法
以下是 floor() 方法的语法:
import math math.floor( x )
注意：floor()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回小于或等于 x 的整数。
实例
以下展示了使用 floor() 方法的实例：
#!/usr/bin/python import math # 导入 math 模块 print ("math.floor(-45.17) : ", math.floor(-45.17)) print ("math.floor(100.12) : ", math.floor(100.12)) print ("math.floor(100.72) : ", math.floor(100.72)) print ("math.floor(math.pi) : ", math.floor(math.pi)) 以上实例运行后输出结果为： math.floor(-45.17) : -46 math.floor(100.12) : 100 math.floor(100.72) : 100 math.floor(math.pi) : 3
- log() 函数
描述
log() 方法返回x的自然对数，x > 0。
语法
以下是 log() 方法的语法:
import math math.log( x )
注意：log()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回 x 的自然对数，x>0。
实例
以下展示了使用 log() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.log(100.12) : ", math.log(100.12)) print ("math.log(100.72) : ", math.log(100.72)) print ("math.log(math.pi) : ", math.log(math.pi)) 以上实例运行后输出结果为： math.log(100.12) : 4.6063694665635735 math.log(100.72) : 4.612344389736092 math.log(math.pi) : 1.1447298858494002
- log10() 函数
描述
log10() 方法返回以10为基数的x对数，x>0。
语法
以下是 log10() 方法的语法:
import math math.log10( x )
注意：log10()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回以10为基数的x对数，x>0。
实例
以下展示了使用 log10() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.log10(100.12) : ", math.log10(100.12)) print ("math.log10(100.72) : ", math.log10(100.72)) print ("math.log10(119) : ", math.log10(119)) print ("math.log10(math.pi) : ", math.log10(math.pi)) 以上实例运行后输出结果为： math.log10(100.12) : 2.0005208409361854 math.log10(100.72) : 2.003115717099806 math.log10(119) : 2.0755469613925306 math.log10(math.pi) : 0.49714987269413385
- max() 函数
描述
max() 方法返回给定参数的最大值，参数可以为序列。
语法
以下是 max() 方法的语法:
max( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最大值。
实例
以下展示了使用 max() 方法的实例：
#!/usr/bin/python print ("max(80, 100, 1000) : ", max(80, 100, 1000)) print ("max(-20, 100, 400) : ", max(-20, 100, 400)) print ("max(-80, -20, -10) : ", max(-80, -20, -10)) print ("max(0, 100, -400) : ", max(0, 100, -400)) 以上实例运行后输出结果为： max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100 以下还有列表和字典的对比 >>> a=[1,2,3,4] >>> type(a) #类型是列表 <type 'list'> >>> max(a) #max函数也返回了最大值 4 >>> >>> >>> a=[(1,2),(2,3),(3,4)] #假设列表里面是元组构成元素呢 >>> max(a) #按照元素里面元组的第一个元素的排列顺序，输出最大值（如果第一个元素相同，则比较第二个元素，输出最大值）据推理是按ascii码进行排序的 (3, 4) >>> a=[('a',1),('A',1)] #实验推测是按ascii码进行排序，比较 a 和 A 的值，得出a > A , 因为ascii 码里面，按照排列顺序 小 a在 A的后面 >>> max(a) ('a', 1) >>> a=[(1,2),(2,3),(3,1)] >>> a=[(1,3),(2,2),(3,1)] #列表里面的元素都由元组构成，元组都由数字组成，输出最大值 >>> max(a) (3, 1) >>> a={1:2,2:2,3:1,4:'aa'} #比较字典里面的最大值，会输出最大的键值 >>> max(a) 4
- min() 函数
描述
min() 方法返回给定参数的最小值，参数可以为序列。
语法
以下是 min() 方法的语法:
min( x, y, z, .... )
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回给定参数的最小值。
实例
以下展示了使用 min() 方法的实例：
#!/usr/bin/python print ("min(80, 100, 1000) : ", min(80, 100, 1000)) print ("min(-20, 100, 400) : ", min(-20, 100, 400)) print ("min(-80, -20, -10) : ", min(-80, -20, -10)) print ("min(0, 100, -400) : ", min(0, 100, -400)) 以上实例运行后输出结果为： min(80, 100, 1000) : 80 min(-20, 100, 400) : -20 min(-80, -20, -10) : -80 min(0, 100, -400) : -400 #列表和字典和max()一样可以比较，这里就不举例了
- modf() 函数
描述
modf() 方法返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
语法
以下是 modf() 方法的语法:
import math math.modf( x )
注意：modf()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回x的整数部分与小数部分，
实例
以下展示了使用 modf() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.modf(100.12) : ", math.modf(100.12)) print ("math.modf(100.72) : ", math.modf(100.72)) print ("math.modf(119) : ", math.modf(119)) print ("math.modf(math.pi) : ", math.modf(math.pi)) 以上实例运行后输出结果为： math.modf(100.12) : (0.12000000000000455, 100.0) math.modf(100.72) : (0.7199999999999989, 100.0) math.modf(119) : (0.0, 119.0) math.modf(math.pi) : (0.14159265358979312, 3.0)
- pow() 函数
描述
pow()方法返回 xy（x 的 y 次方） 的值。
语法
以下是 math 模块 pow() 方法的语法:
import math math.pow( x, y )
内置的 pow() 方法
pow(x, y[, z])
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回 xy（x的y次方） 的值。
实例
以下展示了使用 pow() 方法的实例：
#!/usr/bin/python3 import math # 导入 math 模块 print ("math.pow(100, 2) : ", math.pow(100, 2)) # 使用内置，查看输出结果区别 print ("pow(100, 2) : ", pow(100, 2)) print ("math.pow(100, -2) : ", math.pow(100, -2)) print ("math.pow(2, 4) : ", math.pow(2, 4)) print ("math.pow(3, 0) : ", math.pow(3, 0)) 以上实例运行后输出结果为： math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0
- round() 函数
描述
round()方法返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。
精度要求高的，不建议使用该函数。
语法
以下是 round() 方法的语法:
round( x [, n] )
参数
x -- 数字表达式。
n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
返回值
返回浮点数x的四舍五入值。
实例
以下展示了使用 round() 方法的实例：
#!/usr/bin/python3 print ("round(70.23456) : ", round(70.23456)) print ("round(56.659,1) : ", round(56.659,1)) print ("round(80.264, 2) : ", round(80.264, 2)) print ("round(100.000056, 3) : ", round(100.000056, 3)) print ("round(-100.000056, 3) : ", round(-100.000056, 3)) 以上实例运行后输出结果为： round(70.23456) : 70 round(56.659,1) : 56.7 round(80.264, 2) : 80.26 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0 看下官网给的一个例子： >>> round(2.675, 2) 2.67
按我们的想法返回结果应该是 2.68，可结果却是 2.67，为什么？
这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达，因为换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离 2.67 要更近一点点，所以保留两位小数时就近似到了 2.67。
在实际使用中发现round函数并不总是如上所说的四舍五入。如： In [14]: round(2.355, 2) Out[14]: 2.35 注：环境为 python3.5.2 因为该函数对于返回的浮点数并不是按照四舍五入的规则来计算，而会收到计算机表示精度的影响。 关于该问题搜索后解释比较清楚的文章地址如下：http://www.runoob.com/w3cnote/python-round-func-note.html
- sqrt() 函数
描述
sqrt()方法返回数字x的平方根。
语法
以下是 sqrt() 方法的语法:
import math math.sqrt( x )
注意：sqrt()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数
x -- 数值表达式。
返回值
返回数字x的平方根。
实例
以下展示了使用 sqrt() 方法的实例：
#!/usr/bin/python3 import math # This will import math module print ("math.sqrt(100) : ", math.sqrt(100)) print ("math.sqrt(7) : ", math.sqrt(7)) print ("math.sqrt(math.pi) : ", math.sqrt(math.pi)) 以上实例运行后输出结果为： math.sqrt(100) : 10.0 math.sqrt(7) : 2.6457513110645907 math.sqrt(math.pi) : 1.7724538509055159
3.4 随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：
- choice() 函数
描述
choice()方法返回一个列表，元组或字符串的随机项。
语法
以下是 choice() 方法的语法:
import random random.choice( seq )
注意：choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
seq -- 可以是一个列表，元组或字符串。
返回值
返回随机项。
实例
以下展示了使用 choice() 方法的实例：
#!/usr/bin/python3 import random print ("从 range(100) 返回一个随机数 : ",random.choice(range(100))) print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9])) print ("从字符串中 'lizexiong' 返回一个随机字符 : ", random.choice('lizexiong')) 以上实例运行后输出结果为： 从 range(100) 返回一个随机数 : 68 从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 2 从字符串中 'lizexiong' 返回一个随机字符 : z
- randrange() 函数
描述
randrange()方法返回指定递增基数集合中的一个随机数，基数默认值为1。
语法
以下是 randrange() 方法的语法:
import random random.randrange ([start,] stop [,step])
注意：randrange()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
start -- 指定范围内的开始值，包含在范围内。
stop -- 指定范围内的结束值，不包含在范围内。
step -- 指定递增基数。
返回值
从给定的范围返回随机项。
实例
以下展示了使用 randrange() 方法的实例：
#!/usr/bin/python3 import random # 从 1-100 中选取一个奇数 print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2)) # 从 0-99 选取一个随机数 print ("randrange(100) : ", random.randrange(100)) 以上实例运行后输出结果为： randrange(1,100, 2) : 97 randrange(100) : 42
- random() 函数
描述
random()方法返回随机生成的一个实数，它在[0,1)范围内。
语法
以下是 random() 方法的语法:
import random random.random()
注意：random()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
无
返回值
返回随机生成的一个实数，它在[0,1)范围内。
实例
以下展示了使用 random() 方法的实例：
实例 #!/usr/bin/python # -*- coding: UTF-8 -*- import random # 生成第一个随机数 print ("random() : ", random.random()) # 生成第二个随机数 print ("random() : ", random.random()) 以上实例运行后输出结果为： random() : 0.281954791393 random() : 0.309090465205
- seed() 函数
描述
seed()方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
语法
以下是 seed() 方法的语法:
import random random.seed ( [x] )
我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。
注意：seed()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
x -- 改变随机数生成器的种子 seed。如果你不了解其原理，你不必特别去设定 seed，Python会帮你选择 seed。
返回值
本函数没有返回值。
实例
以下展示了使用 seed() 方法的实例：
#!/usr/bin/python3 import random random.seed() print ("使用默认种子生成随机数：", random.random()) print ("使用默认种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed("hello",2) print ("使用字符串种子生成随机数：", random.random()) 以上实例运行后输出结果为： 使用默认种子生成随机数： 0.4424658799775165 使用默认种子生成随机数： 0.11376245995961698 使用整数 10 种子生成随机数： 0.5714025946899135 使用整数 10 种子生成随机数： 0.5714025946899135 使用字符串种子生成随机数： 0.3537754404730722
- shuffle() 函数
描述
shuffle()方法将序列的所有元素随机排序。
语法
以下是 shuffle() 方法的语法:
import random random.shuffle (lst )
注意：shuffle()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
lst -- 可以是一个列表。
返回值
None
实例
以下展示了使用 shuffle() 方法的实例：
#!/usr/bin/python3 import random list = [20, 16, 10, 5] random.shuffle(list) print ("随机排序列表 : ", list) random.shuffle(list) print ("随机排序列表 : ", list) 以上实例运行后输出结果为： 随机排序列表 : [16, 5, 10, 20] 随机排序列表 : [16, 5, 20, 10]
- uniform() 函数
描述
uniform()方法将随机生成下一个实数，它在 [x, y] 范围内。
语法
以下是 uniform() 方法的语法:
import random random.uniform(x, y)
注意：uniform()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。
参数
x -- 随机数的最小值，包含该值。
y -- 随机数的最大值，包含该值。
返回值
返回一个浮点数 N，取值范围为如果 x<y 则 x <= N <= y，如果 y<x 则y <= N <= x。
实例
以下展示了使用 uniform() 方法的实例：
实例 #!/usr/bin/python # -*- coding: UTF-8 -*- import random print ("uniform(5, 10) 的随机数为 : ", random.uniform(5, 10)) print ("uniform(7, 14) 的随机数为 : ", random.uniform(7, 14)) 以上实例运行后输出结果为： uniform(5, 10) 的随机数为 : 6.98774810047 uniform(7, 14) 的随机数为 : 12.2243345905 #当然这里是浮点类型，也可以改成整数类型 a=int(random.uniform(10,100))
3.5 三角函数
Python包括以下三角函数：
- acos() 函数
描述
acos()返回x的反余弦弧度值。
语法
以下是 acos() 方法的语法:
import math math.acos(x)
注意：acos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- -1到1之间的数值。如果x是大于1，会产生一个错误。
返回值
返回x的反余弦弧度值。
实例
以下展示了使用 acos() 方法的实例：
#!/usr/bin/python import math print ("acos(0.64) : ", math.acos(0.64)) print ("acos(0) : ", math.acos(0)) print ("acos(-1) : ", math.acos(-1)) print ("acos(1) : ", math.acos(1)) 以上实例运行后输出结果为： acos(0.64) : 0.8762980611683406 acos(0) : 1.5707963267948966 acos(-1) : 3.141592653589793 acos(1) : 0.0
- asin() 函数
描述
asin()返回x的反正弦弧度值。
语法
以下是 asin() 方法的语法:
import math math.asin(x)
注意：asin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x : -1 到 1 之间的数值。如果 x 是大于 1，会产生一个错误。
返回值
返回x的反正弦弧度值。
实例
以下展示了使用 asin() 方法的实例：
#!/usr/bin/python3 import math print ("asin(0.64) : ", math.asin(0.64)) print ("asin(0) : ", math.asin(0)) print ("asin(-1) : ", math.asin(-1)) print ("asin(1) : ", math.asin(1)) 以上实例运行后输出结果为： asin(0.64) : 0.694498265626556 asin(0) : 0.0 asin(-1) : -1.5707963267948966 asin(1) : 1.5707963267948966
- atan() 函数
描述
atan()返回x的反正切弧度值。
语法
以下是 atan()方法的语法:
import math math.atan(x)
注意：atan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x的反正切弧度值。
实例
以下展示了使用 atan() 方法的实例：
#!/usr/bin/python import math print ("atan(0.64) : ", math.atan(0.64)) print ("atan(0) : ", math.atan(0)) print ("atan(10) : ", math.atan(10)) print ("atan(-1) : ", math.atan(-1)) print ("atan(1) : ", math.atan(1)) 以上实例运行后输出结果为： atan(0.64) : 0.5693131911006619 atan(0) : 0.0 atan(10) : 1.4711276743037347 atan(-1) : -0.7853981633974483 atan(1) : 0.7853981633974483
- atan2() 函数
描述
atan2()返回给定的 X 及 Y 坐标值的反正切值。
语法
以下是 atan2() 方法的语法:
import math math.atan2(y, x)
注意：atan2()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
y -- 一个数值。
返回值
返回给定的 X 及 Y 坐标值的反正切值。
实例
以下展示了使用 atan2() 方法的实例：
#!/usr/bin/python3 import math print ("atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50)) print ("atan2(0.50,0.50) : ", math.atan2(0.50,0.50)) print ("atan2(5,5) : ", math.atan2(5,5)) print ("atan2(-10,10) : ", math.atan2(-10,10)) print ("atan2(10,20) : ", math.atan2(10,20)) 以上实例运行后输出结果为： atan2(-0.50,-0.50) : -2.356194490192345 atan2(0.50,0.50) : 0.7853981633974483 atan2(5,5) : 0.7853981633974483 atan2(-10,10) : -0.7853981633974483 atan2(10,20) : 0.4636476090008061
- cos() 函数
描述
cos()返回x的弧度的余弦值。
语法
以下是 cos()方法的语法:
import math math.cos(x)
注意：cos()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x的弧度的余弦值,-1 到 1 之间。
实例
以下展示了使用 cos() 方法的实例：
#!/usr/bin/python3 import math print ("cos(3) : ", math.cos(3)) print ("cos(-3) : ", math.cos(-3)) print ("cos(0) : ", math.cos(0)) print ("cos(math.pi) : ", math.cos(math.pi)) print ("cos(2*math.pi) : ", math.cos(2*math.pi)) 以上实例运行后输出结果为： cos(3) : -0.9899924966004454 cos(-3) : -0.9899924966004454 cos(0) : 1.0 cos(math.pi) : -1.0 cos(2*math.pi) : 1.0
- hypot() 函数
描述
hypot()返回欧几里德范数 sqrt(x*x + y*y)。
语法
以下是 hypot() 方法的语法:
import math math.hypot(x, y)
注意：hypot()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
y -- 一个数值。
返回值
返回欧几里德范数 sqrt(x*x + y*y)。
实例
以下展示了使用 hypot() 方法的实例：
#!/usr/bin/python import math print ("hypot(3, 2) : ", math.hypot(3, 2)) print ("hypot(-3, 3) : ", math.hypot(-3, 3)) print ("hypot(0, 2) : ", math.hypot(0, 2)) 以上实例运行后输出结果为： hypot(3, 2) : 3.605551275463989 hypot(-3, 3) : 4.242640687119285 hypot(0, 2) : 2.0
- sin() 函数
描述
sin()返回的x弧度的正弦值。
语法
以下是 sin() 方法的语法:
import math math.sin(x)
注意：sin()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回的x弧度的正弦值，数值在 -1 到 1 之间。
实例
以下展示了使用 sin() 方法的实例：
#!/usr/bin/python3 import math print ("sin(3) : ", math.sin(3)) print ("sin(-3) : ", math.sin(-3)) print ("sin(0) : ", math.sin(0)) print ("sin(math.pi) : ", math.sin(math.pi)) print ("sin(math.pi/2) : ", math.sin(math.pi/2)) 以上实例运行后输出结果为： sin(3) : 0.1411200080598672 sin(-3) : -0.1411200080598672 sin(0) : 0.0 sin(math.pi) : 1.2246467991473532e-16 sin(math.pi/2) : 1.0
- tan() 函数
描述
tan()返回x弧度的正切值。
语法
以下是 tan() 方法的语法:
import math math.tan(x)
注意：tan()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回x弧度的正切值，数值在 -1 到 1 之间。
实例
以下展示了使用 tan() 方法的实例：
#!/usr/bin/python3 import math print ("tan(3) : ", math.tan(3)) print ("tan(-3) : ", math.tan(-3)) print ("tan(0) : ", math.tan(0)) print ("tan(math.pi) : ", math.tan(math.pi)) print ("tan(math.pi/2) : ", math.tan(math.pi/2)) print ("tan(math.pi/4) : ", math.tan(math.pi/4)) 以上实例运行后输出结果为： tan(3) : -0.1425465430742778 tan(-3) : 0.1425465430742778 tan(0) : 0.0 tan(math.pi) : -1.2246467991473532e-16 tan(math.pi/2) : 1.633123935319537e+16 tan(math.pi/4) : 0.9999999999999999
- degrees() 函数
描述
degrees()将弧度转换为角度。
语法
以下是 degrees() 方法的语法:
import math math.degrees(x)
注意：degrees()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个数值。
返回值
返回一个角度值。
实例
以下展示了使用 degrees() 方法的实例：
#!/usr/bin/python3 import math print ("degrees(3) : ", math.degrees(3)) print ("degrees(-3) : ", math.degrees(-3)) print ("degrees(0) : ", math.degrees(0)) print ("degrees(math.pi) : ", math.degrees(math.pi)) print ("degrees(math.pi/2) : ", math.degrees(math.pi/2)) print ("degrees(math.pi/4) : ", math.degrees(math.pi/4)) 以上实例运行后输出结果为： degrees(3) : 171.88733853924697 degrees(-3) : -171.88733853924697 degrees(0) : 0.0 degrees(math.pi) : 180.0 degrees(math.pi/2) : 90.0 degrees(math.pi/4) : 45.0
- radians() 函数
描述
radians()方法将角度转换为弧度。
角度和弧度关系是：2π 弧度 = 360°。从而 1°≈0.0174533 弧度，1 弧度≈57.29578°。
1) 角度转换为弧度公式：弧度=角度÷180×π
2) 弧度转换为角度公式： 角度=弧度×180÷π
语法
以下是 radians() 方法的语法:
import math math.radians(x)
注意：radians()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
x -- 一个角度数值，默认单位是角度 °。
返回值
返回一个角度的弧度值。
实例
以下展示了使用 radians() 方法的实例：
#!/usr/bin/python3 import math print ("radians(90) : ", math.radians(90)) # 1 弧度等于大概 57.3° print ("radians(45) : ", math.radians(45)) print ("radians(30) : ", math.radians(30)) print ("radians(180) : ", math.radians(180)) # 180 度的弧度为 π print("180 / pi : ", end ="") print (math.radians(180 / math.pi)) 以上实例运行后输出结果为： radians(90) : 1.5707963267948966 radians(45) : 0.7853981633974483 radians(30) : 0.5235987755982988 radians(180) : 3.141592653589793 180 / pi : 1.0
3.6 Python数学常量
4.Python3字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!' var2 = "Python Lizexiong"
4.1 Python 访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
#!/usr/bin/python var1 = 'Hello World!' var2 = "Python Lizexiong" print ("var1[0]: ", var1[0]) print ("var2[1:5]: ", var2[1:5]) 以上实例执行结果： var1[0]: H var2[1:5]: ytho
4.2 Python 字符串更新
你可以截取字符串的一部分并与其他字段拼接，如下实例：
#字符串拼接 #!/usr/bin/python # -*- coding: UTF-8 -*- var1 = 'Hello World!' print ("输出 :- ", var1[:6] + 'Lizexiong!') 以上实例执行结果 输出 :- Hello Lizexiong!
4.3 Python转义字符
在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：
4.4 Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
#!/usr/bin/python # -*- coding: UTF-8 -*- a = "Hello" b = "Python" print ("a + b 输出结果：", a + b) #万恶的加号，使用加号会在内存中重新申请空间 print ("a * 2 输出结果：", a * 2 ) print ("a[1] 输出结果：", a[1]) print ("a[1:4] 输出结果：", a[1:4]) if( "H" in a) : print ("H 在变量 a 中") else : print ("H 不在变量 a 中") if( "M" not in a) : print ("M 不在变量 a 中") else : print ("M 在变量 a 中") print (r'\n') print (R'\n') 以上程序执行结果为： a + b 输出结果： HelloPython a * 2 输出结果： HelloHello a[1] 输出结果： e a[1:4] 输出结果： ell H 在变量 a 中 M 不在变量 a 中 \n \n
4.5 Python 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python print ("My name is %s and weight is %d kg!" % ('LiZeXiong', 62)) 以上实例输出结果： My name is LiZeXiong and weight is 62 kg! 但是如果python后面格式化函数方法，就需要有点小小改动，这个需要特别注意，比如时间模块。如果还使用%就会报错 import time print ("time.localtime() : %s", % time.localtime()) 以上实例输出结果为： time.localtime() : %s time.struct_time(tm_year=2022, tm_mon=4, tm_mday=26, tm_ho ur=8, tm_min=55, tm_sec=46, tm_wday=1, tm_yday=116, tm_isdst=0)
python字符串格式化符号:
格式化操作符辅助指令:
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
4.6 Python三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
#!/usr/bin/python3 para_str = """这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( \t )。 也可以使用换行符 [ \n ]。 """ print (para_str) 以上实例执行结果为： 这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( )。 也可以使用换行符 [ ]。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
errHTML = ''' <HTML><HEAD><TITLE> Friends CGI Demo</TITLE></HEAD> <BODY><H3>ERROR</H3> <B>%s</B><P> <FORM><INPUT TYPE=button VALUE=Back ONCLICK="window.history.back()"></FORM> </BODY></HTML> ''' cursor.execute(''' CREATE TABLE users ( login VARCHAR(8), uid INTEGER, prid INTEGER) ''')
4.7 f-string
f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前我们习惯用百分号 (%):
>>> name = 'Lizexiong' >>> 'Hello %s' % name 'Hello Lizexiong'
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：
>>> name = 'Lizexiong' >>> f'Hello {name}' # 替换变量 'Hello Lizexiong' >>> f'{1+2}' # 使用表达式 '3' >>> w = {'name': 'Lizexiong', 'url': 'www.Lizexiong.com'} >>> f'{w["name"]}: {w["url"]}' 'Lizexiong: www.Lizexiong.com'
用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：
>>> x = 1 >>> print(f'{x+1}') # Python 3.6 2 >>> x = 1 >>> print(f'{x+1=}') # Python 3.8 x+1=2
4.8 Python 的字符串内建函数
- capitalize()方法
描述
Python capitalize() 将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。
语法
capitalize()方法语法：
str.capitalize()
参数
无。
返回值
该方法返回一个首字母大写的字符串。
实例
以下实例展示了capitalize()方法的实例：
#!/usr/bin/python3 str = "this is string Example From huawei....wow!!!" print ("str.capitalize() : ", str.capitalize()) 以上实例输出结果如下： str.capitalize() : This is string example from huawei....wow!!!
- center()方法
描述
center() 方法返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
语法
center()方法语法：
str.center(width[, fillchar])
参数
width -- 字符串的总宽度。
fillchar -- 填充字符。
返回值
返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。
实例
以下实例展示了center()方法的实例：
>>> str = 'lizexiong' >>> str.center(20,'*') '*****lizexiong******' >>> str.center(20) ' lizexiong ' >>>
- count()方法
描述
Python count() 方法用于统计字符串里某个字符或子字符串出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法
count()方法语法：
str.count(sub, start= 0,end=len(string))
参数
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
返回值
该方法返回子字符串在字符串中出现的次数。
实例
以下实例展示了count()方法的实例：
#!/usr/bin/python str = "this is string example....wow!!!"; sub = "i"; print ("str.count(sub, 4, 40) : ", str.count(sub, 4, 40)) sub = "wow"; print ("str.count(sub) : ", str.count(sub)) 以上实例输出结果如下： str.count(sub, 4, 40) : 2 str.count(sub) : 1
- bytes.decode()方法
描述
decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。
语法
decode()方法语法：
bytes.decode(encoding="utf-8", errors="strict")
参数
encoding -- 要使用的编码，如"UTF-8"。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
返回值
该方法返回解码后的字符串。
实例
以下实例展示了decode()方法的实例：
#!/usr/bin/python3 str = "李泽雄"; str_utf8 = str.encode("UTF-8") str_gbk = str.encode("GBK") print(str) print("UTF-8 编码：", str_utf8) print("GBK 编码：", str_gbk) print("UTF-8 解码：", str_utf8.decode('UTF-8','strict')) print("GBK 解码：", str_gbk.decode('GBK','strict')) 以上实例输出结果如下： 李泽雄 UTF-8 编码： b'\xe6\x9d\x8e\xe6\xb3\xbd\xe9\x9b\x84' GBK 编码： b'\xc0\xee\xd4\xf3\xd0\xdb' UTF-8 解码： 李泽雄 GBK 解码： 李泽雄
- endswith()方法
描述
Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
语法
endswith()方法语法：
str.endswith(suffix[, start[, end]])
参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
返回值
如果字符串含有指定的后缀返回True，否则返回False。
实例
以下实例展示了endswith()方法的实例：
#!/usr/bin/python str = "this is string example....wow!!!"; suffix = "wow!!!"; print (str.endswith(suffix)) print (str.endswith(suffix,20)) suffix = "is"; print (str.endswith(suffix, 2, 4)) print (str.endswith(suffix, 2, 6)) 以上实例输出结果如下： True True True False
- expandtabs()方法
描述
expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
语法
expandtabs()方法语法：
str.expandtabs(tabsize=8)
参数
tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。
返回值
该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。
实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = "zxiong\t12345\tabc" print('原始字符串: {}'.format(str)) # 默认 8 个空格 # zxiong 有 6 个字符，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，后面的 \t 填充 3 个空格 print('替换 \\t 符号: {}'.format(str.expandtabs())) # 2 个空格 # zxiong 有 6 个字符，刚好是 2 的 3 倍，后面的 \t 填充 2 个空格 # 12345 有 5 个字符，不是 2 的倍数，后面的 \t 填充 1 个空格 print('使用 2 个空格替换 \\t 符号: {}'.format(str.expandtabs(2))) # 3 个空格 print('使用 3 个空格: {}'.format(str.expandtabs(3))) # 4 个空格 print('使用 4 个空格: {}'.format(str.expandtabs(4))) # 5 个空格 print('使用 5 个空格: {}'.format(str.expandtabs(5))) # 6 个空格 print('使用 6 个空格: {}'.format(str.expandtabs(6))) 以上实例输出结果如下： 原始字符串: zxiong 12345 abc 替换 \t 符号: zxiong 12345 abc 使用 2 个空格替换 \t 符号: zxiong 12345 abc 使用 3 个空格: zxiong 12345 abc 使用 4 个空格: zxiong 12345 abc 使用 5 个空格: zxiong 12345 abc 使用 6 个空格: zxiong 12345 abc
- find()方法
描述
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
语法
find()方法语法：
str.find(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
返回值
如果包含子字符串返回开始的索引值，否则返回-1。
实例
以下实例展示了find()方法的实例：
实例1 #!/usr/bin/python str1 = "this is string example....wow!!!"; str2 = "exam"; print (str1.find(str2)) print (str1.find(str2, 10)) print (str1.find(str2, 40)) 以上实例输出结果如下： 15 15 -1 实例2 >>>info = 'abca' >>> print (info.find('a')) # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0 0 >>> print (info.find('a',1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3 3 >>> print (info.find('3')) # 查找不到返回-1 -1 >>>
- index()方法
描述
Python index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
语法
index()方法语法：
str.index(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
返回值
如果包含子字符串返回开始的索引值，否则抛出异常。
实例
以下实例展示了index()方法的实例：
#!/usr/bin/python3 str1 = "this is string example....wow!!!"; str2 = "exam"; print (str1.index(str2)) print (str1.index(str2, 10)) print (str1.index(str2, 40)) 以上实例输出结果如下： 15 15 Traceback (most recent call last): File "test.py", line 8, in print str1.index(str2, 40); ValueError: substring not found shell returned 1
- isalnum()方法
描述
Python isalnum() 方法检测字符串是否由字母和数字组成。
语法
isalnum()方法语法：
str.isalnum()
参数
无。
返回值
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
实例
以下实例展示了isalnum()方法的实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = "this2009"; # 字符中没有空格 print (str.isalnum()) str = "this is string example....wow!!!"; print (str.isalnum()) 以上实例输出结果如下： True False
- isalpha()方法
描述
Python isalpha() 方法检测字符串是否只由字母或文字组成。
语法
isalpha()方法语法：
str.isalpha()
参数
无。
返回值
如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。
实例
以下实例展示了isalpha()方法的实例：
#!/usr/bin/python # coding=utf-8 str = "lizexiong"; print (str.isalpha()) str = "lizexiong华为"; print (str.isalpha()) str = "this is string example....wow!!!"; print (str.isalpha()) 以上实例输出结果如下： True True #这里在python2中会变成false False
- isdigit()方法
描述
Python isdigit() 方法检测字符串是否只由数字组成。
语法
isdigit()方法语法：
str.isdigit()
参数
无。
返回值
如果字符串只包含数字则返回 True 否则返回 False。
实例
以下实例展示了isdigit()方法的实例：
#!/usr/bin/python3 str = "123456"; # Only digit in this string print (str.isdigit()); str = "this is string example....wow!!!"; print (str.isdigit()); 以上实例输出结果如下： True False
- islower()方法
描述
Python islower() 方法检测字符串是否由小写字母组成。
语法
islower()方法语法：
str.islower()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
实例
以下实例展示了islower()方法的实例：
#!/usr/bin/python str = "THIS is string example....wow!!!"; print (str.islower()); str = "this is string example....wow!!!"; print (str.islower()); 以上实例输出结果如下： False True
- isnumeric()方法
描述
isnumeric() 方法检测字符串是否只由数字组成，数字可以是： Unicode 数字，全角数字（双字节），罗马数字，汉字数字。
指数类似 ² 与分数类似 ½ 也属于数字。
# s = '½' s = '\u00BD'
语法
isnumeric()方法语法：
str.isnumeric()
参数
无。
返回值
如果字符串中只包含数字字符，则返回 True，否则返回 False
实例
以下实例展示了isnumeric()方法的实例：
#!/usr/bin/python str = u"this2017"; print (str.isnumeric()); str = u"23443434"; print (str.isnumeric()); 以上实例输出结果如下： False True
Unicode 数字：
#!/usr/bin/python3 #s = '²3455' s = '\u00B23455' print(s.isnumeric()) # s = '½' s = '\u00BD' print(s.isnumeric()) a = "\u0030" #unicode for 0 print(a.isnumeric()) b = "\u00B2" #unicode for ² print(b.isnumeric()) c = "10km2" print(c.isnumeric()) 以上实例输出结果如下： True True True True False
- isspace()方法
描述
Python isspace() 方法检测字符串是否只由空格组成。
语法
isspace()方法语法：
str.isspace()
参数
无。
返回值
如果字符串中只包含空格，则返回 True，否则返回 False.
实例
以下实例展示了isspace()方法的实例：
#!/usr/bin/python3 str = " "; print (str.isspace()); str = "This is string example....wow!!!"; print (str.isspace()); 以上实例输出结果如下： True False
- istitle()方法
描述
Python istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
语法
istitle()方法语法：
str.istitle()
参数
无。
返回值
如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
实例
以下实例展示了istitle()方法的实例：
#!/usr/bin/python3 str = "This Is String Example...Wow!!!"; print (str.istitle()); str = "This is string example....wow!!!"; print (str.istitle()); 以上实例输出结果如下： True False
- isupper()方法
描述
Python isupper() 方法检测字符串中所有的字母是否都为大写。
语法
isupper()方法语法：
str.isupper()
参数
无。
返回值
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
实例
以下实例展示了 isupper() 方法的实例：
#!/usr/bin/python3 str = "THIS IS STRING EXAMPLE....WOW!!!"; print ( str.isupper() ); str = "THIS is string example....wow!!!"; print ( str.isupper() ); 以上实例输出结果如下： True False
- join()方法
描述
Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
语法
join()方法语法：
str.join(sequence)
参数
sequence -- 要连接的元素序列。
返回值
返回通过指定字符连接序列中元素后生成的新字符串。
实例
以下实例展示了join()的使用方法：
#!/usr/bin/python3 str = "-"; seq = ("a", "b", "c"); # 字符串序列 print (str.join( seq )); 以上实例输出结果如下： a-b-c
- len()方法
描述
Python len() 方法返回对象（字符、列表、元组等）长度或项目个数。
语法
len()方法语法：
len( s )
参数
s -- 对象。
返回值
返回对象长度。
实例
以下实例展示了 len() 的使用方法：
>>> str = "lizexiong" >>> len(str) 9 >>> l = [1,2,3,4,5] >>> len(l) 5
- ljust()方法
描述
Python ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
语法
ljust()方法语法：
str.ljust(width[, fillchar])
参数
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
返回值
返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
实例
以下实例展示了ljust()的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.ljust(50, '0')); 以上实例输出结果如下： this is string example....wow!!!000000000000000000
- lower()方法
描述
Python lower() 方法转换字符串中所有大写字符为小写。
语法
lower()方法语法：
str.lower()
参数
无。
返回值
返回将字符串中所有大写字符转换为小写后生成的字符串。
实例
以下实例展示了lower()的使用方法：
#!/usr/bin/python3 str = "THIS IS STRING EXAMPLE....WOW!!!"; print (str.lower()); 以上实例输出结果如下： this is string example....wow!!!
- lstrip()方法
描述
Python lstrip() 方法用于截掉字符串左边的空格或指定字符。
语法
lstrip()方法语法：
str.lstrip([chars])
参数
chars --指定截取的字符。
返回值
返回截掉字符串左边的空格或指定字符后生成的新字符串。
实例
以下实例展示了lstrip()的使用方法：
#!/usr/bin/python3 str = " this is string example....wow!!! "; print (str.lstrip()); str = "88888888this is string example....wow!!!8888888"; print (str.lstrip('8')); 以上实例输出结果如下： this is string example....wow!!! this is string example....wow!!!8888888
- maketrans() 方法
描述
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
两个字符串的长度必须相同，为一一对应的关系。
注：Python3.4 已经没有 string.maketrans() 了，取而代之的是内建函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans() 。
语法
maketrans()方法语法：
string.maketrans(x[, y[, z]])
参数
x -- 必需，字符串中要替代的字符组成的字符串。
y -- 可选，相应的映射字符的字符串。
z -- 可选，要删除的字符。
返回值
返回字符串转换后生成的新字符串。
实例
以下实例展示了使用 maketrans() 方法将所有元音字母转换为指定的数字：
#!/usr/bin/python3 # 字母 R 替换为 N txt = "Lizexiong!" mytable = txt.maketrans("L", "X") print(txt.translate(mytable)) # 使用字符串设置要替换的字符，一一对应 intab = "aeiou" outtab = "12345" trantab = str.maketrans(intab, outtab) str = "this is string example....wow!!!" print (str.translate(trantab)) 以上实例输出结果如下： Xizexiong! th3s 3s str3ng 2x1mpl2....w4w!!!
设置要删除的字符参数：
#!/usr/bin/python3 txt = "Google Lizexiong Taobao!" x = "mSa" y = "eJo" z = "odnght" # 设置删除的字符 mytable = txt.maketrans(x, y, z) print(txt.translate(mytable)) 以上实例输出结果如下： Gle Lizexi Tobo!
- max()方法
描述
Python max() 方法返回字符串中最大的字母。
语法
max()方法语法：
max(str)
参数
str -- 字符串。
返回值
返回字符串中最大的字母。
实例
以下实例展示了max()函数的使用方法：
#!/usr/bin/python3 str = "this is really a string example....wow!!!"; print ("Max character: " + max(str)); str = "this is a string example....wow!!!"; print ("Max character: " + max(str)); 以上实例输出结果如下： Max character: y Max character: x
- min()方法
描述
Python min() 方法返回字符串中最小的字母。
语法
min()方法语法：
min(str)
参数
str -- 字符串。
返回值
返回字符串中最小的字母。
实例
以下实例展示了min()函数的使用方法：
#!/usr/bin/python str = "this-is-real-string-example....wow!!!"; print ("Min character: " + min(str)); str = "this-is-a-string-example....wow!!!"; print ("Min character: " + min(str)); 以上实例输出结果如下： Min character: ! Min character: !
- replace()方法
描述
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法
replace()方法语法：
str.replace(old, new[, max])
参数
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
返回值
返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
实例
以下实例展示了replace()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!! this is really string"; print (str.replace("is", "was")); print (str.replace("is", "was", 3)); 以上实例输出结果如下： thwas was string example....wow!!! thwas was really string thwas was string example....wow!!! thwas is really string
- rfind()方法
描述
Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
语法
rfind()方法语法：
str.rfind(str, beg=0 end=len(string))
参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为 0
end -- 结束查找位置，默认为字符串的长度。
返回值
返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
实例
以下实例展示了rfind()函数的使用方法：
#!/usr/bin/python3 str = "this is really a string example....wow!!!"; substr = "is"; print (str.rfind(substr)); print (str.rfind(substr, 0, 10)); print (str.rfind(substr, 10, 0)); print (str.find(substr)); print (str.find(substr, 0, 10)); print (str.find(substr, 10, 0)); 以上实例输出结果如下： 5 5 -1 2 2 -1
- rindex()方法
描述
Python rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
语法
rindex()方法语法：
str.rindex(str, beg=0 end=len(string))
参数
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度。
返回值
返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。
实例
以下实例展示了rindex()函数的使用方法：
#!/usr/bin/python3 str1 = "this is string example....wow!!!"; str2 = "is"; print (str1.rindex(str2)); print (str1.rindex(str2,30)); 以上实例输出结果如下： 5 Traceback (most recent call last): File "C:/Users/Administrator/Desktop/python3/day2/exercise.py", line 1420, in <module> print (str1.rindex(str2,30)); ValueError: substring not found
- rjust()方法
描述
Python rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
语法
rjust()方法语法：
str.rjust(width[, fillchar])
参数
width -- 指定填充指定字符后中字符串的总长度.
fillchar -- 填充的字符，默认为空格。
返回值
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
实例
以下实例展示了rjust()函数的使用方法：
#!/usr/bin/python3 str = "this is string example....wow!!!"; print (str.rjust(50, '0')); 以上实例输出结果如下： 000000000000000000this is string example....wow!!!
- rstrip()方法
描述
Python rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
语法
rstrip()方法语法：
str.rstrip([chars])
参数
chars -- 指定删除的字符（默认为空白符）
返回值
返回删除 string 字符串末尾的指定字符后生成的新字符串。
实例
以下实例展示了 rstrip() 函数的使用方法：
#!/usr/bin/python3 random_string = 'this is good ' # 字符串末尾的空格会被删除 print(random_string.rstrip()) # 'si oo' 不是尾随字符，因此不会删除任何内容 print(random_string.rstrip('si oo')) # 在 'sid oo' 中 'd oo' 是尾随字符，'ood' 从字符串中删除 print(random_string.rstrip('sid oo')) # 'm/' 是尾随字符，没有找到 '.' 号的尾随字符, 'm/' 从字符串中删除 website = 'www.lizexiong.com/' print(website.rstrip('m/.')) # 移除逗号(,)、点号(.)、字母 s、q 或 w，这几个都是尾随字符 txt = "banana,,,,,ssqqqww....." x = txt.rstrip(",.qsw") print(x) # 删除尾随字符 * str = "*****this is string example....wow!!!*****" print (str.rstrip('*')) print(x) 以上实例输出结果如下： this is good this is good this is g www.lizexiong.co banana *****this is string example....wow!!! banana
- split()方法
描述
Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串
语法
split() 方法语法：
str.split(str="", num=string.count(str)).
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。默认为 -1, 即分隔所有。
返回值
返回分割后的字符串列表。
实例
以下实例展示了 split() 函数的使用方法：
实例1 #!/usr/bin/python # -*- coding: UTF-8 -*- str = "Line1-abcdef \nLine2-abc \nLine4-abcd"; print (str.split( )); # 以空格为分隔符，包含 \n print (str.split(' ', 1 )); # 以空格为分隔符，分隔成两个 以上实例输出结果如下： ['Line1-abcdef', 'Line2-abc', 'Line4-abcd'] ['Line1-abcdef', '\nLine2-abc \nLine4-abcd'] 以下实例以 # 号为分割符，指定第二个参数为 1，返回两个参数列表。 实例2 #!/usr/bin/python # -*- coding: UTF-8 -*- txt = "Google#lizexiong#Taobao#Facebook" # 第二个参数为 1，返回两个参数列表 x = txt.split("#", 1) print (x) 以上实例输出结果如下： ['Google', 'lizexiong#Taobao#Facebook'] 实例3 #!/usr/bin/python # -*- coding: UTF-8 -*- import re a='Beautiful, is; better*than\nugly' # 四个分隔符为：, ; * \n x= re.split(',|; |\*|\n',a) print(x) 以上实例输出结果如下： ['Beautiful', ' is', 'better', 'than', 'ugly'] 实例4 以下演示以 + 和 _ 符号为分隔符： # -*- coding: utf-8 -*- str = "Chris_iven+Chris_jack+Chris_lusy" print (str.split("+")) print (str.split("_")) 输出结果为： ['Chris_iven', 'Chris_jack', 'Chris_lusy'] ['Chris', 'iven+Chris', 'jack+Chris', 'lusy']
- splitlines()方法
描述
Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
语法
splitlines()方法语法：
str.splitlines([keepends])
参数
keepends -- 在输出结果里是否保留换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值
返回一个包含各行作为元素的列表。
实例
以下实例展示了splitlines()函数的使用方法：
#!/usr/bin/python3 str1 = 'ab c\n\nde fg\rkl\r\n' print (str1.splitlines()) str2 = 'ab c\n\nde fg\rkl\r\n' print (str2.splitlines(True)) 以上实例输出结果如下： ['ab c', '', 'de fg', 'kl'] ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
- startswith()方法
描述
Python startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
语法
startswith()方法语法：
str.startswith(str, beg=0,end=len(string));
参数
str -- 检测的字符串。
strbeg -- 可选参数用于设置字符串检测的起始位置。
strend -- 可选参数用于设置字符串检测的结束位置。
返回值
如果检测到字符串则返回True，否则返回False。
实例
以下实例展示了startswith()函数的使用方法：
#!/usr/bin/python3 str = "this is string example....wow!!!" print (str.startswith( 'this' )) # 字符串是否以 this 开头 print (str.startswith( 'string', 8 )) # 从第九个字符开始的字符串是否以 string 开头 print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头 以上实例输出结果如下： True True False
- strip()方法
描述
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
语法
strip()方法语法：
str.strip([chars]);
参数
chars -- 移除字符串头尾指定的字符序列。
返回值
返回移除字符串头尾指定的字符生成的新字符串。
实例
以下实例展示了strip()函数的使用方法：
实例1 #!/usr/bin/python3 str = "00000003210lizexiong01230000000"; print (str.strip( '0' )); # 去除首尾字符 0 str2 = " lizexiong "; # 去除首尾空格 print (str2.strip()); 以上实例输出结果如下： 3210lizexiong0123 lizexiong 从结果上看，可以注意到中间部分的字符并未删除。 以上下例演示了只要头尾包含有指定字符序列中的字符就删除： 实例2 #!/usr/bin/python # -*- coding: UTF-8 -*- str = "123abclizexiong321" print (str.strip( '12' )) # 字符序列为 12 以上实例输出结果如下： 3abclizexiong3
- swapcase()方法
描述
Python swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
语法
swapcase() 方法语法：
str.swapcase();
参数
NA。
返回值
返回大小写字母转换后生成的新字符串。
实例
以下实例展示了 swapcase() 函数的使用方法：
#!/usr/bin/python str = "LIZEXIONG!!!"; print ( str.swapcase() ); str = "lizexiong!!!"; print ( str.swapcase() ); str = "abCDE--LiZeXiong!!!"; print ( str.swapcase() ); 以上实例输出结果如下： lizexiong!!! LIZEXIONG!!! ABcde--lIzExIONG!!!
- title()方法
描述
Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
语法
title()方法语法：
str.title();
参数
NA。
返回值
返回"标题化"的字符串,就是说所有单词都是以大写开始。
实例
以下实例展示了 title()函数的使用方法：
#!/usr/bin/python3 str = "this is string example....wow!!!"; print (str.title()); 以上实例输出结果如下： This Is String Example....Wow!!!
- translate()方法
描述
translate() 方法根据参数 table 给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。
语法
translate()方法语法：
str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])
参数
table -- 翻译表，翻译表是通过maketrans()方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
返回值
返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。
实例
以下实例展示了 translate()函数的使用方法：
实例1 #!/usr/bin/python3 from string import maketrans # 引用 maketrans 函数。 intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!"; print (str.translate(trantab)); 以上实例输出结果如下： th3s 3s str3ng 2x1mpl2....w4w!!! 以下实例演示如何过滤掉的字符 o： 实例2(Python 3.0+) #!/usr/bin/python # 制作翻译表 bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ') # 转换为大写，并删除字母o print(b'lizexiong'.translate(bytes_tabtrans, b'o')) 以上实例输出结果: b'LIZEXING'
- upper()方法
描述
Python upper() 方法将字符串中的小写字母转为大写字母。
语法
upper()方法语法：
str.upper()
参数
NA。
返回值
返回小写字母转为大写字母的字符串。
实例
以下实例展示了 upper()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print ("str.upper() : ", str.upper()) 以上实例输出结果如下： str.upper() : THIS IS STRING EXAMPLE....WOW!!!
- zfill()方法
描述
Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
语法
zfill()方法语法：
str.zfill(width)
参数
width -- 指定字符串的长度。原字符串右对齐，前面填充0。
返回值
返回指定长度的字符串。
实例
以下实例展示了 zfill()函数的使用方法：
#!/usr/bin/python str = "this is string example....wow!!!"; print (str.zfill(40)); print (str.zfill(50)); 以上实例输出结果如下： 00000000this is string example....wow!!! 000000000000000000this is string example....wow!!! #基本跟 string.rjust(width,'0') 输出结果一样
- isdecimal()方法
描述
Python isdecimal() 方法检查字符串是否只包含十进制字符。
语法
isdecimal()方法语法：
str.isdecimal()
参数
无
返回值
True - 如果字符串中的所有字符都是十进制字符。
False - 至少一个字符不是十进制字符。
实例
以下实例展示了 isdecimal()函数的使用方法：
#!/usr/bin/python3 str = "lizexiong2022" print (str.isdecimal()) str = "23443434" print (str.isdecimal()) 以上实例输出结果如下： False True
5.Python3列表
序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['Google', 'Lizexiong', 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = ["a", "b", "c", "d"] list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
5.1 访问列表中的值
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。
#!/usr/bin/python3 list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[0] ) print( list[1] ) print( list[2] ) 以上实例输出结果： red green blue
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
#!/usr/bin/python3 list = ['red', 'green', 'blue', 'yellow', 'white', 'black'] print( list[-1] ) print( list[-2] ) print( list[-3] ) 以上实例输出结果： black white yellow
使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：
#!/usr/bin/python3 nums = [10, 20, 30, 40, 50, 60, 70, 80, 90] print(nums[0:4]) 以上实例输出结果： [10, 20, 30, 40]
使用负数索引值截取：
#!/usr/bin/python3 list = ['Google', 'Lizexiong', "Zhihu", "Taobao", "Wiki"] # 读取第二位 print ("list[1]: ", list[1]) # 从第二位开始（包含）截取到倒数第二位（不包含） print ("list[1:-2]: ", list[1:-2]) 以上实例输出结果： list[1]: Lizexiong list[1:-2]: ['Lizexiong', 'Zhihu']
5.2 更新列表
你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：
#!/usr/bin/python3 list = ['Google', 'Lizexiong', 1997, 2000] print ("第三个元素为 : ", list[2]) list[2] = 2001 print ("更新后的第三个元素为 : ", list[2]) list1 = ['Google', 'Lizexiong', 'Taobao'] list1.append('Baidu') print ("更新后的列表 : ", list1) 注意：我们会在接下来的章节讨论 append() 方法的使用。 以上实例输出结果： 第三个元素为 : 1997 更新后的第三个元素为 : 2001 更新后的列表 : ['Google', 'Lizexiong', 'Taobao', 'Baidu']
5.3 删除列表元素
可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python3 list = ['Google', 'Lizexiong', 1997, 2000] print ("原始列表 : ", list) del list[2] print ("删除第三个元素 : ", list) 以上实例输出结果： 原始列表 : ['Google', 'Lizexiong', 1997, 2000] 删除第三个元素 : ['Google', 'Lizexiong', 2000]
5.4 Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
5.5 Python列表截取与拼接
Python的列表截取与字符串操作类型，如下所示：
L=['Google', 'Lizexiong', 'Taobao']
>>>L=['Google', 'Lizexiong', 'Taobao'] >>> L[2] 'Taobao' >>> L[-2] 'Lizexiong' >>> L[1:] ['Lizexiong', 'Taobao'] >>>
列表还支持拼接操作：
>>>squares = [1, 4, 9, 16, 25] >>> squares += [36, 49, 64, 81, 100] >>> squares [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>>
5.6 嵌套列表
使用嵌套列表即在列表里创建其它列表，例如：
>>>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'
5.7 Python列表函数
Python包含以下函数:
- List len()方法
描述
len() 方法返回列表元素个数。
语法
len()方法语法：
len(list)
参数
list -- 要计算元素个数的列表。
返回值
返回列表元素个数。
实例
以下实例展示了 len()函数的使用方法：
#!/usr/bin/python list1, list2 = [123, 'xyz', 'zara'], [456, 'abc'] print ("First list length : ", len(list1)) print ("Second list length : ", len(list2)) 以上实例输出结果如下： First list length : 3 Second lsit length : 2
- List max()方法
描述
max() 方法返回列表元素中的最大值。
语法
max()方法语法：
max(list)
参数
list -- 要返回最大值的列表。
返回值
返回列表元素中的最大值。
实例
以下实例展示了 max()函数的使用方法：
#!/usr/bin/python list1, list2 = ['123', 'xyz', 'zara', 'abc'], [456, 700, 200] print ("Max value element : ", max(list1)) print ("Max value element : ", max(list2)) 以上实例输出结果如下： Max value element : zara Max value element : 700 #这里有很重要的一点，看到123，用引号标识起来，是因为只能比较同类型的值，如果是str和int，max函数会报错。
- List min()方法
描述
min() 方法返回列表元素中的最小值。
语法
min()方法语法：
min(list)
参数
list -- 要返回最小值的列表。
返回值
返回列表元素中的最小值。
实例
以下实例展示了 min()函数的使用方法：
#!/usr/bin/python list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200] print ("min value element : ", min(list1)) print ("min value element : ", min(list2)) 以上实例输出结果如下： min value element : 123 min value element : 200
- List list()方法
描述
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法
list()方法语法：
list( seq )
参数
seq -- 要转换为列表的元组或字符串。
返回值
返回列表。
实例
以下实例展示了 list() 函数的使用方法：
#!/usr/bin/python3 aTuple = (123, 'Google', 'Lizexiong', 'Taobao') list1 = list(aTuple) print ("列表元素 : ", list1) str="Hello World" list2=list(str) print ("列表元素 : ", list2) 以上实例输出结果如下： 列表元素 : [123, 'Google', 'Lizexiong', 'Taobao'] 列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
5.8 Python列表方法
Python包含以下方法:
- List append()方法
描述
append() 方法用于在列表末尾添加新的对象。
语法
append()方法语法：
list.append(obj)
参数
obj -- 添加到列表末尾的对象。
返回值
该方法无返回值，但是会修改原来的列表。
实例
以下实例展示了 append()函数的使用方法：
#!/usr/bin/python3 aList = [123, 'xyz', 'zara', 'abc']; aList.append( 2017 ); print ("Updated List : ", aList) 以上实例输出结果如下： Updated List : [123, 'xyz', 'zara', 'abc', 2017]
- List count()方法
描述
count() 方法用于统计某个元素在列表中出现的次数。
语法
count()方法语法：
list.count(obj)
参数
obj -- 列表中统计的对象。
返回值
返回元素在列表中出现的次数。
实例
以下实例展示了 count()函数的使用方法：
#!/usr/bin/python3 aList = [123, 'xyz', 'zara', 'abc', 123]; print ("Count for 123 : ", aList.count(123)) print ("Count for zara : ", aList.count('zara')) 以上实例输出结果如下： Count for 123 : 2 Count for zara : 1
- List extend()方法
描述
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
语法
extend()方法语法：
list.extend(seq)
参数
seq -- 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
返回值
该方法没有返回值，但会在已存在的列表中添加新的列表内容。
实例
以下实例展示了 extend()函数的使用方法：
#!/usr/bin/python3 list1 = ['Google', 'Lizexiong', 'Taobao'] list2=list(range(5)) # 创建 0-4 的列表 list1.extend(list2) # 扩展列表 print ("扩展后的列表：", list1) 以上实例输出结果如下： 扩展后的列表： ['Google', 'Lizexiong', 'Taobao', 0, 1, 2, 3, 4]
不同数据类型：
#!/usr/bin/python3 # 语言列表 language = ['French', 'English', 'German'] # 元组 language_tuple = ('Spanish', 'Portuguese') # 集合 language_set = {'Chinese', 'Japanese'} # 添加元组元素到列表末尾 language.extend(language_tuple) print('新列表: ', language) # 添加集合元素到列表末尾 language.extend(language_set) print('新列表: ', language) 新列表: ['French', 'English', 'German', 'Spanish', 'Portuguese'] 新列表: ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Chinese', 'Japanese']
- List index()方法
描述
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法
index()方法语法：
list.index(x[, start[, end]])
参数
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
返回值
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
实例
以下实例展示了 index()函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aList = [123, 'xyz', 'lizexiong', 'abc'] print ("xyz 索引位置: ", aList.index( 'xyz' )) print ("lizexiong 索引位置 : ", aList.index( 'lizexiong', 1, 3 )) 以上实例输出结果如下： xyz 索引位置: 1 lizexiong 索引位置 : 2 补充案例场景 如果 list 存储了若干复杂结构的值，比如这样的一个列表： temp = [('a', 1, 1.5), ('b', 2, 5.1), ('c', 9, 4.3)] 你想找到其中是 ('b', XX, XX) 这样的元素，其中 XX 可以为任意值。这种情况无法通过 index 函数来获得，我们可以利用 sort 的 key 参数来实现。 list.sort（或者 sorted 函数）有一个 key 参数，你可以提供一个函数来作为排序的依据。此时我们可以传入以下值： temp.sort(key = lambda x:x[0]!='b') 随后我们会发现，所有形如 ('b', XX, XX) 的元素全部浮动到了列表的头部，此时我们访问 temp[0] 就可以获得想要查找的值了。 我们也可以写一个简单的函数： findindex = lambda self,i,value:sorted(self,key=lambda x:x[i]!=value)[0] 那我们只需要这样调用： >>> findindex(temp,0,'b') 就会返回它找到的第一个值： >>> ('b',2)
- List insert()方法
描述
insert() 函数用于将指定对象插入列表的指定位置。
语法
insert()方法语法：
list.insert(index, obj)
参数
index -- 对象 obj 需要插入的索引位置。
obj -- 要插入列表中的对象。
返回值
该方法没有返回值，但会在列表指定位置插入对象。
实例
以下实例展示了 insert()函数的使用方法：
#!/usr/bin/python3 aList = [123, 'xyz', 'zara', 'abc'] aList.insert( 3, 2017) print ("Final List : ", aList) 以上实例输出结果如下： Final List : [123, 'xyz', 'zara', 2017, 'abc'] #列表为空时，位置参数无效
- List pop()方法
描述
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法
pop()方法语法：
list.pop([index=-1])
参数
index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
返回值
该方法返回从列表中移除的元素对象。
实例
以下实例展示了 pop()函数的使用方法：
#!/usr/bin/python3 list1 = ['Google', 'lizexiong', 'Taobao'] list_pop=list1.pop(1) print "删除的项为 :", list_pop print "列表现在为 : ", list1 以上实例输出结果如下： 删除的项为 : lizexiong 列表现在为 : ['Google', 'Taobao']
- List remove()方法
描述
remove() 函数用于移除列表中某个值的第一个匹配项。
语法
remove()方法语法：
list.remove(obj)
参数
obj -- 列表中要移除的对象。
返回值
该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
实例
以下实例展示了 remove()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 'xyz']; aList.remove('xyz'); print ("List : ", aList) aList.remove('abc'); print "List : ", aList; 以上实例输出结果如下： List : [123, 'zara', 'abc', 'xyz'] List : [123, 'zara', 'xyz']
- List reverse()方法
描述
reverse() 函数用于反向列表中元素。
语法
reverse()方法语法：
list.reverse()
参数
NA。
返回值
该方法没有返回值，但是会对列表的元素进行反向排序。
实例
以下实例展示了 reverse()函数的使用方法：
#!/usr/bin/python aList = [123, 'xyz', 'zara', 'abc', 'xyz'] aList.reverse() print ("List : ", aList) 以上实例输出结果如下： List : ['xyz', 'abc', 'zara', 'xyz', 123]
- List sort()方法
描述
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
sort()方法语法：
list.sort( key=None, reverse=False)
参数
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值
该方法没有返回值，但是会对列表的对象进行排序。
实例
以下实例展示了 sort() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- aList = ['123', 'Google', 'lizexiong', 'Taobao', 'Facebook']; aList.sort(); print("List : ") print(aList) 以上实例输出结果如下： List : ['123', 'Facebook', 'Google', 'lizexiong', 'Taobao']
以下实例降序输出列表：
#!/usr/bin/python # -*- coding: UTF-8 -*- # 列表 vowels = ['e', 'a', 'u', 'o', 'i'] # 降序 vowels.sort(reverse=True) # 输出结果 print('降序输出:') print( vowels ) 以上实例输出结果如下： 降序输出: ['u', 'o', 'i', 'e', 'a']
以下实例演示了通过指定列表中的元素排序来输出列表：
#!/usr/bin/python # -*- coding: UTF-8 -*- # 获取列表的第二个元素 def takeSecond(elem): return elem[1] # 列表 random = [(2, 2), (3, 4), (4, 1), (1, 3)] # 指定第二个元素排序 random.sort(key=takeSecond) # 输出类别 print('排序列表：') print(random) 以上实例输出结果如下： 排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]
- List clear()方法
描述
clear() 函数用于清空列表，类似于 del a[:]。
语法
clear()方法语法：
list.clear()
参数
无。
返回值
该方法没有返回值。
实例
以下实例展示了 clear()函数的使用方法：
#!/usr/bin/python3 list1 = ['Google', 'Lizexiong', 'Taobao', 'Baidu'] list1.clear() print ("列表清空后 : ", list1) 以上实例输出结果如下： 列表清空后 : []
- List copy()方法
描述
copy() 函数用于复制列表，类似于 a[:]。
语法
copy()方法语法：
list.copy()
参数
无。
返回值
返回复制后的新列表。
实例
以下实例展示了 copy()函数的使用方法：
#!/usr/bin/python3 list1 = ['Google', 'Lizexiong', 'Taobao', 'Baidu'] list2 = list1.copy() print ("list2 列表: ", list2) list3 = ['Google', 'Lizexiong', 'Taobao', {'Baidu':{'chanpin':'baiduyunpan'}}] list4 = list3.copy() print ("list4 列表: ", list4) 输出以下 list2 列表: ['Google', 'Lizexiong', 'Taobao', 'Baidu'] list4 列表: ['Google', 'Lizexiong', 'Taobao', {'Baidu': {'chanpin': 'baiduyunpan'}}]
6.Python元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
>>> tup1 = ('Google', 'Lizexiong', 1997, 2000) >>> tup2 = (1, 2, 3, 4, 5 ) >>> tup3 = "a", "b", "c", "d" # 不需要括号也可以 >>> type(tup3) <class 'tuple'>
创建空元组
tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号, 否则括号会被当作运算符使用：
>>> tup1 = (50) >>> type(tup1) # 不加逗号，类型为整型 <class 'int'> >>> tup1 = (50,) >>> type(tup1) # 加上逗号，类型为元组 <class 'tuple'>
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
6.1 访问元组
元组可以使用下标索引来访问元组中的值，如下实例:
#!/usr/bin/python tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5]) 以上实例输出结果： tup1[0]: physics tup2[1:5]: (2, 3, 4, 5)
6.2 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python3 tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) 以上实例输出结果： (12, 34.56, 'abc', 'xyz')
6.3 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
#!/usr/bin/python3 tup = ('physics', 'chemistry', 1997, 2000) print (tup) del tup print ("After deleting tup : ") print (tup) 以上实例元组被删除后，输出变量会有异常信息，输出如下所示： ('physics', 'chemistry', 1997, 2000) After deleting tup : Traceback (most recent call last): File "test.py", line 9, in <module> print tup NameError: name 'tup' is not defined
6.4 元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
6.5 元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
元组：
tup = ('Google', 'Lizexiong', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup = ('Google', 'Lizexiong', 'Taobao', 'Wiki', 'Weibo','Weixin') >>> tup[1] #读取第二个元素 'Lizexiong' >>> tup[-2] #反向读取，读取倒数第二个元素 'Weibo' >>> tup[1:] #截取元素,从第二个开始后的元素 ('Lizexiong', 'Taobao', 'Wiki', 'Weibo', 'Weixin') >>> tup[1:4] #截取元素，从第二个开始到第四个元素（索引为3） ('Lizexiong', 'Taobao', 'Wiki') >>>
6.6 元组内置函数
Python元组包含了以下内置函数
6.7 关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
>>> tup = ('l','i','z','e','x','i','o','n','g') >>> tup[0] = 'g' # 不支持修改元素 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 31094344 >>> tup = (1,2,3) >>> id(tup) 41035880 # 内存地址不一样了
从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
7.Python3字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2, key3 : value3 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
一个简单的字典实例：
tinydict = {'name': 'lizexiong', 'likes': 123, 'url': 'www.lizexiong.com'}
也可如此创建字典：
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
7.1 创建空字典
使用大括号 { } 创建空字典：
# 使用大括号 {} 来创建空字典 emptyDict = {} # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:", len(emptyDict)) # 查看类型 print(type(emptyDict)) 以上实例输出结果： {} Length: 0 <class 'dict'>
使用内建函数 dict() 创建字典：
emptyDict = dict() # 打印字典 print(emptyDict) # 查看字典的数量 print("Length:",len(emptyDict)) # 查看类型 print(type(emptyDict)) 以上实例输出结果： {} Length: 0 <class 'dict'>
7.2 访问字典里的值
把相应的键放入到方括号中，如下实例:
#!/usr/bin/python3 tinydict = {'Name': 'Lizexiong', 'Age': 7, 'Class': 'First'} print ("tinydict['Name']: ", tinydict['Name']) print ("tinydict['Age']: ", tinydict['Age']) 以上实例输出结果： tinydict['Name']: Lizexiong tinydict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3 tinydict = {'Name': 'Lizexiong', 'Age': 7, 'Class': 'First'} print ("tinydict['Alice']: ", tinydict['Alice']) 以上实例输出结果： Traceback (most recent call last): File "test.py", line 5, in <module> print ("tinydict['Alice']: ", tinydict['Alice']) KeyError: 'Alice'
7.3 修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
#!/usr/bin/python3 tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} tinydict['Age'] = 8 # 更新 tinydict['School'] = "LIZEXIONG" # 添加 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 以上实例输出结果： tinydict['Age']: 8 tinydict['School']: LIZEXIONG
7.4 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：
#!/usr/bin/python3 tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} del tinydict['Name'] # 删除键是'Name'的条目 tinydict.clear() # 清空字典所有条目 del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age']) print ("tinydict['School']: ", tinydict['School']) 但这会引发一个异常，因为用del后字典不再存在： tinydict['Age']: Traceback (most recent call last): File "test.py", line 10, in <module> print "tinydict['Age']: ", tinydict['Age'] NameError: name 'tinydict' is not defined
注：del() 方法后面也会讨论。
7.5 字典键的特性
字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3 tinydict = {'Name': 'LIZEXIONG', 'Age': 7, 'Name': 'Manni'} print ("tinydict['Name']: ", tinydict['Name']) 以上实例输出结果： tinydict['Name']: Manni
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
#!/usr/bin/python3 tinydict = {['Name']: 'Zara', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name']) 以上实例输出结果： Traceback (most recent call last): File "test.py", line 3, in <module> tinydict = {['Name']: 'Zara', 'Age': 7} TypeError: unhashable type: 'list'
7.6 字典内置函数
Python字典包含了以下内置函数：
7.7 字典内置方法
Python字典包含了以下内置方法：
- 字典(Dictionary) clear()方法
描述
Python 字典(Dictionary) clear() 函数用于删除字典内所有元素。
语法
clear()方法语法：
dict.clear()
参数
NA。
返回值
该函数没有任何返回值。
实例
以下实例展示了 clear()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7}; print ("Start Len : %d" % len(tinydict)) tinydict.clear() print ("End Len : %d" % len(tinydict)) 以上实例输出结果为： Start Len : 2 End Len : 0
- 字典(Dictionary) copy()方法
描述
Python 字典(Dictionary) copy() 函数返回一个字典的浅复制。
语法
copy()方法语法：
dict.copy()
参数
NA。
返回值
返回一个字典的浅复制。
实例
以下实例展示了 copy()函数的使用方法：
#!/usr/bin/python dict1 = {'Name': 'Zara', 'Age': 7}; dict2 = dict1.copy() print ("New Dictinary : %s" % str(dict2)) 以上实例输出结果为： New Dictinary : {'Age': 7, 'Name': 'Zara'}
直接赋值和 copy 的区别
可以通过以下实例说明：
#!/usr/bin/python # -*- coding: UTF-8 -*- dict1 = {'user':'LIZEXIONG','num':[1,2,3]} dict2 = dict1 # 浅拷贝: 引用对象 dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用 # 修改 data 数据 dict1['user']='root' dict1['num'].remove(1) # 输出结果 print(dict1) print(dict2) print(dict3) 实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。 {'num': [2, 3], 'user': 'root'} {'num': [2, 3], 'user': 'root'} {'num': [2, 3], 'user': 'LIZEXIONG'}
- 字典(Dictionary) fromkeys()方法
描述
Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value为字典所有键对应的初始值。
语法
fromkeys()方法语法：
dict.fromkeys(seq[, value])
参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
返回值
该方法返回一个新字典。
实例
以下实例展示了 fromkeys() 函数的使用方法：
#!/usr/bin/python3 seq = ('Google', 'LIZEXIONG', 'Taobao') thisdict = dict.fromkeys(seq) print "新字典为 : %s" % str(dict) thisdict = dict.fromkeys(seq, 10) print "新字典为 : %s" % str(thisdict) 以上实例输出结果为： 新字典为 : {'Google': None, 'Taobao': None, 'LIZEXIONG': None} 新字典为 : {'Google': 10, 'Taobao': 10, 'LIZEXIONG': 10}
不指定值：
#!/usr/bin/python3 x = ('key1', 'key2', 'key3') thisdict = dict.fromkeys(x) print(thisdict) 以上实例输出结果为： {'key1': None, 'key2': None, 'key3': None}
- 字典(Dictionary) get()方法
描述
Python 字典(Dictionary) get() 函数返回指定键的值。
语法
get()方法语法：
dict.get(key[, value])
参数
key -- 字典中要查找的键。
value -- 可选，如果指定键的值不存在时，返回该默认值。
返回值
返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。
实例
以下实例展示了 get() 函数的使用方法：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'Name': 'LIZEXIONG', 'Age': 27} print ("Age : %s" % tinydict.get('Age')) # 没有设置 Sex，也没有设置默认的值，输出 None print ("Sex : %s" % tinydict.get('Sex')) # 没有设置 Salary，输出默认的值 0.0 print ('Salary: %s' % tinydict.get('Salary', 0.0)) 以上实例输出结果为： Age : 27 Sex : None Salary: 0.0
get() 方法 Vs dict[key] 访问元素区别
get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。
dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。
实例 >>> lizexiong = {} >>> print('URL: ', lizexiong.get('url')) # 返回 None URL: None >>> print(lizexiong['url']) # 触发 KeyError Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'url' >>>
嵌套字典使用
get() 方法对嵌套字典的使用方法如下：
#!/usr/bin/python # -*- coding: UTF-8 -*- tinydict = {'LIZEXIONG' : {'url' : 'www.lizexiong.com'}} res = tinydict.get('LIZEXIONG', {}).get('url') # 输出结果 print("LIZEXIONG url 为 : %s" % str(res)) 以上实例输出结果为： LIZEXIONG url 为 : www.lizexiong.com
- 字典 in 操作符
描述
Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。
语法
in 操作符语法：
key in dict
参数
key -- 要在字典中查找的键。
返回值
如果键在字典里返回true，否则返回false。
实例
以下实例展示了 in 操作符在字典中的使用方法：
#!/usr/bin/python3 thisdict = {'Name': 'Lizexiong', 'Age': 7} # 检测键 Age 是否存在 if 'Age' in thisdict: print("键 Age 存在") else : print("键 Age 不存在") # 检测键 Sex 是否存在 if 'Sex' in thisdict: print("键 Sex 存在") else : print("键 Sex 不存在") # not in # 检测键 Age 是否存在 if 'Age' not in thisdict: print("键 Age 不存在") else : print("键 Age 存在") 以上实例输出结果为： 键 Age 存在 键 Sex 不存在 键 Age 存在
- 字典(Dictionary) items()方法
描述
Python 字典 items() 方法以列表返回视图对象，是一个可遍历的key/value 对。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
语法
items()方法语法：
dict.items()
参数
NA。
返回值
返回可视图对象。
实例
以下实例展示了 items()函数的使用方法：
#!/usr/bin/python # coding=utf-8 tinydict = {'Google': 'www.google.com', 'lizexiong': 'www.lizexiong.com', 'taobao': 'www.taobao.com'} print "字典值 : %s" % tinydict.items() # 遍历字典列表 for key,values in tinydict.items(): print key,values 以上实例输出结果为： 字典值 : [('Google', 'www.google.com'), ('taobao', 'www.taobao.com'), ('lizexiong', 'www.lizexiong.com')] Google www.google.com taobao www.taobao.com lizexiong www.lizexiong.com
- 字典(Dictionary) keys()方法
描述
Python3 字典 keys() 方法返回一个视图对象。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
注意：Python2.x 是直接返回列表
语法
keys()方法语法：
dict.keys()
参数
NA。
返回值
返回一个视图对象。
实例
以下实例展示了 keys()函数的使用方法：
>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()
>>> # 迭代
>>> n = 0
>>> for val in values:
... n += val
>>> print(n)
504
>>> # keys 和 values 以相同顺序（插入顺序）进行迭代
>>> list(keys) # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]
>>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']
- 字典(Dictionary) setdefault()方法
描述
Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
语法
setdefault() 方法语法：
dict.setdefault(key, default=None)
参数
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。
返回值
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
实例
以下实例展示了 setdefault() 函数的使用方法：
#!/usr/bin/python3 tinydict = {'lizexiong': '华为', 'google': 'Google 搜索'} print ("Value : %s" % tinydict.setdefault('lizexiong', None)) print ("Value : %s" % tinydict.setdefault('Taobao', '淘宝')) 以上实例输出结果为： Value : 华为 Value : 淘宝
- 字典(Dictionary) update()方法
描述
Python 字典(Dictionary) update() 函数把字典 dict2 的键/值对更新到 dict 里。
语法
update()方法语法：
dict.update(dict2)
参数
dict2 -- 添加到指定字典dict里的字典。
返回值
该方法没有任何返回值。
实例
以下实例展示了 update()函数的使用方法：
#!/usr/bin/python tinydict = {'Name': 'Zara', 'Age': 7} tinydict2 = {'Sex': 'female' } tinydict.update(tinydict2) print ("Value : %s" % tinydict) 以上实例输出结果为： Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
用 update 更新字典 a，会有两种情况：
（1）有相同的键时：会使用最新的字典 b 中 该 key 对应的 value 值。
（2）有新的键时：会直接把字典 b 中的 key、value 加入到 a 中。
>>> a = {1: 2, 2: 2}
>>> b = {1: 1, 3: 3}
>>> a.update(b)
>>> print(a)
{1: 1, 2: 2, 3: 3}
- 字典(Dictionary) values()方法
描述
Python3 字典 values() 方法返回一个视图对象。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。
视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
语法
values()方法语法：
dict.values()
参数
NA。
返回值
返回视图对象。
实例
以下实例展示了 values()函数的使用方法：
>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()
>>> # 迭代
>>> n = 0
>>> for val in values:
... n += val
>>> print(n)
504
>>> # keys 和 values 以相同顺序（插入顺序）进行迭代
>>> list(keys) # 使用 list() 转换为列表
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]
>>> # 视图对象是动态的，受字典变化的影响，以下删除了字典的 key，视图对象转为列表后也跟着变化
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(values)
[1, 500]
>>> #相同两个 dict.values() 比较返回都是 False
>>> d = {'a': 1}
>>> d.values() == d.values()
False
- 字典 pop() 方法
描述
Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。
语法
pop() 方法语法：
pop(key[,default])
参数
key - 要删除的键
default - 当键 key 不存在时返回的值
返回值
返回被删除的值：
-
- 如果 key 存在 - 删除字典中对应的元素
- 如果 key 不存在 - 返回设置指定的默认值 default
- 如果 key 不存在且默认值 default 没有指定 - 触发 KeyError 异常
实例
以下实例展示了 pop() 方法的使用方法：
#!/usr/bin/python3 site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('name') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： 删除的元素为:华为 字典为:{'url': 'www.lizexiong.com', 'alexa': 10000}
如果删除的键不存在会触发异常：
#!/usr/bin/python3 site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('nickname') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： Traceback (most recent call last): File "test.py", line 6, in <module> element = site.pop('nickname') KeyError: 'nickname'
可以设置默认值来避免异常：
#!/usr/bin/python # -*- coding: UTF-8 -*- site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} element = site.pop('nickname', '不存在的 key') print('删除的元素为:') print(element) print('字典为:') print(site) 输出结果为： 删除的元素为:不存在的 key 字典为:{'url': 'www.lizexiong.com', 'alexa': 10000, 'name': '华为'}
- 字典 popitem() 方法
描述
Python 字典 popitem() 方法返回并删除字典中的最后一对键和值。
如果字典已经为空，却调用了此方法，就报出 KeyError 异常。
语法
popitem()方法语法：
popitem()
参数
无
返回值
返回最后插入键值对(key, value 形式)，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。
注意：在 Python3.7 之前，popitem() 方法删除并返回任意插入字典的键值对。
实例
以下实例展示了 popitem() 方法的使用方法：
#!/usr/bin/python3 site= {'name': '华为', 'alexa': 10000, 'url': 'www.lizexiong.com'} # ('url': 'www.lizexiong.com') 最后插入会被删除 result = site.popitem() print('返回值 = ', result) print('site = ', site) # 插入新元素 site['nickname'] = 'lizexiong' print('site = ', site) # 现在 ('nickname', 'lizexiong') 是最后插入的元素 result = site.popitem() print('返回值 = ', result) print('site = ', site) 结果输出: 返回值 = ('url', 'www.lizexiong.com') site = {'name': '华为', 'alexa': 10000} site = {'name': '华为', 'alexa': 10000, 'nickname': 'lizexiong'} 返回值 = ('nickname', 'lizexiong') site = {'name': '华为', 'alexa': 10000}
8.Python3 集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
或者
set(value)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
类似列表推导式，同样集合支持集合推导式(Set comprehension):
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
8.1 添加元素
语法格式如下：
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Lizexiong'}
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
x 可以有多个，用逗号分开。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Lizexiong'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Lizexiong'} >>>
8.2 移除元素
语法格式如下：
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google', 'Lizexiong'} >>> thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Facebook' >>>
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Lizexiong'}
我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop() ######################################### thisset = set(("Google", "Lizexiong", "Taobao", "Facebook")) x = thisset.pop() print(x) 输出结果： $ python3 test.py Lizexiong
多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
8.3 计算集合元素个数
语法格式如下：
len(s)
计算集合 s 元素个数。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> len(thisset) 3
8.4 清空集合
语法格式如下：
s.clear()
清空集合 。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> thisset.clear() >>> print(thisset) set()
8.5 判断元素是否在集合中存在
语法格式如下：
x in s
判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
>>> thisset = set(("Google", "Lizexiong", "Taobao")) >>> "Lizexiong" in thisset True >>> "Facebook" in thisset False >>>
8.6 集合内置方法完整列表
- Set add()方法
描述
add() 方法用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。
语法
add()方法语法：
set.add(elmnt)
参数
elmnt -- 必需，要添加的元素。
返回值
无。
实例
以下实例展示了 add() 方法的使用：
fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)
输出结果为：
{'apple', 'banana', 'orange', 'cherry'}
已存在的元素，则不执行添加操作：
实例 2 fruits = {"apple", "banana", "cherry"} fruits.add("apple") print(fruits) 输出结果为： {'apple', 'banana', 'cherry'}
- Set clear()方法
描述
clear() 方法用于移除集合中的所有元素。
语法
clear()方法语法：
set.clear()
参数
无。
返回值
无。
实例
移除 fruits 集合中的所有元素：
fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(fruits)
输出结果为：
set()
- Set copy()方法
描述
copy() 方法用于拷贝一个集合。
语法
copy() 方法语法：
set.copy()
参数
无。
返回值
返回拷贝的集合。
实例
拷贝 fruits 集合：
sites = {"Google", "Lizexiong", "Taobao"}
x = sites.copy()
print(x)
输出结果为：
set(['Google', 'Taobao', 'Lizexiong'])
- Set difference() 方法
描述
difference() 方法用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
语法
difference() 方法语法：
set.difference(set)
参数
set -- 必需，用于计算差集的集合
返回值
返回一个新的集合。
实例
返回一个集合，元素包含在集合 x ，但不在集合 y ：
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
print(z)
输出结果为：
{'cherry', 'banana'}
- difference_update() 方法
描述
difference_update() 方法用于移除两个集合中都存在的元素。
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。
语法
difference_update() 方法语法：
set.difference_update(set)
参数
set -- 必需，用于计算差集的集合
返回值
无。
实例
移除两个集合都包含的元素：
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y)
print(x)
输出结果为：
{'cherry', 'banana'}
- Set discard() 方法
描述
discard() 方法用于移除指定的集合元素。
该方法不同于 remove() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
语法
discard() 方法语法：
set.discard(value)
参数
value -- 必需，要移除的元素
返回值
无。
实例
移除集合中的元素 banana：
fruits = {"apple", "banana", "cherry"}
fruits.discard("banana")
print(fruits)
输出结果为：
{'cherry', 'apple'}
- Set intersection() 方法
描述
intersection() 方法用于返回两个或更多集合中都包含的元素，即交集。
语法
intersection() 方法语法：
set.intersection(set1, set2 ... etc)
参数
set1 -- 必需，要查找相同元素的集合
set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
返回值
返回一个新的集合。
实例
返回一个新集合，该集合的元素既包含在集合 x 又包含在集合 y 中：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
z = x.intersection(y)
print(z)
输出结果为：
{'apple'}
计算多个集合的交集：
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print(result)
输出结果为：
{'c'}
- Set intersection_update() 方法
描述
intersection_update() 方法用于获取两个或更多集合中都重叠的元素，即计算交集。
intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。
语法
intersection_update() 方法语法：
set.intersection_update(set1, set2 ... etc)
参数
set1 -- 必需，要查找相同元素的集合
set2 -- 可选，其他要查找相同元素的集合，可以多个，多个使用逗号 , 隔开
返回值
无。
实例
移除 x 集合中不存在于 y 集合中的元素：
x = {"apple", "banana", "cherry"} # y 集合不包含 banana 和 cherry，被移除
y = {"google", "lizexiong", "apple"}
x.intersection_update(y)
print(x)
输出结果为：
{'apple'}
计算多个集合的并集：
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
x.intersection_update(y, z)
print(x)
输出结果为：
{'c'}
- Set isdisjoint() 方法
描述
isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。。
语法
isdisjoint() 方法语法：
set.isdisjoint(set)
参数
set -- 必需，要比较的集合
返回值
返回布尔值，如果不包含返回 True，否则返回 False。
实例
判断集合 y 中是否有包含 集合 x 的元素：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "facebook"}
z = x.isdisjoint(y)
print(z)
输出结果为：
True
如果包含返回 False：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
z = x.isdisjoint(y)
print(z)
输出结果为：
False
- Set issubset() 方法
描述
issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。
语法
issubset() 方法语法：
set.issubset(set)
参数
set -- 必需，要比查找的集合
返回值
返回布尔值，如果都包含返回 True，否则返回 False。
实例
判断集合 x 的所有元素是否都包含在集合 y 中：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)
输出结果为：
True
如果没有全部包含返回 False：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
z = x.issubset(y)
print(z)
输出结果为：
False
- Set issuperset() 方法
描述
issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。
语法
issuperset() 方法语法：
set.issuperset(set)
参数
set -- 必需，要比查找的集合
返回值
返回布尔值，如果都包含返回 True，否则返回 False。
实例
判断集合 y 的所有元素是否都包含在集合 x 中：
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)
输出结果为：
True
如果没有全部包含返回 False：
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)
输出结果为：
False
- Set pop() 方法
描述
pop() 方法用于随机移除一个元素。
语法
pop() 方法语法：
set.pop()
参数
无
返回值
返回移除的元素。
实例
随机移除一个元素：
fruits = {"apple", "banana", "cherry"}
fruits.pop()
print(fruits)
输出结果为：
{'apple', 'banana'}
输出返回值：
fruits = {"apple", "banana", "cherry"}
x = fruits.pop()
print(x)
输出结果为：
banana
- Set remove() 方法
描述
remove() 方法用于移除集合中的指定元素。
该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
语法
remove() 方法语法：
set.remove(item)
参数
item -- 要移除的元素
返回值
没有返回值。
实例
移除元素 banana：
fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print(fruits)
输出结果为：
{'cherry', 'apple'}
- Set symmetric_difference() 方法
描述
symmetric_difference() 方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。
语法
symmetric_difference() 方法语法：
set.symmetric_difference(set)
参数
set -- 集合
返回值
返回一个新的集合。
实例
返回两个集合组成的新集合，但会移除两个集合的重复元素：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
z = x.symmetric_difference(y)
print(z)
输出结果为：
{'google', 'cherry', 'banana', 'lizexiong'}
- Set symmetric_difference_update() 方法
描述
symmetric_difference_update() 方法移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
语法
symmetric_difference_update() 方法语法：
set.symmetric_difference_update(set)
参数
set -- 要检测的集合
返回值
无。
实例
在原始集合 x 中移除与 y 集合中的重复元素，并将不重复的元素插入到集合 x 中：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
x.symmetric_difference_update(y)
print(x)
输出结果为：
{'google', 'cherry', 'banana', 'lizexiong'}
- Set union() 方法
描述
union() 方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。
语法
union() 方法语法：
set.union(set1, set2...)
参数
set1 -- 必需，合并的目标集合
set2 -- 可选，其他要合并的集合，可以多个，多个使用逗号 , 隔开。
返回值
返回一个新集合。
实例
合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
z = x.union(y)
print(z)
输出结果为：
{'cherry', 'lizexiong', 'google', 'banana', 'apple'}
合并多个集合：
x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}
result = x.union(y, z)
print(result)
输出结果为：
{'c', 'd', 'f', 'e', 'b', 'a'}
- Set update() 方法
描述
update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
语法
update() 方法语法：
set.update(set)
参数
set -- 必需，可以是元素或集合
返回值
无。
实例
合并两个集合，重复元素只会出现一次：
x = {"apple", "banana", "cherry"}
y = {"google", "lizexiong", "apple"}
x.update(y)
print(x)
输出结果为：
{'banana', 'apple', 'google', 'lizexiong', 'cherry'}