Python基础知识笔记（二）

一.函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。函数包括内置函数和用户自定义函数。

1.函数定义

（1）函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

（2）任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

（3）函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

（4）函数内容以冒号 : 起始，并且缩进。

（5）return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return
相当于返回 None。

格式：
…

def 函数名([形参数1,形参数2,...]):

	函数体

	return [表达式]

调用：

函数名([实参1,实参2,…])

2.可变参数

(1)函数的参数个数不定，加了星号 *
的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

注意：有固定参数时，可变参数必须放在固定参数后。

定义方式1：

def 函数名(*args): # 以元组(tuple)的形式导入

函数体

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

(2)加了两个星号 ** 的参数会以字典的形式导入。

定义方式2：

def 函数名(**kwargs)

函数体

如果给函数形参赋值的时候传递的是一个字典：传递实参：**变量名（字典名），这里首先将传递的字典参数进行拆包，拆成一个个键值对（key=value)->函数名(key1=value1,
key2=value2,…)

步骤：

(1)将字典进行拆包

(2)函数里面的参数都是关键字参数

(3)将关键字参数进行装包

(4)装包成功：kwargs就是装包成功的字典

3.默认参数：key=value

调用函数时，如果没有传递参数，则会使用默认参数。

def 函数名(a, b=value):

函数体

调用：

函数名(a = 10, b = 10) # 关键字参数

4.返回值

return [表达式]
语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

(1)return后面可以是一个参数

(2)return后面可以是多个参数，如果是多个参数则底层会将多个参数先放在一个元组中，将元组作为整体返回

(3)接收返回值的时候也可以是多个，例如：return ‘hello’,‘world’ x, y =
(‘hello’,‘world’) -->x = ‘hello’ y = ‘world’

5.函数的嵌套调用

二.全局变量和局部变量

1.局部变量:声明在函数内部的变量，仅限于在声明该变量的函数中使用

2.全局变量:声明在函数外部的变量，所有函数都可以访问，不可在函数内部修改全局变量

如何在函数中修改全局变量？

在函数内部声明:global 变量名

3.全局变量如果是不可变的，在函数中修改需要加关键字global关键字，如果全局变量是可变的，在函数中修改则不需要加global关键字

三.嵌套函数

1.内部函数–在函数内部声明的函数

(1)定义
…

def func():

	...

	def inner_func(): # 内部函数

			...

(2)调用
…

def func():

	...

	def inner_func(): # 定义

		...

	inner_func() # 调用

(3)特点：

a.可以访问外部函数的变量

b.内部函数可以修改外部函数的可变类型的变量

c.如果要在内部函数中修改外部函数的不可变类型的变量，则需要在内部函数中使用关键字nonlocal声明变量

d.内部函数修改全局的不可变变量时，需要在内部函数声明global 变量名

(4)locals()内置函数–查看当前函数中声明的内容，以字典形式输出

(5)globals()内置函数–查看全局变量有哪些，以字典形式输出(会包含一些系统的键值对)

四.闭包

1.概念(条件)

在函数中提出的概念，在外部函数中定义内部函数时，外部函数是有返回值的，返回的值是内部函数名(不能加括号)，内部函数引用了外部函数的变量

2.格式
…

def 外部函数():

	内容

	def 内部函数():

			内容

	return 内部函数

# 调用外部函数

func = 外部函数()

# 调用反出来的内部函数

func()

3.闭包的应用

(1)闭包保存参数的状态(外层函数变量的状态)

例如：

def func(a, b):
    c = 10
    def inner_func():
        s = a + b + c
        print('相加结果为：', s)
    return inner_func
func1 = func(6, 9) # a=6,b=9-->inner_func()内部函数中-->返回内部函数(此时返回的内部函数已经记录此时的a和b的值，所以不会受到外界a,b值改变的影响)
func2 = func(2, 8) # a=2,b=8-->保存在本次的inner_func内部函数中-->返回的时候返回的是保存2,8的内部函数
func2()
func1()

输出结果：

相加结果为：20

相加结果为：25

4.闭包缺点

(1)作用域不太直观

(2)变量不会被回收，所以存在内存占用问题

5.闭包作用

(1)可以使用同级作用域

(2)读取其他元素的内部变量

(3)延长作用域

6.闭包总结

(1)闭包优化了变量，原来需要类对象完成的工作，可用闭包完成

(2)由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

(3)闭包使得代码变得简洁易读

(4)闭包是理解装饰器的基础

五.装饰器

1.特点

(1)函数A是作为参数出现，函数B接收函数A作为参数

(2)要有闭包的特点

2.定义例子

def decorate(func):
    a = 100
    def wrapper():
        print('------>11111')
        func()
        print('------>22222', a)
    return wrapper
# 使用装饰器
@decorate  #该标识以下的函数为被装饰函数，被装饰函数作为参数传给装饰器decorate，然后执行装饰器decorate
def house():
    print('-------')
house()

3.多层装饰器

(1)如果装饰器是多层的，哪个装饰器离函数距离最近就优先使用哪个装饰器

(2)装饰器带参数(三层)

def outer(a):   # 第一层:负责接收装饰器的参数
    def decorate(func):  # 第二层:负责接收函数
        def wrapper(*args, **kwargs):  # 第三层:负责接收函数的参数
            ...
        return wrapper
    return decorate

@outer(10)
def house():  # 被装饰函数
    ...

4.装饰器的应用–登录验证

import time

isLogin = False  # 默认未登录状态
# 定义一个登录函数
def login():
    username = input('请输入用户名：')
    password = input('请输入密码：')
    if username == 'admin' and password == '123456':
        return True
    else:
        return False


# 定义一个装饰器，进行付款验证
def login_required(func):
    def wrapper(*args, **kwargs):
        global isLogin
        print('--------付款---------')
        # 验证用户是否登录
        if isLogin:
            func(*args, **kwargs)
        else:
            print('用户未登录！')
            # 跳转到登录页面
            isLogin = login()
            print('result:', isLogin)
    return wrapper


@login_required
def pay(money):
    print('正在付款，付款金额{}元'.format(money))
    print('付款中...')
    time.sleep(2)
    print('付款成功')


pay(100)
pay(1000)

六.匿名函数

作用：简化函数定义
1.格式
lambda 参数1, 参数2, … : 运算(返回结果)

2.匿名函数作为参数
def func(x, y, func1):
…
func(1, 2, lambda a, b:a+b)

3.匿名函数与内置函数结合使用
例如：
(1)max()函数

 # 找出列表中的最大值
list1 = [10, 25, 23, 20]
m = max(list1)
print(m)
list2 = [{'a': 10, 'b': 20}, {'a': 25, 'b': 20}, {'a': 9, 'b': 20}, {'a': 29, 'b': 20}]
m = max(list2, key=lambda x: x['a'])
print(m)

(2)reduce()函数–对列表中的元素进行加减乘除运算

# 对元组中的元素进行加法操作(减、乘、除类似)
from functools import reduce

tuple1 = (3, 5, 7, 9, 6, 5, 2)
result = reduce(lambda x, y: x + y, tuple1)  # 结果为37
result1= reduce(lambda x, y: x + y, tuple1, 10)  # 结果为47
print(result)
print(result1)

(3)filter()筛选函数

 # 筛选出列表中大于10的元素
list1 = [6, 12, 65, 2, 89, 54, 9]
result = filter(lambda x: x > 10, list1)
print(list(result))

(4)map()函数–对列表中的每一个元素进行操作

七.递归函数

函数自己调用自己
1.特点
(1)递归函数必须设置终点，否则会无线循环报递归错误（RecursError)
(2)通常有一个入口
2.实例

 # 求和1+2+...+100
def sum(n):
    if n == 0:
        return 0
    else:
        return n + sum(n - 1)
result = sum(100)
print(result)