1.列表相關的用法
1.列表賦值

a.直接使用一個列表變量給另一個列表變量賦值，賦的是地址。
賦完值之后，對其中一個列表進行增刪改，會影響另一個列表
b.如果賦值的時候賦的列表的切片或者拷貝,會產生新的地址，然后使用新的地址賦值。
賦完值之后，兩個列表相互之間不影響

現象1：
list1 = [1, 2, 3]
list2 = list1
list2.append(100)
print(list1)   # [1, 2, 3, 100]
list1 = [1, 2, 3]
list2.append(200)
print(list1)

現象2：
list1 = [1, 2, 3]
list2 = list1[:]
list2.append(100)
print(list1)   # [1, 2, 3]

2.列表中的方法

1.列表.count(元素) - 獲取指定元素在列表中出現的次數

numbers = [100, 34, 90, 89, 100, 7, 100, 18]
print(numbers.count(100))
2.列表.extend(序列) - 將序列中所有的元素都添加到列表中

numbers.extend(['abc', 'hello'])
print(numbers)
numbers.extend('world')
print(numbers)
numbers.extend(range(11, 15))
print(numbers)

3.列表.index(元素) - 獲取指定元素的下標

注意:a.如果元素有多個，只去第一個的下標
b.如果這個元素不存在，會報錯(ValueError)

numbers = [3, 1, 2, 3, 4, 5, 3]
print(numbers.index(3))   # 0
# print(numbers.index(33))  # ValueError: 33 is not in list

4.列表.reverse() - 反向列表(將列表元素倒序)

numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.reverse()
print(numbers)

5.列表.sort() - 對列表進行升序排序(從小到大)
列表.sort(reverse=True) - 對列表進行降序排序(從大到小)

注意：列表的要求：a.列表的元素類型必須一樣 b.元素支持比較運算符

numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.sort()
print(numbers)

numbers = [19, 89, 2, 8, 98, 10, 32]
numbers.sort(reverse=True)
print(numbers)

names = ['路飛', '娜美', '山治', '羅賓', '弗蘭克', '喬巴', '佐羅']
names.sort()
print(names)

6.列表.clear() - 清空列表

names = ['路飛', '娜美', '山治', '羅賓', '弗蘭克', '喬巴', '佐羅']

names.clear()
print(names)

7.列表.copy() - 將列表中元素直接賦值一份產生一個新的列表。和列表[:]效果一樣
注意: 這兒的拷貝是淺拷貝

list1 = [1, 2, 3]
list2 = list1.copy()
print(list2)
print(list1 is list2)   # False

copy

copy.copy(對象) - 淺拷貝 （直接拷貝元素的值產生一個新的地址）
copy.deepcopy(對象) - 深拷貝(不會直接復制地址，
而是將地址對應的值拷貝一份產生新的地址)

numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]

print('1.淺拷貝：')
list2 = list1.copy()
print('修改前l(fā)ist1:', list1)
print('修改前l(fā)ist2:', list2)
print('針對list1進行修改')
list1.append(111)
list1[0].append(100)
print('修改后list1:', list1)
print('修改后list2:', list2)

numbers1 = [1, 2, 3]
numbers2 = [10, 20, 30]
list1 = [numbers1, numbers2]
print('2.深拷貝')
list2 = copy.deepcopy(list1)
print('修改前l(fā)ist1:', list1)
print('修改前l(fā)ist2:', list2)
print('針對list1進行修改')
list1.append(111)
list1[0].append(100)
print('修改后list1:', list1)
print('修改后list2:', list2)

元組

1.什么是元祖（tuple）
元祖就是不可變的列表。（有序，不可變）
有序 - 可以通過下標獲取元素
不可變 - 不支持增、刪、改
2.元祖的字面量: 通過小括號將多個元素括起來，多個元素之間用逗號隔開
tuple1 = (1, True, 'abc', [1, 2], 1)
print(tuple1)

a.只要一個元素的元祖: 在元素的后面必須加一個逗號

tuple2 = (10,)
print(tuple2, type(tuple2))

b.直接將多個數據用逗號隔開，不用括號括起來。還是一個元祖值

tuple3 = 1, 2, 3, 'abc'
print(tuple3, type(tuple3))

c.獲取元祖元素

tuple4 = (10, 20)
print(tuple4[0], tuple4[-2])

可以通過變量個數和元祖元素個數保持一致來獲取元祖中的每個元素

x, y = tuple4  # x, y = 10, 20
print(x, y)

通過在變量名前加,獲取沒有的變量獲取到的元素的剩下的部分。以列表的形式返回

tuple5 = ('余婷', 98, 90, 99, 87, 78)
name, *scores = tuple5
print(name, scores)  # '余婷' [98, 90, 99, 87, 78]

name, number, *scores = tuple5
print(name, number)   # '余婷'  98
print(scores)  # [90, 99, 87, 78]

*list1, num = tuple5
print(list1, num)  # ['余婷', 98, 90, 99, 87]  78

num1, *list1, num2 = tuple5
print(num1, num2)   # 余婷 78
print(list1)  # [98, 90, 99, 87]

字典

1.什么是字典（dict）
字典是python中內置的容器類的數據類型,可變，無序的。字典的元素是鍵值對

2.字典的字面量：使用大括號括起來，大括號中是鍵值對，多個鍵值對之間用逗號隔開
鍵值對- 鍵:值
鍵(key) - 不可變的；唯一的 (一般使用字符串作為key)
值(value) - 任何類型的數據
列表和字典不能作為key

 dict2 = {{'a': 1}: 100, 10: 'abc', (10, 20): 'hello'}  # TypeError

key是唯一的

dict2 = {'aa': 100, 'aa': 200, 'bb': 300}
print(dict2)   # {'aa': 200, 'bb': 300}

什么時候使用字典:
如果一個容器里面存儲的數據是不同意義的數據(數據之間需要區(qū)分),就使用字典

用一個變量來存儲一個學生的信息：姓名、年齡、電話、成績、學號

student = {'name': '小明', 'age': 28, 
'tel': '1627399992', 'score': 30, '
學號':'1982001'}
print(student['name'])

字典的增刪改

a.獲取單個值
字典[key] - 獲取字典中key對應的值 (注意：如果key不存在，會報錯:KeyError)

字典.get(key) - 獲取字典中key對應的值 (如果key不存在，不會報錯，并且會返回一個默認值None)

None是python中的關鍵字，表示一個特殊值，(沒有、空的意思)

dog1 = {'name': '旺財', 'age': 3, 'color': '黃色', 'type': '土狗'}
print(dog1['name'])
print(dog1['color'])
# print(dog1['sex'])   # KeyError: 'sex'

print(dog1.get('age'))
print(dog1.get('type'))
print(dog1.get('sex'))

b.遍歷

# 直接遍歷字典拿到的是字典中所有的key
for key in dog1:
    print(key, dog1[key])

2.增(添加鍵值對)

字典[key] = 值 - 當key不存的時候，就是在字典中添加鍵值對

dict1 = {'a': 100}
dict1['b'] = 200
print(dict1)

字典1.update(序列) - 將序列中的元素轉換成鍵值對，然后再添加到字典1中

注意:在這兒的序列要求是能夠轉換成字典的序列。序列中的元素是只有兩個元素的小序列

dict1 = {'a': 100, 'b': 200}

當key值有重名的時候，會用序列中鍵值對對應的值，更新原字典的key對應的值

dict1.update({'aa': 10, 'bb': 20, 'a': 'abc'})
print(dict1)

dict1.update([[1, 2], ['a', 2], [2, 'b']])
print(dict1)

dict1.update([('aaa', 100), [12, 200]])
print(dict1)

3.改(修改key對應的值)

字典[key] = 值 - 當key存在的時候，就是修改key對應的值

dict1 = {'a': 10, 'b': 20}
dict1['a'] = 100
print(dict1)

4.刪(刪除鍵值對)

a. del 字典[key] - 刪除字典中key對應的鍵值對

person = {'name': '張三', 'age': 30, 'sex': '男'}
del person['sex']
print(person)

b.字典.pop(key) - 取出字典中key對應的值（刪除整個鍵值對）

person = {'name': '張三', 'age': 30, 'sex': '男'}
age = person.pop('age')
print(person, age)

person = {'name': '張三', 'age': 30, 'sex': '男'}

刪除最后一個鍵值對(取出最后一個鍵值對, 以元祖的形式返回) - 無意義

value = person.popitem()
print(person, value)