python基础-3

 1.三大器

　　装饰器

　　　　作用:不改变原函数的代码 ,不改变原函数调用方式 ,为函数增加新功能 ,通过闭包函数实现

# 基本格式
import functools
def wapper(f):
　　@functools.wraps(f)　　　　　　　　　　　　#不改变原函数的.__name__属性
　　def inner(*args,**kwargs):             #inner就是被装饰以后调用的函数 ,传参
　　　　a = 10　　　　　　　　　　　　　　　　　　#为原函数增加了个变量a
　　　　ret = f(*args,**kwargs)　　　　　　　　#真正执行的原函数 
       return ret　　　　　　　　　　　　　　　　#返回值是原函数的返回值
　　return inner　　　　　　　　　　　　　　　　#将内函数的地址返回

@wapper
def a1():
　　pass

a1()　　　　　　　　　　　　　　　　　　　　　　#这实际就是执行了inner函数


# 简单例子:执行增删改查时判断用户是否登录状态　

import functools
login_status = 'False'  # 登录状态

def login():  # 登录函数
    username = input('请输入用户名:')
    password = input('请输入密码:')
    if username == 'admin' and password == '123':
        global login_status
        login_status = 'True'
    else:
        print('login error')

def wapper(f):  # 装饰器判断登录状态
    @functools.wraps(f)
    def inner(*args, **kwargs):
        while 1:
            if login_status == 'True':  # 在执行增删改查之前 ,判断登录状态
                ret = f(*args, **kwargs)
                return ret
            else:
                login()
    return inner

@wapper
def add():
    pass

@wapper
def delete():
    pass

@wapper
def update():
    pass

@wapper
def select():
    pass

select()
add()

　　可迭代对象

　　　　可迭代对象可以简单的理解为 ,该对象拥有__iter__方法 ,使用dir(对象)可以查看 ,set list dict set tuple都是可迭代对象 ,也可以也理解为可以使用for循环的都是可迭代对象

　　　　可迭代对象内部都有__iter__方法 ,执行后返回一个迭代器 ,可以使用__next__调用

x = [1, 2, 3]
a = x.__iter__()　　　　　　　　　　　　　　# 执行了list对象的__iter__方法返回一个迭代器
print(a.__next__())
print(a.__next__())

　　迭代器

　　　　迭代器的特点是每次执行__next__方法的时候才会返回一个值 ，懒加载机制记录当前的位置，如果使用next()调用迭代器在没有元素后会抛出异常 ,使用for循环就是for循环通过迭代器获取一个个元素

　　生成器

　　　　生成器是可以创建迭代器, 拥有next与iter方法

生成器表达式 (列表推导式的换成小括号)  

y = (x for x in range(5))
print(y.__next__())
print(y.__next__())
for i in y:
    print(i)

2.函数

　　作用: 函数对功能封装简化代码

　　语法:

　　　　def 函数名(形参):

　　　　　　函数体

　　　　　　return 返回值

　　　　函数名(实参)　　　　　　　　　　　　　　　　　　#调用

　　参数:

　　　　形参:函数声明需要参数

　　　　　　1.位置参数

　　　　　　2.关键字参数（默认值参数）

　　　　　　3.动态传参（*聚合,可以将位置参数聚合为一个tuple  ,**聚合,可以将关键字参数聚合为一个dict）

　　　　　　　　*args 　　　　　　　　　　　　　　　　#按顺序接受所有位置参数

　　　　　　　　**kwargs　　　　  　　　　　　　　　　#按顺序接受关键词参数

　　　　形参定义顺序: 位置参数 ,*args ,默认值参数 ,**kwargs　　　

　　　　实参:函数调用填入参数

　　　　　　1.位置参数(位置必须对应) 

　　　　　　2.关键字参数 

　　　　实参调用顺序 :位置参数 ,关键字参数

# 聚合与打散
def func1(*args, **kwargs):  # 将打散数据聚合为一个元祖 一个字典 ,函数可以通过args元祖 和kwargs字典直接获取参数
    print(args, kwargs)


t1 = (1, 2, 3, 4)
t2 = ('a', 'b', 'c', 'd')

t3 = {'name': 'qgw', 'age': 12}
t4 = {'school': 'ppp'}

func1(*t1, *t2, **t3, **t4)  # 将元祖,字典在实参位置打散 ,调用时可以直接写字典元祖

# (1, 2, 3, 4, 'a', 'b', 'c', 'd') {'name': 'qgw', 'age': 12, 'school': 'ppp'}

　　返回值

　　　　return  结果　　　　　　　　　　　　　　　　#返回值直接返回给了函数名

　　函数名可以传递使用 ,指向同一函数内存地址

def func1(*args):
    print(args)

func2=func1

func1('ok')
func2('yes')

3.匿名函数

　　匿名函数(一种语法)

　　　　语法:lambda 参数:返回值    　　　　　　　　#函数整体就是是return

　　　　简单用法:f=lambda x,y=1:x+y ;f(1)  　　　　 

1.根据字典中某个key的值排序

dict1 = [{"name": "uuu", "age": 10}, {"name": "qqq", "age": 20}, {"name": "bbb", "age": 100}]

dict1.sort(key=lambda x:x['age'])

print(dict1)

4.作用域函数嵌套

　　作用域 ,变量的作用范围 ,以及函数寻找变量的顺序 ,匹配即停 

　　　　globals()　　　　　　　　　　　　　　　　　　　　　　　　　　#查看全局作用变量 

　　　　locals()　　　　　　　　　　　　　　　　　　　　　　　　　　#查看当前局部作用变量

a = 10                      # 全局作用域 Global
def a1():
    a = 5                   # 嵌套作用域 Enclosing
    def b1():
        a = 1               # 局部作用域 Local
        print(locals())
        return a
    return b1
print(a1()())
print(globals())

　　函数嵌套

　　　　globla 变量　   　　　　　　　　　　　　　　　　　　　　　　　　#函数内部引用全局变量 ,会改变全局变量 ,影响全局

　　　　nolocal  变量　　　　　　　　　　　　　　　　　　　　　　　　　#函数内部引用外层函数的变量 ,会改变外层函数 ,影响外层函数

a = 10  　　　　　　　　　　　　# 全局作用域 Global
b = 20
def a1():
    a = 5  　　　　　　　　　　# 嵌套作用域 Enclosing
    def b1():
        nonlocal a  　　　　　# 声明使用外层函数的变量a
        global b  　　　　　　# 声明使用全局的变量b
        a +=1
        return a + b
    return b1
print(a1()())
print(a)

5.异常处理

　　最简单的异常处理就是if else

　　异常处理的语法 ,所有的异常类型继承了父类 Exception

try:
    代码段            #代码段报错位置开始终止 ,开始执行except
except 错误类型(NameError):
    代码段            #出现NameError异常执行代码段
except 错误类型(IndexError):
    代码段            #出现IndexError异常执行代码段
    return 
finally:
　　 代码段
    print('return也不会影响我的代码段')