列表

简单数据类型：整型，浮点型和布尔型。

容器数据类型：列表，元组，字典，集合和字符串。

1. 列表的定义

列表是有序集合，无固定大小，能够保存任意数量任意类型的Python对象。

• 语法的关键点是中括号[]和逗号,
• 中括号：把所有元素绑在一起。
• 逗号：把每个元素一一分开。

2. 列表的创建

• 创建一个普通列表

x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x,type(x))

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] <class 'list'>

• 利用range()创建列表

x = list(range(10))
print(x,type(x))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

• 利用推导式创建列表

x = [0]*5
print(x,type(x))

[0, 0, 0, 0, 0] <class 'list'>

x = [0 for i in range(5)]
print(x,type(x))

[0, 0, 0, 0, 0] <class 'list'>

x = [i for i in range(1,10,2)]
print(x,type(x))

[1, 3, 5, 7, 9] <class 'list'>

x = [i for i in range(100) if (i%2)!=0 and (i%3)==0]
print(x,type(x))

[3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

注：

• 由于list的元素是任意对象，因此列表中所保存的是对象的指针，即使最简单的[1,2,3]，也有三个整数对象。
• x = [a] * 4中，如果a发生了改变，x中4个a也会随之改变。

举例：

x = [[0]*3]*4
print(x,type(x))

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x,type(x))

[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x,type(x))

[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x,type(x))

[[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

• 创建混合列表`

mix = [1,'lsgo',3.14,[1,2,3]]
print(mix,type(mix))

[1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>

• 创建一个空列表

empty = []
print(empty,type(empty))

[] <class 'list'>

由于列表的元素可以随意更改，所以附加(append,extend)、插入(insert)、删除(remove,pop)这些操作列表都可以使用

3.添加元素

• list.append(obj) 在列表末尾添加新对象，参数可以是任意数据类型

x = ['Monday','Tuesday','Webnesday','Thursday','Friday']
x.append('Thursday')
print(x)

['Monday', 'Tuesday', 'Webnesday', 'Thursday', 'Friday', 'Thursday']

• 添加list时将list作为整体追加，注意append()和extend()的区别

x = ['Monday','Tuesday','Webnesday']
x.append(['Thursday','Sunday'])
print(x)

['Monday', 'Tuesday', 'Webnesday', ['Thursday', 'Sunday']]

• list.extend(seq)在列表末尾一次性追加另一个序列（可迭代）中的多个值

x = ['Monday','Tuesday','Webnesday']
x.extend(['Thursday','Sunday'])
print(x)

['Monday', 'Tuesday', 'Webnesday', 'Thursday', 'Sunday']

• list.insert(index,obj)在索引index处插入obj

x = ['Monday','Tuesday','Webnesday','Thursday','Friday']
x.insert(2,'Sunday')
print(x)

['Monday', 'Tuesday', 'Sunday', 'Webnesday', 'Thursday', 'Friday']

4. 删除元素

• list.remove(obj)依据某值删除对应元素

x = ['Monday','Tuesday','Webnesday','Thursday','Friday']
x.remove('Monday')
print(x)

['Tuesday', 'Webnesday', 'Thursday', 'Friday']

• list.pop([index = -1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

x = ['Monday','Tuesday','Webnesday','Thursday','Friday']
y = x.pop()
print(y)

Friday

• del var1[,var2...]删除单个或多个对象。

知道要删除元素在列表中的位置，可以使用del

x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
del x[0:2]
print(x)

['Wednesday', 'Thursday', 'Friday']

5. 获取列表中的元素

• 通过元素的索引值，从列表中获取单个元素
• 通过将索引指定为-1，可以让python返回最后一个列表元素，依次类推。

x = ['Monday','Tuesday','Wednesday']
print(x[0],x[-1])

Monday Wednesday

切片的通用写法 start:stop:step

x = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(x[3:])
print(x[:3])
print(x[1:3])
print(x[1:-1:2])

['Thursday', 'Friday']
['Monday', 'Tuesday', 'Wednesday']
['Tuesday', 'Wednesday']
['Tuesday', 'Thursday']

6. 列表的常用操作符

• 等号操作符：==
• 连接操作符 +
• 重复操作符 *
• 成员关系操作符 in、not in

列表拼接有两种方式，用+和*，前者首尾拼接，后者复制拼接

list1 = [123,456]
list2 = [456,123]
list3 = [123,456]

print(list1 == list2)
print(list1 == list3)

list4 = list1+list2
print(list4)

list5 = list3*3
print(list5)

print(123 in list3)
print(456 not in list3)

False
True
[123, 456, 456, 123]
[123, 456, 123, 456, 123, 456]
True
False

7. 列表的其它方法

• list.count(obj)统计某个元素在列表中出现的次数

list1 = [123,456]*3
print(list1)
num = list1.count(123)
print(num)

[123, 456, 123, 456, 123, 456]
3

• list.index(x,start,end)从列表中找出某个值第一个匹配项的索引位置

list1 = [123,456] * 5
print(list1.index(123))
print(list1.index(123,1))
print(list1.index(123,3,7))

0
2
4

• list.reverse()反向列表中的元素

x = [123,456,789]
x.reverse()
print(x)

[789, 456, 123]

• list.sort(key = None,reverse = False)对原列表进行排序

x = [123,456,789,213]
x.sort()
print(x)

x.sort(reverse=True)
print(x)

元组

1. 创建并访问元组

t1 = (1,10.31,'python')
t2 = 1,10.31,'python'
print(t1,type(t1))
print(t2,type(t2))

tup = (1,2,3,4,5,6,7,8)
print(tup[1])
print(tup[5:])
print(tup[:5])
tup1 = tup
print(tup1)

(1, 10.31, 'python') <class 'tuple'>
(1, 10.31, 'python') <class 'tuple'>
2
(6, 7, 8)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5, 6, 7, 8)

• 注：元组中只包含一个元素时，需要在元素后面添加逗号，不然括号会被当作运算符使用

2. 更新和删除一个元组

week = ('Monday','Tuesday','Thursday','Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)

('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

3. 元组相关的操作符

t1 = (123,456)
t2 = (456,123)
t3 = (123,456)

print(t1 == t2)
print(t1 == t3)

t4 = t1 + t2
print(t4)

4. 内置方法

t = (1,10.31,'python')
print(t.count('python'))
print(t.index(10.31))

1
1

5. 解压元组

#解压一维元组
t = (1,10.31,'python')
(a,b,c) = t
print(a,b,c)

#解压二维元组
t = (1,10.31,('OK','python'))
(a,b,(c,d)) = t
print(a,b,c,d)

#通配符提取你想要的变量
t = 1,2,3,4,5
a,b,*rest,c = t
print(a,b,c)
print(rest)

#不需要变量名就用*加上下划线代替
t = 1,2,3,4,5
a,b,*_ = t
print(a,b)

1 10.31 python
1 10.31 OK python
1 2 5
[3, 4]
1 2

字符串

1. 字符串的定义

t1 = 'i love Python'
print(t1,type(t1))

i love Python <class 'str'>

• 常用转义字符

print('let\'s go')
print("let's go")
print('C:\\now')
print('C:\\Program Files\\Intel\\Wifi\\Help')

let's go
let's go
C:\now
C:\Program Files\Intel\Wifi\Help

• 原始字符串只需要加上英文字母r即可

print(r'C:\Program Files\Intel\Wifi\Help')

C:\Program Files\Intel\Wifi\Help

2. 字符串的切片与拼接

str1 = 'I love LsgoGroup'
print(str1[:6])
print(str1[5])
print(str1[:6]+'插入的字符串'+str1[6:])

I love
e
I love插入的字符串 LsgoGroup

3. 字符串的常用内置方法

• capitalize() 将字符串的第一个字符转换为大写

str2 = 'xiaoxie'
print(str2.capitalize())

Xiaoxie

• lower() 转换字符串中所有大写字符为小写
• upper() 转换字符串中的小写字母为大写
• swapcase() 将字符串中大写转换为小写，小写转换为大写

str2 = 'DAXIExiaoxie'
print(str2.lower())
print(str2.upper())
print(str2.swapcase())

daxiexiaoxie
DAXIEXIAOXIE
daxieXIAOXIE

• count(str,beg = 0,end = len(string))返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数

str2 = 'DAXIExiaoxie'
print(str2.count('xi'))

2

• find(str,beg = 0,end = len(string))检测str是否包含在字符串中，包含返回索引值，否则返回-1.
• rfind(str,beg = 0,end = len(string)) 和 find函数作用相同，从右边开始查找

str2 = 'DAXIExiaoxie'
print(str2.find('xi'))
print(str2.find('ix'))
print(str2.rfind('xi'))

5
-1
9

• isnumeric()如果字符串只包含数字字符，则返回True，否则返回False

str3 = '12345'
print(str3.isnumeric())
str3 += 'a'
print(str3.isnumeric())

True
False

• ljust(width,fillchar)返回原字符串的左对齐，并使用fillchar（默认空格填充至长度width的新字符）
• rjust(width,fillchar)返回原字符串的右对齐。

str4 = '1101'
print(str4.ljust(8,'0'))
print(str4.rjust(8,'0'))

11010000
00001101

• lstrip([chars])截掉字符串左边的空格或指定字符
• rstrip([chars])删除字符串末尾的空格或指定字符
• strip([chars])在字符串上同时执行lstrip()和rstrip()

str5 = ' I love LsgoGroup '
print(str5.lstrip())
print(str5.lstrip().strip('I'))
print(str5.rstrip())
print(str5.strip())
print(str5.strip().strip('p'))

I love LsgoGroup 
 love LsgoGroup 
 I love LsgoGroup
I love LsgoGroup
I love LsgoGrou

• partition(sub)找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)

str5 = 'I Love LsgoGroup'
print(str5.strip().partition('o'))
print(str5.strip().partition('m'))

('I L', 'o', 've LsgoGroup')
('I Love LsgoGroup', '', '')

• replace(old,new,max)将字符串中的old替换成new，max指定为最大替换次数

str5 = 'I Love LsgoGroup'
print(str5.strip().replace('I','We'))

We Love LsgoGroup

• split(str = "",num)不带参数默认以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num各2子字符串，返回切片后的子字符串拼接的列表。

str5 = 'I Love LsgoGroup'
print(str5.strip().split())
print(str5.strip().split('p'))

['I', 'Love', 'LsgoGroup']
['I Love LsgoGrou', '']

• splitlines([keepends])按照行('\r','\r\n',\n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为False，不包含换行符，如果为True，则保留换行符

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())
print(str6.splitlines(True))

['I ', ' Love ', ' LsgoGroup']
['I \n', ' Love \n', ' LsgoGroup']

• maketrans(intab,outtab)创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
• translate(table,deletechars = '')根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

str7 = 'this is string example...wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab,outtab)
print(trantab)
print(str7.translate(trantab))

{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
th3s 3s str3ng 2x1mpl2...w4w!!!

4. 字符串格式化

• format格式化函数

str8 = "{0} Love {1}".format('I','Lsgogroup') #位置参数
print(str8)

str8 = "{a} Love {b}".format(a = 'I',b = 'Lsgogroup') #关键字参数
print(str8)

str8 = "{0} Love {b}".format('I',b = 'Lsgogroup') #位置参数要在关键字参数之前
print(str8)

str8 = '{0:.2f}{1}'.format(27.658,'GB')#保留小数点后两位
print(str8)

I Love Lsgogroup
I Love Lsgogroup
I Love Lsgogroup
27.66GB

• Python字符串格式化符号

• 格式化操作符辅助指令
  

字典

1.可变类型与不可变类型

• 序列以连续的整数为索引，字典以'关键字'为索引，关键字可以是任意不可变类型，通常用字符串或数值。
• 字典是Python唯一的一个映射类型，字符串、元组和列表属于序列类型。

判断数据类型X是否为可变类型的方法：

• 麻烦：用id(X)函数，比较操作前后的id，如果不一样就是不可变类型，如果一样就是可变类型。
• 便捷：用hash(X),只要不报错，证明X可被哈希，就是不可变类型，反之为可变类型。

i = 1
print(id(i))
i += 2
print(id(i))

l = [1,2]
print(id(l))
l.append('Python')
print(id(l))

140726725256992
140726725257056
2553863469376
2553863469376

print(hash({1,2,3}))

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-26-653299afdf87> in <module>
----> 1 print(hash({1,2,3}))


TypeError: unhashable type: 'set'

• 数值、字符和元组都能被哈希，因此它们是不可变类型
• 列表、集合、字典不能被哈希，因此它们是可变类型

2. 创建和访问字典

brand = ['李宁','Nike','Adidas']
slogan = ['一切皆有可能','Just do it','Impossible is nothing']
print('Nike 的口号是：',slogan[brand.index('Nike')])

dic = {'李宁':'一切皆有可能','Nike':'Just do it','Adidas':'Impossible is nothing'}
print('Nike 的口号是：',dic['Nike'])

Nike 的口号是： Just do it
Nike 的口号是： Just do it

• 以元组和列表的形式创建字典

dic1 = dict([('apple',4139),('peach',4127),('cherry',4098)])
dic2 = dict((('apple',4139),('peach',4127),('cherry',4098)))
print(dic1)
print(dic2)

{'apple': 4139, 'peach': 4127, 'cherry': 4098}
{'apple': 4139, 'peach': 4127, 'cherry': 4098}

4.字典内置方法

• dict.fromkeys(seq,value)用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

seq = ('name','age','sex')
dic1 = dict.fromkeys(seq)
print(dic1)

dic2 = dict.fromkeys(seq,10)
print(dic2)

dic3 = dict.fromkeys(seq,('小马','8','男'))
print(dic3)

{'name': None, 'age': None, 'sex': None}
{'name': 10, 'age': 10, 'sex': 10}
{'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}

• dict.keys()返回一个迭代器，可以使用list()来转换为列表，列表为字典中的所有值。

dic = {'Sex':'female','Age':7,'Name':'Zara'}
print(dic.values())

print(list(dic.values()))

dict_values(['female', 7, 'Zara'])
['female', 7, 'Zara']

• dict.items()以列表返回可遍历的元组数组

dic = {'Name':'Lsgogroup','Age':7}
print(dic.items())

print(tuple(dic.items()))
print(list(dic.items()))

dict_items([('Name', 'Lsgogroup'), ('Age', 7)])
(('Name', 'Lsgogroup'), ('Age', 7))
[('Name', 'Lsgogroup'), ('Age', 7)]

• dict.get(key,default = None)返回指定键的值，如果值不在字典中则返回默认值

dic = {'Name':'Lsgogroup','Age':27}
print('Age 值为：%s'% dic.get('Age'))
print('Sex 值为：%s'% dic.get('Sex','NA'))
print(dic)

Age 值为：27
Sex 值为：NA
{'Name': 'Lsgogroup', 'Age': 27}

• dict.setdefault(key,default = None),与get方法类似，如果键不在字典中，则添加键并将值设为默认值

dic = {'Name':'Lsgogroup','Age':7}
print('Age 键的值为：%s' % dic.setdefault('Age',None))
print('Sex 键的值为：%s' % dic.setdefault('Sex',None))
print(dic)

Age 键的值为：7
Sex 键的值为：None
{'Name': 'Lsgogroup', 'Age': 7, 'Sex': None}

• dict.pop(key,default)删除字典给定键key所对应的值，返回值为被删除的值，key值必须给出，若key不存在，则返回default值。
• del dict[key] 删除字典给定键key所对应的值

dic1 = {1:'a',2:{1,2}}
print(dic1.pop(1),dic1)

print(dic1.pop(3,'nokey'),dic1)

del dic1[2]
print(dic1)

a {2: {1, 2}}
nokey {2: {1, 2}}
{}

• dict.popitem()随机返回并删除字典中的一对键和值

dic1 = {1:'a',2:[1,2]}
print(dic1.popitem())
print(dic1)

(2, [1, 2])
{1: 'a'}

• dict.clear()用于删除字典内所有元素

dic = {'Name':'Zara','Age':7}
print("字典长度：%d" % len(dic))
dic.clear()
print("字典删除后的长度：%d" % len(dic))

字典长度：2
字典删除后的长度：0

集合

1. 集合的创建

• 先创建对象再加入元素
• 创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)

{'banana', 'apple'}

• 集合会自动过滤重复元素

• 使用set()函数将列表或元组转换成集合

a = set('abracadabra')
print(a)

b = set(('Google','Lsgogroup','Taobao','Taobao'))
print(b)

{'a', 'r', 'b', 'c', 'd'}
{'Google', 'Lsgogroup', 'Taobao'}

• 访问集合中的值

s = set(['Google','Baidu','Taobao'])
for item in s:
    print(item)

Google
Baidu
Taobao

3. 集合内置方法

• set.add(elmnt)用于给集合添加元素。

fruits = {'apple','banana','cherry'}
fruits.add('orange')
print(fruits)

fruits.add('apple')
print(fruits)

{'banana', 'cherry', 'orange', 'apple'}
{'banana', 'cherry', 'orange', 'apple'}

• set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

x = {'apple','banana','cherry'}
y = {'google','baidu','apple'}
x.update(y)
print(x)

y.update(['lsgo','dreamtech'])
print(y)

{'banana', 'apple', 'baidu', 'cherry', 'google'}
{'apple', 'baidu', 'google', 'dreamtech', 'lsgo'}

• set.remove(item)用于移除集合中的指定元素，如果元素不存在，则会发生错误

fruits = {'apple','banana','cherry'}
fruits.remove('banana')
print(fruits)

{'cherry', 'apple'}

• set.discard(value)用于移除指定的集合元素，元素不存在不会发生错误。

fruits = {'apple','banana','cherry'}
fruits.discard('banana')
print(fruits)

{'cherry', 'apple'}

• set.pop()用于随机移除一个元素

fruits = {'apple','banana','cherry'}
x = fruits.pop()
print(fruits)
print(x)

{'cherry', 'apple'}
banana

#set.intersection(set1,set2)返回两个集合的交集
#set1 & set2 返回两个集合的交集
#set.intersection_update(set1,set2)交集，在原始的集合上移除不重叠的元素
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)

c = a.intersection(b)
print(c)
print(a&b)
print(a)
a.intersection_update(b)
print(a)

print('*'*80)

#set.union(set1,set2)返回两个集合的并集
#set1 | set2 返回两个集合的并集
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)

print(a | b)
print(a.union(b))
print('*'*80)
#set.difference(set)返回集合的差集
#set1 - set2 返回集合的差集
#set.difference_update(set)集合的差集，直接在原集合中移除元素，没有返回值
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)

c  = a.difference(b)
print(c)
print(a-b)

print(a)
a.difference_update(b)
print(a)
print('*'*80)

#set.symmetric_difference(set)返回集合的异或。
#set1 ^ set2 返回集合的异或
#set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
a = set('abracadabra')
b = set('alacazam')
print(a)  # {'r', 'a', 'c', 'b', 'd'}
print(b)  # {'c', 'a', 'l', 'm', 'z'}

c = a.symmetric_difference(b)
print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}

print(a)  # {'r', 'd', 'c', 'a', 'b'}
a.symmetric_difference_update(b)
print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}

{'a', 'r', 'b', 'c', 'd'}
{'a', 'm', 'z', 'l', 'c'}
{'a', 'c'}
{'a', 'c'}
{'a', 'r', 'b', 'c', 'd'}
{'a', 'c'}
********************************************************************************
{'a', 'r', 'b', 'c', 'd'}
{'a', 'm', 'z', 'l', 'c'}
{'a', 'm', 'z', 'l', 'r', 'b', 'c', 'd'}
{'a', 'm', 'z', 'l', 'r', 'b', 'c', 'd'}
********************************************************************************
{'a', 'r', 'b', 'c', 'd'}
{'a', 'm', 'z', 'l', 'c'}
{'d', 'r', 'b'}
{'d', 'r', 'b'}
{'a', 'r', 'b', 'c', 'd'}
{'r', 'b', 'd'}
********************************************************************************
{'a', 'r', 'b', 'c', 'd'}
{'a', 'm', 'z', 'l', 'c'}
{'m', 'z', 'l', 'd', 'r', 'b'}
{'m', 'z', 'l', 'd', 'r', 'b'}
{'a', 'r', 'b', 'c', 'd'}
{'m', 'z', 'l', 'r', 'b', 'd'}

4. 集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)

print(se,type(se))
print(li,type(li))
print(tu,type(tu))

{0, 1, 2, 3} <class 'set'>
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>

序列

1. 针对序列的内置函数

• reversed(seq)函数返回一个反转的迭代器

s = 'lsgogroup'
x = reversed(s)
print(type(x))  # <class 'reversed'>
print(x)  # <reversed object at 0x000002507E8EC2C8>
print(list(x))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
print(list(reversed(t)))
# ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']

r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]

x = [-8, 99, 3, 7, 83]
print(list(reversed(x)))
# [83, 7, 3, 99, -8]

<class 'reversed'>
<reversed object at 0x000002529EC08880>
['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
[8, 7, 6, 5]
[83, 7, 3, 99, -8]

• enumerate(sequence,start) 用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。

seasons = ['Spring','Summer','Fall','Winter']
a = list(enumerate(seasons))
print(a)

b = list(enumerate(seasons,1))
print(b)

for i,element in a:
    print('{0},{1}'.format(i,element))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
0,Spring
1,Summer
2,Fall
3,Winter

• zip(iter1,iter2,...)
  • 用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由元组组成的对象，节省内存。
  • 我们使用list()转换来输出列表
  • 如果各个迭代器对象个数不一致，则返回列表长度与最短对象相同，利用*号操作符，可以将元组解压成列表

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]

zippd = zip(a,b)
print(zippd)
print(list(zippd))
zippd = zip(a,c)
print(list(zippd))

a1,a2 = zip(*zip(a,b))
print(list(a1))
print(list(a2))

<zip object at 0x000002529E144880>
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[1, 2, 3]
[4, 5, 6]