01-序列-元組簡介

元組 tuple
元組是一個不可變序列

一般希望數據不改變的時候，就是用用元組。其餘情況都是使用列表


創建元組

使用（）創建的
my_tuple = ()  #創建一個空的元組

添加元素

my_tuple = (1,2,3,4,5)

# my_tuple[3] = 10  元組是一個不可變序列 
print(my_tuple,type(my_tuple))
>>>
(1, 2, 3, 4, 5) <class 'tuple'>


my_tuple = (1,2,3,4,5)
print(my_tuple[0])
print(my_tuple[3])
》》》
1
4


# 如果一個元組不是空的元組，那麼它裏面至少需要一個逗號
my_tuple1 = 10,  # 這是一個元組
my_tuple2 = 10,20,30,40   # 這也是一個元組
print(my_tuple1,my_tuple2)
>>>
(10,) (10, 20, 30, 40)

元組的解包：元組的解包指的是將元組當中的每一個元素都賦值給一個變量

my_tuple = 10,20,30,40   # 這也是一個元組

a,b,c,d = my_tuple
print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
》》》
a = 10
b = 20
c = 30
d = 40

這也是一個解包的過程
a = 6
b = 8

b,a = a,b
temp = a      # temp = a =6
a = b         # a = b = 8
b = temp      # b = temp = 6
print('a =',a,'b =',b)
》》》
a = 8 b = 6

在對一個元組解包時，變量的數量必須和元組中的元素要一一對應，如果出現變量和元素沒有對等的情況下，我們可以在變量面前加一個* ，這樣變量就會將獲取元組中所有剩餘的元素以列表的形式返回

my_tuple = 10,20,30,40
a,b,c,d = my_tuple
print(a,b)
》》》
10 20

my_tuple = 10,20,30,40,50,60
*a,b,c = my_tuple   # [10, 20, 30, 40] 50 60
a,*b,c = my_tuple   # 10 [20, 30, 40, 50] 60
a,b,*c = my_tuple   # 10 20 [30, 40, 50, 60]

print(a,b,c)

在這裏怎麼操作列表，就怎麼操作元組

a,b,*c = [1,2,3,4,5,6,7]  #   1 2 [3, 4, 5, 6, 7]

a,b,*c = 'python java'     # p y ['t', 'h', 'o', 'n', ' ', 'j', 'a', 'v', 'a']

print(a,b,c)

02 - 對象 - 可變對象

每個對象在每個內存當中保存了三個數據
id(標識）
value（值）
列表據是一個可變對象 a = [1,2,3]
a[0] = 10 (改對象） 這個操作是通過修改變量去修改對象的值
a = [4，5，6] （改變量）
改變對象不會使內存地址發生改變
改變變量纔會使內存地址發生改變

這個操作是在給變量重新賦值，這種操作會改變變量指向的對象，一般只有在爲變量賦值時纔是修改變量，其餘的都是在修改對象

改變對象不 使內存地址發生改變
a = [1,2,3]
print('修改前：',a,id(a))

# 通過索引來改變列表   內存地址是一樣的
a[0] = 10
print('修改後：',a,id(a))
>>>
修改前： [1, 2, 3] 2199726601352
修改後： [10, 2, 3] 2199726601352

改變變量 會使 內存地址發生改變
# 爲變量賦值
a = [4,5,6]
print('修改後：',a,id(a))
>>>
修改後： [4, 5, 6] 2199727447688



a = [1,2,3]
b = a
b[0] = 10
print('a',a,id(a))
print('b',b,id(b))
>>>
a [10, 2, 3] 2199726601352
b [10, 2, 3] 2199726601352
這個操作是在給變量重新賦值，這種操作會改變變量指向的對象，其內存地址一定會發生改變，一般只有在爲變量賦值時纔是修改變量，其餘的都是在修改對象


案例一：
a = [1,2,3]
b = a
b = [1,2,3]
print('a',a,id(a))
print('b',b,id(b))
》》》
a [1, 2, 3] 1399834227848
b [1, 2, 3] 1399835074184

案例二：
a = [1,2,3]
print('修改前',a,id(a))
a = [1,2,3]
print('修改後',a,id(a))
修改前 [1, 2, 3] 1939110305544
修改後 [1, 2, 3] 1939109459080


**加粗樣式**這個操作是在爲變量重新賦值，雖然說重新賦值的這個值看起來和賦值之前的值沒有什麼差別，但是其內存地址發生了改變。

03. 序列 - == 和 is

== ，！= 和 is ， is not
== 和！= 比較的是對象的值是否相等
is 和 is not 比較的是對象的id是否相等（比較兩個對象是否是同於一個對象）

a = [1,2,3]
b = [1,2,3]
print(a,b)
print(id(a),id(b))
print(a==b)
print(a is b）

》》》[1, 2, 3] [1, 2, 3]
1558503634056 1558504480392
True
False

04 - 映射 - 字典簡介

1.字典

字典屬於一個新的數據結構，稱之爲映射(打開Python官網Welcome to Python.org——>Documentation——>Python 3.x Docs——>Library Reference——>Mapping Types - dict)
字典的作用和列表差不多，都是用來存儲對象的容器

每一個元素都有一個名字，通過這個唯一的名字可以快熟查找到我要的元素
唯一的名字（key）通過key可以快速查詢到 Value
key 不可變;value可變
所以提字典也成爲鍵值對（key-value）結構
每個字典當中有多個鍵值對，每個鍵值對稱之爲一項（item）

創建字典  dict
語法   {key:value,key:value,key:value}
d = {'name':'鋼鐵俠','age':30,'sex':'男'}    #   {'name': '鋼鐵俠', 'age':                                                30, 'sex': '男'} <class 'dict'>

字典的鍵可以是任意不可變對象(int,str,bool,key:value)
字典的值可以是任意對象
字典當中的鍵是不可以重複的,如果重複後邊的會替換前邊的
d = {'name':'鋼鐵俠','age':30,'sex':'男','name':'葫蘆娃'}  
# {'name':'葫蘆娃', 'age': 30, 'sex': '男'} <class 'dict'>

d = {
    'name':'鋼鐵俠',    #  有的人喜歡這樣寫 ,也可以
    'age':18,           # {'name': '鋼鐵俠', 'age': 18, 'sex': '男'} <class                            'dict'>
    'sex':'男'
}

可以根據鍵來獲取值
print(d['name'],d['age'],d['sex'])  
>>>
鋼鐵俠 30 男

05 - 映射 - 字典的使用

使用dict()函數來創建字典

d = dict(name = '鋼鐵俠',age = 30,sex = '男')
print(d,type(d))
>>>
{'name': '鋼鐵俠', 'age': 30, 'sex': '男'} <class 'dict'>


# 可以將一個包含有雙值子序列的序列轉換爲字典
# 雙值序列,序列當中只有2個值  [1,2] ('b',6] 'de'
# 子序列, 如果序列當中的元素也是序列,那麼我們稱這個元素爲子序列
# 例如:[(2,3),(7,8)]
# d = dict([('name','鋼鐵俠'),('age',18)])

# d = dict(name = '鋼鐵俠',age = 30,sex = '男')
# 獲取字典當中的長度 len()
# print(len(d))   # 3

# in 檢查字典當中是否包含指定的鍵
# not in 檢查字典當中是否不包含指定的鍵
# print('Hello' in d)  # False

# 獲取字典當中的值, 根據鍵來獲取
# 語法 d[key]
# print(d['age'])   #  30

# w = 'name'
# print(d[w])   # 鋼鐵俠
# print(d.get('name'))  # 鋼鐵俠     get後面的括號裏面填的是name,打印出來是 鋼鐵俠
# print(d.get('鋼鐵俠'))  # None      get後面填的是鋼鐵俠,        打印出來是  None
# print(d.get('python'))  # None

w = 'name'
# get(key[,deafult])
print(d.get('python','返回值'))    #   返回值
print(d.get('python','66'))           #   66

(1).修改字典, d[key] = value

d = dict(name = ‘鋼鐵俠’,age = 30,sex = ‘男’)

修改字典
d[key] = value
如果key值存在就覆蓋,不存在就添加
d[‘name’] = ‘葫蘆娃’ # {‘name’: ‘葫蘆娃’, ‘age’: 30, ‘sex’: ‘男’}
print(d)

d[‘phone’] = ‘1,2,3,4,5,6’
print(d) # {‘name’: ‘葫蘆娃’, ‘age’: 30, ‘sex’: ‘男’, ‘phone’: ‘1,2,3,4,5,6’}

(2).setdefault(key[,default]) 就是向字典中添加key-value

如果key已經存在字典中,則返回key的值,不會對字典做任何操作
如果key不存在,則向字典中添加這個key,並設置value
setdefault(key[key[,default])
d = dict(name = ‘鋼鐵俠’,age = 30,sex = ‘男’)
d.setdefault(‘name’,‘葫蘆娃’)
print(d) # {‘name’: ‘鋼鐵俠’, ‘age’: 30, ‘sex’: ‘男’}

result = d.setdefault(‘python’,‘葫蘆娃’)
print(result) # 葫蘆娃
print(d) # {‘name’: ‘鋼鐵俠’, ‘age’: 30, ‘sex’: ‘男’, ‘python’: ‘葫蘆娃’}

自主測試(注意:不要把setdefault寫成了setfault)
result = d.setdefault(‘遊戲名稱’,‘葫蘆娃’)
print(result) # 葫蘆娃
print(d) # {‘name’: ‘鋼鐵俠’, ‘age’: 30, ‘sex’: ‘男’, ‘遊戲名稱’: ‘葫蘆娃’}

(3).update(), 添加

update() 添加
將其他字典當中的key-value 添加到當前字典當中
如果有重複的key,則後邊的會替換到前面的 a
d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6}
d.update(d2)
print(d) # {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6,‘a’:7}
d.update(d2)
print(d) # {‘a’: 7, ‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6}

(4).del d[key] ,刪除

d = {‘a’:1,‘b’:2,‘c’:3}
d2 = {‘d’:4,‘e’:5,‘f’:6,‘a’:7}
d.update(d2)
刪除
del d[‘a’] # {‘b’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6} a被刪除掉了
del d[‘b’] # {‘c’: 3, ‘d’: 4, ‘e’: 5, ‘f’: 6} 緊接着 b 又被刪除掉了
print(d)

(5).popitem() 隨機刪除字典當中的一個鍵值對,一般都會刪除最後一個鍵值對

d.popitem() # {‘c’: 3, ‘d’: 4, ‘e’: 5}
result = d.popitem()
print(result) # (‘e’, 5) 刪除的對象是: e
d.popitem() # {‘c’: 3, ‘d’: 4}
print(d)

(6).clear() 清空字典

clear() 清空字典
d.clear()
print(d) # {}

06 - 函數 - copy()

d = {'a':1,'b':2,'c':3}

d2 = d
print('d = ' ,d)    # d =  {'a': 1, 'b': 2, 'c': 3}
print('d2 = ',d2)   # d2 =  {'a': 1, 'b': 2, 'c': 3}

d['b'] = 10
print('d = ' ,d)   #  d =  {'a': 1, 'b': 10, 'c': 3}
print('d2 = ',d2)   #  d2 =  {'a': 1, 'b': 10, 'c': 3}

上面的操作不是複製,真正的複製是:複製後兩個對象之間沒有什麼關係了,就算是改變其中一個鍵值對的value(值)時,對另一個對象中的鍵值對的value(值)沒有什麼影響猜對.

copy()函數應該是以下操作
copy()  該方法是用來對字典進行一個潛複製
複製以後的對象 ,和原對象就是對立 , 修改一個不會影響第二個
d = {'a':1,'b':2,'c':3}

d2 = d.copy()
print('d = ',d,id(d))  # d =  {'a': 1, 'b': 2, 'c': 3} 2241405152712
print('d2 = ',d2,id(d2))  # d2 =  {'a': 1, 'b': 2, 'c': 3} 2241405152280
以上兩個的結果一樣，對象不一樣（即內存地址不一樣），這個叫做複製

d = {'a':1,'b':2,'c':3}

d2 = d.copy()
d['a'] = 88
print('d = ',d,id(d))     # d =  {'a': 88, 'b': 2, 'c': 3} 1519759117912
print('d2 = ',d2,id(d2))  # d2 =  {'a': 1, 'b': 2, 'c': 3} 1519758240792

潛複製會簡單複製對象內部的值,如果這個值也是一個可變對象,這個可變對象是不會被複制的(比如:d裏面的這個值{'name':'鋼鐵俠','age':30}是不會被複制的
d = {'a':{'name':'鋼鐵俠','age':30},'b':2,'c':3}

d2 = d.copy()
print('d =',d,id(d)) # d = {'a': {'name': '鋼鐵俠', 'age': 30}, 'b': 2, 'c': 3} 2158889823328
print('d2 =',d2,id(d2)) # d2 = {'a': {'name': '鋼鐵俠', 'age': 30}, 'b': 2, 'c': 3} 2158889823688

07 - 映射 - 遍歷字典

字典的遍歷
keys()
values()
items()

(1).keys()

d = {‘name’:‘鋼鐵俠’,‘age’:30,‘sex’:‘男’}

通過遍歷keys()來獲取所有的鍵

for k in d.keys():
print(d[k]) # # 這個可以獲取到key的值
,>>>鋼鐵俠
30
男

(2).values()

values()
for v in values():
print(v) # # 這個不能獲取到key的值,只能獲取到value的值,一般不用這個
,>>>鋼鐵俠
30
男

(3).items()

item()
該方法會返回字典中所有的項
它會返回一個序列,序列中包含有雙值子序列
雙值分別是字典中的key 和 value
print(d.items()) # dict_items([(‘name’, ‘鋼鐵俠’), (‘age’, 30), (‘sex’, ‘男’)])

for k,v in d.items():
print(k,’=’,v)
,>>>
name = 鋼鐵俠
age = 30
sex = 男

08 - 映射 - 字典練習

練習:爬取喜馬拉雅輕音樂的下載地址
import requests

import json

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36'
}
url = 'https://www.ximalaya.com/revision/play/album?albumId=291718&pageNum=1&sort=1&pageSize=30'

r = requests.get(url,headers=headers)
ret = r.text
result = json.loads(ret)
content_list = result['data']['tracksAudioPlay']
# print(ret,type(ret))

for content in content_list:
    print(content['src'])
    >>>打印出來的是一列以 http 爲開頭的輕音樂下載地址

a = '123'
a = "{'name':'python'}"
print(a,type(a))  # {'name':'python'} <class 'str'>

c = '{"name":"python"}'   # json類型的 字符串

a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}

b = a['data']  # {"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}

c = b['result'] # [{"src":"python1"},{"src":"python2"},{"src":"python3"}]

for i in c:
    print(i['src'])
# python1
# python2
# python3

第八章：元組和字典

01-序列-元組簡介

元組的解包：元組的解包指的是將元組當中的每一個元素都賦值給一個變量

在對一個元組解包時，變量的數量必須和元組中的元素要一一對應，如果出現變量和元素沒有對等的情況下，我們可以在變量面前加一個* ，這樣變量就會將獲取元組中所有剩餘的元素以列表的形式返回

02 - 對象 - 可變對象

這個操作是在給變量重新賦值，這種操作會改變變量指向的對象，一般只有在爲變量賦值時纔是修改變量，其餘的都是在修改對象

03. 序列 - == 和 is

04 - 映射 - 字典簡介

1.字典

05 - 映射 - 字典的使用

(1).修改字典, d[key] = value

(2).setdefault(key[,default]) 就是向字典中添加key-value

(3).update(), 添加

(4).del d[key] ,刪除

(5).popitem() 隨機刪除字典當中的一個鍵值對,一般都會刪除最後一個鍵值對

(6).clear() 清空字典

06 - 函數 - copy()

07 - 映射 - 遍歷字典

(1).keys()

(2).values()

(3).items()

08 - 映射 - 字典練習

第十五章:封裝

第十四章:面向對象 - 類的簡介

第十六章: 面向對象 - 繼承和多態

第十二章:函數 - 函數三

第十一章: - 函數 - 函數二

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

第八章：元組和字典

01-序列-元組簡介

元組的解包： 元組的解包指的是將元組當中的每一個元素都賦值給一個變量

在對一個元組解包時，變量的數量必須和元組中的元素要一一對應 ，如果出現變量和元素沒有對等的情況下，我們可以在變量面前加一個* ，這樣變量就會將獲取元組中所有剩餘的元素以列表的形式返回

02 - 對象 - 可變對象

這個操作是在給變量重新賦值，這種操作會改變變量指向的對象，一般只有在爲變量賦值時纔是修改變量，其餘的都是在修改對象

03. 序列 - == 和 is

04 - 映射 - 字典簡介

1.字典

05 - 映射 - 字典的使用

(1).修改字典, d[key] = value

(2).setdefault(key[,default]) 就是向字典中添加key-value

(3).update(), 添加

(4).del d[key] ,刪除

(5).popitem() 隨機刪除字典當中的一個鍵值對,一般都會刪除最後一個鍵值對

(6).clear() 清空字典

06 - 函數 - copy()

07 - 映射 - 遍歷字典

(1).keys()

(2).values()

(3).items()

08 - 映射 - 字典練習

元組的解包：元組的解包指的是將元組當中的每一個元素都賦值給一個變量

在對一個元組解包時，變量的數量必須和元組中的元素要一一對應，如果出現變量和元素沒有對等的情況下，我們可以在變量面前加一個* ，這樣變量就會將獲取元組中所有剩餘的元素以列表的形式返回