pythonlist字典

A. python基礎-列表 元組 集合 字典區別和用法

Python中有六個標準的數據類型：Number(數字)，String(字元串)，List(列表)，Tuple(元組)，Set(集合)，Dictionary(字典)。其中：Number(數字）、String(字元串)、Tuple（元組）是不可變數據，其餘三種是可變數據。

轉義字元

輸出結果

布爾值
布爾值是一個邏輯值，只有真(True)和假（False)

輸出結果

Python數據結構包括列表(list)、元組(tuple)、集合(set)、字典(dict)等，這里主要講解列表，列表有兩個特點：

輸出結果

修改表中元素

輸出結果

列表中插入元素

輸出結果

輸出列表中的元素

輸出結果

元素是否在列表元素中及統計個數

輸出結果

查找某個元素在列表中的位置

輸出結果

順序結構

輸出結果

if 條件 1

輸出結果

if 條件 2

輸出結果

循環結構

輸出結果

循環語句求和

輸出結果

可重復，類型可不同。 類型不同也是跟數組最本質的區別。 python里的列表用「[]」表示：

對比a和b的結果

列表的 --- 增 -- 刪 -- 改 -- 查

循環輸出列表內容，在結尾添加指定的內容

字元串是 Python 中最常用的數據類型。 我們可以使用引號('或")來創建字元串。

元組與列表相似，不一樣之處在於 元組的元素不能修改。
元組使用小括弧，列表使用方括弧。
元組建立很簡單，只須要在括弧中添加元素，並使用逗號隔開便可。

字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括弧({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }

字典函數

集合（set）是一個 無序的不重復元素序列。
可使用大括弧 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。
它的主要做用以下： 1.去重，把一個列表變成集合，就自動去重了 。2.關系測試，測試兩組數據以前的交集、差集、並集等關系。

關系測試

輸出結果

元素的添加和刪除

B. python字典轉換為list後選中最後一個值

設為星標，第一時間獲取更多干貨

在python中，數據類型主要由以下幾類組成：

列表(list): [a, b]

元組(tuple)：(a, b, )

集合(set)： {a, b}

字典(Dictonary): {a: 『aaa』, b: 『bbb』}

1. 列表

列表(List)

列表是Python中使用最頻繁的數據類型，專門用於存儲一串信息

列表是一種有序和可更改的集合。允許重復的元素

列表使用[]定義，元素之間使用，分隔。例：[1,2, ...]

列表的索引從位置0開始

索引就是元素在列表中的位置編號，索引又可以被稱為下標

注意：從列表中取值時，如果超過索引范圍，程序會報錯

雖然列表可以存儲不同類型元素，但是曰常中一般存儲相同類型的元素

如何使用列表

列表[索引]: 從列表中取值，獲取指定索引的元素

列表[開始索引:結束索引:步長]:

返回從開始索引到結束索引-1的列表，如果設置步長，按步長跳過元素

len(列表): 獲取列表的長度

元素 in 列表: 判斷元素是否在列表中

列表.count(元素): 返回指定元素在列表中的個數

列表.index(元素): 返回指定元素在列表中第一次出現的索引，查找失敗時報錯

列表.sort(): 從小到大排序，括弧內增加reverse=True ,則是從大到小排序

列表_reverse(): 逆序(反轉)列表

列表.clear(): 清空列表

Eg:

# 0 init listL = [1, 2, 3, 4, 5, 7, 6]# 1 index valueL[1] # --> 2# 2 stepL[2: 5: 2] # --> [3, 5]# 3 lengthlen(L) # --> 6# 4 in6 in L # ---> True8 in L # ---> False# 5 countL.count(1) # ---> 1# 6 indexL.index(2) # ---> 1# 7 sortL.sort() # ---> [1, 2, 3, 4, 5, 6, 7] 注意：會改變自己 返回None # 8 reverseL.reverse() # 由於第7步改變了自己， 這里變成[7, 6, 5, 4, 3, 2, 1] 會改變自己 返回None # 9. clearL.clear() # ---> []
列表特有的一些使用方法

L = [1, 2, 3, 4, 5]
列表[索引]=元素：修改指定索引的元素，索引不存在會報錯

L[2] = 7 L # ---> [1, 2, 7, 4, 5]
列表 . append(元素)：在列表的末尾追加元素

L.append(6)L # ---> [1, 2, 7, 4, 5, 6]
列表 . insert(索引，元素)：在指定索引位置插入元素，索引不存在時在末尾追加

L.insert(3, 9)L # ---> [1, 2, 7, 4, 9, 5, 6]
列表.pop(索引)：

刪除並返回指定索引的元素，未指定索引時刪除最後一項，索引不存在時報錯

L.pop(3) # 4, L 變成[1, 2, 7, 9, 5, 6]L.pop() # 6, L 變成[1, 2, 7, 9, 5]
列表 . remove(元素)：刪除列表中第一個出現的指定元素，查找失敗時報錯

L.remove(2) # L 變成[1, 7, 9, 5]
del 列表[索引]: 刪除指定索引位置的元素，索引不存在時報錯

del L[3] # L 變成[1, 7, 9]
列表l.extend(列表2): 將列表2拼接在列表1後

L.extend([8, 9, 10]) L # L 變成[1, 7, 9, 8, 9, 10], 等價於 L = L + [8, 9, 10]
2. 元組

元組(Tuple)

元組是一種有序且不可更改的集合, 允許重復的成員

元組與列表的類似，不同之處在於元組元素不可修改

元組使用()定義，元素之間使用,分隔。例：(a, b, …)

元組中只包含一個元素時，可以省略()，只需要在元素後加逗號

init_tuple = 100,type(init_tuple) # ---> tuple# ---- 另外寫法init_tuple = (100, ) # 逗號一定要加
注意：如果一個非元組類型的數據突然變成元組，檢查是不是誤加了逗號

集合與元組的通用方法

元組[索引]:從元組中取值，獲取指定索弓丨的元素

元組[開始索引:結束索引:步長]:

返回從開始索引到結束索引-1的元組，如果設置步長，按步長跳過元素

len(元組)：獲取元組的長度

元素in元組：判斷元素是否在元組中

元組.count(元素)：返回指定元素在元組中的個數

元組.index(元素)：返回指定元素在元組中第一次出現的索引，查找失敗會報錯

元組和列表之間的轉換

list(元組)：將元組轉換成列表

tuple(列表): 將列表轉換成元組

3. 集合

集合(Set)

集合是一種無序和無索引的序列。沒有重復的元素

集合會自動刪除重復的元素，一般應用於去重、交並差運算場景

集合使用{}定義，元素之間使用，分隔。例：{a, b, …}

集合與列表的通用方法

len(集合)：獲取集合的長度

元素in集合：判斷元素是否在集合中

集合.clear(): 清空集合

集合特有的使用方法

s = {1, 2, 3}

集合.add(元素)：將元素添加到集合中

s.add(5) # ---> {1, 2, 3, 5}
集合1.update(集合2): 添加新的元素或集合到當前集合中

s.add{4, 5, 6} # ---> {1, 2, 3, 5, 4, 6}
集合.remove(元素): 刪除指定的元素，元素不存在時報錯

s.remove(4) # ----> {1, 2, 3, 5, 6}
集合1&集合2 : 交集，獲得由集合1和集合2中都存在的元素組成的新集合

s & {3, 4, 5} # ---> {3, 5}
集合1|集合2: 並集，獲得集合1和集合2中所有元素的新集合

s | {8, 9, 10} # ---> {1, 2, 3, 5, 6, 8, 9, 10}
集合1 - 集合2 : 差集，獲得在集合1中存在但是在集合2中不存在的元素集合

s - {9, 10} # ---> {1, 2, 3, 5, 6, 8}
集合和列表之間的轉換(也可以和元組進行轉換，方式類似)

list(集合)：將集合轉換成列表

set(列表)：將列表轉換成集合

C. 在python中，列表，字典的相互轉換

列表、元組、集合、字典相互轉換
一、列表元組轉其他
1、列表轉集合(去重)
list1
=
[6,
7,
7,
8,
8,
9]
set(list1)
#
{6,
7,
8,
9}
2、兩個列表轉字典
list1
=
['key1','key2','key3']
list2
=
['1','2','3']
dict(zip(list1,list2))
#
{'key1':
'1',
'key2':
'2',
'key3':
'3'}
3、嵌套列表轉字典
list3
=
[['key1','value1'],['key2','value2'],['key3','value3']]
dict(list3)
#
{'key1':
'value1',
'key2':
'value2',
'key3':
'value3'}
4、列表、元組轉字元串
list2
=
['a',
'a',
'b']
''.join(list2)
#
'aab'
tup1
=
('a',
'a',
'b')
''.join(tup1)
#
'aab'
二、字典轉其他
1、
字典轉換為字元串
dic1
=
{'a':1,'b':2}
str(dic1)
#
"{'a':
1,
'b':
2}"
2、字典key和value互轉
dic2
=
{'a':
1,
'b':
2,
'c':
3}
{value:key
for
key,
value
in
a_dict.items()}
#
{1:
'a',
2:
'b',
3:
'c'}
三、字元串轉其他
1、字元串轉列表
s
=
'aabbcc'
list(s)
#
['a',
'a',
'b',
'b',
'c',
'c']
2、字元串轉元組
tuple(s)
#
('a',
'a',
'b',
'b',
'c',
'c')
3、
字元串轉集合
set(s)
#
{'a',
'b',
'c'}
4、字元串轉字典
dic2
=
eval("{'name':'ljq',
'age':24}")
5、切分字元串
a
=
'a
b
c'
a.split('
')
#
['a',
'b',
'c']

D. 淺析Python中元祖，列表和字典的區別

1、列表（list）
list是處理一組有序項目的數據結構，即你可以在一個列表中存儲一個序列的項目。
列表中的項目應該包括在方括弧中，這樣Python就知道你是指明一個列表。一旦你創建了一個列表，就可以添加、刪除，或者是搜索列表中的項目。由於你可以增加或者刪除項目，我們說列表是可變的數據類型，即這種類型是可以被改變的，且列表是可以嵌套的。
2、元祖(tuple)
元祖和列表十分相似，不過元祖是不可變的。即你不能修改元祖。
元祖通過圓括弧中用逗號分隔的項目定義。元祖通常在使語句或者用戶定義的函數能夠安全的採用一組值得時候，即被使用的元祖的值不會改變。元祖可以嵌套。
3、字典(Dictionary)
字典類似於你通過聯系人名稱查找地址和聯系人詳細情況的地址簿，即我們把鍵（名字）和值（詳細情況）聯系在一起。注意，鍵必須是唯一的，就像如果有兩個人恰巧同名的話，你無法找到正確信息。
鍵值對在字典中以這樣的方式標記：d={key:value,key2:value2}.注意他們的鍵/值對用冒號分割，而各個隊用逗號分隔，所有這些都包括在花括弧中。另外，記住字典中的鍵/值是沒有順序的。如果你想要一個特定的順序，那麼你應該在使用前對他們排序。

E. python內置數據類型列表list和字典dict的性能

    我們來討論下python的兩種最重要的內置數據類型列表list和字典dict上，各種操作的復雜度。

list列表數據類型常用操作性能：

1、按索引取值和賦值（v=a[i]，a[i]=v）

由於列表的隨機訪問特性，這兩個操作執行時間與列表大小無關，均為O（1）

2、列表的曾長，可以選擇append()和_add_() "+"

list.append(v)的執行時間O(1)

list = list + [v]，執行時間是O(n+k)，因為新增了一個新的列表，其中k是被加的列表長度

舉例：4種生成前n個整數列表的方法

如圖：

我們可以計算一下這四個函數的耗時，如下

執行結果：

我們可以看到，4種方法運行時間差別很大，test1使用列表連接最慢，而test4使用list range最快，速度相差近200倍。

    如下圖，我們總結下list基本操作的性能如何：

上圖可知pop()從列表末尾移除元素O(1),但是pop(i)從列表中間移除元素要O(n)，為什麼呢？

因為從中部移除元素，要把移除元素後面的元素全部向前挪一位，才保證了列表按索引取值和賦值很快，達到O(1)。

dict數據類型：

    字典和列表不同，dict根據key找到value，而list根據index。

    字典最常用的取值get和賦值set，其性能為O(1),而contain(in)操作判斷字典是否存在某個key，其性能也是O(1)

list和dict的in操作對比：

    設計一個性能試驗，驗證list中檢索一個值，對比dict中檢索一個值的耗時對比。如下程序：

如果如下：

可見list的in操作復雜度為O(n)

PS：大家可以去python官方的演算法復雜度網站看看：

https://wiki.python.org/moin/TimeComplexity

F. python 列表內有字典怎麼使用

Python字典是另一種可變容器模型，且可存儲任意類型對象，如字元串、數字、元組等其他容器模型。
一、創建字典
字典由鍵和對應值成對組成。字典也被稱作關聯數組或哈希表。基本語法如下：

復制代碼代碼如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此創建字典：

復制代碼代碼如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

注意：
每個鍵與值用冒號隔開（:），每對用逗號，每對用逗號分割，整體放在花括弧中（{}）。
鍵必須獨一無二，但值則不必。
值可以取任何數據類型，但必須是不可變的，如字元串，數或元組。
二、訪問字典里的值
把相應的鍵放入熟悉的方括弧，如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
#以上實例輸出結果：
#dict['Name']: Zara
#dict['Age']: 7

如果用字典里沒有的鍵訪問數據，會輸出錯誤如下：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Alice']: ", dict['Alice'];

#以上實例輸出結果：
#dict['Zara']:
#Traceback (most recent call last):
# File "test.py", line 4, in <mole>
# print "dict['Alice']: ", dict['Alice'];
#KeyError: 'Alice'[/code]
三、修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#以上實例輸出結果：
#dict['Age']: 8
#dict['School']: DPS School

四、刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 刪除詞典

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#但這會引發一個異常，因為用del後字典不再存在：
dict['Age']:
#Traceback (most recent call last):
# File "test.py", line 8, in <mole>
# print "dict['Age']: ", dict['Age'];
#TypeError: 'type' object is unsubscriptable

五、字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#dict['Name']: Manni

2）鍵必須不可變，所以可以用數，字元串或元組充當，所以用列表就不行，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#Traceback (most recent call last):
# File "test.py", line 3, in <mole>
# dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable

六、字典內置函數&方法
Python字典包含了以下內置函數：
1、cmp(dict1, dict2)：比較兩個字典元素。
2、len(dict)：計算字典元素個數，即鍵的總數。
3、str(dict)：輸出字典可列印的字元串表示。
4、type(variable)：返回輸入的變數類型，如果變數是字典就返回字典類型。
Python字典包含了以下內置方法：
1、radiansdict.clear()：刪除字典內所有元素
2、radiansdict.()：返回一個字典的淺復制
3、radiansdict.fromkeys()：創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
4、radiansdict.get(key, default=None)：返回指定鍵的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果鍵在字典dict里返回true，否則返回false
6、radiansdict.items()：以列表返回可遍歷的(鍵, 值) 元組數組
7、radiansdict.keys()：以列表返回一個字典所有的鍵
8、radiansdict.setdefault(key, default=None)：和get()類似, 但如果鍵不已經存在於字典中，將會添加鍵並將值設為default
9、radiansdict.update(dict2)：把字典dict2的鍵/值對更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值