一、recode

列表(list) - 有序、可變
[12, 34, 56]

列表元素的要求：任何類型的數(shù)據(jù)都可以作為列表元素

獲取單個(gè)元素、獲取部分元素(切片)、遍歷

相關(guān)運(yùn)算: +, *, ==/!=, in / not in, len(), list(), max(), min()

name = '張三'
list1 = [12, 'abc', True, name, max('abcz')]
print(list1[-1])

補(bǔ)充： == 和 is

== - 判斷兩個(gè)數(shù)據(jù)的值是否相等

is - 判斷地址是否相等

python數(shù)據(jù)存儲(chǔ):1.給變量賦值的時(shí)候，如果數(shù)據(jù)的類型是數(shù)字或者字符串，不會(huì)直接開辟空間存數(shù)據(jù)，
而是現(xiàn)在數(shù)字字符串對應(yīng)的緩存區(qū)里面去查看是否已經(jīng)存儲(chǔ)過對應(yīng)的數(shù)據(jù)。如果已經(jīng)存了，
直接將之前的數(shù)據(jù)對應(yīng)的地址賦給變量。如果沒有存儲(chǔ)才會(huì)開辟空間存儲(chǔ)數(shù)據(jù)。
其他類型的數(shù)據(jù)，都是直接開辟空間存儲(chǔ)數(shù)據(jù)。然后再把地址返回
2.容器類型中的元素，在容器中不是直接存的值，而是元素值對應(yīng)的地址

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)
print(list1 is list2)
print('===:',list1[0] is list2[0])
print(list1 is list3)
number1 = 10
number2 = 10
print(number1 is number2)

二、列表相關(guān)方法

1.列表賦值

a.直接使用一個(gè)列表變量給另外一個(gè)列表變量賦值，賦的是地址。
賦完值之后，對其中一個(gè)列表進(jìn)行增刪改，會(huì)影響另外一個(gè)列表

list1 = [1,2,3]
list2=list1
list2.append(100)
print(list1)

b.如果賦值的時(shí)候賦的是列表的切片或者拷貝，會(huì)產(chǎn)生新的地址，然后使用新的地址賦值。
賦完值之后，兩個(gè)列表相互之間不影響

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

2.列表中的方法

1.列表.count（元素） - 獲取指定元素在列表中出現(xiàn)的次數(shù)

2.列表.extend（序列） - 將序列中的所有元素都添加到列表中

nums=[2,3,45,34]
nums.extend(['hello'])
print(nums) #[2, 3, 45, 34, 'hello']
nums.extend('what')
print(nums) #[2, 3, 45, 34, 'hello', 'w', 'h', 'a', 't']
nums.extend(range(10))
print(nums) #[2, 3, 45, 34, 'hello', 'w', 'h', 'a', 't', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3.列表.index（元素） - 獲取指定元素在列表中下標(biāo)

注意：a.如果元素有多個(gè)，只取第一個(gè)的下標(biāo)
b.如果元素不存在，會(huì)報(bào)錯(cuò)

4.列表.reverse() - 反向列表 （將列表倒序）

5.列表.sort() - 將列表進(jìn)行升序排序（從小到大）

列表.sort（reverse=Ture） - 對列表進(jìn)行降序排序（從大到小排）
注意：A.列表元素的類型必須一樣 B.元素支持比較運(yùn)算符

nums1=[23,22,434,55,112,6,67,8]
nums1.sort()
print(nums1) # [6, 8, 22, 23, 55, 67, 112, 434]
nums1.sort(reverse=True)
print(nums1) # [434, 112, 67, 55, 23, 22, 8, 6]

6.列表.clear（） - 清空列表

nums1=[23,22,434,55,112,6,67,8]
nums1.clear()
print(nums1) #[]
#注意：盡量使用上面的方法清空列表 列表.clear（）
nums1=[23,22,434,55,112,6,67,8]
nums1=[]
print(nums1) #[]

7.列表.copy（） - 將列表中的元素直接賦值一份產(chǎn)生一個(gè)新的列表。和列表[:]（切片）效果一樣

注意：這兒的拷貝是淺拷貝

nums1=[23,22,434,55,112,6,67,8]
nums2=nums1.copy()
print(nums2)#[23,22,434,55,112,6,67,8]
print(nums2==nums1) #True
print(nums1 is nums2) #False

三、淺拷貝和深拷貝

copy.copy(對象) - 淺拷貝 （直接拷貝元素的值產(chǎn)生一個(gè)新的地址）
copy.deepcopy(對象) - 深拷貝(不會(huì)直接復(fù)制地址，而是將地址對應(yīng)的值拷貝一份產(chǎn)生新的地址)

import copy
copy.copy(對象) - 淺拷貝
nums1=[1,2,3]
nums2=[10,20,30]
list1=[nums1,nums2]
list2=copy.copy(list1) 或者寫成list2=list.copy()
list1.append(111)
print('淺拷貝list1：',list1)淺拷貝list1： [[1, 2, 3], [10, 20, 30], 111]
print('淺拷貝list2：',list2)淺拷貝list2： [[1, 2, 3], [10, 20, 30]]
修改list1元素中元素
list1[0].append(112)
print('修改淺拷貝list1：',list1)修改淺拷貝list1： [[1, 2, 3, 112], [10, 20, 30], 111]
print('修改淺拷貝list2：',list2)修改淺拷貝list2： [[1, 2, 3, 112], [10, 20, 30]]
copy.deepcopy(對象) - 深拷貝
nums1=[1,2,3]
nums2=[10,20,30]
list1=[nums1,nums2]
list2=copy.deepcopy(list1)
print('深拷貝list1:',list1)深拷貝list1: [[1, 2, 3], [10, 20, 30]]
print('深拷貝list2:',list2)深拷貝list2: [[1, 2, 3], [10, 20, 30]]
list1.append(222)
print('深拷貝修改list1后list1:',list1)深拷貝修改list1后list1: [[1, 2, 3], [10, 20, 30], 222]
print('深拷貝修改list1后list2:',list2)深拷貝修改list1后list2: [[1, 2, 3], [10, 20, 30]]
list1[0].append(333)
print('深拷貝修改list1中元素后list1:',list1)深拷貝修改list1中元素后list1: [[1, 2, 3, 333], [10, 20, 30], 222]
print('深拷貝修改list1中元素后list2:',list2)深拷貝修改list1中元素后list2: [[1, 2, 3], [10, 20, 30]]

四、元祖

1.什么是元祖（tuple）

元祖就是不可變的列表。（有序，不可變）
有序 - 可以通過下標(biāo)獲取元素
不可變 - 不支持增、刪、改

2.元祖的字面量：通過小括號將多個(gè)元素括起來，多個(gè)元素之間用逗號隔開

a.只有一個(gè)元素的元祖：小括號里面的元素后面必須加一個(gè)逗號

tuple1=(10,)
print(tuple1,type(tuple1))(10,) <class 'tuple'>

b.直接將多個(gè)數(shù)據(jù)用逗號隔開，不用小括號括起來。還是一個(gè)元祖值

tuple2=1,2,3,34
print((tuple2,type(tuple2)))((1, 2, 3, 34), <class 'tuple'>)

c.獲取元祖元素

1.可以通過變量個(gè)數(shù)和元祖元素個(gè)數(shù)保持一致來獲取元祖中的每個(gè)元素

tuple2=1,2,3,'34'
x,y,z,k = tuple2
print(x,y,z,k) #1 2 3 34
print(k,type(k)) #34 <class 'str'>

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

tuple2=（1,2,3,'34'）
a,*b=tuple2
print(a)
print(*b,type(*b))
(了解)
*列表、*元祖等直接獲取列表元祖中元素的值  
tuple1 = (1, 2, 3)
print(*tuple1)
list1 = ['aa', 'bb', 'cc']
a = list1[0]
 b = list1[1]
c = list1[2]
*list1 == a b c
print(*list1)

3.獲取元祖元素和獲取列表元素一模一樣

4.相關(guān)運(yùn)算和列表一樣

+, *, in/not in, len(), tuple(), max(), min()

print((1, 2) + ('a', 'n'))
print((1, 2) * 3)
print(1 in (1, 2))
print(len((1, 2, 4)))
print(max((1, 89, 0)))
print(min((1, 89, 0)))

5.元祖的相關(guān)方法：只有列表中的count和index

tuple2=(1,2,3,'34')
a,*b=tuple2
print(a)
print(b)

五、認(rèn)識字典

1.什么是字典（dict）

字典是python中內(nèi)置的容器類的數(shù)據(jù)類型，可變，無序的。字典的元素是鍵值對

2.字典的字面量：大括號{}括起來，大括號中是鍵值對，多個(gè)鍵值對之間用逗號隔開

鍵值對 -- 鍵：值
鍵(key) - 不可變的；唯一的 （一般使用字符串作為key）
值(value) - 任何類型的數(shù)據(jù)

dict1={'aa':100,10:'abc',(10,20):'hello'}
dict2={[1,2]:100,10:'abc',(10,20):'hello'} TypeError: unhashable type: 'list' 列表不能作為key
ict2={{1:100}:1,10:'abc',(10,20):'hello'}  TypeError: unhashable type: 'dict' 字典不能作為key
key是唯一的
dict2={'aa':100,'aa':1001,'bb':323}
print(dict2)#{'aa': 1001, 'bb': 323}
用一個(gè)變量儲(chǔ)存一個(gè)學(xué)生的信息：姓名、年齡、電話、成績、學(xué)號
student={'name':'小明','age':28,'tel':18282053064,'score':30,'學(xué)號':58}
print(student['name'])

什么時(shí)候使用字典：

如果一個(gè)容器里面存儲(chǔ)的數(shù)據(jù)是不同意義的數(shù)據(jù) - 數(shù)據(jù)之間需要區(qū)分

六、字典的增刪改查

1.查（獲取字典的值）

a.獲取單個(gè)值
字典[key] - 獲取字典中key對應(yīng)的值(如果key不存在會(huì)發(fā)生異常) key確定使用此法
字典.get（key） - 獲取字典中key對應(yīng)的值(如果key不存在不會(huì)報(bào)錯(cuò)，并且會(huì)返回一個(gè)默認(rèn)值None)

None是python中的關(guān)鍵字，表示一個(gè)特殊值（沒有或者空）

dog1={'name':'旺財(cái)','age':3,'color':'黃色','type':'土狗'}
print(dog1['name']) #旺財(cái)
print(dog1['color'])#黃色
print(dog1.get('type'))#土狗

b.遍歷

直接遍歷字典拿到的是字典中所有的key值

dog1={'name':'旺財(cái)','age':3,'color':'黃色','type':'土狗'}
for x in dog1:
    print(x)

同時(shí)獲取key和value(看著方便但性能差，內(nèi)存消耗大)
for key,value in dog1.items():
    print(key,value)
print(dog1.items())

2.增（添加鍵值對）

字典[key] = 值 - 當(dāng)key不存在的時(shí)候，就是在字典中添加鍵值對
dict1={'a':100}
dict1['b']=233
print(dict1){'a': 100, 'b': 233}

字典1.update(序列) - 將序列中的元素轉(zhuǎn)化成鍵值對然后再添加到字典1中
注：在這兒的序列要求是能夠轉(zhuǎn)換成字典的序列，并且序列中的元素是只有兩個(gè)元素的小序列

當(dāng)key值有重名的時(shí)候，會(huì)用序列中鍵值對對應(yīng)的值，更新原字典中的key對應(yīng)的值

dict1={'a':100,'b': 233}
dict1.update({'aa':22,'bb':24,'a':222})
print(dict1)#{'a': 222, 'b': 233, 'aa': 22, 'bb': 24}

3.改（修改key對應(yīng)的值）

字典[key] = 值 - 當(dāng)key存在的時(shí)候就是修改key對應(yīng)的值
dict1={'a':10,'b':20}
dict1['a']=100
print(dict1) #{'a': 100, 'b': 20}

4,刪（刪除鍵對）

a.del 字典[key] - 刪除字典中key對應(yīng)的鍵對
person={'name':'張三','age':18,'sex': '男'}
del person['sex']
print(person)  {'name': '張三', 'age': 18}

b.字典.pop() - 取出字典中key對應(yīng)的值
person={'name':'張三','age':18,'sex': '男'}
age=person.pop('age')
print(person,age) {'name': '張三', 'sex': '男'} 18
刪除最后一個(gè)鍵值對（取出最后一個(gè)鍵值對，以元祖形式返回） 描述是隨機(jī)刪除因?yàn)樽值涫菬o序的
person={'name':'張三','age':18,'sex': '男'}
a=person.popitem()
print(a)     ('sex', '男')

七、字典的相關(guān)運(yùn)算和方法

1.字典不支持+和*

1.in 和 not in
dict1={'a':1,'b':2,'c':3}
print('a' in dict1)

key in 字典 - 判斷字典中是否存在指定的key