1. 【判断可迭代对象中的元素是否全为True】all()函数
语法参考
all()函数用于判断可迭代对象是否包括假值即0、空、False，除此之外都属于真值。如果包括假值结果就为False，否则结果就为True。all()函数的语法格式如下：
all(iterable)
参数说明：
-
iterable：可迭代对象，如列表、元组等。
-
返回值：返回值为True或False，如果可迭代对象不包括空、0、False的元素，那么返回值为True，否则返回值为False。
锦囊1 判断列表、元组、字典、集合可迭代对象的元素是否为True
判断列表、元组、字典、集合可迭代对象的元素是否为True。示例代码如下：
a_list = [0,1,2,3,4,5] # 元素中包含0的列表
b_list = ['0',1,2,3,4,5] # 当列表元素中包含字符类型的'0'时，将视为True
c_tuple = ('a','b','c','') # 元组中包含''空字符串
d_tuple = (None,'b','c','d') # 元组中包含None
e_set = {
'P', 'Y',False, 'T', 'H','H','O','N'} # 集合元素中包含False
f_dict ={
0:1} # 字典中key为0
g_dict = {
1:0} # 字典中值为0
print('元素为0时：',all(a_list))
print('元素为字符“0”时：',all(b_list))
print('元组中包含空字符串元素时：',all(c_tuple))
print('元组中包含None元素时：',all(d_tuple))
print('集合数据为：',e_set)
print('集合中包含False元素时：',all(e_set))
print('字典中key为0时：',all(f_dict))
print('字典中值为0时：',all(g_dict))
锦囊2 使用all()函数判断可迭代对象是否包括空、0、False的元素
下面使用all()函数判断下列可迭代对象是否包括空、0、False的元素，代码如下：
print(all([1,3,5,7,9])) # 列表元素都不为空、0、False，返回True
print(all(('Python','Java'))) # 元组元素都不为空、0、False，返回True
print(all([0,2,4,6,8])) # 列表元素中存在一个为0的元素，返回False
print(all(['a','b','c',''])) # 列表元素中存在一个为空的元素，返回False
注意：如果可迭代对象中元素个数为0，则返回值为True，例如空列表、空元组、空字典的返回值为True，代码如下：
print(all([])) # 空列表，返回True
print(all(())) # 空元组，返回True
print(all({
})) # 空字典，返回True
提示：all()函数以一个可迭代器对象为参数，当参数为空或者提供的参数不是可迭代器对象时将提示TypeError错误信息，代码如下：
# 将提示TypeError: all() takes exactly one argument (0 given)
print(all()) # 参数不能为空
# 将提示TypeError: 'int' object is not iterable
print(all(2)) # 参数必须为可迭代对象
锦囊3 判断列表中是否包括0
生成随机数列表，并通过all()函数的返回值判断随机数列表中是否包括0，如果包括0则输出该列表，如果不包括0则程序重新执行，代码如下：
import random # 导入随机数模块
while 1:
a=[random.randint(0,5) for _ in range(5)] # 生成0-5之间的随机数列表
if all(a)==False:
print(a)
break
else:
print('随机数列表中没有0，程序重新执行！')
2. 【根据传入的参数创建一个字典对象】dict函数
语法参考
dict()函数用于创建一个字典对象，其语法格式如下：
dict()
dict(**kwargs)
dict(mapping,**kwargs)
dict(iterable,**kwargs)
参数说明：
-
** kwargs，一到多个关键字参数；如dict(one=1, two=2, three=3)
-
mapping，元素容器，如zip函数；
-
iterable，可迭代对象；
-
返回值：一个字典。如果不传入任何参数时，则返回空字典；
锦囊1 通过给定的关键字参数创建字典
使用dict()函数，然后通过给定的关键字参数创建字典。示例代码如下：
# 通过给定的关键字参数创建字典
d1 = dict(mr='www.mingrisoft.com') # 字符串的key与值
print(d1) # 打印d1字典内容
d2 = dict(Python=98, English=78, Math=81) # 字符串的key，int类型的值
print(d2) # 打印d2字典内容
d3 = dict(name='Tom', age=21, height=1.5) # 字符串的key，多种类型的值
print(d3) # 打印d3字典内容
提示：使用dic()函数通过给定的关键字参数创建字典时，name键名必须都是Python中的标识符，否则会提示SyntaxError。错误代码如下：
# 将会提示SyntaxError: keyword can't be an expression
print(dict(1='a',2='b')) # 数字不是标识符
锦囊2 通过传入映射函数创建字典
使用dict()函数，然后通过传入映射函数创建字典。示例代码如下：
# 通过映射函数创建字典
a1 = dict(zip((1,2,3,4),('杰夫•贝佐斯','比尔•盖茨','沃伦•巴菲特','伯纳德•阿诺特')))
print(a1) # 打印a1字典内容，key为int类型，值为字符串类型
a2 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(a2) # 打印a2字典内容，key为字符串类型，值为int类型
a3 = dict(zip(['北京','上海','长春'],['晴','大雨','小雪']))
print(a3) # 打印a3字典内容，key与值都是字符串类型
锦囊3 通过传入可迭代对象创建字典
使用dict()函数，然后通过传入可迭代对象创建字典。示例代码如下：
# 通过可迭代对象创建字典
b1 = dict([('Monday',1),('Tuesday',2),('Wednesday',3)]) # 元组对象
print(b1) # 打印b1字典内容
b2 = dict([['apple',6.5], ['orange',3.98], ['pear',8], ['banana',2.89]]) # 列表对象
print(b2) # 打印b2字典内容
锦囊4 通过关键字索引访问字典成员
在访问字典成员时，可以通过使用关键字作为索引或者字典key所对应的值，还可以使用运算符对字典中的值进行计算。示例代码如下：
# 商品信息
commodity= {
'name':'Chocolates',
'number':12,
'price':19.8}
name = commodity['name'] # 获取字典中商品名称
# 根据获取的商品数量和商品单价，计算商品总价
total_price = commodity['number']*commodity['price']
print('商品名称为：',name) # 输出商品名称
print('商品总价为：',total_price) # 输出商品总价
锦囊5 通过关键字索引插入与修改字典中的成员
在字典中不仅可以使用关键字索引的方式获取指定key所对应的值，还可以通过关键字索引插入以及修改字典中的成员。示例代码如下：
name={
'刘能': '刘', '赵四': '赵', '谢广坤': '坤'} # 名字数据
print('原字典数据为：',name) # 打印原字典数据
name[ '谢广坤'] = '谢' # 将名字值修改为姓氏
print('修改后的字典数据为：',name) # 打印修改后的字典数据
name['王长贵'] = '王' # 向原字典数据中插入数据
print('插入新数据的字典为：',name) # 打印插入新数据后的字典
3. 【根据可迭代对象创建一个enumerate对象】enumerate函数
语法参考
enumerate()函数将一个可迭代的对象组合为一个带有数据和数据下标的索引序列，返回一个枚举对象，enumerate()函数多用在for循环中，用于遍历序列中的元素以及它们的下标。其语法格式如下：
enumerate(iterable, start=0)
参数说明：
-
iterable：一个序列、迭代器或其他支持迭代的对象，如列表、元组、字符串等；
-
start：下标的起始值，默认从0开始；
-
返回值：返回一个enumerate(枚举)对象。
锦囊1 将enumerate对象转换为列表
定义一个元组，使用enumerate()函数根据定义的元组创建一个enumerate对象，并使用list()函数将其转换为列表，示例代码如下：
num = ('one','two','three','four') # 创建元组数据
print(enumerate(num)) # 返回一个enumerate对象
print(list(enumerate(num))) # 使用list()函数转换为列表，下标的起始值默认从0开始
print(list(enumerate(num,2))) # 设置下标的起始值从2开始
锦囊2 通过enumerate()函数合并列表索引
定义两个列表，通过enumerate()函数将其组成索引序列，最后合成一个列表，并且实现下标的连续性。示例代码如下：
list1 = ['python', 'java', 'asp.net', 'c++','vb'] # 创建列表list1
list2 = ['sqlserver','oracle','mysql','mongodb'] # 创建列表list2
en1 = enumerate(list1) # 创建list1列表的enumerate对象
en2 = enumerate(list2,start=5) # 创建list2列表的enumerate对象，下标以5开始
resultList = list(en1) + list(en2) # 将两个enumerate对象转换为列表，并合为一个列表
print('合并后的列表内容为：\n',resultList) # 打印合并后的列表内容
锦囊3 循环遍历序列中的元素及下标
enumerate()函数多用在for循环中，用于遍历序列中的元素以及它们的下标。使用for循环和enumerate()函数实现同时输出索引值和元素内容的功能，其语法格式如下：
for index,item in enumerate(listname):
# 输出index和item
参数说明：
-
index：用于保存元素的索引；
-
item：用于保存获取到的元素值，要输出元素内容时，直接输出该变量即可；
-
listname：序列名称。
通过enumerate()函数，循环遍历序列中的元素及下标。示例代码如下：
list3=['Forever', 'I Need You', 'Alone', 'Hello'] # 列表数据
for index,item in enumerate(list3): # 循环遍历列表中的元素及下标
print('列表元素下标为:',index,'列表元素为：',item)
4. 【获取序列的长度或项目个数】len函数
示例
len()函数的主要功能是获取一个（字符、列表、元组等）序列的长度或项目个数。例如，分别获取字符串、列表、元组、集合与字典长度，可以参考以下示例代码：
a_str = 'hello word' # 字符串
a_list = [1,2,3,4,'123',2.15] # 列表
a_tuple = (('威尼斯',1),('阿姆斯特丹运河',2),('马尔代夫',3),('迪拜',4))
a_set = {
7,7,5,8} # 集合
a_dict = {
'Name':'Aaron','Age':18,'height':1.72,'weight':55,'sex':'g'} # 字典
print('字符串长度为：',len(a_str)) # 字符串中的空格也会占用一个位置
print('列表长度为：',len(a_list)) # 不区分元素类型
print('元组长度为：',len(a_tuple)) # 默认获取外层元组长度
print('集合长度为：',len(a_set)) # 获取集合去重后的长度
print('字典长度为：',len(a_dict)) # 获取字典键值对个数
5. 【将序列转换为列表】list函数
语法参考
list()函数用于将序列转换成列表类型并返回一个数据列表，其语法格式如下：
list(seq)
参数说明：
-
seq：表示可以转换为列表的数据，其类型可以是range对象、字符串、列表、元组、字典或者其他可迭代类型的数据；
-
返回值：列表。
-
list()函数可以传入一个可迭代对象，如字符串、元组、列表、range对象等，结果将返回可迭代对象中元素组成的列表。list()函数也可以不传入任何参数，结果返回一个空列表。
提示：如果list()函数的参数为列表，将会原样返回。
锦囊2 将字典转换为列表
使用list()函数将字典转换为列表，示例代码如下：
dictionary = {
'Python':98,'Java':80,'C语言':75} # 定义字典
print(list(dictionary)) # 使用list()函数转换为列表
提示：list()函数的参数为字典时，会返回字典的key组成的列表。如果需要将字典中的values()转换为列表时可以使用如下代码：
print(list(dictionary.values())) # 将字典中values转换为列表
6. 【获取序列（或元素）的最大值】max函数
示例
max()函数可以返回给定参数中的最大值，参数可以是序列。例如，分别获取字符串、列表、元组、集合与字典中最大值，可以参考以下示例代码：
a_str = ['刀','枪','剑','戟'] # 字符型列表
a_int = [1,2,3,4] # 数值型列表
b_int = [2,4,6,8]
print('字符串中最大值为：',max('HELLO WORD'))
print('直接指定参数中的最大值：',max(7,9,3,2,1))
print('字符列表中最大元素为：',max(a_str))
print('数值型最大列表为：',max(a_int,b_int))
a_tuple = (1,3,5,7,9) # 数值元组
print('元组中最大值为：',max(a_tuple))
a_set = {
2,4,6,8,0} # 数值型集合
print('集合中最大值为：',max(a_set))
a_dict = {
1:2,3:4,5:6} # 字典
print('字典中最大值为：',max(a_dict)) # 默认情况下获取字典中键最大值
7. 【获取一个对象的内存查看对象】memoryview函数
语法参考
memoryview()函数用来返回指定对象的内存查看对象，实际上是内存查看对象的构造函数。
其语法格式如下：
memoryview(object)
参数说明：
-
object：要获取其内存查看对象的对象名，该对象必须支持缓冲区协议（buffer protocol），Python内置对象中支持缓冲区协议的对象有bytes和bytearray。
-
返回值：获取到的内存查看对象。
说明：所谓内存查看对象（Momory view），就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必复制，就可以直接使用。
说明：memoryview()函数类似C语言中的指针。如果某个对象支持缓冲区协议，那么就可以通过memory去访问到它内部的数据。
注意：不能修改memoryview对象的大小。
锦囊1 memoryview函数的使用
memoryview()函数的基本使用方式，示例代码如下：
v = memoryview(b'Python') # 不可变字节数组为'Python'
print('字节数组P的内存对象为：',v[0]) # 打印字节数组中P的内存对象
print('字节数组y的内存对象为：',v[1]) # 打印字节数组中y的内存对象
print('字节数组n的内存对象为：',v[-1]) # 打印字节数组中n的内存对象
print('字节数组yth的内存对象为：',v[1:4]) # 打印字节数组中yth的内存对象
print('v[1:4]内存对象的字节数组为：',bytes(v[1:4])) # 打印v[1:4]内存对象的字节数组
锦囊2 获取bytearray数组在内存中的数据
使用memoryview()函数获取一个bytearray数组在内存中的数据，示例代码如下：
b = bytearray('abcefg', 'utf-8') # 可变字节数组
v = memoryview(b) # 获取内存对象
print('可变字节数组b的内存对象为：',v) # 打印可变字节数组的内存对象
print('缓存中的数据为：',v.tobytes()) # tobytes()方法返回在缓存中的数据
print('缓存中的内存对象为：',v.tolist()) # tolist()方法以一个整数列表的形式返回缓存中的数据
print('字节数组中a的内存对象为：',v[0]) # 打印字节数组中a的内存对象
print('字节数组中b的内存对象为：',v[1]) # 打印字节数组中b的内存对象
print('字节数组中bce的内存对象为：',v[1:3]) # 打印字节数组中bce的内存对象
8. 【获取序列（或元素）的最小值】min函数
示例
min()函数用于执行与max()函数相反的操作，可以获取指定的多个参数中的最小值或可迭代对象元素中的最小值。例如，分别获取字符串、列表、元组、集合与字典中最小值，可以参考以下示例代码：
a_list = ['你','好','p','y','t','h','o','n'] # 列表
a_tuple = (7,14,21,28,35,42,49,56,63) # 元组
a_set = {
'1','3','5','7','9'} # 集合
a_dict = {
'小明qq':875897,'小红qq':5343215,'小李qq':77582,'小华qq':873541843} # 字典
print('字符串中最小值为：',min('12345'))
print('列表中最小值为：',min(a_list))
print('元组中最小值为：',min(a_tuple))
print('集合中最小值为：',min(a_set))
print('字典中最小值为：',min(a_dict)) # 默认情况下获取字典中键最小值
9. 【将可迭代对象转换为可变集合】set函数
语法参考
set()函数用于将可迭代对象转换为一个无序不重复元素的可变集合，返回的集合是可以修改的，我们可以对集合元素进行添加或删除等，还可以进行交集、并集、差集等操作，其语法格式如下：
set([iterable])
参数说明：
-
iterable：表示要转换为集合的可迭代对象，可以是列表、元组、range对象、字符串等；
-
返回值：返回一个新的集合对象；当不传入参数时，生成一个新的空集合。
锦囊1 根据传入的参数创建一个新的集合
使用set()函数，然后根据传入的参数创建一个新的集合。示例代码如下：
print(set()) # 不传入参数，创建空集合
print(set('Happy')) # 将字符串转换为集合，返回不重复字符的集合，重复的被删除
print(set(('人生苦短', '我用Python'))) # 将元组转换为集合
print(set(['Forever', 'I Need You', 'Alone', 'Hello'])) # 将列表转换为集合
print(set([88,100,67,88,88,67])) # 将列表转换为集合，重复的被删除
print(set(range(10))) # 将range对象转换为集合
锦囊2 去掉随机数中的重复数字
随机生成20个1到19间（含19）的随机数，然后通过set()函数去掉生成的重复数字。示例代码如下：
import random # 导入随机数函数
list=[] # 保存随机数的列表
for i in range(0,20):
list.append(random.randint(1,20)) # 将随机数添加到空列表
s1=set(list) # 将列表转换为集合
print('随机后的整数列表',list)
print('去掉重复后的整数列表：',s1)
锦囊3 通过lambda过滤集合中不是指定类型的元素
如果不想使用for循环的方式去筛选集合元素时，可以使用简短的lambda表达式来实现。示例代码如下：
a_set = {
'a', 123, 12.1, -1} # 创建多类型元素的集合
new_set = set(filter(lambda x: type(x) != str, a_set)) # 过滤集合中不是字符类型的元素
print('过滤后的集合为：',new_set) # 打印过滤后的集合
10. 【对序列进行求和计算】sum函数
示例
sum()函数用于对列表、元组或集合中的数值元素进行求和计算。例如，对列表、元组、集合进行求和计算，可以参考以下示例代码：
a_list = [1,3,5,7,9] # 列表
b_tuple = (2,4,6,8,0) # 元组
c_set = {
1,2,3,4,5} # 集合
print('列表的求和结果为：',sum(a_list))
print('元组的求和结果为：',sum(b_tuple))
print('集合的求和结果为：',sum(c_set))
11. 【将序列转换为元组】tuple()函数
语法参考
通过tuple()函数可以将一个序列作为参数，并将这个序列转换为元组。其语法格式如下：
tuple(seq)
参数说明：
-
seq：表示可以转换为元组的数据，其类型可以是range对象、字符串、列表、字典、元组或者其他可迭代类型的数据；如果参数是元组，参数则会被原样返回；
-
返回值：元组。如果不传入任何参数，将返回一个空元组。
锦囊1 将序列转换为元组
通过tuple()函数实现将序列转换为元组，示例代码如下：
print(tuple('Python')) # 参数为字符串
print(tuple(range(10, 20, 2))) # 创建一个10~20之间（不包括20）所有偶数的元组
print(tuple((89,63,100))) # 原样返回
锦囊2 将列表转换为元组
定义一个歌曲列表并进行元组转换，然后将原列表以及转换后的元组进行输出，示例代码如下：
list1=['Forever', 'I Need You', 'Alone', 'Hello'] # 英文歌曲列表
print('列表：',list1) # 输出英文歌曲列表
tuple1=tuple(list1) # 转换为元组
print('元组：',tuple1) # 输出元组
print('将列表中指定元素转换为元组：',tuple(list1[3]))
print('将列元素范围转换为元组：',tuple(list1[1:]))
锦囊3 将字典转换为元组
定义一个保存好友的名称和生日的字典并输出，然后将原字典以及转换后的元组进行输出，代码如下：
# 定义的字典数据
dictionary={
'小英子':'5月5日','阳光':'12月8日','茜茜':'7月6日',}
print(dictionary) # 输出字典
print(tuple(dictionary)) # 转换为元组输出
提示：tuple()函数的参数为字典时，会返回字典的key组成的元组。如果需要将字典中的values()转换为元组时可以使用如下代码：
print(tuple(dictionary.values())) # 将字典中values转换为元组
锦囊4 将generator对象转换为元组
生成一个包含10个随机数的生成器对象，然后将其转换为元组并输出，代码如下：
import random # 导入random标准库
# 创建一个包含10个随机数的生成器对象
randomnumber = (random.randint(10,100) for i in range(10))
randomnumber = tuple(randomnumber) # 转换为元组
print('转换后：',randomnumber) # 输出转换后的元组
12. 【序列切片】
语法参考
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素。通过切片操作可以生成一个新的序列。其语法格式如下：
sname[start : end : step]
参数说明：
-
sname：表示序列的名称；
-
start：表示切片的开始位置（包括该位置），如果不指定，则默认为0；
-
end：表示切片的截止位置（不包括该位置），如果不指定则默认为序列的长度；
-
step：表示切片的步长，如果省略，则默认为1，当省略该步长时，最后一个冒号也可以省略。
在进行切片操作时，如果指定了步长，那么将按照该步长遍历序列的元素，否则将一个一个遍历序列。
锦囊1： 获取字符串指定范围内的元素
创建一个带有空格的字符串，然后分别获取字符串中指定范围内符合条件的元素。示例代码如下：
a_str = 'hello word' # 字符串
print('字符串中前五个字符为：',a_str[0:5])
print('空格以后的字符为：',a_str[6:])
print('前五个字符串中最大值为：',max(a_str[0:6]))
print('后四个字符串中最小值为：',min(a_str[6:11]))
print('字符串中指定范围的长度为：',len(a_str[2:6]))
说明：在字符串中通过切换获取指定范围的元素时，空格也会占用一个元素的位置。
锦囊2： 获取列表中指定范围内的元素
创建列表数据，首先获取列表中第2个到第5个元素，然后获取第1个、第3个和第5个元素，示例代码如下：
nba = ["迈克尔・乔丹", "比尔・拉塞尔", "卡里姆阿卜杜勒・贾巴尔", "威尔特・张伯伦",
"埃尔文・约翰逊", "科比・布莱恩特", "蒂姆・邓肯", "勒布朗・詹姆斯", "拉里・伯德",
"沙奎尔・奥尼尔"]
print(nba[1:5]) # 获取第2个到第5个元素
print(nba[0:5:2]) # 获取第1个、第3个和第5个元素
锦囊3： 排序元组中指定范围的元素
创建数值型元组数据，通过lambda表达式与列表转换的方式实现元组指定范围元素的排序。示例代码如下：
a_tuple = (5, 2, 1, 1, 3, 1, 4) # 数值型元组数据
print('lambda表达式排序：',tuple(sorted(a_tuple[2:6], key=lambda i: i)))
a_list=list(a_tuple[2:6]) # 将元组数据转换为列表
a_list.sort() # 对数据进行排序
print('列表转换的方式排序：',tuple(a_list))
13. 【序列相乘】
语法参考
在Python中，使用数字n乘以一个序列会生成新的序列。新序列的内容为原来序列被重复n次的结果。其语法格式如下：
sequence * n = new_ sequence
参数说明：
-
sequence：原序列对象；
-
n：对原序列重复的次数；
-
new_ sequence：重复n次后的新序列对象；
锦囊1：字符串相乘
创建一个字符串数据，让该字符串乘以3，产生一个新的字符串。示例代码如下：
a_str = '人生苦短，我用Python！' # 字符串数据
three_str = a_str*3 # 字符串乘以3
print('重要的使用说三遍：',three_str)
锦囊2：列表相乘
创建4个列表，其元素类型分别为字符、数值、浮点以及混合类型，然后分别相乘对应的数字。示例代码如下：
str_lst = ['华为Mate 10','Vivo X21'] # 字符型列表
int_list = [1,2,3,4,5] # 数值型列表
float_list = [3.14,2.16,5.21] # 浮点型列表
blend_list = [(1,2,3),'123',[1,2,3]] # 混合类型列表
print('相乘1：',str_lst*1)
print('相乘2：',int_list*2)
print('相乘3：',float_list*3)
print('相乘4：',blend_list*4)
锦囊3：元组相乘
元组的相乘与列表类似，示例代码如下：
num = (7,14,21,3.1415) # 创建数值与浮点元组
team= ('马刺','火箭','勇士') # 创建字符串类型元组
# 混合类型元组
untitle = ('Python',28,('人生苦短','我用Python'),['爬虫','自动化运维','云计算','Web开发'])
print('相乘3：',num*3)
print('相乘2：',team*2)
print('相乘1：',untitle*1)
锦囊4：初始化指定长度列表
在进行序列的乘法运算时，还可以实现初始化指定长度列表的功能。例如下面的代码，将创建一个长度为5的列表，列表的每个元素都是None，表示什么都没有。
emptylist = [None]*5 # 列表None元素相乘
print(emptylist)
锦囊5：序列中空元素相乘
在序列中，如果元素为空，此时相乘后的新序列依然为空。示例代码如下：
a_str = '' # 空字符串
b_list = [] # 空列表
c_tuple = () # 空元组
print('空字符串相乘：',a_str*3)
print('空列表相乘：',b_list*3)
print('空元组相乘：',c_tuple*3)
14. 【序列相加】
语法参考
在Python中，支持两种相同类型的序列相加操作。即将两个序列进行连接，使用加（+）运算符实现。其语法格式如下：
sequence1 + sequence2 = new_ sequence
参数说明：
-
sequence1：需要连接的序列1对象；
-
sequence2：需要连接的序列2对象；
-
new_ sequence：连接后的新序列对象；
锦囊1：字符串连接
创建三个字符串，然后通过+号将字符串进行连接。示例代码如下：
a = '人生苦短'
b = ','
c = '我用python!'
print('连接字符串：',a+b+c)
锦囊2：列表连接
创建两个列表，然后通过+号将列表进行连接。示例代码如下：
nba1 = ["德怀特・霍华德","德维恩・韦德","凯里・欧文","保罗・加索尔"]
nba2 = ["迈克尔・乔丹","比尔・拉塞尔","卡里姆阿卜杜勒・贾巴尔","威尔特・张伯伦",
"埃尔文・约翰逊","科比・布莱恩特","蒂姆・邓肯","勒布朗・詹姆斯","拉里・伯德",
"沙奎尔・奥尼尔"]
print('连接列表：',nba1+nba2)
锦囊3：元组连接
创建两个元组对象，一个是列表转换的元组，另一个为字符类型的元组，再通过+号将两个元组进行连接。示例代码如下：
tuple1 = tuple(['㈠', '㈡', '㈢', '㈣'])
tuple2 = ('❶', '❷', '❸', '❹')
print('连接元组：',tuple1+tuple2)
锦囊4：连接元素类型不同的序列
在进行序列相加时，相同类型的序列是指，同为字符串、列表、元组等，序列中的元素类型可以不同。示例代码如下：
num = [7,14,21,28,35,42,49,56]
nba = ["德怀特・霍华德","德维恩・韦德","凯里・欧文","保罗・加索尔"]
print('连接元素类型不同的序列:',num + nba)
注意：通过+号实现序列的连接时，不能是列表和元组相加，或者列表和字符串相加。例如，下面的代码就是错误的。
num = [7,14,21,28,35,42,49,56,63]
print(num + "输出是7的倍数的数")