函數的一些簡單筆記

函數

數學定義：y=f(x),y是x的函數，x是自變量

Python函數：
    1、有若干個語句組成的語句塊、函數名稱、參數列表構成，它是組織代碼的最小單元
    2、完成一定的功能
    
函數的作用：
    1、結構化編程對代碼的基本的封裝，一般按照功能組織一段代碼
    2、封裝的目的為了復用，減少冗余代碼
    3、代碼更加簡潔美觀、可讀易懂

函數的分類：
    1、內建函數，如max()、reversed()等
    2、庫函數，如math.ceil()等

函數定義、調用

def語句定義函數：
    def 函數名(參數列表)：
        函數體(代碼塊)
        [return 返回值]
        
    1、函數名就是標識符，命名要求一樣
    2、語句塊必須縮進，約定4個空格
    3、Python的函數沒有return語句，隱式會返回一個None值
    4、定義中的參數列表成為形式函數，只是一種符號表達，簡稱形參

調用：
    1、函數定義，只是聲明了一個函數，它不會被執行，需要調用
    2、調用的方式，就是函數名加上小括號，括號內寫上參數
    3、調用時寫的參數是實際參數，是實實在在傳入的值，簡稱實參

函數舉例
    def add(x,y):
        result = x+y
        return result
    out = add(4,5)
    print(out)
    
    1、上面只是一個函數的定義，有一個函數叫做add，接收2個參數
    2、計算的結果，通過返回值返回
    3、調用通過函數名add加2個參數，返回值可使用變量接收
    4、定義需要在調用前，也就是說調用時，已經被定義過了，否則拋NameError異常
    5、函數是可調用對象，callable()

函數參數：
    參數調用時傳入的參數要和定義的個數相匹配(可變參數例外)
    
    位置參數：
        1、def f(x,y,z)調用使用f(1,3,5)
        2、按照參數定義順序傳入實參
        
    關鍵字參數：
        1、def f(x,y,z)調用使用f(x=1,y=3,z=5)
        2、使用形參的名字來傳入實參的方式，如果使用了形參名字，那么傳參順序就可和定義順序不同
        
        f(z=None,y=10,x=[1])
        f((1),z=6,y=4.1)
        備注：要求位置參數必須在關鍵字參數之前傳入，位置參數是按位置對應的
    
    參數默認值：
        1、定義時，在形參后跟上一個值
        2、def add(x=4,y=5):
               return x+y
        add(6,10),add(5,y=9),add(x=3),add(),add(y=8),add(x=1,y=2),add(y=2,x=100)
        
        舉例：
            定義一個函數login，參數名稱為host、port、username、password
            def login(host='127.0.0.1',port='80',username='eric',password='123456'):
                print('{}:{}@{}/{}'.format(host,port,username,password))
            login()
            login('127.0.0.1',80,'eric','123456')
            
            login('localhost',username='root')
            
            login('localhost',port=3306,password='123456')
            
            login(port=80,password='123456',host='172.16.15.100')
            
    可變參數：
        累加求和的問題
        def add(nums):
            sum = 0
            for x in nums:
                sum += x
            return sum
        add([1,3,5])
        add((2,4,6))
        傳入一個可迭代對象，迭代元素求和
        
        一個形參可以匹配任意個參數
        
    位置參數的可變參數：
        有多個數，需要累加求和
        def add(*nums):
            sum = 0
            print(type(nums))
            for x in nums:
                sum += x
            print(sum)
        In [68]: add(3,6,9)
        <class 'tuple'>
        18 
    在形參前使用*表示該形參是可變參數，可以接收多個實參

函數的返回值

舉例：
def showplus(x):
    print(x)
    return x+1
showplus(5)
執行結果為：5

def showplus(x):
	if x > 3:
			return ">3"
	else:
			return "<=3"
print(showplus(5))
返回：>3


例子：
def showplus(x):
	if x > 3:
			return x
	else:
			print("{} is not greater than 3".format(x))
print(showplus(2))
返回：
2 is not greater than 3
None


def showplus(x):
	if x > 3:
			return x
	else:
			print("{} is not greater than 3".format(x))
print(showplus(5))
返回值為：5

總結：
    1、Python函數使用return語句返回“返回值”
    2、所有函數都有返回值，如果沒有return語句，隱式調用return None
    3、return語句并不一定是函數的語句塊的最后一條語句
    4、一個函數可以存在多個return語句，但是只有一條可以被執行。如果沒有一條return語句被執行到，隱式調用return None
    5、如果有必要，可以顯示調用return None，可以簡寫為return
    6、如果函數執行了return語句，函數就會返回，當前被執行的return語句之后的其它語句就不會被執行了
    7、作用：結束函數調用、返回值

返回多個值：

def showplus():
	return [1,3,5]
showplus()
print(showplus())
打印出：[1,3,5]

def showplus():
	return 1,3,5
showplus()
print(showplus())
打印出：(1, 3, 5)

1、函數不能同時返回多個值
2、return[1,3,5]是指明返回一個列表，是一個列表對象
3、return 1,3,5看似返回多個值，隱式的被Python封裝成了一個元組

使用解構提取出來，將更加方便和明白
def showplus():
	return 1,3,5
x,y,z = showplus()
print(x,y,z)
打印結果為：1 3 5

函數嵌套

在一個函數中定義了另外一個函數
def fn():
	def add():
			print("add")
	print("fn")
	add()
fn()
打印結果為：
    fn
    add

def fn():
	def add():
			print("add")
	print("fn")
	add()
fn()
add()#這個是會報錯的，因為函數有可見范圍，也就是作用域，內部的函數不能被外部直接使用，會拋出NameError異常

作用域

1、一個標識符的可見范圍，這就是標識符的作用域。一般常說的是變量的作用域

x = 6
def fn():
	print(x)
fn()
返回值打印結果為：6

x = 6
def fn():
	#x = 3
	x += 1
	print(x)
fn()
注：如果把x=3注釋掉，就會報語法錯誤
原因：x += 1其實就是x = x + 1，相當于在fn內部定義一個局部變量x，那么fn內部所有x都是這個局部變量x了，但是這個x還沒有完成賦值，就被拿來做加1操作了

全局作用域：
    在整個程序運行環境中都可見

局部作用域：
    1、在函數、類等內部可見
    2、局部變量使用范圍不能超過其所在的局部作用域

嵌套解構

def fn():
	o =65
	def add():
			print("add{}".format(o))
			print(chr(o))
	print("fn{}".format(o))
	add()
fn
打印結果：
    fn65
    add65
    A

def fn():
	o =65
	def add():
			o = 97
			print("add{}".format(o))
			print(chr(o))
	print("fn{}".format(o))
	add()
fn()
打印結果為：
    fn65
    add97
    a
從以上嵌套的例子可以看出：
    1、外層變量作用域在內層作用域可見
    2、內層作用域中add，如果定義了o=97，相當于當前作用域中重新定義了一個新變量o，但是這個o并沒有覆蓋外層作用域fn中的o
    
    
例子：
    x = 6
    def fn():
	    #x = 4
	    y = x + 1
	    #x += 1
	    print(x)
    fn()
    注：如果把x += 1前面的#號取消掉，同樣還是報錯，是因為x還沒有完成賦值，就被拿來做加1操作了
    
全局變量global:
    x = 6
    def fn():
	    global x
	    x += 1
    fn()
    print(x)
    返回值：7
    
原因：使用global關鍵字的變量，將fn內的x聲明為使用外部的全局作用域中定義的x；全局作用域中必須有x的定義

#x = 6
def fn():
	global x
	x = 10
	x += 1
	print(x)
fn()
print(x)
返回結果為：
    11
    11
原因：使用global關鍵字的變量，將fn內的聲明為使用外部的全局作用域中定義的x；但是，x=10賦值即定義，x在內部作用域為一個外部作用域的變量賦值，所以x+=1不會報錯，但是需要注意的是，這里的x作用域還是全局的。

global總結

x += 1這種是特殊形式產生的錯誤，先引用，后賦值，而python動態語言是賦值才算定義，才能被引用。在語句之前加上x=0之類賦值語句，或者使用global告訴內部作用域，去全局作用域查找變量定義。

內部作用域使用x=5之類的賦值語句會重新定義局部作用域使用的變量x，但是，一旦這個作用域中使用global聲明x為全局的，那么x=5相當于在為全局作用域的變量x賦值。

global使用原則：
    1、外部作用域變量在內部最用于可見，但也不要在這個內部的局部作用域中直接使用，因為函數的目的就是為了封裝，盡量與外界隔離。
    2、如果函數需要使用外部全局變量，請使用函數的形參傳參解決
    3、一句話：不用global。學習知識為了深刻理解變量作用域