函数的作用

• 功能性
• 隐藏细节：无论函数内部写得如何复杂，你只需要传两个参数，他返回你结果
• 避免编写重复代码

认识函数

• 查看內置函數功能和作用，使用help，比如：help(print)

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

函数的定义及运行特点

函数基本结构

• def 定义函数
• 參數可以沒有
• return value none （可以返回调用结果return或yield，也可以不返回默认return None）

def funcname(parameter_list):
    """  Docstring 文档字符串说明函数的作用  """
    函数体
    return 

def 是可执行语句，这意味着函数直到被调用前，都是不存在的。当程序调用函数时，def语句才会创建一个新的函数对象，并赋予其名字。

Python不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，同样的一个函数，可以同时应用在整型/列表/字符串等的操作中。

在编程语言中，这种行为被称为多态。这也是Python和其他函数，比如java/C等很大的一个不同点。Python这种方便的特性，在在实际使用中也会带来诸多问题。因此，必要时需要在开头加上数据的类型检查。

调用函数

• python顺序，先定义再调用

def print(code):
    print(code)

print("code")

输出：
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

[上一行重复了 996 次以上]
递归错误：超过最大递归深度

无限递归

• 不用內置函數和变量，容易无限递归

def print_code(code):
    print(code)

print_code("code")

code

• sys.setrecursionlimit()方法用于将Python解释器堆栈的最大深度设置为所需的限制。此限制可防止任何程序进入无限递归，否则无限递归将导致C堆栈溢出并使Python崩溃。

imort sys
sys.setrecursionlimit(10)

def print(code):
    print(code)

print("code")

return

• return 后面的代码是不会执行的

def print_code(code):
    print(code)
    return
    print(code)
    print(code)
    print(code)
    
print_code("code")

code

• 别的语言会去指定返回值的类型，python不需要

int def print_code(code): 
				print(code) return

• 返回多个值，返回的值写法

def print_code(codea, codeb):
    codea = codea + 1
    codeb = codeb + 1
    return codea, codeb

print(type(print_code(1, 2)))

<class 'tuple'>

• 提取值的方式
• []索引
• 序列解包：有意义的变量名称来接收结果，容易知道是什么意思

code = print_code(1, 2)
print(code[0],code[1])

codea, codeb = print_code(1, 2)
print(codea, codeb)

2 3
2 3

序列解包与链式赋值

a = 1
b = 2
c = 3
print(a, b, c)

a, b, c = 1, 2, 3
print(a, b, c)

1 2 3
1 2 3

d = 1, 2, 3
print(d)
print(type(d))  # 序列

(1, 2, 3)
<class 'tuple'>

a, b, c = d
print(a, b, c)

1 2 3

# 链式赋值
a, b, c = 1, 1, 1
a = b = c = 1 
print(a, b, c)

1 1 1

参数相关

必选参数

def add(x, y):   #必须赋值 （形式参数）       
  return x + y       

     
add(1, 2)#实际参数  

3

默认参数

• 定义和调用，必选参数放前面，默认参数放后面
• 必选参数需按照顺序对应传参，关键字可以不按照顺序传参
• 可以不传参
• 意义：代码的可读性

def add(x, y=1):
    return x + y

print(add(x=2))

3

def student_info(name, school="xx中学", age="10"):
    print(name)
    print(school)
    print(age)
    
student_info(name="张三", school="xx中学",age="10")
print("----------------------------")
student_info(name="张三")

张三
xx中学
10
----------------------------
张三
xx中学
10

可变参数

def print(self, *args, sep=' ', end='\n', file=None): 
    pass

• 多个参数传参使用 [] () 集合方式进行传参,python会自己把多个实参转变为元组

def demo(param):
    print(param)
    print(type(param))
    
demo((1, 2, 3, 4))

(1, 2, 3, 4)
<class 'tuple'>

def demo(*param):
    print(param)
    print(type(param))
    
demo(1, 2, 3, 4)

(1, 2, 3, 4)
<class 'tuple'>

demo((1, 2, 3, 4))  # 二维元组

((1, 2, 3, 4),)
<class 'tuple'>

• 二维元组可以使用 * 把元素拿出来，传进可变参数里去

demo(*(5, 6, 7, 8))

(5, 6, 7, 8)
<class 'tuple'>

• 可以和必选参数，默认参数 一起使用

def demo(param1, param2=2, *param):
    print("param1 : ", param1)
    print("param2 : ", param2)
    print("param : ", param)


demo(1, 3, 4, 6)

param1 :  1
param2 :  3
param :  (4, 6)

def demo(param1, *param, param2=2):
    print("param1 : ", param1)
    print("param : ", param)
    print("param2 : ", param2)


demo(1, 2, 3, 4)

param1 :  1
param :  (2, 3, 4)
param2 :  2

demo(1, 2, 3, param2=4)

param1 :  1
param :  (2, 3)
param2 :  4

关键字参数

def city_temp(**param):
    for k, v in param.items():
        print(f"{k} : {v}")
        
 
city_temp(bj="12℃",sz="32℃")

bj : 12℃
sz : 32℃

c = {"北京": "12℃", "深圳": "32℃"}
city_temp(**c)

北京 : 12℃
深圳 : 32℃

作用域相关

变量作用域

• python没有块级作用域
  if else for while 循环代码块，是没办法形成一个块级作用域
  函数可以形成一个作用域，所以它可以引用

c = 10  # 全局变量 

def add(x, y):
    c = x + y  # 函数里面定义的叫做局部变量
    print("add_c : ", c)
    
    for i in range(1):  
        print("for_c : ", c)  # 看是相对谁的局部变量，是有相对性的
        for_x = 100
        
    print("for_x : ", for_x)  
    
add(1, 2)

print("c : ", c)

add_c :  3
for_c :  3
for_x :  100
c :  10

作用域链

c = 1
def fun1():
    # c = 2
    def fun2():
        # c = 3
        print(c)  # 优先使用局部变量  ，逐级寻找才叫作用域链，for不是，因为for都没有形成作用域
    fun2()
fun1()

1

global关键字

• 函数内部定义一个局部变量，但是在外部又想使用 机制 global
• 全部变量在整个程序都是使用的，可以使用impoert用于别的模块，不单是这个模块

嵌套函数

• Python函数的另一个特性，是Python支持函数的嵌套。所谓的函数嵌套，就是指函数里面有函数。

def f1():
    print("hello")
    def f2():
        print("world")
    f2()
    
# 调用f1
f1()

hello
world