Python学习（六）—— 函数、全局变量与局部变量

函数

函数的定义

def test(x):
    "The function definition"
    x += 1
    return x

def：定义函数的关键字

test：函数名

（）：内可定义形参

“”：文档描述，非必要，但添加后可使得函数更易理解

x += 1：泛指代码块或程序处理逻辑，最好不要过多，让函数的功能简洁明了

return ：定义返回值

调用运行：可以带参数也可以不带

函数名（）

def test(x):
    "The function definition"
    x += 1
    return x
y = test(5)
print(y)
# 6
def test1():
    "The function definition"
    x = 5
    y = x * 2 + 1
    return y
y = test1()
print(y)
#11

注意：函数名一旦重名，后写的函数会覆盖先写的函数，因为Python是从上到下读取的。

使用函数的意义 

实现特定的功能，避免重复代码

1、代码重用

2、保持一致性，易于维护

3、可扩展性

函数与过程 

过程本质是函数，但是没有设定返回值，而在Python中，会自动为过程返回None

def test01():
    x = "I like Python"
    print(x)
    return x
t1 = test01()
print(t1)
"""
I like Python
I like Python
"""
def test02():
    x = "I like Python"
    print(x)
t2 = test02()
"""
I like Python
None
"""

返回值数：0 => None

返回值数：1 => 返回object

返回值数：>1 =>返回tuple

函数参数

形参：只有在被调用时才分配内存单元，在调用结束后，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

实参：可以是常量、变量、表达式、函数等，无论是何种类型，在进行函数调用时，它们都必须有明确的值，以便将这些值传给形参。因此，应预先用赋值、输入等方法使参数获得确定值。 

位置参数和关键字：标准调用：实参和形参位置意义对应；关键字调用：位置无需固定

def test(x,y,z): #x,y,z是形参
    h = x + y ** z
    return h
t1 = test(1,2,3) #1,2,3是实参，属于位置参数
print(t1)
t2 = test(x = 2, y =2, z = 2) #属于关键字调用
print(t2)
"""
9
6
"""

注意：二者混用时，位置参数一定要在关键字参数的 左边

默认参数

def test(x,type="None"): #type是默认参数
    print(x)
    print(type)

test(5)
test(5,type="Class")
"""
5
None
5
Class
"""

参数组

**字典 *列表

def test(x,*args): 
    print(x)
    print(args)
    print(args[0])
test(1,2,3,5)
"""
1
(2, 3, 5)
2
"""

def test(x,*args,**kwargs):
    print(x)
    print(args)
    print(kwargs)
test(1,2,3,5,7,9,y=9)
"""
1
(2, 3, 5, 7, 9)
{'y': 9}
"""

 全局变量与局部变量

定头写的是全局变量，在整个py文件中都可以调用

局部变量是子程序中定义的变量，只能在子程序中调用

name = "Sister" #全局变量
def test():
    name = "Jenny" #局部变量
    print("change_name:",name)
test()
#change_name: Jenny

强制修改成全部变量的方法： 用global

name = "Sister"
def test():
    global name #将其定义为全局变量
    name = "Jenny"
    print("change_name:",name)
test()
print(name)
"""
change_name: Jenny
Jenny
"""

注意：

1、如果函数内无global关键字，优先读取局部变量，能读取全局变量，无法对全局变量重新赋值，但对于可变类型，可以对内部元素进行操作

name = "Sister"
def test():
    name = "Jenny"
    print("I love ", name)
test()
print(name)
"""
I love  Jenny
Sister
"""
name1 = ["Allen", "Paul"]
def test1():
    name1.append("Jenny")
    print("I love ", name1)
test1()
print(name1)
"""
I love  ['Allen', 'Paul', 'Jenny']
['Allen', 'Paul', 'Jenny']
"""

2、如果函数中有global关键字，变量本质上就是全局的特定变量，可读取可赋值

3、全局变量名全用大写，局部变量名全用小写

函数的嵌套 

def huangwei():  #执行顺序： 1→14→2、3→4→12→5、6→7→10→11→8、9→13
    name = "黄伟"
    print(name)
    def liuyang():
        name = "刘洋"
        print(name)
        def nulige():
            name = '沪指花'
            print(name)
        print(name)
        nulige()
    liuyang()
    print(name) #只调用这个子函数内部的变量
huangwei()
"""
黄伟
刘洋
刘洋
沪指花
黄伟
"""

注意：可以用nonlocal直接指定上一级变量

前向引用 ：函数即变量

def top():
    print("from top to bottom")
def bottom():
    print("from bottom to top")
    top()
bottom()
"""
from bottom to top
from top to bottom
"""
def bottom():
    print("from bottom to top")
    top()
def top():
    print("from top to bottom")
bottom()
"""
from bottom to top
from top to bottom
"""

递归

def calc(n):
    print(n)
    calc(n)
calc(10)
#Wrong

import time
def calc(n):
    print(n)
    time.sleep(1)
    calc(n)
calc(10)
#结果会不停输出10

递归的特性：

1、必须有一个明确的结束条件

满足某个条件 return

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n
    res = calc(int(n / 2))
    return res
res = calc(10)
print(res)
"""
10
5
2
1
1
"""

2、递归的效率不高，递归层次过多会导致栈溢出。

作用域

def test01():                                                   
    print("test")                                               
def test02():                                                   
    print("test2")                                              
    return 1                                                    
res = test02()                                                  
print(res)                                                      
  # test2                                                       
  # 1                                                           
def test1():                                                    
    print("test1")                                              
def test2():                                                    
    print("test2")                                              
    return test1                                                
res = test2()                                                   
print(res)                                                      
 # test2                                                        
 # <function test1 at 0x00000213CED9A510>   这是test              
def test1():                                                    
    print("test1")                                              
def test2():                                                    
    print("test2")                                              
    return test1                                                
res = test2()                                                   
print(res())                                                    
 # test2                                                        
 # test1           这是test1()的执行过程                               
 # None            这是因为没有return值所以添加的默认值                        

函数运行的结果与其定义有关，与其在哪里调用无关

def name1():                                                    
    name = "1"                                                  
    def name2():                                                
        name = "2"                                              
        def name3():                                            
            print(name)                                         
        return name3                                            
    return name2                                                
z = name1()                                                     
print(z)                                                        
#<function name1.<locals>.name2 at 0x000001E8FFAFA488>          
name2 = name1()                                                 
name3 = name2()                                                 
name3()                                                         
#2                                                              
name1()()()                                                     
# 2