----------------------------------------------- ?[ 列表 ] ---------------------------------------------

列表利用位置定位某一元素，列表是可變的，你可以直接對原始列表進行增、刪、改，在列表中具有相同值的元素允許出現多次。

使用[]或list()創建列表:

列表可以由零個或多個元素組成，元素之間用逗號分開，整個列表被括號所包裹;

>>> empty_list = []
>>> weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
>>> weekdays
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
>>> another_empty_list = list()
>>> another_empty_list
[]
>>>

list()函數可以將其它數據類型轉換成列表:

>>> list("cat")
['c', 'a', 't']
>>> a_tuple = ("one", "two", "three")
>>> list(a_tuple)
['one', 'two', 'three']

>>> birthday = "26/8/1988"
>>> birthday.split("/") ?
['26', '8', '1988']
>>> splitme = "a/b//c/d///e"
>>> splitme.split('/')
['a', 'b', '', 'c', 'd', '', '', 'e']
>>> splitme.split('//')
['a/b', 'c/d', '/e'] ? ? ? ? ? ?

#split()可以根據分隔符將字符串切割成若干個子串組成的列表，如果待分割的字符串中包含連續的分割符，那么在返回的列表中會出現空串元素。

?

使用 [offset] 獲取元素：

>>> weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
>>> weekdays[0]
'Monday'
>>> weekdays[::2]
['Monday', 'Wednesday', 'Friday']
>>> weekdays[1:3]
['Tuesday', 'Wednesday']
>>> weekdays[-1]
'Friday'
>>> weekdays[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> weekdays[-6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range ? ? ? ?#當列表偏移量超出列表元素的范圍時會產生異常

?

?

>>> weekdays = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
>>> weekdays[1] = "TUESDAY" ? ? ? ? ?#使用[offset]修改元素
>>>
>>> weekdays
['Monday', 'TUESDAY', 'Wednesday', 'Thursday', 'Friday']

>>> weekdays.pop() ? ? ? ?#pop()默認刪除最后一個元素，添加參數后刪除指定位置的元素
'Friday'
>>> weekdays.pop(1)
'TUESDAY'
>>> weekdays
['Monday', 'Wednesday', 'Thursday']
>>> del weekdays[-1] ? ? ? ? ? ?#del刪除指定位置的元素
>>> weekdays
['Monday', 'Wednesday']
>>>
>>> weekdays.append("TT1") ? ? ? ? ?#append()添加元素至末尾
>>> weekdays
['Monday', 'Wednesday', 'TT1']
>>> weekdays.insert(1,"hello") ?#在指定位置插入元素
>>> weekdays
['Monday', 'hello', 'Wednesday', 'TT1']
>>>
>>> weekdays.remove("TT1") ? ? #指定指定值的元素
>>> weekdays
['Monday', 'hello', 'Wednesday']
>>>

>>> weekdays
['Monday', 'hello', 'Wednesday']
>>> others = ["a", "b", 1]
>>> weekdays.extend(others) ? ? ? ? ? ? ? ?#使用extend()或+=合并列表
>>> weekdays
['Monday', 'hello', 'Wednesday', 'a', 'b', 1]
>>> t1 = [123, 456]
>>> weekdays += t1
>>> weekdays
['Monday', 'hello', 'Wednesday', 'a', 'b', 1, 123, 456]

>>> weekdays.index("hello") ? ? ? #使用index()查詢指定值的元素的位置
1
>>> weekdays.index("a")
3

>>> "hello" in weekdays ? ? ? ?#使用in判斷值是否存在列表中
True
>>> "aaa" in weekdays
False

>>> weekdays
['Monday', 'hello', 'Wednesday', 'a', 'b', 1, 123, 456, 'hello']
>>> weekdays.count("a") ? ? ? ? ? ?#count()記錄指定值在列表中出現的次數
1
>>> weekdays.count("hello")
2
>>>

>>> l = ["a", "b", "c", "d"]
>>> ','.join(l) ? ? ? ? #使用join()把列表轉換為字符串， join()函數的參數是字符串或其他可迭代的包含字符串的序列，它的輸出是一個字符串
'a,b,c,d'
>>> ''.join(l)
'abcd'

join()是split()的逆過程:

>>> friends = ["jacky", "eric", "jerry"]
>>> s = "*"
>>> joined = s.join(friends)
>>> joined
'jacky*eric*jerry'
>>> separated = joined.split(s)
>>> separated
['jacky', 'eric', 'jerry']
>>> friends == separated
True
>>>

>>> friends
['jacky', 'eric', 'jerry', 'tina', 'tom']
>>> friends.sort() ? ? ? ? ? ? ? ? ?#列表中的元素是字符串，則會按照字母表順序排列;
>>> friends
['eric', 'jacky', 'jerry', 'tina', 'tom']
>>> numbers = [2, 3, 10, 9, 25]
>>> numbers.sort() ? ? #列表中的元素是數字，會默認排列成從小到大的升序； ?列表方法sort()會對原列表進行排序，改變原列表的內容
>>> numbers
[2, 3, 9, 10, 25]
>>>

>>> len(friends) ? ? ? # len()獲取長度
5

使用=賦值，使用copy()復制

>>> a = [1, 2, 3] ? ? ? #a與b實際上指向的是同一個對象，所以不管通過a還是通過b來修改列表的內容，其結果都會作用于雙方
>>> b = a
>>> b
[1, 2, 3]
>>> a[0] = "surprise"
>>> a
['surprise', 2, 3]
>>> b
['surprise', 2, 3]
>>> ? ? ? ? ? ? ? ? ? ??

下面任意一種方法，都可以將一個列表的值復制到另一個新列表中:

* 列表copy()函數

* list()轉換函數

* 列表分片[:]

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:] ? ? ? ? ? ? ? #b、c、d都是a的復制，它們是自身帶有值的新對象，與原始的a所指向的列表對象[1,2,3]沒有任何關聯，改變a不影響b、c、d的復制
>>> a[0] = "hello"
>>> a
['hello', 2, 3]
>>> b
[1, 2, 3]
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]
>>>

?----------------------------------------------- ?[ 元組 ] ---------------------------------------------

與列表類似，元組也是由任意類型元素組成的序列。與列表不同的是，元組是不可變的，這意味著一旦元組被定義，將無法進行增、刪、改元素等操作。

>>> empty_tuple = () ? ? ? ? #使用()創建元組
>>> empty_tuple
()
>>> a_tuple = ("one", "two", "three")
>>> a_tuple
('one', 'two', 'three')
>>> a, b, c = a_tuple ? ? ? #元組解包
>>> a
'one'
>>> b
'two'
>>> c
'three'
>>>

>>> hello = "abcdef"
>>> tuple(hello) ? ? ? ? ? ? ?#tuple()函數可以用其他類型的數據來創建元組
('a', 'b', 'c', 'd', 'e', 'f')
>>> a_list = [1, 2, 3, 4]
>>> tuple(a_list)
(1, 2, 3, 4)

?

?----------------------------------------------- ?[ 字典 ] ---------------------------------------------

字典(dictionay)與列表類似，但其中元素的順序無關緊要，因為它們不是通過像0或1的偏移量訪問的。 取而代之，每個元素擁有與之對應的互不相同的鍵(key),需要通過鍵來訪問

元素。鍵通常是字符串，但它還可以是python中其他任意的不可變的類型:布爾型、整型、浮點數、元組、字符串等。字典是可變的，因此可以增、刪和修改其中的鍵值對。

>>> empty_dict = {} ? ?#用大括號{}將一系列以逗號隔開的鍵值對(key:value)包裹起來即可進行字典的創建。最簡單的字典是空字典，它不包含任何鍵值對
>>> empty_dict
{}
>>> dict1 = {"a": 1, "b": 2, "c": 3}
>>> dict1
{'c': 3, 'a': 1, 'b': 2}
>>>

?使用dict()轉換為字典 (用dic()將包含雙值子序列的序列轉換成字典，每個子序列的第一個元素為鍵，第二個元素為值)

>>> lol = [ ["a", "b"],["c", "d"],["e", "f"] ]
>>> dict(lol) ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?
{'e': 'f', 'c': 'd', 'a': 'b'}
>>>
>>> lot = [("a", "b"), ("c", "d"), ("e", "f")]
>>> dict(lot)
{'e': 'f', 'c': 'd', 'a': 'b'}
>>>
>>> tol = (["a", "b"], ["c", "d"], ["e", "f"])
>>> dict(tol)
{'e': 'f', 'c': 'd', 'a': 'b'}
>>>
>>> los = ["ab", "cd", "ef"]
>>> dict(los)
{'e': 'f', 'c': 'd', 'a': 'b'}
>>>
>>> tos = ("ab", "cd", "ef")
>>> dict(tos)
{'e': 'f', 'c': 'd', 'a': 'b'}
>>>

>>> d = {"a":1, "b":2, "c":3}?
>>> d["d"] = 4 ? ? ? ? ? ? ? ? ? ? ? ? ? ?#使用 [key] 添加或修改元素
>>> d
{'d': 4, 'c': 3, 'a': 1, 'b': 2}
>>> d["b"] = 6
>>> d
{'d': 4, 'c': 3, 'a': 1, 'b': 6}
>>>

?

>>> d
{'d': 4, 'c': 3, 'a': 1, 'b': 6}
>>>
>>> d1 = {"e":10, "f": "ww", "h": "cc"}
>>> d1
{'e': 10, 'h': 'cc', 'f': 'ww'}
>>> d.update(d1) ? ? ? ? ? ? ? ? ? ? ? ? #使用update()進行合并字典
>>> d
{'d': 4, 'c': 3, 'a': 1, 'f': 'ww', 'h': 'cc', 'e': 10, 'b': 6}
>>>

>>> d
{'d': 4, 'c': 3, 'a': 1, 'f': 'ww', 'h': 'cc', 'e': 10, 'b': 6}
>>> del d["f"] ? ? ? ? ? ? ? ? #使用del刪除具有指定鍵的元素
>>> d
{'d': 4, 'c': 3, 'a': 1, 'h': 'cc', 'e': 10, 'b': 6}
>>>
>>> d.clear() ? ? ? #使用clear()刪除所有元素
>>> d
{}
>>>

>>> d
{'c': 3, 'a': 1, 'b': 2}
>>> "a" in d ? ? ? ? ?#使用in判斷某一個鍵是否存在于一個字典中
True
>>> "f" in d
False

>>> d["a"] ? ? ? ? ? #使用 [key] 獲取元素
1
>>> d["no"] ? ? ? ?#如果字典中不包含指定的鍵，會產生一個異常，有兩種方法可以避免這種情況，一種是在訪問前通過in測試鍵是否存在，另一種是使用字典函數get()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'no'
>>>
>>> d.get("b") ? ? ? ?#get()函數，如果鍵存在，會得到與之對應的值；若鍵不存在，如果你指定了可選值，那么get()函數將返回這個可選值；否則會得到None
2
>>> d.get("no")

>>> d.get("no","Not a python")
'Not a python'

?

>>> d.keys() ? ? ? ?#使用keys()獲取所有鍵
dict_keys(['c', 'a', 'b'])
>>> d.values() ? ?#使用values()獲取所有值
dict_values([3, 1, 2])
>>>
>>> list(d.items()) ? #使用items()獲取所有鍵值對
[('c', 3), ('a', 1), ('b', 2)]
>>>

使用=賦值，使用copy()復制;?

>>> d
{'c': 3, 'a': 1, 'b': 2}
>>>
>>> a = d
>>> a
{'c': 3, 'a': 1, 'b': 2}
>>> d["c"] = 3000 ? ? ? ? ? ? #與列表一樣，對字典內容進行的修改會反映到所有與之相關聯的變量名上：
>>> d
{'c': 3000, 'a': 1, 'b': 2}
>>> a
{'c': 3000, 'a': 1, 'b': 2}
>>>
>>> c = d.copy() ? ? ? ? ? #若想避免這種情況，可以使用copy()將字典復制到一個新的字典中:
>>> d["a"] = "wwwwwww"
>>> d
{'c': 3000, 'a': 'wwwwwww', 'b': 2}
>>> c
{'c': 3000, 'a': 1, 'b': 2}
>>>

?

?----------------------------------------------- ?[ 集合] ---------------------------------------------

?

轉載于:https://www.cnblogs.com/helloworld899/p/7571704.html

總結

以上是生活随笔為你收集整理的列表、元组、字典与集合的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。