函数

1. 函数嵌套

1.1 函数嵌套调用

　　函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数

def bar():
    print("from in the bar.")

def foo():
    print("from in the foo.")
    bar()

foo()

 

1.2 求函数最大值

def max2(x,y):
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3

res = max4(2,5,3,-4)
print(res)

 

1.3 函数嵌套定义

函数的嵌套定义：在一个函数的内部，又定义另外一个函数

def f1():
    x = 1
    def f2():
        print("from f2.")
    f2()   # 只能在函数内部调用

f1()

2. 名称空间

2.1 介绍

　　名称空间：存放名字的地方，准确的说名称空间是存放名字与变量值绑定关系的地方。

　　内置名称空间：在python解析器启动时产生，存放一些python内置的名字。

　　全局名称空间：在执行文件时产生，存放文件级别定义的名字。

　　局部名称空间：在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间，用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效。

2.2 加载、查找顺序

　　加载顺序：内置名称空间 --> 全局名称空间 --> 局部名称空间

　　查找顺序：局部名称空间 --> 全局名称空间 --> 内置名称空间

                                 

3. 作用域

3.1 基本概念

　　作用域：作用的范围

　　全局作用域：全局存活、全局有效

　　局部作用域：临时存活、局部有效

　　查看作用域：globals(),locals()

　　　　查看全局作用域：globals()

　　　　查看局部作用域：locals()

3.2 global

　　局部修改全局的名字：global

　　针对全局不可变类型，用global进行修改

　　针对全局可变类型，在函数内部可以直接修改全局变量的内容

　　利用global，在函数内部进行修改全局变量；此种方法慎用；以后尽量避免利用局部修改全局的名字

# 不可变类型，利用global进行修改全局变量值
x = 20
def foo():
    global x
    x = 30
foo()
print(x)        # 此时x的值已经被修改，变为30
 
# 可变类型的全局变量，在函数内部进行直接修改
l = []
def foo():
    l.append("jack")
foo()
print(l)    # 此时l已经变为：['jack']

3.3 nonlocal

　　nonlocal,修改的局部变量的上一层变量，只是修改局部的变量；

x = 0
def f1():
    x = 100
    def f2():
        x = 200
        def f3():
            nonlocal x
            x = 300
        f3()
        print(x)   # 利用nonlocal定义的变量 进行修改上一层的局部变量
    f2()
    print(x)      # nonlocal只修改上一层局部变量，此时打印f1定义的变量
f1()

 

3.2 作用域关系

　　作用域关系：在函数定义时就已经确定，与调用位置无关；在调用函数时，必须回到函数原来定义的位置去找作用域关系

x = 1
def f1():
    def f2():
        print(x)
    return f2

func = f1()
x = 10000
func()       # 此时打印1000，只是打印的是x = 1定义的地方，只是在后面进行修改 x = 10000
 

# 作用域关系，在定义阶段就已经确定，与调用位置无关

x = 1
def f1():
    def f2():
        print(x)
    return f2

def foo(func):
    x = 30000
    func()   # 相当于调用f2,打印x为1

foo(f1())

4. 闭包函数

4.1 定义

　　闭包函数简单理解就是：闭合、包裹的函数

　　闭包函数：定义在函数内部的函数，包含对外部作用域名字的引用，而不是对全局作用域名字的引用，那么该内部函数就称为闭包函数

4.2 实例

# wrapper称为闭包函数，定义deco内部的函数，并对外部x的引用，而变量x不是全局变量
def deco():
    x = 1000
    def wrapper():
        print(x)
    return wrapper

func = deco()
func()

4.3 闭包应用-惰性计算

　　爬网页的简单程序

import requests   # pip3 install requests
def index(url):
    def wrapper():
        # return requests.get(url).text
        print(requests.get(url).text)
    return wrapper

python_web = index("https://www.python.org")
baidu_web = index("https://www.baidu.com")

python_web()
baidu_web()

4.4 查看闭包函数参数

　　查看闭包函数外面包裹的参数

import requests   # pip3 install requests
def index(url):
    def wrapper():
        print(requests.get(url).text)
    return wrapper
python_web = index("https://www.python.org")
print(python_web.__closure__)   # (<cell at 0x00000000021A7528: str object at 0x0000000002209DB0>,)
print(python_web.__closure__[0].cell_contents) # 查看闭包函数的包裹的参数 https://www.python.org

5. 装饰器

5.1 基本概念

　　开放封闭原则：对扩展是开放的，对修改是封闭的

　　装饰器：装饰其他对象的工具

　　　　装饰器本身可以是任意可调用对象，被装饰的对象也可以是任意可调用对象

　　装饰器的遵循的原则：

　　　　1.不修改被装饰对象的源代码

　　　　2.不修改被调用对象的调用方式

　　装饰器的目的是：

　　　　在遵循1和2原则的前提，为其他可调用对象添加新功能

　　装饰器名：必须写在被装饰对象的正上方，并且是单独一行

5.2 装饰器前奏

5.2.1 修改源代码

import time
def index():
    start_time = time.time()
    time.sleep(2)
    print("from in index")
    stop_time = time.time()
    print("run time is %s" % (stop_time - start_time))
index()

5.2.2 修改了调用方式

import time
def wrapper(func):
    start_time = time.time()
    time.sleep(2)
    func()
    stop_time = time.time()
    print("run time is %s" % (stop_time - start_time))

def index():
    time.sleep(2)
    print("from in index.")

wrapper(index)  # 修改了函数的调用方式

5.2.3 应用实例

import time
def timmer(func):
    def wrapper():
        start_time = time.time()
        func()
        stop_time = time.time()
        print("run time is %s" %(stop_time - start_time))
    return wrapper
@timmer  # index=timmer(index)
def index():
    time.sleep(2)
    print("from in index")
@timmer  # home=timmer(home)
def home():
    time.sleep(2)
    print("from in home")

index()
home()

　　运行结果：

from in index
run time is 2.0001142024993896
from in home
run time is 2.0001144409179688

5.3 被装饰的对象有参数

　　解决装饰器的闭包函数，能够适应有参数、无参数、各种各样的参数的形式

import time
def timmer(func):
    def wrapper(*args, **kwargs):
        start=time.time()
        func(*args, **kwargs)
        stop=time.time()
        print('run time is %s' %(stop-start))
    return wrapper

@timmer # home=timmer(home)
def home(name):
    time.sleep(2)
    print('welcome %s to home page' %name)

home('jack')  #  hom('jack'） wrapper('jack')

5.4 被装饰的对象有返回值

　　有返回值的情况，需要在装饰器处理有返回值的情况，也就是在wrapper最后，利用return进行返回处理结果

import time
def timmer(func):
    def wrapper(*args, **kwargs):
        start=time.time()
        res=func(*args, **kwargs)
        stop=time.time()
        print("run time is %s" %(stop-start))
        return res
    return wrapper

@timmer # home=timmer(home)
def home(name):
    time.sleep(2)
    print("welcome %s to home page" %name)
    return "from home return ok."

res = home('jack') # wrapper('jack')
print(res)         # from home return ok.

5.5 装饰器：登录认证

　　实行认证功能的装饰器，需要对用户输入用户名和密码进行验证，在输入正确的情况下，才执行被装饰函数的内容。

5.5.1 无参数装饰器实现认证

current_user={'user':None}
def auth(func):
    def wrapper(*args, **kwargs):
        if current_user['user']:    # 自带bool判断功能
            return func(*args, **kwargs)

        name=input('name: ').strip()
        password=input('password: ').strip()

        with open('db.txt', encoding='utf-8') as f:
            user_dic = eval(f.read())
        if name in user_dic and password == user_dic[name]:
            res=func(*args,**kwargs)
            current_user['user']=name
            return res
        else:
            print('user or password error')
    return wrapper

@auth #index=auth(index) index=wrapper
def index():
    print('from index')
@auth
def home(name):
    print('welcome %s' %name)

index() #wrapper()
home('jack')

5.5.2 有参函数装饰器

current_user={"user":None}
def auth(auth_type="file"):
    def deco(func):
        def wrapper(*args, **kwargs):
            if auth_type == "file":
                if current_user["user"]:
                    return func(*args, **kwargs)
                name = input("name: ").strip()
                password = input("password: ").strip()

                with open("db.txt", encoding="utf-8") as f:
                    user_dic = eval(f.read())
                if name in user_dic and password == user_dic[name]:
                    res = func(*args, **kwargs)
                    current_user["user"] = name
                    return res
                else:
                    print("user or password error")
            elif auth_type == "mysql":
                print("mysql")
            elif auth_type == "ldap":
                print("ldap")
            else:
                print("not valid auth_type")
        return wrapper
    return deco
@auth(auth_type="mysql") #@deco  #index=deco(index)
def index():
    print("from index")
@auth(auth_type='file')
def home(name):
    print("welcome %s" %name)
index() #wrapper()
home('jack')

5.6 装饰器的其他属性

5.6.1 被装饰函数的注释信息

 　　需要导入functools模块，在被装饰的函数上方加@wraps(func)

from functools import wraps
def decorator(func):
    @wraps(func)
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return wrapper

@decorator
def index():
    '''这是注释index信息'''
    print('from to index')
    return "in the index"

print(index.__doc__)
# print(help(index))

5.6.2 一个函数被多个装饰器装饰

　　一个函数的多个装饰器，在上面的装饰器先执行，在下面的装饰器后执行

def timmer(func):
    def wrapper(*args, **kwargs):
        print("this is timmer.")
        res=func(*args,**kwargs)
        return res
    return wrapper
def auth(auth_type='file'):
    def deco(func):
        def wrapper(*args, **kwargs):
            print("this is auth.")
            return func(*args, **kwargs)
        return wrapper
    return deco

@timmer #index=timmer(wrapper)
@auth() # @deco #index=deco(index) #wrapper
def index():
    '''这是index函数'''
    print('welcome to index')
    return "from in index"

index()

6. 迭代器

6.1 解析

　　迭代：是一个重复的过程，每一次重复，都是基于上一次的结果而来；取出序列类型的元素，就是迭代

　　序列类型：列表、元组、字符串

　　下面的方法按照索引的取值方式，不适用没有索引的数据类型

l=['aa','bb','cc','dd']
count=0
while count < len(l):
    print(l[count])
    count+=1

　　不依赖索引方式，进行取值，就是迭代器；迭代非序列类型编程可能。

6.2可迭代对象

　　可迭代对象iterable：凡是对象下有__iter__方法：对象.__iter__，该对象就是可迭代对象

s='hello '                      # 字符串
l=['a','b','c','d']             # 列表
t=('a','b','c','d')             # 元组
dic={'name':'egon','sex':'m'}   # 字典
set1={1,2,3}                    # 集合
f=open('db.txt')                # 文件

s.__iter__()
l.__iter__()
t.__iter__()
dic.__iter__()
set1.__iter__()
f.__iter__()

6.3迭代器对象

　　迭代器对象：可迭代对象执行内置的__iter__方法，得到的结果就是迭代器对象

　　迭代器：本身也是可迭代对象

　　什么是迭代器对象：

　　　　1.有__iter__,执行得到仍然是迭代本身

　　　　2.有__next__方法

dic = {'name': 'egon', 'sex': 'm', "age": 18}
i = dic.__iter__()
# print(i) #iterator迭代器

# i.__next__() #next(i)
print(next(i))
print(next(i))
print(next(i))
print(next(i))  # StopIteration

l = ['a', 'b', 'c', 'd']

i = l.__iter__()
print(next(i))
print(next(i))
print(next(i))
print(next(i))
print(next(i))  # StopIteration

　　可以不依赖于索引的取值方式

l=['a','b','c','d']
dic={'name':'egon','sex':'m',"age":18}
iter_l=iter(l)
iter_dic=iter(dic)
while True:
    try:
        # print(next(iter_l))
        k=next(iter_dic)
        print(k,dic[k])
    except StopIteration:
        break

6.4迭代器优缺点

　　迭代器对象的优点

　　　　1：提供了一种统一的（不依赖于索引的）迭代方式

　　　　2：迭代器本身，比起其他数据类型更省内存

l = ['a', 'b', 'c', 'd']
i = iter(l)

dic = {'a': 1, 'b': 2}
x = dic.keys()
print(x)
i = x.__iter__()  # 执行__iter()__，成为迭代器对象；可以对i执行next()的方法

# 文件是迭代器对象
with open('a.txt') as f:
    # print(next(f))
    # print(next(f))
    # print(next(f))
    f.read()

　　迭代器对象的缺点

　　　　1:一次性，只能往后走，不能回退，不如索引取值灵活

　　　　2：无法预知什么时候取值结束，即无法预知长度

l=['a','b','c','d']
i=iter(l)
print(next(i))
print(next(i))
print(next(i))

6.5 for循环原理

　　for循环遵循迭代器协议，有__iter__方法，还有__next__方法。

　　for循环，利用迭代器，进行循环；for，可跟可迭代对象的数据类型；自动进行捕捉异常，自动调用__iter__方法

　　例如列表：for循环，先调用__iter__方法，变为迭代器对象，然后再进行循环

　　迭代器：有__iter__方法，为for循环准备的。

l=['a','b','c','d']
for item in l: #iter_l=l.__iter__()
    print(item)

for item in {1,2,3,4}:   # 可循环集合
    print(item)

with open('a.txt') as f:
    # for line in f: #i=f.__iter__()  可循环文件 把文件变成可迭代对象
    #     print(line)
    print(f is f.__iter__())

6.6 判断可迭代对象、迭代器对象

　　需要利用模块Iterable、Iterator进行判断

from collections import Iterable,Iterator
s='hello'
l=['a','b','c','d']
t=('a','b','c','d')
dic={'name':'egon','sex':'m',"age":18}
set1={1,2,3}
f=open('a.txt')

# 判断是否可迭代对象；所有对象都是可迭代对象
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(dic,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))

# 判断是否迭代器对象
print(isinstance(s,Iterator))
print(isinstance(l,Iterator))
print(isinstance(t,Iterator))
print(isinstance(dic,Iterator))
print(isinstance(set1,Iterator))
print(isinstance(f,Iterator))   #只有文件是迭代器对象

7. 生成器

7.1 简介

　　生成器：在函数内部包含yield关键，那么该函数执行的结果是生成器

　　生成器就是迭代器

　　yield的功能：

　　　　1 把函数的结果做成迭代器（以一种优雅的方式封装好__iter__,__next__）

　　　　2 函数暂停与再继续运行的状态是由yield保存

7.2 应用实例

实例1：

def func():
    print("first")
    yield 111
    print("second")
    yield 222
    print("third")
    yield 333
    print("forth")

g = func()
from collections import Iterator
print(isinstance(g,Iterator))          # 生成器就是迭代器

# print(next(g))
# print('======>')
# print(next(g))
# print('======>')
# print(next(g))
# print('======>')
# print(next(g))
for i in g: #i=iter(g)
    print(i)

实例2：

　　产生无穷无尽的值，是个重复的过程。利用生成器解决此问题。

def func(n):
    print('我开动啦')
    while True:
        yield n
        n+=1
g = func(0)    # 没有任何执行效果
# print(next(g))
# print(next(g))
for i in g:
    print(i)

实例3：

　　模拟range功能，在python3中，range只是一个迭代器对象，并没有产生所需数据。

def my_range(start,stop):
    while True:
        if start == stop:
            raise StopIteration
        yield start
        start+=1

g = my_range(1,5)  # 是个生成器，就是一个迭代器
print(next(g))
print(next(g))
print(next(g))

for i in my_range(1,5):
    print(i)

7.3 yield与return的比较

　　相同：都有返回值的功能

　　不同：return只能返回一次值，而yield可以返回多次值

7.4 模拟tail、grep

# python3 tail.py -f access.log | grep 'error'
import time

def tail(filepath):
    with open(filepath, 'r') as f:
        f.seek(0, 2)
        while True:
            line = f.readline()
            if line:
                yield line
            else:
                time.sleep(0.2)

def grep(pattern,lines):
    for line in lines:
        if pattern in line:
            print(line,end='')

grep('error',tail('access.log'))

8. 三元表达式

def foo(x):
    if x > 3:
        return 'ok'
    else:
        return 'no'

# 利用三元表达式，使代码更简洁
x = 5
res = x if x > 3 else 'no'
print(res)

def max2(x,y):
    return x if x > y else y
print(max2(1,3))

name='egon'
print('SB' if name == 'alex' else 'shuai')

9. 列表解析

　　列表解析，也就是列表生成式

　　列表解析，直接在列表中，写for循环进行生产列表

l=[]
for i in range(10):
     l.append('egg%s' %i)
print(l)

# 产生10个值的列表
l=['egg%s' %i for i in range(10)]
print(l)

# 按照条件，产生一个列表，支持if判断，不支持else
l=['egg%s' %i for i in range(10) if i > 5]   # 只有条件成立执行，不支持else
print(l)

# 对原列表进行附加操作，进行生产新列表
nums=[1,2,3,4,5,6]
nums_new=[item**2 for item in nums if item > 3]
print(nums_new)

# 对原列表根据条件进行筛选，生产新列表
names=['alex_sb','wupeiqi_sb','egon','yuanhao_sb']
names_new=[name for name in names if name.endswith('sb')]
print(names_new)

10. 生成器表达式

　　g=('egg%s' %i for i in range(1000))

　　上面就是生成器，其实就是迭代器；每次在内存中就只有一条值

　　场景：数据量大的场景，

　　生成器：就是生成值。

　　生成器表达式：就是拿到生产数据的机器。

　　实例1：

g=('egg%s' %i for i in range(1000))
print(g)
print(next(g))
print(next(g))
print(next(g))

　　实例2：

# 获取文件最长一行的值
with open('db.txt',encoding='utf-8') as f:
    res = max(len(line) for line in f)     #python提供简写的形式，去掉多余的小括号
    print(res)

　　实例3：

　　　　模拟求总价

with open('a.txt',encoding='utf-8') as f:
    l = ( float(line.split()[1]) * int(line.split()[2]) for line in f)  # 解决文件过大的问题
    print(sum(l))
#等价于
with open('a.txt', encoding='utf-8') as f:
    l=[]
    for line in f:
       goods=line.split()
       price=float(goods[1])
       count=int(goods[2])
       cost=price * count
       l.append(cost)

    print(sum(l)) #196060.0

　　实例4：

　　　　模拟数据库查询，根据条件进行查询

# [{'name': 'apple', 'price': 333, 'count': 3}, ]
with open('a.txt',encoding='utf-8') as f:
    info=[
        {
            'name':line.split()[0],
            'price':float(line.split()[1]),
            'count':int(line.split()[2])
        } for line in f if float(line.split()[1]) >= 30000
    ]
    print(info)