python序列

列表

python變量不存放值，之存放值的引用，所以列表中元素可以是不同類型

1.常用方法

1.1 增加元素

• append,在末尾插入元素

• extend，將一個列表整體插入到尾部

• insert，將某個元素插入到特定位

• +/*，拼合或拼合多個元素，該操作不是原地操作，會創建新地址

• 上三個都是原地操作，在源地址上增刪查改，最后兩個會新開辟一個地址

1.2 刪除元素

• del，刪除對象，用在所有對象上，刪除的元素會在合適時間被回收，可以gc.collect()立即回收
• remove，從列表里移除某個值與特定值相等的元素
• pop，從列表里移除某個特定位置的元素，并返回該元素
• clear，清空列表中所有元素，但保留列表自身對象

1.3 排序

• sort：按指定規則對元素排序，默認規則是比較元素大小

• reverse：按制定規則逆序排序

• sorted：sort異地排序

• reversed：reverse異地排序

• 前兩個在原來基礎上排，后兩個返回新對象

1.4 查找

• count
• index:返回元素在列表中首次出現的位置

1.5其他

• zip：將多個列表中的元素重新組合為元組，并返回包含這些元組的zip對象
• enumerate：返回包含下標和值的迭代對象，可用來判斷一個對象是否是迭代對象
• map():將一個函數依次作用到序列或迭代器對象的每個元素上，并返回map對象
• reduce():接受兩個函數的參數，并從左到右把這兩個函數依次作用在迭代對象的每個元素上，在functools標準庫中

>>> a=[1,2,3,4]
>>> b=[5,6,7]
>>> ab=zip(a,b)
>>> ab
<zip object at 0x0000028A50A61608>
>>> list(ab)
[(1, 5), (2, 6), (3, 7)]
>>> en=enumerate(a)
>>> en
<enumerate object at 0x0000028A50A6BC60>
>>> list(en)
[(0, 1), (1, 2), (2, 3), (3, 4)]
>>>

zip兩個列表的元素個數不同時以短的為準，里面的參數是可迭代對象

map：

>>> def fun(a):return a+5>>> a=map(fun,range(5))
>>> a
<map object at 0x0000019F517923C8>
>>> list(a)
[5, 6, 7, 8, 9]
>>>

也可以是多參數函數，返回的map對象中的所有元素都是經過函數處理過后的，但map不會對迭代對象做修改

>>> z=zip(a,range(10))
>>> z
<zip object at 0x0000028A50A08748>
>>> list(z)
[(1, 0), (2, 1), (3, 2), (4, 3)]
>>> z=zip(a,"1"*11)
>>> list(z)
[(1, '1'), (2, '1'), (3, '1'), (4, '1')]

2. 列表推導式

[表達式 for 變量 in 序列或迭代對象]

可以嵌套多重循環，也可以使用判斷

例：

j=[1,3,2]
ss=[s*2 for s in j]
print(ss)# 輸出：[2, 6, 4]

• 使用推導式平鋪嵌套列表

a=[[a for a in range(3)]]*3
print(a)
s=[j for i in a for j in i]
print(s)# 輸出
# [[0, 1, 2], [0, 1, 2], [0, 1, 2]]
# [0, 1, 2, 0, 1, 2, 0, 1, 2]

• 寫一個列表生成式，產生一個公差為11的等差數列

    def 等差數列(self,begin,num):l=[begin+11*a for a in range(num) ]print(l)

• 在一個字典中找出最大值

    def 成績最好(self):dir={'zhangsan':95,'lisi':59,'wangwu':78,'zhaoliu':87,'xiaohua':100}max_score=max(dir.values())max_name=[max_name for max_name in dir if dir[max_name]==max_score]print(max_name)

• 矩陣轉置

 def 矩陣轉置(self):l=[[1,2,3],[4,5,6],[7,8,9]]s=[[r[i] for r in l] for i in range(3)]print(s)

3. 切片

由兩個冒號，三個數字組成，三個數字分別是起始，終止，步長，切片可以用在列表，元組，字符串等上

使用切片可以實現淺復制，修改值等操作。

元組

元組不能修改，比較安全，訪問速度比列表快(tuple)

1.生成器推導式

(表達式 for 變量 in 迭代器)

生成器推導式形式與列表推導式類似，但生成器推導式返回一個生成器對象，生成器對象用完即銷毀,生成器對象需要轉換成列表或元組等數據類型才能使用，也可以通過生成器對象的__next__屬性訪問，生成器對象具有惰性求值的特點，只在需要的時候才返回元素，因此比列表推導式效率高，適合大量數據的遍歷。

>>> s=(a for a in range(5))
>>> s
<generator object <genexpr> at 0x00000135FDE62C00>
>>> list(s)
[0, 1, 2, 3, 4]
>>> list(s)
[]
>>> s=(a for a in range(5))
>>> tuple(s)
(0, 1, 2, 3, 4)
>>>

字典

字典是一種無序可變序列，鍵是不可變類型，值是可變類型，字典訪問速度也比列表快

1.常用方法

• dict :創建字典
• update： 將一個字典添加到另一個字典中
• pop：刪除，并返回給定鍵對應的值
• popitem：隨機彈出一個元素，返回元素
• del
• clear
• copy
• setdefault：查詢字典中的元素，不存在就添加一個
• get：查詢，不存在允許輸出特定值
• items：返回字典中的元素
• key：返回鍵的列表
• value：返回值的列表

>>> key=['name','id']
>>> value=['zhangsan',11]
>>> s=dict(zip(key,value))
>>> s
{'name': 'zhangsan', 'id': 11}
>>> s2={'sex':'boy'}
>>> s.update(s2)
>>> s
{'name': 'zhangsan', 'id': 11, 'sex': 'boy'}
>>> s.pop
<built-in method pop of dict object at 0x00000135FDE0F288>
>>> s.pop('name')
'zhangsan'
>>> s
{'id': 11, 'sex': 'boy'}
>>> s.popitem()
('sex', 'boy')
>>> s
{'id': 11}
>>> s.get('name','No This Key')
'No This Key'
>>> s.setdefault('name','No This Key')
'No This Key'
>>> s
{'id': 11, 'name': 'No This Key'}

集合

集合只支持元組等可哈希數據，列表，字典等可變類型不能成為集合中的元素，可以使用函數hash()判斷是否是可哈希數據，字典和集合使用哈希表存儲數據，所以操作速度高于列表等。(set)

1.集合操作

• add()
• update()
• pop():隨即刪除并返回一個元素，不存在拋出異常
• remove()：刪除一個特點元素，元素不存在拋出異常
• discard()：刪除一個特定元素，不存在就忽視該操作
• clear()：刪除幾何中所有元素

>>> s={1,2,3,4,5}
>>> s.pop()
1
>>> s
{2, 3, 4, 5}
>>> s.remove(0)
Traceback (most recent call last):File "<pyshell#53>", line 1, in <module>s.remove(0)
KeyError: 0
>>> s.remove(2)
>>> s
{3, 4, 5}
>>> s.discard(0)
>>> s
{3, 4, 5}
>>>

2.集合運算

• 交：&
• 并：|
• 差：-
• 對稱差：^
• 比較:> < <= >= 用來判斷并包關系，不是比較大小

3. 集合推導式

{表達式 for 變量 in 迭代器}

如：

>>> import random
>>> s={random.randint(1,500) for i in range(20)}
>>> s
{1, 387, 268, 411, 293, 167, 48, 53, 441, 187, 191, 195, 324, 465, 473, 474, 481, 362, 114, 123}
>>> len(s)
20
>>> s={random.randint(1,5) for i in range(20)}
>>> s
{1, 2, 3, 4, 5}
>>>

集合不允許元素重復，所以可以利用這一特性實現去重。

序列解包

>>> x,y,z=1,2,3
>>> p=(2,3,4)
>>> (x,y,z)=p
>>> p
(2, 3, 4)
>>> p=map(str,range(3))
>>> p
<map object at 0x000001BB8B842320>
>>> list(p)
['0', '1', '2']