day 9~11 函数

今日内容

'''
函数四个组成部分
函数名：保存的是函数的地址，是调用函数的依据
函数体：就是执行特定功能的代码块
函数返回值：代码块执行的结果反馈
函数参数：完成功能需要的条件信息
​
1、函数的概念
2、函数的定义
3、从函数的组成部分来详解介绍
重点：定义函数的思想
'''

函数

​
'''
函数：
>>> 重复利用的工具
>>> 可以完成特定功能的代码块，函数就是存放代码块的容器
'''
​

定义函数的语法

• 函数四部分

'''
1. 函数名：使用该函数的依据
2. 函数体：完成功能的代码块
3. 返回值：功能完成的反馈结果
4. 参数：完成功能需要的条件信息
'''
​

• 用def关键词来声明函数

def 函数名(参数们):
    函数体
    return '返回值'

如何使用函数

​
'''
函数名：拿到函数的地址
函数名(): 拿到函数的地址，并执行函数中存放的代码块(函数体)  *****
函数名(参数)：执行函数并传入参数
​
函数名(): 执行完毕后，会得到函数的返回值，返回值就跟普通变量一样，可以直接打印、使用、运算
'''
def fn(num):
    print("传入的num值：%s" % num)
    return '收到了'
​
res = fn(10)
​
# 控制台会打印：传入的num值：10
# res的值为：'收到了'
​
​
# 注：函数一定要先定义在调用
​

函数的分类

根据参数列表划分

• 无参函数：不需外界资源

def start():
    print('系统启动')
start()

• 有参函数：需要外键资源

def login(usr, pwd):
    if usr == 'owen' and pwd == '123':
        print('登录通过')
    else:
        print('登录失败')
        
 login('owen', '123')

根据返回值划分：return是用来结束函数的

• 空返回：返回None

def demo(x, y):
    print( x + y )
    
def demo(x, y):
    print( x + y )
    return  # 用来强行结束函数的（像break结束循环一样）

• 一值返回

def demo(x, y):
    return x + y

• 多值返回

def demo(x, y):
    return x + y, x - y, x * y, x / y # 本质就是返回装有多个值的元组

函数的嵌套调用

# 求两个数最大值
def max_2(n1, n2):
    if n1 > n2:
        return n1
    return n2
​
# 求三个
def max_3(n1, n2, n3):
    m2 = max_2(n1, n2)
    return max_2(m2, n3)
​
# 求四个
def max_4(n1, n2, n3, n4):
    m2 = max_2(n1, n2)
    return max_3(m2, n3, n4)
​
# 循环调用：在一个函数的内部调用另一个函数

​

形参与实参

'''
def fn(形参们):
    pass

fn(实参们)
'''
# 形参：定义函数，在括号内声明的变量名，用来接受外界传来的值
# 实参：调用函数，在括号内传入的实际值，值可以为常量、变量、表达式或三者的组合
​
# 注：形参随着函数的调用而产生，随着调用结束而销毁(有特例)

实参分类

'''
位置实参：必须按照顺序给形参传值
关键字实参：按照关键字给形参传值，所以顺序可以颠倒
​
# 注：位置实参、关键字实参共存是，关键字实参必须出现在所有位置实参之后
'''

形参的分类

'''
位置形参：位置实参与关键字实参都可以对其传参
默认形参：位置实参与关键字实参都可以对其传参，也可以不被传参
可变长位置形参：接收位置形参、默认形参没有接收完的所有位置实参
无初值关键字形参：只能由关键字实参传值
有初值关键字形参：只能由关键字实参传值，也可以不被传值
可变长关键字形参：接收两种关键字形参没有接收完的所有关键字实参
​
注：各种形参出现的先后
位置形参 - 默认形参 - 可变长位置形参 - 无|有初值关键字形参 - 可变长关键字参数
'''
def fn(a, b, c=10, *args, d, e=20, f, **kwargs):
    pass
# 位置形参：a、b
# 默认形参：c
# 可变长位置形参：args(在*后的才是关键字形参，如果没有*，那么代表的均是位置形参)
# 无初值关键字形参：d、f
# 有初值关键字形参：e
# 可变长关键字参数：kwargs

可变参数的整体使用

# 1、可变位置形参以元组方式接收值
# 如：接收10，20，30三个数
def fn1(*args):
    print(args)  # (10, 20, 30)
    
# 第一种传参
fn1(10, 20, 30)
​
# 第二种传参
t = (10, 20, 30)  # 单列集合及字符串类型都可以
fn1(*t)
​
​
# 2、可变位置实参以字典方式接收值
def fn2(**kwargs):
    print(kwargs)  # {'name': 'Owen', 'age': 18}
# 第一种传参
fn2(name='Owen', age=18)
​
# 第二种传参
d = {'name': 'Owen', 'age': 18}  # 单列集合及字符串类型都可以
fn2(**d)

函数总结

# 函数的定义：
def func(a, b):
    print(a, b)
    return a + b
​
​
# 函数四个组成部分
# 函数名：调用函数的依据，必须的
# 函数体：执行函数逻辑的，必须的
# 参数列表：为函数内部提供资源，非必须的
# 返回值：将函数执行结果返回给外界，（非必须的）
​
# 返回值：空返回（没有return|空return） | 一值返回  | 多值返回：装有多个值的元组
​
# 参数列表：
# 实参：外界调用函数传入的参数，拥有实际值
# 形参：函数定义时，()中定义用来接受实参的值
​
# 参数重点一：形参是对实参的值拷贝 *****
ls = [1, 2, 3, 4, 5]
num = 10
​
​
def fn(arg, n):
    arg[2] = 300
    print('1:', arg[2])
    print(id(n))
    n = 100
    print(id(n))
​
​
fn(ls, num)
# arg是对ls的值拷贝
print('2:', ls[2])
print(id(num))
​
​
# 实参的分类
# 位置实参：按位置对应传递参数，必须出现在关键字实参之前
# 关键字实参：不需要按位置对应传参，用参数名标注为谁传参，必须出现在位置实参之后
​
# 参数重点二：先位置实参后关键字实参传参
​
# 参数重点三：
# 位置实参：只能给位置形参传参（位置形参|默认形参|可变长位置形参）
# 关键字实参：可以给任意形参传参
​
# 出现顺序
# 参数重点四：
# 位置形参 > 默认形参 > 可变长位置形参 > 关键字形参 > 可变长关键字形参
​
def fn1(a, b, c=10, *args, d, e=20, f, **kwargs):
    pass
​
​
​

函数对象

# 函数名就是存放了函数的内存地址，存放了内存地址的变量都是对象，即 函数名 就是 函数对象
​
# 函数对象的应用
# 1 可以直接被引用  fn = cp_fn
# 2 可以当作函数参数传递 computed(cp_fn, 100, 20)
# 3 可以作为函数的返回值  get_cp_fn(cmd): return add
# 4 可以作为容器类型的元素  method_map: 对应关系中的值

def add(a, b):
    return a + b
def low(a, b):
    return a - b
def jump(a, b):
    return a * b
def full(a, b):
    return a / b
def quyu(a, b):
    return a % b
def computed(fn, n1, n2):
    res = fn(n1, n2)
    return res
method_map = {
    'add': add,
    'low': low,
    'jump': jump,
    'full': full,
    'quyu': quyu,
}
# 根据指令获取计算方法
def get_cp_fn(cmd):
    if cmd in method_map:
        return method_map[cmd]
    return add  # 输入有误用默认方法处理
​
​
while True:
    cmd = input('cmd: ')
    if cmd == 'quit':
        break
    cp_fn = get_cp_fn(cmd)
    result = computed(cp_fn, 100, 20)
    print(result)
​

名称空间

# 名称空间：存放名字与内存空间地址对应关系的容器
# 作用：解决由于名字有限，导致名字重复发送冲突的问题
​
# 三种名称空间
# Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
# Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销毁
# Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁
​
# 注：
# del 名字：可以移除查找最近的名字与内存空间地址的对应关系
# 加载顺序：Built-in > Global > Local

global关键词

def fn()
    global num
    num = 20
    print(num)
# global关键词可以将Local的名字提升为Global的名字
# 一个文件中的Global名字就是一个，所以函数内部外部使用的名字都是一个
fn()  # 注：一定要调用函数，才能产生名字，并提升
print(num)

函数的嵌套定义

# 将函数直接定义到另一个函数内部，就可以使用外部函数的中的名字
def outer():
    num = 20
    def inner():
        print(num)  # inner就可以直接使用outer中的名字
    inner()
outer()

作用域

# 作用域：名字起作用的范围
# 作用：解决同名字可以共存问题
​
# 四种作用域
# Built-in：内置作用域，所有文件所有函数
# Global：全局作用域，当前文件所有函数
# Enclosing：嵌套作用域，当前函数与当前函数的内部函数
# Local：局部作用域，当前函数
​
# 注：
# 不同作用域之间名字不冲突，以达到名字的重用
# 查找顺序：Local > Enclosing > Global > Built-in

len = 10
def outer():
    len = 20  # 外层函数的局部变量：Enclosing - 嵌套作用域
    def inner():
        len = 30
        print('1:', len)  # 30， inner -> outer -> global -> built-in
    inner()
    print('2:', len)  # 20， outer -> global -> built-in
outer()
print('3:', len)  # 10， global -> built-in
​
del len
print('4:', len)  # len地址， built-in

闭包

# closure：被包裹的函数，称之为闭包
# 完整的闭包结构：1.将函数进行闭包处理；2.提升函数名的作用域，将内部函数对象作为外部函数的返回值
​
def outer(url):
    def get_html():
        html = requests.get(url)
        print(html.text)
    return get_html
# 先预定义多个爬虫方法，爬页面操作并未执行
baidu = outer('https://www.baidu.com')
python = outer('https://www.python.org')
sina = outer('https://www.sina.com.cn')
# 什么时候想爬什么页面就调用指定页面的爬虫方法
baidu()
sina()
baidu()

​