一、函数简介

函数(function)：可以用来保存代码，在需要时，对这些代码进行重复的调用

总结函数的优点：

遇到重复功能的时候，直接调用即可，减少代码量
提升代码，项目的结构性，分工明确，提高代码可读性
遇到扩展功能时，修改比较方便

二、函数定义

定义函数

def 函数名(形参1,形参2....,形参n):
    代码块

函数的命名规则和变量的命名规则一样

由数字，字母，下划线组成
不能数字开头
不能用关键字

def fn():
    print("这是我的第一个函数")

三、函数调用

语法
  函数名()

函数必须遵守先定义再调用

def fn():  # 函数名 : fn
    print("这是我的第一个函数")
    print("hello")
    print("睡了吗")
fn()
fn()
fn()

fn是什么

函数对象=》表示存代码的位置=》内存地址本体

fn() 是什么

调用函数

print 是什么

函数对象

print() 是什么

调用函数

小练习

定义一个login函数功能是输入用户名和密码，验证是否正确

def login():
    username = input("请输入用户名：")
    password = input("请输入密码：")
    if username == 'root' and password == '123456':
        print("登录成功")
    else:
        print("用户名或密码错误，登录失败")
login()

四、函数的参数

1、形参和实参

定义一个函数，可以用来求任意两个数的和

# - 定义一个函数，可以用来求任意两个数的和
# def sum(a, b):
#     print(f"{a} + {b} = {a+b}")

函数的参数：在定义函数时，可以在函数名后()中定义数量不等的形参，多个形参之间使用 , 隔开

形参(形式参数):定义形参就相当于在函数内部声明了变量，但是变量没有值

实参(实际参数):在调用时候也必须传递实参，实参会赋值给对应位置的形参。

# 定义函数时指定形参
def fn(a, b):
    print("a =", a)
    print("b =", b)
# 调用户数时，来传递实参
fn(10, 20)
fn(666, 333)

总结：定义函数时的参数叫形参，调用的时候的参数叫实参
定义了多少个形参就必须传递多少个实参

2、默认值参数

# 定义形参的时候可以为形参指定默认值
def fn(a, b, c=10):
    print("a =", a)
    print("b =", b)
    print("c =", c)
fn(1, 2) # 如果不传递c，则采用默认值
fn(1, 2,3) # 如果传递了。优先使用用户传的实参

3、实参的传递方式

3.1位置参数

就是将对应位置的实参赋值给对应位置的形参

位置参数缺点：需要记忆形参的位置的意思

3.2关键字参数

关键字参数：可以不按照形参定义的顺序来传递，而是根据参数名来传递参数

def fn(a,b,c):
    print("a =", a)
    print("b =", b)
    print("c =", c)
fn(b=1,c=3,a=2) # 根据名字传参

位置参数和关键字参数可以混合使用

def fn(a, b, c):
    print("a =", a)
    print("b =", b)
    print("c =", c)
fn(1,2,c=20)

注意：可以混着，但是必须把位置参数写关键字参数前面

def fn(a, b, c):
    print("a =", a)
    print("b =", b)
    print("c =", c)
fn(c=20,1,2)

4、实参的类型

实参在传递的时候有没有类型的限制？

函数调用不会限制你的类型，实参可以传递任意类型

实参是可以任意一个数据类型，什么都行，啥都行

5、可变参数

5.1 args

形参的前面加一个 * 号的参数就是可变参数，可以接收任意的位置参数，并且将所有的实参装到一个元组当中。

def f(*a):
    print("a =", a)
    print(type(a))
f(10,20,30,40,50,60,70,80,90,100)
def new_sum(*a):  # *a 可以接收一切位置参数，并装包成一个元组
    print(sum(a))  # a就是元组
new_sum(1, 2, 3, 4, 5)

无论传入几个参数，都会统一保存到一个元组当中，这个操作也可以称之为装包

1.带 * 号的形参只能有一个，因为你写多了就没法分

2.带 * 号的形参可以和其他参数配合使用，但是得写在后面

def fn(*a, b, c):
    print("a =", a)
    print("b =", b)
    print("c =", c)
fn(1, 2, 3, 4, 5, 6,7,8,9,10,20,30,b=4,c=3)

注意，平时取带*参数的名字的时候一般是取args

5.2 kwargs

形参可以接收任意的关键字参数，会将这些参数统一保存到字典里，字典的键就是参数的名字，字典的值就是参数的值。

注意：形参也是只能一个，并且必须写在所有参数最后。
命名潜规则：kwargs

def fn(**kwargs):
    print("kwargs =",kwargs) 
    print(type(kwargs)) # 字典
fn(a=1,b=2,c=3)

6、参数解包

def fn(a, b, c, d):
    print("a =", a)
    print("b =", b)
    print("c =", c)
    print("d =", d)
t = [1, 2, 3 ,4]

fn(*t) # 传递实参时，可以在序列类型添加 * 号

def fn(a, b, c):
    print("a =", a)
    print("b =", b)
    print("c =", c)
t = (10,20,30)
d = {"b": 10, "a": 20, "c": 30}

fn(*t) # 传递实参时，可以在序列类型添加 * 号

fn(**d) # 传递实参时，可以在序列类型添加 * 号

五、函数返回值

返回值：函数执行以后返回一个结果

例如 f(x) = 2x + 1

f(2)的值是5

def f(x):
    return 2*x+1
print(f(2)) # 5

python 可以通过 return 来指定函数的返回值，return 后是什么函数返回值就是什么

f(2)两个意思

1.函数调用，会执行函数里面的代码

2.本体还表示函数的返回值

返回值可以是任意类型，包括函数

None 代表空值（N必须要大写）

注意None千万不可以理解为0

如果函数没有写reutrn，返回None，表示空值

总结：如果仅仅写一个reutrn 或者不写return ，等价于 return

None是python的特别的空值，用来代表空的

在函数中 return 代表函数执行结束，后面代码不会执行。

break：退出整个循环
return : 结束函数

def f(x):
    print(x) # print(6)
    return x + 1
    print(x + 1)
print(f(6)) # print(7)
def f(x):
    print(x) 
    return x+1
    return x+2
print(f(5))
def sum2(*args):
    result = 0
    for i in args:
        result += i
    return result
r = sum2(1, 2, 3, 4, 5)
print(r)

fn 和 fn()

print(fn) # 函数对象，打印fn就是打印函数对象地址 print(fn()) #

调用函数，打印fn()其实就是在打印fn里面的返回值

六、作用域

1、作用域简介

作用域直白来说就是产生作用的区域

程序中就是：指的是变量生效的区域

y = 2
def fn():
    x = 1
    print("函数内部y =", y)
fn()
print("函数外部y =", y)
print("函数外部x =", x)

在Python作用域一共有2种

1.全局作用域

2.函数作用域

2、全局作用域

全局作用域：全局都有效

全局作用域的生命周期：全局作用域在程序执行时创建了，在程序执行结束时候销毁

所有函数以外的都是全局作用域

在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问

y = 2  # 全局变量
def fn():
    print("函数内部y =", y)
fn()
print("函数外部y =", y)

3、函数作用域

函数作用域就是在函数内部

函数作用域生命周期：函数作用域在函数调用时创建，在调用结束时销毁

def fn():
    a = 10
    print("a =",a)
fn()
fn()
fn()
# 程序执行过程中创建了3次 函数作用域
函数中定义的变量，只能在函数内部访问
def fn():
    a = 10
    print("内部a =",a)
fn()
print("外部a =",a)

变量的使用规则：变量可以由内往外看，不能由外往里看

ef fn1():
    a = 30
    def fn2():
        print(a)
    fn2()
def fn1():
    def fn2():
        a = 10
    print(a) # 不能由内往里看
def fn1():
    a = 20
    def fn2():
        a = 10
        print(a)  
    fn2()
fn1() # 输出10

使用变量的时候，会优先在当前作用域中寻找该变量，如果找到就使用，没有则继续往上一级作用域寻找。如果全局作用域都没有，则报错

如果希望在函数中去修改全局变量

可以使用 global 关键字来声明变量

a = 1
def fn1():
    global a  # 声明在函数内部使用的a 是全局变量
    a = 2 # 修改了全局中的a
fn1()
print(a)

总结:

1.变量里面能看外面的，但是外面不能看里面的

2.如果局部修改全局变量可以加上一个global关键字

七、命名空间

1、介绍

命名空间是指变量存储的位置，每个变量都需要存储到指定的命名空间中。

2、分类：

1、局部命名空间(local)：函数或类的方法的命名空间，它记录了函数的变量，包括函数的参数和局部定义的变量。

2、闭包命名空间（enclosing function）：闭包函数的名称空间（Python 3 引入）。

3、全局命名空间(global)：每个模块自己的命名空间，它记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。

4、内置命名空间(builtin)：任何模块均可访问它，它存放着内置的函数和异常。

3、查找顺序

当一行代码要使用变量 x 的值时，Python 会到所有可用的名字空间去查找变量，按照如下顺序：

局部命名空间：

特指当前函数或类的方法。如果函数定义了一个局部变量 x，或一个参数 x，Python 将使用它，然后停止搜索。

全局命名空间：

特指当前的模块。如果模块定义了一个名为 x 的变量，函数或类，Python 将使用它然后停止搜索。

内置命名空间：

对每个模块都是全局的。作为最后的尝试，Python 将假设 x 是内置函数或变量。

如果 Python 在这些名字空间找不到 x，它将放弃查找并引发一个 NameError 异常，如，NameError: name ‘aa’ is not defined。

4、命名空间的生命周期

不同的命名空间在不同的时刻创建，有不同的生存期。

1、内置命名空间在 Python 解释器启动时创建，会一直保留，不被删除。

2、模块的全局命名空间在模块定义被读入时创建，通常模块命名空间也会一直保存到解释器退出。

3、当函数被调用时创建一个局部命名空间，当函数返回结果或抛出异常时，被删除。每一个递归调用的函数都拥有自己的命名空间。

Python 函数基础

目录