函式

- 程式碼的一種組織形式
- 一個函式一般完成一項特定的功能

函式使用

- 函式需要先定義
- 使用函式，俗稱呼叫

定義一個函式

- 只是定義的話不會執行
- def 函式名()
- 函式名自己定義，起名需要遵循命名規則，約定俗成，大駝峰只給類用
- 後面括號和冒號不能省，括號內可以有引數
- 函式內所有程式碼縮排
def func()
	print("hello python!")

函式的呼叫

- 定義函式時有引數，呼叫時也要有引數，定義時沒有引數，呼叫時也沒有，收集引數，預設引數除外
- 函式名後面跟括號 
func()

函式的引數和返回值

引數

- 負責給函式傳遞一些必要的資料或者資訊
- 引數分類：普通引數，預設引數，關鍵字引數，收集引數
	- 普通引數：定義的時候直接定義變數名，呼叫的時候直接把變數或者值放入指定位置
		def 函式名(引數1,引數2......)
			函式體
		#呼叫
		函式名(value1,value2......)
	
		#呼叫的時候，具體值參考的是位置，按位置賦值
		- 形參（形式引數）：在函式定義的時候用到的引數，沒有具體值，只是一個佔位符號，稱為形參（引數1，引數2......）形參定義
		- 實參（實際引數）：在呼叫的時候輸入的值（value1,value2......）實參呼叫
		def hello(person):
			print("(0)，你好".format(person))
		p = "girl"
		hello(p)  #girl,你好
		- 引數person只是一個符號，代表的是呼叫時候的某個資料
		- 呼叫的時候，會用p代替函式中所有的person
	- 預設引數
		- 形參具有預設值
		- 呼叫的時候如果沒有對應的形參賦值，則使用預設值
			def func_name(p1=v1,p2=v2......)
				func_block
			#呼叫1
			func_name()
			#呼叫2
			value1 = 100
			value2 = 200
			func_name(value1,value2)
		示例：
		#報名函式，需要知道學生性別
		#學習Python的學生基本都是男生，所以，報名的時候如果沒有特別指定，我們認為是男生
		def reg(name,age,gender="male"):
			if gender == "male":
				print("{0} is {1},he is a good student".format(name,age))
			else:
				print("{0} is {1},she is a good student".format(name,age))
		
		reg("xiaoming",21)
		reg("xiaohong",19,"female")  #xiaoming is 21,he is a good student
														xiaohong is 19,she is a good student
	- 關鍵字引數
		語法：
		def func(p1=v1,p2=v2......)
			func_body
		- 比較麻煩，但有好處：
			- 不容易混淆，一般實參和形參只是按照位置一一對應即可，容易出錯
			- 使用關鍵字引數，可以不考慮引數位置
			def stu_key(name,age,addr):
				print("{} is {},住在{}".format(name,age,addr))
			n = "xiaoming"
			a = 16
			addr = "china"
			stu_key(age=a,name=n,addr=addr)
			#xiaoming is 16,住在china
	- 收集引數
		- 把沒有位置，不能和定義時的引數位置相對應的引數，放入一個特定的資料結構中
		- 語法：
		def func(*args):
			func_body  #可以按照list使用方式訪問args得到傳入的引數
		#呼叫
		func(p1,p2......)
	- 引數名args不是必須這麼寫，但是推薦用args，約定俗成
	- 引數名args前需要星號，表示收集引數
	- 收集引數可以和其他函式並存
	- 示例：
	
	“”“”“”
	函式模擬一個學生進行自我介紹，但具體內容不清楚
	把args看做tuple
	“”“”“”
	def stu(*args):
		print("hello")
		for item in args:
			print(item)
	stu("xiaoming", 22, "heilongjiang")
	stu("xiaohong")
	stu()  #收集引數可以不帶任何實參呼叫，此時收集引數為空tuple
	  #hello
	  	xiaoming
	  	22
	  	heilongjiang
	  	hello
	  	xiaohong
	  	hello
	  	
- 如果使用關鍵字引數格式呼叫，會出問題
- 收集引數之關鍵字收集引數
	- 把關鍵字引數按字典格式存入收集引數
	- 語法：
	def func(**kwargs):
		func_body
	#呼叫
	func(p1=v1,p2=v2......)
	- 約定俗成用kwargs
	- 呼叫的時候，把多餘的關鍵字引數放入kwargs
	- 訪問kwargs需要按照字典格式訪問
	#案例1：
	def stu(**kwargs):
		print("hello")
		for k,v in kwargs.items():
    		print(k,"---",v)
	stu(name="xiaoming", age=22, addr="heilongjiang")
	stu()
	 #hello
	  	name---xiaoming
	  	age---22
	  	addr---heilongjiang
	  	hello
	 #案例2
	 def func(*args,**kwargs) :
	 	print(args)
	 	print(kwargs)
	 func(1,2,3,a=4,b=5,c=6)	
	 func(*(1,2,3),**{"a":4,"b":5,"c":6})
	 #(1, 2, 3)
		{'a': 4, 'b': 5, 'c': 6}
		(1, 2, 3)
		{'a': 4, 'b': 5, 'c': 6}
 

返回值

- 函式和過程的區別：有無返回值
- 函式的執行結果
- 使用return關鍵字，如果沒有return，預設返回一個none
- 函式執行後返回值
- 函式一旦執行return語句，則無條件返回，即結束函式的執行
- 推薦寫法：不論有沒有返回值，都以return結束
案例1：	
def hello(person):
	print("(0)，你好".format(person))
	return "end"
	print("hello")
p = "girl"
rst = hello(p)
print(rst)  #girl,你好
				  end
案例2：
def func1():
	print("func1")
a = func1()
print(a)
print("*"*10)
def func2():
	print("func2")
	return "ok"
b = func2()
print(b)  #func1
				None
			  **********
				func2
				ok		
 

Python內建函式

Python簡單內建函式

- 內建物件檢視：dir
- 常見函式：len(求長度),min(求最小值),max(求最大值),sorted(排序),reversed(反向),sum)(求和)
- 進位制轉換函式：bin(轉換為二進位制),oct(轉換為八進位制),hex(轉換為十六進位制),ord(字元轉ASCII碼),chr(ASCII碼轉字元)

dir

- dir():檢視當前模組的屬性列表
- dir([ ])檢視列表的方法，也可以檢視字典等基本型別。	
a = "sdfgfd"

常見函式

- 作用於字串，列表等
a = sdfgfd
- len(a)  #6
- sorted(a)  #['d', 'd', 'f', 'f', 'g', 's']
- reversed(a)  #<reversed at 0x7f254db0f080>
- list(reversed(a))  #['d', 'f', 'g', 'f', 'd', 's']

Python高階內建函式

- enumerate,exec,map,eval,filter,zip

enumerate

- 根據可迭代物件建立列舉物件
seasons = ["spring","summer","fall","winter"]
list(enumerate(seasons)) 
#[(0,spring),(1,summer),(2,fall),(3,winter)]
list(enumerate(seasons,start=1))  #指定起始值
#[(1,spring),(2,summer),(3,fall),(4,winter)]

eval

- 取出字串中的內容
- 將字串str當成有效的表示式來求值並返回結果
- 計算指定表示式的值
x = 10
def func():
	y = 20  #區域性變數y
	a = eval("x+y")
	print("a:",a)  #x沒有就呼叫全域性變數
	b = eval("x+y",{"x":1,"y":2}) #定義區域性變數，優先呼叫
	print("b:",b)
	c = eval("x+y",{"x":1,"y":2},{"y":3,"z":4})
	print("c:",c)
	d = eval("print(x,y)")
	print("d:",d)  #對於變數d，因為print()函式不是一個計算表示式，因此沒有返回值
func()
#a:30
  b:3
  c:4
  10 20
  d:None	

exec

-exec可以執行復雜的Python程式碼，而不像eval函式那樣只能計算一個表示式的值，返回值永遠為none
x = 10
def func():
	y = 20  
	a = exec("x+y")
	print("a:",a)  
	b = exec("x+y",{"x":1,"y":2})  
	print("b:",b)
	c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4})
	print("c:",c)
	d = exec("print(x,y)")
	print("d:",d)  
func()
#a:None	
  b:None	
  c:None	
  10 20	#為exec("print(x,y)")的結果
  d:None	
示例2：
i = 2
j = 3
exec("ans=i+j")
print("answer is:",ans)  #answer is 5	

map

map會接收一個函式f和一個list，並通過把函式f依次作用在list的每個元素上，得到一個新的list並返回，會根據提供的函式對指定序列做對映
def square(x):
	return x ** 2 
list(map(square,[1,2,3,4,5]))   #計算列表各個元素的平方
#[1,4,9,16,25]
list(map(lambda x,y:x+y,[1,3,5,7]))  #使用lambda匿名函式
#[1,9,25,49]
lambda表示式，通常是在需要一個函式，但是不想去命名一個函式的場合下使用的
add = lambda x,y:x+y
lambda 引數： 表示式

filter

filter函式用於過濾序列，過濾掉不符合條件的元素，返回一個迭代物件，如果要轉換成列表，可以用list來轉換
list(filter(lambda x:x%2==0,range(1,10)))   #[2, 4, 6, 8]

zip

zip函式用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，然後返回由這些元素組成的物件，好處是節約記憶體，可以用list轉換輸出列表
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
list(zip(a,b))  #[(1,4),(2,5),(3,6)]  #把返回的物件轉換成列表
list(zip(a,c))  #[(1,4),(2,5),(3,6)]  #元素個數與最短的一致
zip(*)正好相反用於解壓
案例：
a = [1,2,3]
def stu(*args):
	print(args)
	for i in args:
    	print(i)
stu(*a)
#(1, 2, 3)
  1
  2
  3

函式文件

- 函式的文件的作用是對當前函式提供使用相關的參考資訊

文件的寫法

- 在函式內部開始的第一行使用三引號字串定義符
- 一般具有特定格式

文件檢視

- 使用help函式，形如help(func)
- 使用__doc__
def stu(age,name,*args):
	"""
	hello
	everyone
	"""
	print("這是文件")
help(stu)
print(stu.__doc__)
#  stu(age, name, *args)
    hello
    everyone
    hello
    everyone