Python基礎學習05

函數

一、什麽是函數

定義：函數是指將一組語句的集合通過一個名字(函數名)封裝起來，要想執行這個函數，只需調用其函數名即可

特性:
1.減少重復代碼
2.使程序變的可擴展
3.使程序變得易維護

語法定義：

1 def test():        #test為函數名
2     print("in the test..")
3 test()        # 用test函數
4 
5 def test_1(x,y): #帶參數的函數
6     print(x)
7     print(y)
8 
9 test_1(2,3)   #調用時必須傳入參數（實參）

二、參數

1、形參實參

形參：形式參數，不是實際存在，是虛擬變量。在定義函數和函數體的時候用形參，目的是在函數調用時接收實參（實參個數，類型應與實參一一對應），形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。因此，形參只在函數內部有效。函數調用結束返回主調用函數後則不能再使用該形參變量

實參：實際參數，調用函數時傳給函數的參數，可以是常量、變量、表達式、函數等，無論實參是何種類型的量，在進行函數調用時，它們都必須有確定的值，以便把這些值傳送給形參。因此應預先用賦值，輸入等辦法使參數獲得確定值

區別：形參是虛擬的，不占用內存空間，形參變量只有在被調用時才分配內存單元，實參是一個變量，占用內存空間，數據傳送單向，實參傳給形參，不能形參傳給實參

1 def test_1(x,y): #x,y為形參
2     print(x)
3     print(y)
4 test_1(2,3)   #調2,3為實參

2、位置參數調用與關鍵字調用

 1 #位置參數和關鍵字（標準調用：實參和形參一一對應，關鍵字調用：位置無需固定）
 2 
 3 def test_1(x,y):
 4     print(x)
 5     print(y)
 6 test_1(2,3)   #這種調用為位置參數調用，形參和實參必須一一對應
 7 
 8 def test_1(x,y):
 9     print(x)
10     print
 
(y)
11 test_1(y=3,x=2)   #這種調用為關鍵字調用，位置無需固定
12 
13 def test_1(x,y,z):
14     print(x)
15     print(y)
16     print(z)
17 test_1(2,z=4,y=3)   #既有位置參數調用，又有關鍵字調用時，位置調用參數必須寫在關鍵字調用參數之前

3、默認參數，可變參數

 1 #默認參數
 2 def test_1(x,y=3):  #y為默認參數
 3     print(x)
 4     print(y)
 5 test_1(2)         #調用時可以不賦值，如果不賦值則y=3 結果為：2,3
 6 test_1(2,4)       #調用時如果賦值，則y=4（調用時賦的值） 結果為：2,4
 7 #默認參數特點：調用函數的時候，默認參數非必須傳值
 8 
 9 #可變參數（參數組）
10 def test_2(*args):     #可以接收多個值
11     print(args)
12 test_2(1,2,3,4,5,6)    #直接傳遞參數，結果以元組的形式輸出：(1, 2, 3, 4, 5, 6)
13 test_2(*[1,2,3,4,5,6])  #或者在list或tuple前面加一個*號，把list或tuple的元素變成可變參數傳進去,結果同上
14 
15 def test_3(x,*args):
16     print(x,args)
17 test_3(1,2,3,4,5,6)   #輸出：1 (2, 3, 4, 5, 6)
18 
19 def test_2(**kwargs):     #可以接收多個關鍵字參數
20     print(kwargs)
21 test_2(name="zz",age="2")  #將關鍵字參數轉換成字典的形式：{‘age‘: ‘2‘, ‘name‘: ‘zz‘}
22 test_2(**{‘age‘: ‘2‘, ‘name‘: ‘zz‘})   #同上

三、其他特性

1、作用域：局部與全局變量

在子程序中定義的變量稱為局部變量，在程序的一開始定義的變量稱為全局變量。
全局變量作用域是整個程序，局部變量作用域是定義該變量的子程序。
當全局變量與局部變量同名時：在定義局部變量的子程序內，局部變量起作用；在其它地方全局變量起作用。

1 name = "aaa"
2 def change_name(name):
3     print("before change:",name)       #aaa
4     name = "zzz"
5     print("after change", name)        #zzz
6 change_name(name)
7 print("在外面的name",name)             #aaa

2、返回值

返回值的目的是要想獲取函數的執行結果，函數在執行過程中只要遇到return語句，就會停止執行並返回結果，return 語句代表著函數的結束；如果未在函數中指定return,那這個函數的返回值為None

3、匿名函數

匿名函數就是不需要顯式的指定函數，只能處理比較簡單的運算例如：三元運算，不能處理判斷循環等復雜運算。匿名函數主要是和其它函數搭配使用

1 #常規函數定義
2 def calc(n):
3     return n**n
4 print(calc(10))
5 
6 #換成匿名函數
7 calc = lambda n:n**n
8 print(calc(10))

4、遞歸

在函數內部，可以調用其他函數。如果一個函數在內部調用自身本身，這個函數就是遞歸函數。

遞歸特性:
1. 必須有一個明確的結束條件
2. 每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減少
3. 遞歸效率不高，遞歸層次過多會導致棧溢出（遞歸上限999次）

 1 def num(n):
 2     print(n)
 3     if int(n/4) ==0:
 4         return n
 5     return num(int(n/4))
 6 num(20)
 7 ‘‘‘輸出：
 8 20
 9 5
10 1
11 ‘‘‘

四、內置函數

  1 #abs() 返回數字的絕對值
  2 print(abs(-32))  #輸出：32
  3 
  4 #all() 如果可叠代對象中所有元素都為真則返回真
  5 print(all([1,-1,2]))    #輸出：True(非0即真)
  6 print(all([0,-1,2]))    #輸出：False
  7 
  8 #any()  如果可叠代對象中任意元素為真則返回真
  9 print(any([0,-1,2]))    #輸出：True
 10 print(any([]))           #輸出：False
 11 
 12 #ascii() 把一個內存對象變成一個可打印的字符串
 13 print([ascii([1,-1,2])])   #輸出：[‘[1, -1, 2]‘]
 14 
 15 #bin() 十進制數字轉二進制
 16 print(bin(12))   #輸出：0b1100
 17 
 18 #bool  判斷真假
 19 print(bool("asd"))    #輸出：True(非0即真)
 20 print(bool([]))       #輸出：False
 21 
 22 #bytearray  可修改的二進制字節格式(沒啥用)
 23 b = bytearray("abcd",encoding="utf-8")
 24 print(b[1])   #輸出：98   (ascii碼的值)
 25 b[1] = 99     #必須是ascii碼的值
 26 print(b)      #輸出:bytearray(b‘accd‘)
 27 
 28 #bytes() 返回值為一個新的不可修改字節數組
 29 b = bytes("abcd",encoding="utf-8")
 30 print(b)        #輸出：b‘abcd‘
 31 
 32 #callable()  判斷是否可以調用
 33 print(callable([1,2]))   #輸出：False 列表不可調用，函數可調用
 34 
 35 #chr()  返回數字對應的ascii碼表中對應字母
 36 print(chr(100))      #輸出：d
 37 
 38 #ord()   返回字母對應的ascii碼表中的數字
 39 print(ord("d"))     #輸出：100
 40 
 41 #classmethod()  #類方法，修飾符對應的函數不需要實例化，不需要 self 參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，類的方法，實例化對象等
 42 class A(object):
 43     bar = 1
 44     def func1(self):
 45         print (‘foo‘)
 46     @classmethod
 47     def func2(cls):
 48         print (‘func2‘)
 49         print (cls.bar)
 50         cls().func1()   # 調用 foo 方法
 51 A.func2()               # 不需要實例化
 52 """輸出：
 53 func2
 54 1
 55 foo
 56 """
 57 
 58 #compile() #底層的，用於把代碼進行編譯（用不到）
 59 
 60 #complex() 函數用於創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數
 61 print(complex(1, 2))    #輸出：(1+2j)
 62 # 註意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯
 63 print(complex("1+2j"))  #輸出：(1+2j)
 64 
 65 #delattr() 函數用於刪除屬性（面向對象：delattr()、getattr()、hasattr()、setattr()）
 66 class Coordinate:
 67     x = 10
 68     y = -5
 69     z = 0
 70 point1 = Coordinate()
 71 print(‘x = ‘,point1.x)
 72 print(‘y = ‘,point1.y)
 73 print(‘z = ‘,point1.z)
 74 delattr(Coordinate, ‘z‘)
 75 print(‘--刪除 z 屬性後--‘)
 76 print(‘x = ‘,point1.x)
 77 print(‘y = ‘,point1.y)
 78 # 觸發錯誤
 79 # print(‘z = ‘,point1.z)  #AttributeError: ‘Coordinate‘ object has no attribute ‘z‘
 80 
 81 #dir() 函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。
 82 print(dir()) #輸出：[‘A‘, ‘Coordinate‘, ‘__builtins__‘, ‘__cached__‘, ‘__doc__‘, ‘__file__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘b‘, ‘point1‘]
 83 
 84 # divmod() 函數把除數和余數運算結果結合起來，返回一個包含商和余數的元組(a // b, a % b)。
 85 print(divmod(7, 2))  #輸出：(3, 1)
 86 
 87 #enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環當中。
 88 seasons = [‘Spring‘, ‘Summer‘, ‘Fall‘, ‘Winter‘]
 89 print(list(enumerate(seasons)))  #輸出：[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fall‘), (3, ‘Winter‘)]
 90 print(list(enumerate(seasons, start=1)) )      # 下標從 1 開始[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fall‘), (4, ‘Winter‘)]
 91 for i, element in enumerate(seasons):
 92     print (i, seasons[i])
 93 ‘‘‘0 Spring
 94 1 Summer
 95 2 Fall
 96 3 Winter
 97 ‘‘‘
 98 
 99 #eval() 執行一個字符串表達式，並返回表達式的值。
100 print(eval( ‘3 * 2‘ ))  #輸出：6
101 
102 #exec()  執行一個文件
103 # exec(hello.py)
104 
105 #filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。該接收兩個參數，第一個為函數，第二個為序列，序列的每個元素作為參數傳遞給函數進行判，然後返回 True 或 False，最後將返回 True 的元素放到新列表中。
106 #過濾出1~100中平方根是整數的數：
107 import math
108 def is_sqr(x):
109     return math.sqrt(x) % 1 == 0
110 newlist = filter(is_sqr, range(1, 101))
111 for i in newlist:
112     print(i)   #在py2中為列表，3中為叠代器需要循環打印
113 
114 filter(lambda n:n>5,range(10))  #也可以用匿名函數
115 
116 #float() 將整數和字符串轉換成浮點數
117 print(float("123"))  #輸出：123.0
118 print(float(123))
119 
120 #format()  格式化輸出
121 
122 #frozenset() 返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素。
123 print(frozenset(range(10))) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
124 
125 #getattr() 函數用於返回一個對象屬性值。(面向對象)
126 
127 #globals() 以字典類型返回當前位置的全部全局變量。
128 print(globals())
129 
130 #hasattr() 用於判斷對象是否包含對應的屬性。(面向對象)
131 
132 #hash() 用於獲取取一個對象（字符串或者數值等）的哈希值。
133 print(hash("asdf"))  #輸出：5704709918237842944
134 
135 #help() 用於查看函數或模塊用途的詳細說明。
136 help(‘sys‘)
137 help(‘str‘)
138 a = [1,2,3]
139 help(a)
140 help(a.append)
141 
142 #hex() 函數用於將10進制整數轉換成16進制，以字符串形式表示
143 print(hex(100))  #輸出：0x64
144 
145 #id() 函數用於獲取對象的內存地址。
146 a = "a"
147 print(id(a))  #輸出：3231243404264
148 
149 #input() 函數接受一個標準輸入數據，返回為 string 類型
150 #int() 函數用於將一個字符串或數字轉換為整型。
151 #isinstance() 函數來判斷一個對象是否是一個已知的類型，類似 type()。
152 a = 2
153 print(isinstance (a,int))      #  True
154 print(isinstance (a,str))      #  False
155 print(isinstance (a,(str,int,list)))    # 是元組中的一個返回 True
156 
157 ‘‘‘isinstance() 與 type() 區別：
158 type() 不會認為子類是一種父類類型，不考慮繼承關系。
159 isinstance() 會認為子類是一種父類類型，考慮繼承關系。
160 如果要判斷兩個類型是否相同推薦使用 isinstance()。
161 ‘‘‘
162 class A:
163     pass
164 class B(A):
165     pass
166 print(isinstance(A(), A))    #  True
167 print(type(A()) == A  )      #  True
168 print(isinstance(B(), A) )   #  True
169 print(type(B()) == A )       #  False
170 
171 #issubclass() 方法用於判斷參數 class 是否是類型參數 classinfo 的子類。(面向對象)
172 #iter() 用來生成叠代器
173 lst = [1, 2, 3]
174 for i in iter(lst):
175     print(i)
176 
177 #len() 方法返回對象（字符、列表、元組等）長度或項目個數
178 str = "runoob"
179 print(len(str) )            # 字符串長度:6
180 l = [1,2,3,4,5]
181 print(len(l)  )             # 列表元素個數:5
182 
183 #locals() 函數會以字典類型返回當前位置的全部局部變量。(參考globals)
184 print(locals())
185 
186 #map() 會根據提供的函數對指定序列做映射。
187 #第一個參數 function 以參數序列中的每一個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。
188 def square(x) :            # 計算平方數
189     return x ** 2
190 map(square, [1,2,3,4,5])   # 計算列表各個元素的平方：[1, 4, 9, 16, 25]
191 map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函數：[1, 4, 9, 16, 25]
192 # 提供了兩個列表，對相同位置的列表數據進行相加
193 map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])  #[3, 7, 11, 15, 19]
194 #py3中結果為叠代器需循環打印
195 
196 #max() 方法返回給定參數的最大值，參數可以為序列。
197 print(max(1,3,4,2,0))   #輸出：4
198 #min() 方法返回給定參數的最小值，參數可以為序列。
199 print(min(1,3,4,2,0))   #輸出：0
200 
201 #memoryview() 函數返回給定參數的內存查看對象(Momory view)。所謂內存查看對象，是指對支持緩沖區協議的數據進行包裝，在不需要復制對象基礎上允許Python代碼訪問。
202 #next() 返回叠代器的下一個項目。
203 #object() 定義對象
204 #oct() 函數將一個整數轉換成8進制字符串。
205 print(oct(100))   #輸出：0o144
206 
207 #open() 文件操作
208 #pow() 方法返回 xy（x的y次方） 的值
209 print(pow(3,4))   #輸出：81
210 
211 #print() 方法用於打印輸出，最常見的一個函數。
212 #property() 函數的作用是在新式類中返回屬性值。（面向對象）
213 #range() 函數可創建一個整數列表，一般用在 for 循環中
214 #repr() 函數將對象轉化為供解釋器讀取的形式
215 #reverse() 函數用於反向列表中元素(列表操作中的一樣)
216 aList = [123, ‘xyz‘, ‘zara‘, ‘abc‘, ‘xyz‘]
217 aList.reverse()
218 print("List : ", aList) #輸出：List :  [‘xyz‘, ‘abc‘, ‘zara‘, ‘xyz‘, 123]
219 
220 #round() 方法返回浮點數x的四舍五入值。
221 print(round(1.234,2))  #輸出：1.23
222 
223 #set() 函數創建一個無序不重復元素集（參考創建集合）
224 #setattr 函數對應函數 getatt()，用於設置屬性值，該屬性必須存在。（面向對象）
225 #slice() 函數實現切片對象，主要用在切片操作函數裏的參數傳遞。
226 #sorted() 函數對所有可叠代的對象進行排序操作。
227 ‘‘‘
228 sort 與 sorted 區別：
229 sort 是應用在 list 上的方法，sorted 可以對所有可叠代的對象進行排序操作。
230 list 的 sort 方法返回的是對已經存在的列表進行操作，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。
231 ‘‘‘
232 a = [5,7,6,3,4,1,2]
233 b = sorted(a)       # 保留原列表
234 print(a)            #[5, 7, 6, 3, 4, 1, 2]
235 print(b)            #[1, 2, 3, 4, 5, 6, 7]
236 
237 L=[(‘b‘,2),(‘a‘,1),(‘c‘,3),(‘d‘,4)]
238 print(sorted(L, key=lambda x:x[1]) )              #  [(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
239 
240 students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
241 sorted(students, key=lambda s: s[2])            # 按年齡排序[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
242 sorted(students, key=lambda s: s[2], reverse=True)      # 按降序[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
243 
244 #staticmethod 返回函數的靜態方法(面向對象)
245 #str() 函數將對象轉化為適於人閱讀的形式
246 #sum() 列表求和計算
247 #super() 函數是用於調用父類(超類)的一個方法（面向對象）
248 #tuple() 將列表轉換為元組
249 #type()  所有數據類型的根源
250 #vars() 返回對象object的屬性和屬性值的字典對象
251 #zip() 函數用於將可叠代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。
252 # 如果各個叠代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。
253 a = [1,2,3]
254 b = [4,5,6]
255 c = [4,5,6,7,8]
256 zipped = zip(a,b)     # 打包為元組的列表[(1, 4), (2, 5), (3, 6)]
257 zip(a,c)              # 元素個數與最短的列表一致[(1, 4), (2, 5), (3, 6)]
258 zip(*zipped)          # 與 zip 相反，可理解為解壓，返回二維矩陣式[(1, 2, 3), (4, 5, 6)]
259 #py3中為叠代器，需循環打印
260 
261 #__import__() 函數用於動態加載類和函數 。
262 # 如果一個模塊經常變化就可以使用 __import__() 來動態載入。

python基礎05