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)
 #
 def test1():
     "The function definition"
     x = 5
     y = x * 2 + 1
     return y
 y = test1()
 print(y)
 #

注意：函数名一旦重名，后写的函数会覆盖先写的函数，因为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 = ""
     def name2():
         name = ""
         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