概要：深淺拷貝、函數、lambda、內置函數、文件操作

一、深淺拷貝

1.對於字符串、數字來說，賦值、深拷貝、淺拷貝的結果是一樣的，都是用的內存中的同一個地址。

如下圖所示：

 1 import copy
 2 ‘‘‘
 3 
 4 a1 = 123
 5 a2 = 123
 6 #a2 = a1
 7 print(id(a1))
 8 print(id(a2))
 9 #淺拷貝，內存中的地址一樣
10 a3 = copy.copy(a1)
11 print(id(a1))
12 print(id(a3))
13 #深拷貝，內存中地址一樣
14 a4 = copy.deepcopy(a1)
 
15 print(id(a1))
16 print(id(a4))
17 #結論：對於字符串、數字來說，賦值，深淺拷貝用的都是內存中的同一個地址。

2.其他類型，如列表、字典、元組

對於字典、元組、列表 而言，進行賦值、淺拷貝和深拷貝時，其內存地址的變化是不同的

賦值：只是新創建了一個變量，該變量還是指向原來的內存地址

n1 = {‘k1‘:‘v1‘,‘k2‘:123,‘k3‘:["alex",678]}

n2 = n1

淺拷貝：在內存地址裏只拷貝一層，字典裏的元素沒拷貝

深拷貝：有多少層拷貝多少份，在內存中將所有的數據重新創建一份

 1 #!/usr/bin/env python3
 

 2 #author:Alnk
 3 import copy
 4 
 5 #其他，如元組，列表，字典...
 6 n1 = {‘k1‘:‘v1‘,‘k2‘:123,‘k3‘:["alex",678]}
 7 
 8 #賦值 --內存地址還是一樣的
 9 n2 = n1
10 print(id(n1))
11 print(id(n2))
12 
13 #淺拷貝：在內存中只額外創建第一層數據
14 #第一層的內存地址已經不一樣了
15 n3 = copy.copy(n1)
16 print(id(n1))
17 print(id(n3))
18 #其他層的內存地址是一樣的
19 
20 
21 #
 
深拷貝：在內存中將所有的數據重新創建一份。更改拷貝後的數據，原來的數據不會收到影響
22 n4 = copy.deepcopy(n1)
23 print(id(n1))
24 print(id(n4))
25 #
26 print(id(n1[‘k1‘]))
27 print(id(n4[‘k1‘]))
28 print(id(n1[‘k2‘]))
29 print(id(n4[‘k2‘]))
30 print(id(n1[‘k3‘]))
31 print(id(n4[‘k3‘]))
32 print(id(n1[‘k3‘][0]))
33 print(id(n4[‘k3‘][0]))

 1 import copy
 2 
 3 #示例
 4 #監控模版
 5 #已經被監控的10臺機器當CPU超過80時報警，現在要新添加10臺機器的監控，CPU超過60就報警
 6 dic = {
 7     "cpu":[80,],
 8     "mem":[80,],
 9     "dis":[80,]
10 }
11 
12 ###如果用賦值的話則會把原來老的監控指標也更改了###
13 new_dic = dic
14 new_dic[‘cpu‘][0] = 60
15 print("old:",dic)
16 print("new:",new_dic)
17 ###################################################
18 
19 ####如果用淺拷貝的話則會把原來老的監控指標也更改了####
20 new_dic = copy.copy(dic)
21 new_dic[‘cpu‘][0] = 60
22 print("old:",dic)
23 print("new:",new_dic)
24 ###################################################
25 
26 #####深拷貝不會更改原來老的監控指標#####
27 new_dic = copy.deepcopy(dic)
28 new_dic[‘cpu‘][0] = 60
29 print("old:",dic)
30 print("new:",new_dic)
31 ###################################################

二、函數

1.基本概念

 1 #!/usr/bin/env python3
 2 #author:Alnk
 3 
 4 def mail():
 5     n = 123
 6     n+=1
 7     print(n)
 8 
 9 #調用函數
10 mail()
11 
12 #賦值 ，f 指向了mail函數的內存地址
13 f = mail
14 #調用
15 f()

2.函數返回值

　　函數如果沒有return，那麽默認返回None

　　return作用：

　　　　返回一個值

　　　　中斷函數

 1 #!/usr/bin/env python3
 2 #author:Alnk
 3 ‘‘‘
 4 #函數返回值練習（函數默認返回值為None）
 5 def mail():
 6     n = 123
 7     n+=1
 8     return 123
 9 
10 #執行函數，並且賦值給ret，拿到返回值
11 ret = mail()
12 print(ret)
13 ‘‘‘
14 
15 #return 返回一個值並且中斷函數操作
16 def show():
17     print(‘a‘)
18     return [11,22]
19     print(‘b‘)
20 ret = show()
21 print(ret)

擴展：pycharm斷點調試的方法

3.函數參數

函數參數可分為：

　　普通參數（又叫位置參數）

　　默認參數 #註意默認參數必須指向不可變對象！

　　動態參數：

　　　　可變參數 #調用的時候需要先組裝出一個list或tuple

　　　　關鍵字參數 #關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict

　　　　命名關鍵字參數

在Python中定義函數，可以用位置參數、默認參數、可變參數、關鍵字參數和命名關鍵字參數，這5種參數都可以組合使用。但是請註意，參數定義的順序必須是：位置參數、默認參數、可變參數、命名關鍵字參數和關鍵字參數。

 1 #!/usr/bin/env python3
 2 #author:Alnk
 3 ‘‘‘
 4 #1.沒有參數
 5 def show():
 6     pass
 7 
 8 
 9 #2.位置參數 ：一個參數
10 def show(arg):
11     print(arg)
12 show(‘kkkk‘)
13 #兩個參數,或者多個參數
14 def show(arg1,arg2):
15     print(arg1,arg2)
16 show(‘kkkk‘,‘bbbb‘)
17 
18 
19 #3.默認參數   -- 定義默認參數要牢記一點：默認參數必須指向不變對象！
20 def show(a1,a2=333):
21     print(a1)
22     print(a2)
23 show(‘aaa‘)
24 show(‘aaa‘,‘bbb‘)
25 #指定參數
26 def show(a1,a2):
27     print(a1)
28     print(a2)
29 show(a2=123,a1=999)
30 
31 
32 #4.動態參數（可變參數）--生成一個元組
33 def show(arg):
34     print(arg)
35 def show2(*arg):
36     print(arg,type(arg))
37 show(1)
38 show2(1)
39 show2(1,2,3,4,5)
40 
41 #動態參數（關鍵字參數） --生成一個字典
42 def show3(**kw):
43     print(kw,type(kw))
44 show3(a1=8)
45 show3(a1=8,a2=88)
46 #可變參數+關鍵字參數 --*args在前，**kw在後
47 def show(*args,**kw):
48     print(args,type(args))
49     print(kw,type(kw))
50 l = [11,22,33]
51 d = {"n1":66,"a1":99}
52 #show(11,222,333,44,a="bb",n3="cc")  #傳參數時註意位置
53 show(l,d)  #都放進*args裏面去了
54 show(*l,**d) #把列表或元組整個賦值給動態參數，需要加 * 或者 **
55 
56 #動態參數(命名關鍵字參數)
57 #對於關鍵字參數，函數的調用者可以傳入任意不受限制的關鍵字參數。至於到底傳入了哪些，就需要在函數內部通過kw檢查。
58 #如果要限制關鍵字參數的名字，就可以用命名關鍵字參數，例如，只接收city和job作為關鍵字參數。這種方式定義的函數如下
59 #和關鍵字參數**kw不同，命名關鍵字參數需要一個特殊分隔符*，*後面的參數被視為命名關鍵字參數
60 def person(name, age, *, city, job):
61     print(name, age, city, job)
62 person(‘Jack‘, 24, city=‘Beijing‘, job=‘Engineer‘)
63 person(‘Jack‘, 24, job=‘Beijing‘, city=‘Engineer‘)
64 #如果函數定義中已經有了一個可變參數，後面跟著的命名關鍵字參數就不再需要一個特殊分隔符*了
65 def person(name, age, *args, city, job):
66     print(name, age, args, city, job)
67 #person(‘Jack‘, 24, ‘Beijing‘, ‘Engineer‘)   #調用失敗
68 
69 
70 #格式化
71 s1 = "{0} is {1}"
72 l = ["alnk","shuaiguo"]
73 #result = s1.format("alnk","shuaiguo")
74 result = s1.format(*l)
75 #print(s1.format("alnk","shuaiguo"))
76 print(result)
77 
78 s1 = "{name} is {acter}"
79 result = s1.format(name="alnk",acter="666")
80 print(result)
81 d = {"name":"alnk","acter":666}
82 result = s1.format(**d)
83 print(result)
84 ‘‘‘

三、lambad

 1 #!/usr/bin/env python3
 2 #author:Alnk
 3 
 4 def f1(a):
 5     b = a + 1
 6     return b
 7 ret = f1(4)
 8 print(ret)
 9 
10 #lambda表達式  --簡單的函數表式方式
11 f2 = lambda a:a+1   #創建了形式參數a，創建了函數內容 a+1 ，並且把結果return
12 ret = f2(99)
13 print(ret)

四、內置函數

目前熟悉下圖標註的函數即可

  1 #!/usr/bin/env python3
  2 #author:Alnk
  3 ‘‘‘
  4 #abs() --絕對值
  5 print(abs(11))
  6 print(abs(-11))
  7 
  8 #all() --傳一個序列，會去循環該序列，一旦存在假的值就會返回False
  9 print(all([]))
 10 print(all(["",]))
 11 print(all([0,1,2]))
 12 #以下都為假，空的類型
 13 print(bool(None))
 14 print(bool(""))
 15 print(bool([]))
 16 print(bool(0))
 17 print(bool({}))
 18 
 19 #any() --只要有一個為真，就返回True
 20 print(any([0,1,2]))
 21 
 22 #bin() --返回二進制
 23 print(bin(100))
 24 
 25 #bool() --布爾值
 26 print(bool(None))
 27 print(bool(""))
 28 print(bool([]))
 29 print(bool(0))
 30 print(bool({}))
 31 print(bool(1))
 32 
 33 #chr() --把字符轉為ascii碼
 34 print(ord(‘a‘))
 35 
 36 #ord() --把ascii碼轉為字符，
 37 print(chr(97))
 38 
 39 #dict() --創建一個字典
 40 a =dict(v1=‘k1‘,v2=‘k2‘)
 41 print(a)
 42 
 43 #dir() --當前變量所有的方法
 44 a = ()
 45 print(dir(a))
 46 
 47 #divmod() --返回一個元組，第一個元素位商，第二個元素位余數
 48 print(divmod(4,2))
 49 
 50 #enumerate() --輸出編號
 51 li = ["a","b","c"]
 52 for i,item in enumerate(li,1):
 53     print(i,item)
 54 
 55 #eval() --字符串裏的數字乘積
 56 print(eval("6*8"))
 57 
 58 #filter() --用於過濾序列
 59 li = [11,22,33,44]
 60 def fun(x):
 61     if x > 33:
 62         return True
 63     else:
 64         return False
 65 l = filter(fun,li) #過濾
 66 print(list(l))
 67 
 68 #map() --加工
 69 li = [11,22,33,44]
 70 new_li = map(lambda x:x+100,li)
 71 l = list(new_li)
 72 print(l)
 73 
 74 #float() --創建小數
 75 a = 1
 76 b = float(a)
 77 print(b)
 78 
 79 #help() --幫助函數
 80 
 81 #id() --查看對象在內存中的地址
 82 
 83 #input() --輸入函數
 84 
 85 #int() --創建一個整數
 86 
 87 #len() --判斷一個對象的長度
 88 l1 = [1,23,44]
 89 print(len(l1))
 90 s1 = "str1"
 91 print(len(s1))
 92 
 93 #list() --創建一個列表
 94 a = list((1,2,3,4))
 95 print(a)
 96 
 97 #max() --返回最大值
 98 print(max(1,2,3,4))
 99 
100 #min() --返回最小值
101 print(min(1,2,3,4))
102 
103 #oct() --八進制
104 print(oct(10))
105 
106 #pow() --返回（x的y次方） 的值。
107 print(pow(2,5))
108 
109 #range() --返回一個序列
110 print(range(1,10))
111 
112 #reversed() --反轉叠代
113 l1 = [‘a‘,‘b‘,‘c‘]
114 l2 = reversed(l1)
115 for i in l2:
116     print(i)
117 
118 #round()  --四舍五入
119 print(round(8.9))
120 print(round(8.4))
121 
122 #set() --集合
123 a = set([1,2,3])
124 print(a)
125 
126 #sort() --排序
127 a = [‘b‘,‘c‘,‘a‘]
128 a.sort()
129 print(a)
130 
131 #str() --創建一個字符串
132 a = str("abcde")
133 print(a)
134 
135 #sum() --求和
136 print(sum([1,2,3],3))
137 print(sum([1,2]))
138 
139 #tuple() --元組
140 t = tuple([1,2,3,])
141 print(t)
142 
143 #type() --返回對象的類型
144 a = 1
145 print(type(a))
146 
147 #vars() --返回對象的屬性和屬性值的字典對象
148 class fo():
149     a = 1
150 print(vars(fo))
151 
152 #zip()  --映射
153 x = [1,2,3]
154 y = [4,5,6]
155 z = [7,8,9]
156 zipped = zip(x,y,z)
157 print(list(zipped))
158 ‘‘‘

五、文件操作（open()函數）

 1 #!/usr/bin/env python3
 2 #author:Alnk
 3 ‘‘‘
 4 #read 按照字符來讀的
 5 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘)
 6 ret = f.read(2)  #按照字符讀，不是按照字節
 7 f.close()
 8 print(ret)
 9 
10 #tell() --查看當前指針的位置，按照字節來的
11 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘)
12 f.read(2)
13 print(f.tell())  #按照字節，不是字符
14 f.close()
15 
16 #seek --用來指定指針的位置，按照字節來的
17 f = open(‘log.txt‘,‘r‘,encoding=‘utf-8‘)
18 f.seek(3)
19 print(f.read())  #不加參數，全部讀取，加參數，指定讀取字符。是字符字符字符。。。
20 f.close()
21 
22 #truncate()  --截取指針前面的字節，並且刪除指針後面的數據
23 f = open(‘log.txt‘,‘r+‘,encoding=‘utf-8‘)
24 f.seek(3)
25 #print(f.read())
26 print(f.truncate())
27 f.close()
28 ‘‘‘

python3自動化學習03