列表

簡單資料型別：整型，浮點型和布林型。

容器資料型別：列表，元組，字典，集合和字串。

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]