1.數據類型
列表、元組、字典、集合、字符串均屬於python3的標准數據類型。
字符串和元組屬於不可變數據，即創建后不可修改。
列表、字典、集合屬於可變數據，即創建后可以修改元素。
2.創建有元素的對象
3.創建沒有元素的對象
列表使用eval()或list()或中括號[]進行創建，元素之間使用逗號分隔。若不添加任何元素，則創建空列表。
# 使用[]創建 list_ = [1, 2, 3, 4, 5] print(type(list_)) # <class 'list'> # 使用eval()創建,eval()方法用來執行一個字符串表達式,並返回表達式的值 list_ = eval("[1,2,3,4,5]") print(type(list_)) # <class 'list'> # 使用list()創建,list()方法用於將元組轉換為列表 list_ = list((1, 2, 3, 4, 5)) print(type(list_)) # <class 'list'>
元組使用eval()或tuple()或小括號()進行創建，元素之間使用逗號分隔。若不添加任何元素，則創建空元組。如果元組只有一個元素，則必須在這個元素后面加上逗號。
# 使用()創建 tuple_ = (1, 2, 3, 4, 5) print(type(tuple_)) # <class 'tuple'> # 使用eval()創建 tuple_ = eval("(1,2,3,4,5)") print(type(tuple_)) # <class 'tuple'> # 使用tuple()創建,tuple()函數用於將列表轉換為元組 tuple_ = tuple([1, 2, 3, 4, 5]) print(type(tuple_)) # <class 'tuple'>
字典使用eval()或dict()函數或者大括號{}創建，元素之間用逗號分隔。每個元素必須是一個鍵(key)值(value)對。若不添加任何元素，則創建空字典。
# 使用{}創建 dict_ = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5} print(type(dict_)) # <class 'dict'> # 使用eval()創建 dict_ = eval("{'a':1,'b':2,'c':3,'d':4,'e':5}") print(type(dict_)) # <class 'dict'> # 使用dict()創建 dict_ = dict(a=1, b=2, c=3, d=4, e=5) # 傳入關鍵字方式來構造字典 print(type(dict_)) # <class 'dict'> dict_ = dict(zip(['a', 'b', 'c', 'd', 'e'], [1, 2, 3, 4, 5])) # 映射函數方式來構造字典 print(type(dict_)) # <class 'dict'> dict_ = dict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]) # 可迭代對象方式來構造字典 print(type(dict_)) # <class 'dict'>
集合使用eval()或set()或{}進行創建，元素之間使用逗號分隔。由於{}用於創建空字典，所以只能通過不傳參的set()來創建空集合。
# 使用{}創建 set_ = {1, 2, 3, 4, 5} print(type(set_)) # <class 'set'> # 使用eval()創建 set_ = eval("{1,2,3,4,5}") print(type(set_)) # <class 'set'> # 使用set()創建,參數為可迭代對象 set_ = set("python") print(type(set_)) # <class 'set'>
字符串使用str()或單引號''或雙引號""進行創建，引號內元素為一個整體，不需要使用分隔符。若引號內不添加字符或str()不傳參，則創建空字符串
# 使用引號創建 str_ = '12345' print(type(str_)) # <class 'str'> # 使用str()創建 str_ = str(12345) print(type(str_)) # <class 'str'>
4.元素的類型
5.元素是否可以重復
6.元素順序
列表內的元素可以為任意類型。元素之間可以重復。元素順序遵循創建時的順序。
list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}] print(list_) # [1, 2.5, 1, 'a', ['b'], ('c',), {'d': 'e'}, {'f'}]
元組內的元素可以為任意類型。元素之間可以重復。元素順序遵循創建時的順序。
tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}) print(tuple_) # (1, 2.5, 1, 'a', ['b'], ('c',), {'d': 'e'}, {'f'})
字典中的鍵只能為數字、字符串、元組類型，值可以為任意類型。鍵(key)是唯一的，可以多次賦值(value)。若對應的鍵多次賦值，則后面賦的值會覆蓋前面賦的值。元素順序遵循創建時的順序。
dict_ = {1: ["a"], 2.5:("b",), "c":{"d": "e"}, True:["f"], ("f",):{"g"}}
print(dict_) # {1: ['f'], 2.5: ('b',), 'c': {'d': 'e'}, ('f',): {'g'}} True際上是1，所以覆蓋了前面的["a"]
集合內的元素只能為數字、字符串、元組類型。集合會在創建時自動剔除重復元素。元素順序隨機。
set_ = {1, 2.5, 1, "a", ("b",)}
print(set_) # {'a', 1, 2.5, ('b',)}
字符串創建時，引號內可以是任意字符。若在引號前加r，則不對引號內的字符轉義。不存在重復元素和元素順序的說法，因為字符串創建后就不能修改了。
str_ = "123\tabc" print(str_) # 123 abc str_ = r'123\tabc' print(str_) # 123\tabc
7.訪問元素
8.修改元素
列表、元組、字典、集合、字符串都可以使用for遍歷所有元素。
列表使用索引訪問和修改指定位置元素。
list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}] print(list_[1]) # 2.5 list_[2] = 3 for e in list_: print(e, end="\t") # 1 2.5 3 a ['b'] ('c',) {'d': 'e'} {'f'}
元組使用索引訪問指定位置元素。元組創建后不可修改。
tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}) print(tuple_[6]) # {'d': 'e'}
字典使用鍵(key)訪問和修改指定元素。
dict_ = {1: ["a"], 2.5: ("b",), "c": {"d": "e"}, True: ["f"], ("f",): {"g"}}
print(dict_[("f",)]) # {'g'}
dict_[True] = ["a"]
for e in dict_:
print(str(e) + ":" + str(dict_[e]),end="\t")
# 1:['a'] 2.5:('b',) c:{'d': 'e'} ('f',):{'g'}
集合不能使用索引訪問和修改元素。但可以通過先刪除后添加實現修改元素。
set_ = {1, 2.5, 1, "a", ("b",)}
set_.remove(1)
set_.add(3)
for i in set_:
print(i, end="\t")
# 2.5 3 a ('b',)
字符串使用索引訪問指定位置元素。字符串創建后不可修改。
str_ = r'123\tabc' print(str_[3]) # \
9.切片
可以使用索引訪問的都可以切片。即列表、元組、字符串可切片。
list_ = [1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}] print(list_[3:6]) # ['a', ['b'], ('c',)] tuple_ = (1, 2.5, 1, "a", ["b"], ("c",), {"d": "e"}, {"f"}) print(tuple_[4:7]) # (['b'], ('c',), {'d': 'e'}) str_ = r'123\tabc' print(str_[3:]) # \tabc
10.添加元素
11.刪除元素
列表使用list.append(單個元素)方法在list列表末端增加一個元素；使用list.extend([元素1，元素2])在list列表末端增加多個元素；使用list.insert(索引，元素)在列表指定位置增加一個元素。使用list.remove(元素)從列表中刪除一個元素；使用del list[索引]從列表中刪除指定位置的元素；使用list.pop(索引)從列表中刪除指定位置元素，返回值為刪除的元素值，如果空參默認刪除末尾元素；使用list.clear()清空整個列表。
list_ = [] list_.insert(0, 0) list_.append(1) list_.extend([2, 3]) print(list_) # [0, 1, 2, 3] list_.remove(0) del list_[0] list_.pop(0) print(list_) # [3] list_.clear() print(list_) # []
元組一旦創建就不可修改，所以沒有添加和刪除元素的方法。可將元組轉化為列表進行相應操作后再轉為元組。
tuple_ = () tuple_ = list(tuple_) tuple_.insert(0, 0) tuple_.append(1) tuple_.extend([2, 3]) print(tuple(tuple_)) # (0, 1, 2, 3) tuple_.remove(0) del tuple_[0] tuple_.pop(0) print(tuple(tuple_)) # (3,) tuple_.clear() print(tuple(tuple_)) # ()
字典使用dict[key]=value添加元素，如果已存在該元素，則將其覆蓋；使用dict.setdefault(key，value)添加元素，若該元素已存在，則不會將其覆蓋，若只傳一個參數，則key為該參數，value為None。使用dict.pop(key)刪除元素，此方法必須傳入一個key，若除key之外還傳了一個參數，則這個參數作為key不存在時的方法返回值；使用dict.popitem()刪除隨機的一個元素；使用del dict[key]刪除指定元素，使用dict.clear()清空整個字典。
dict_ = {0: ["a"]}
dict_.setdefault(1, ["a"])
dict_[True] = ["b"]
dict_[2.5] = ("c",)
dict_.setdefault("d")
print(dict_) # {0: ['a'], 1: ['b'], 2.5: ('c',), 'd': None}
dict_.pop("d")
dict_.popitem()
print(dict_) # {0: ['a'], 1: ['b']}
dict_.clear()
print(dict_) # {}
集合使用set.add(元素)添加元素；使用set.update(元素)添加元素，此方法傳參可以為多個，添加元素時會將參數中的列表、元組、字典、集合進行遍歷添加。使用set.remove(元素)刪除元素，元素不存在會報錯KeyError；使用set.discard(元素)刪除元素，元素不存在不會報錯；使用set.pop()隨即刪除元素。
set_ = {1, 2.5, ("a",)}
set_.add(3)
set_.update([4, 5, 6], ("a",), {"b": 7}, {"c", "d"})
print(set_) # {1, 2.5, 3, 4, 5, 6, 'a', 'b', 'd', 'c', ('a',)}
set_.remove(2.5)
set_.discard("a")
set_.pop()
print(set_) # {3, 4, 5, 6, 'b', 'd', ('a',), 'c'}
字符串本質上不存在添加和刪除元素的方法。可使用str.replace(old_str,new_str)進行字符串替換完成添加字符和刪除字符的操作，也可以將其轉化為列表進行添加和刪除操作。