day8笔记
一、上節回顧
1，id() 內存地址
2， == 比較的是值
is 比較的是內存地址
數字，字符串，有小數據池，
#內存地址一樣的
int -5--256
str：1，不能有空格。
2，長度不能超過20。
3，不能有特殊字符如：#@.....
列表元組字典這些除了賦值的都是內存地址不一樣的
py3:
str：表現形式：s = 'alex' 實際編碼方式：unicode
bytes：表現形式：s = b'alex' 實際編碼方式：utf-8,gbk,gb2312...
s = b'\x2e\x2e\x2e\x2e\x2e\x2e'
unicode:所有字符（無論英文，中文等） 1個字符：4個字節
gbk：一個字符，英文1個字節，中文兩個字節。
utf-8:英文 1 個字節，歐洲：2個字節，亞洲：3個字節。
二、數據類型補充
? 1.元組
tu = (1)tu1 = ('name',)print(tu,type(tu)) # 1 <class 'int'>print(tu1,type(tu1))tu = ('dfas')tu1 = ('name',)print(tu,type(tu)) # dfas <class 'str'>print(tu1,type(tu1))tu = (True)tu1 = ('name',)print(tu,type(tu)) # True <class 'bool'>print(tu1,type(tu1))tu = ([1,2,3])tu1 = ('name',)print(tu,type(tu)) # [1, 2, 3] <class 'list'>print(tu1,type(tu1))#當數據類型外邊只加括號的時候。這個數據類型還是自己本身，如果想變為元組。那么后邊加一個,號2.,列表當循環列表時，如果在循環中刪除某個或者某些元素，列表元素個數改變，索引改變，容易出錯。
# #刪除奇數位索引值 #方一： a = [1,2,3,4,5,6,7] del a[1::2] print(a) #方法二 a = [1,2,3,4,5,6,7] a = a[0::2] print(a) #方法三(不建議使用此方法，如果有兩個相同的元素可能會出錯) a = [1,2,3,4,5,6,7] b = a.copy() for i in range(len(b)):if i%2==1:a.remove(b[i]) print(a) #方法四 a = [1,2,3,4,5,6,7] for i in range(0,len(a)):if i%2==1:del a[(i+1)//2] print(a) #方法五 a = [1,2,3,4,5,6,7] b = [] for i in range(len(a)):if i%2 ==0:b.append(a[i]) a = b #方法五 a = [1,2,3,4,5,6,7] b = [] for i in range(len(a)):if i%2 ==0:b.append(a[i]) a = b print(a)''' e = {1:2,3:4} e.pop(1) print(e)# 方法6 a = [1, 2, 3, 4, 5, 6, 7] for i in range(len(a)-1,-1,-1):if i % 2 == 1:del a[i] print(a) 列表中奇數位索引元素刪除3,字典
當循環字典時，如果在循環中刪除某個或者某些鍵值對，字典的鍵值對個數改變，長度改變，容易出錯。
4.轉化：
1，int --> str :str(int) 2, str ---> int:int(str) 字符串必須全部由數字組成 3，bool ---> str:str(bool) 4,str ----> bool(str) 除了空字符串，剩下的都是True 5，int ---> bool 除了0，剩下的全是True 6，bool ---> int True ---> 1 False ----> 0 7,str ---> list split 8,list ---> str() join 9,元祖列表： tu = (1,2,3) l = list(tu) print(l,type(l))li = [4,5,6] print(tuple(li),type(tuple(li)))#str ---> list print(list('ab_c'))#str ---> list print(tuple('ab_c'))# 0,"",{},[],(),set() ---->False a='a' b = 1 d = 1, f = '' g = () h = list(g) e = list(f) # c = list(1,) 報錯 c = list(d) print(c) print (d,type(d)) # 一個字母可以通過工廠函數轉化 print(e) # 空字符串也可以 print(h) # 空元組也可以5、列表轉化為字典：fromkeys
dic = dict.fromkeys([1,2,3]) # dic1 = dict.fromkeys('abc','楊杰') print(dic) # 如果單獨的一個列表，后邊沒有參數，那么返回的是三個值為None的字典 dic[4] = 'dfdsa' print(dic) # {1: None, 2: None, 3: None, 4: 'dfdsa'} dic = dict.fromkeys(['barry','alex',],[]) dic['ritian'] = [] dic['barry'] = [] dic['barry'].append(11) print(dic) # # {'barry': [11], 'alex': [], 'ritian': []} 如果后邊的參數是一個列表（或元組或），那么所有的鍵值對的值都指向該列表#即內存地址一樣，其中一個列表變化所有值都變化6、集合
# ①集合的元素是可哈希的，不可變的。②集合本身是不可哈希。列表，字典不能出現，集合也不行③集合是無序的 ④值是唯一的內建函數創建set代碼如下:
se1 = set([1, 2, 3, 4]) se1 = {1,2,3,4,5} print(se1,type(se1)) # {1, 2, 3, 4, 5} <class 'set'> #se2 = {1,'a',2,3,{1,2,3}} 報錯 #se2 = {1,'a',2,3,{1,2,3,[1]}} 報錯 se2 = {1,'a',2,3,(1,2,3)} print(se2) # 集合是無序的 但是可迭代 可遍歷增：
se1 = {1,2,3,4,5} a = se1.add('老王') #print(a,se1) #集合是可以增的 None {1, 2, 3, 4, 5, '老王'} #update #se1.update('abc') #{1, 2, 3, 4, 5, '老王', 'a', 'b', 'c'}迭代增加 #se1.update((11,22)) # {1, 2, 3, 4, 5, '老王', 11, 22} # se1.update({11,22}) # print(se1) #{1, 2, 3, 4, 5, 11, '老王', 22} 也可以增加集合刪：
se1 = {1,2,3,4,5} # a = se1.remove(1) # print(a,se1) # None {2, 3, 4, 5} 刪除指定源元素，沒有返回值 沒有參數會報錯 # a = se1.pop(1) # print(a,se1) #1 {2, 3, 4, 5} 有返回值 隨機刪除一個元素返回值是該元素 無索引故無參數 # se1.clear() # 清空集合 # print(se1) # set() 這就是空集合 del se1 print(se1) #: name 'se1' is not defined 刪除集合改：
#凍結集合frozenset 它是不可變的，可哈希的。set 是可變的 set中可以包含frozenset # s = frozenset([1,2,33,33,4]) # print(s,type(s)) # se1.add(s) # print(se1) s1 = frozenset(se1) print(s1) # frozenset({1, 2, 3, 4, 5}) 集合也可以轉變為凍結集合 s2 = set(s1) print(s2) # {1, 2, 3, 4, 5} 凍結集合可以轉變為集合查：
# 查 由于是可迭代的，故可以用for 循環將其遍歷 for i in se1:print(i)附加功能
t.add('x') # 添加一項 s.update([10,37,42]) # 在s中添加多項 t.remove('H') # 刪除一項 len(s) # set 的長度 x in s # 測試 x 是否是 s 的成員 x not in s # 測試 x 是否不是 s 的成員 s.issubset(t) s <= t # 測試是否 s 中的每一個元素都在 t 中 s.issuperset(t) s >= t # 測試是否 t 中的每一個元素都在 s 中 s.union(t) s | t # 返回一個新的 set 包含 s 和 t 中的每一個元素 s.intersection(t) s & t # 返回一個新的 set 包含 s 和 t 中的公共元素 s.difference(t) s - t # 返回一個新的 set 包含 s 中有但是 t 中沒有的元素 s.symmetric_difference(t) s ^ t # 返回一個新的 set 包含 s 和 t 中不重復的元素 s.copy() # 返回 set “s”的一個淺復制 # #交集 & intersection # set1 = {1,2,3,4,5} # set2 = {4,5,6,7,8} # print(set1 & set2) # {4, 5} # print(set1.intersection(set2)) # {4, 5}# set1 = {1,2,3,4,5} # set2 = {4,5,6,7,8} # print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7} # print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}# set1 = {1,2,3,4,5} # set2 = {4,5,6,7,8} # print(set1 - set2) # {1, 2, 3} set1獨有 # print(set1.difference(set2)) # {1, 2, 3} # print(set2 - set1)# set1 = {1,2,3,4,5} # set2 = {4,5,6,7,8} # print(set1 ^ set2) # {1, 2, 3, 6, 7, 8} # print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8} set1 = {1,2,3,4} set2 = {1,2,3,4,5} set3 = frozenset({1,2}) a = (1,) print(set3 < set1) # set3是set1的子集 print(set1.issubset(set2)) # set1<= set2 # set1是set2的子集 print(set2 > set1) # set2 是set1 的超集 print(set2.issuperset(set1)) # set2 >=set1 # 這兩個相同，都是說明set2是set1超集。 print(set1.issuperset(a) ) # 符號形式不能和集合外的比較 函數形式的可以和可迭代對象比較 詳細舉例作用：去重
#去重 lst = [1,2,3,4,1] print (list(set(lst))) # [1, 2, 3, 4]四、賦值和深淺拷貝
?
將某一數值賦給某個變量的過程，或者將某一變量賦值給另一變量的過程。稱為賦值。
l1 = [1,2,3] l2 = l1 l1.append('barry') print(l1) # [1,2,3,'barry'] print(l2) # [1,2,3,'barry'] dic = {'name':'barry'} dic1 = dic dic['age'] = 18 print(dic) # {'name': 'barry', 'age': 18} print(dic1) # {'name': 'barry', 'age': 18} s = 'alex' s1 = s s3 = s.replace('e','E') print(s) # alex print(s1) # alex print(s3) # alEx s1 = s print(id(s),id(s1)) # 相同 s = 'alex ' s1 = 'alex ' print(id(s),id(s1)) # 相同 # 賦值時候，兩個變量指向了同一個內存空間，并沒有開辟新的空間來 # lst = [1,2,3,4,1] # print (list(set(lst))) # [1, 2, 3, 4] l1 = [288,1,2,3] l2 = l1 l1.append('barry') print(l1[0] is l2[0] ) # True 內層也一樣淺拷貝：創建一個新的對象，其元素是對原對象元素的引用。實現方法：（切片操作、工廠函數、對象的copy方法、模塊中的copy函數。）
三 >>> ssw ='bangzi' >>> ssb =list(ssw) #ssb是通過工廠函數淺拷貝過來的一個新的對象 >>> ssw 'bangzi' >>> ssb ['b', 'a', 'n', 'g', 'z', 'i']>>> id(ssw),id(ssb) (139798160206232, 139798160220040) #兩個對象的內存地址不一樣 >>> for x,y in zip(ssw,ssb): #針對于對象中的元素來說，兩個對象中的每個元素指向的都是一個元對象。 ... print(id(x),id(y)) ... 139798160566736 139798160335792 139798160718736 139798160372040 139798160206512 139798160567856通過工廠函數所得到的對象：工廠函數有：list()、tuple()、dict()、str()。 >>> YY1 = [1,2,3,4,5,6] >>> YY2 =tuple(YY1) #序列變元祖 >>> YY2 (1, 2, 3, 4, 5, 6) >>> id(YY1),id(YY2) (139798032994568, 139798159622216) >>> for x,y in zip(YY1,YY2): ... print(id(x),id(y)) ... 9323200 9323200 #對象中的元素與原對象中的元素id號一致。 9323232 9323232 9323264 9323264 9323296 9323296 9323328 9323328 9323360 9323360 通過切片操作得到的對象 >>> a = [1,2,3,4,5] >>> b = a[:3] >>> id(a)>>> id(b)>>> id(b[0]) #對原對象元素的引用。>>> id(a[0])>>> id(b[1])>>> id(a[1]) 通過copy函數得到的對象也是淺拷貝 >>> info = {'name':'kebi','age':'28'} >>> INFO = info.copy() >>> INFO {'name': 'kebi', 'age': '28'}>>> id(info) #內存地址雖然不同>>> id(INFO)>>> id(info['name']) #元素都指向一個地方，明顯的淺拷貝。>>> id(INFO['name']) 種淺拷貝深拷貝：創建一個新的對象，然后遞歸拷貝原對象所包含的子對象。深拷貝出來的對象和元對象沒有關聯。
深拷貝和淺拷貝的區別僅僅是對組合對象來所。所謂的組合對象就是包含了其它對象的對象，例如列表、元祖等數據容器。
對于非容器類型（例如：字符串、數字和其他原子類型）來說，沒有拷貝一說，產生的對象都是對原對象的應用。
區別在于新對象中的元素與原對象中的元素是否存在聯系。如果有聯系則屬于淺拷貝，否則屬于深拷貝。
import copy l1 = [258,[258,33,44],3,4,] l2 = copy.deepcopy(l1)l1[0] = 111 print(l1,l2)l1[1].append('barry') print(l1,l2) # [111, [22, 33, 44], 3, 4] [1, [22, 33, 44], 3, 4] [111, [22, 33, 44, 'barry'], 3, 4] [1, [22, 33, 44], 3, 4] print(l1[1][0] is l2[1][0]) # True 內層的非容器元素地址相同，內層的容器元素地址不同 深拷貝?
?
?
?
?轉載于:https://www.cnblogs.com/zjchao/p/7743033.html
《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀總結
- 上一篇： xargs 主要用于不支持管道的shel
- 下一篇： java生成扑克牌----java基础学