day13学习整理-Python函数进阶

20190812 学习整理

函数进阶

闭包函数

一、什么是闭包

闭包：闭是封闭（函数内部函数），包是包含（该内部函数对外部作用域而非全局作用域的变量的引用）。简单来说就是用函数包起来一个对象。闭包指的是：函数内部函数对外部作用域而非全局作用域的引用。

1.1 两种为函数传参的方式

方式一：使用参数的形式

def func(x):
    print(x)
   
func(1)
func(1)

1
1

方式二：包给函数

def outter(x):
    x = 1 
    def intter():
        print(x)
    return intter

f = outter(1)
f()
f()

# 查看闭包的元素
print(f"f.__closure__[0].cell_contents: {f.__closure__[0].cell_contents}")

1
1
f.__closure__[0].cell_contents: 1

闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。

装饰器

什么是装饰器？

装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。

器指的是工具，而程序中的函数就是具备某一功能的工具，所以装饰器指的是为被装饰器对象添加额外功能。因此定义装饰器就是定义一个函数，只不过该函数的功能是用来为其他函数添加额外的功能。

需要注意的是：

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

为什么要用装饰器？

如果我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候可以使用装饰器。因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能指的是开放的。

装饰器的实现必须遵循两大原则：

1. 不修改被装饰对象的源代码
2. 不修改被装饰对象的调用方式

装饰器其实就是在遵循以上两个原则的前提下为被装饰对象添加新功能。

无参装饰器

怎么用装饰器

def index():
    print("I'm going to a concert")
    time.sleep(1)
def time_count(func):
    #  计时器装饰器
    def warpper():
        start = time.time()
        func()
        end = time.time()
        print(f'{fun} time is {end - start}')
    return wapper

index = time_count(index)
index()

I'm going to a concert
<function index at 0x102977730> time is 1.0038220882415771

完善装饰器

import time


def home(name):
    print(f"welcome {name} to home")
    time.sleep(1)

    return name


def time_count(func):
    # func = 最原始的index
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print(f"{func} time is {start-end}")

        return res
    return wrapper


home = time_count(home)

res = home('HuGe')
print(f"res: {res}")

welcome HuGe to home
<function home at 0x102977378> time is -1.0039079189300537
res: egon

装饰器语法糖

在被装饰函数正上方，并且是单独一行写上`@装饰器名

import time


def time_count(func):
    # func = 最原始的index
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print(f"{func} time is {start-end}")

        return res
    return wrapper


@time_count  # home = time_count(home)
def home(name):
    print(f"welcome {name} to home page")
    time.sleep(1)

    return name


@time_count  # index = time_count(index)
def index():
    print('welcome to index')
    time.sleep(1)

    return 123


res = home('egon')
print(f"res: {res}")

welcome egon to home page
<function home at 0x102977620> time is -1.0005171298980713
res: egon

装饰器模板

def outter(func):
    def wapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return =res
    return wapper

有参装饰器

无参装饰器只套了两层，本节将讲一个套三层的装饰器——有参装饰器，但现在我们先实现一个用户登录注册的装饰器。

import time

current_uesr = {'username': None}


def auth(user_type = 'admin'):

    def login(func):
        # func = 最原始的index
        def wrapper(*args, **kwargs):

            if current_user['username']:
                res = func(*args, **kwargs)

                return res

            user = input('username: ').strip()
            pwd = input('password: ').strip()

            if user_type == 'admin':
                if user == 'nick' and pwd == '123':
                    print('login successful')
                    current_uesr['usre'] = user
                    res = func(*args, **kwargs)

                    return res
                else:
                    print('user or password error')
            elif user_type == 'user':
                if user == 'nick' and pwd == '123':
                    print('login successful')
                    current_uesr['usre'] = user
                    res = func(*args, **kwargs)

                    return res
                else:
                    print('user or password error')
           

        return wrapper

    return login


@auth(user_type ='admin')
def admin():
    print(f"welcome to admin menu")
    time.sleep(1)


@auth(user_type ='file')
def user():
    print('welcome to user menu')
    time.sleep(1)


res = index()

username: huge
password: 123
login successful
welcome to admin menu

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。

迭代器：迭代的工具。迭代是更新换代，如你爷爷生了你爹，你爹生了你，迭代也可以说成是重复，并且但每一次的重复都是基于上一次的结果来的。如计算机中的迭代开发，就是基于软件的上一个版本更新。以下代码就不是迭代，它只是单纯的重复

字符串，列表或元组对象都可用于创建迭代器：

可迭代对象

python中一切皆对象，对于这一切的对象中，但凡有__iter__方法的对象，都是可迭代对象。

# x = 1.__iter__  # SyntaxError: invalid syntax

# 以下都是可迭代的对象

name = 'nick'.__iter__
lis = [1, 2].__iter__
tup = (1, 2).__iter__
dic = {'name': 'nick'}.__iter__
s1 = {'a', 'b'}.__iter__
f = open('49w.txt', 'w', encoding='utf-8')
f.__iter__
f.close()

总结

可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象。

特点：

1. 内置有__iter__方法的都叫可迭代的对象。

迭代器对象

只有字符串和列表都是依赖索引取值的，而其他的可迭代对象都是无法依赖索引取值的。因此我们得找到一个方法能让其他的可迭代对象不依赖索引取值。

在找到该方法前，首先我们给出迭代器对象的概念：可迭代的对象执行__iter__方法得到的返回值。并且可迭代对象会有一个__next__方法。

# 不依赖索引的数据类型迭代取值
dic = {'a': 1, 'b': 2, 'c': 3}
iter_dic = dic.__iter__()
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())
# print(iter_dic.__next__())  # StopIteration:

a
b
c

# 依赖索引的数据类型迭代取值
lis = [1, 2, 3]
iter_lis = lis.__iter__()
print(iter_lis.__next__())
print(iter_lis.__next__())
print(iter_lis.__next__())
# print(iter_lis.__next__())  # StopIteration:

1
2
3

上述的方法是非常繁琐的，我们可以使用while循环精简下。其中使用的try...except...为异常处理模块，以后会详细讲解。

s = 'hello'
iter_s = s.__iter__()

while True:
    try:
        print(iter_s.__next__())
    except StopIteration:
        break

h
e
l
l
o

总结

迭代器对象：执行可迭代对象的__iter__方法，拿到的返回值就是迭代器对象。
特点：

1. 内置__next__方法，执行该方法会拿到迭代器对象中的一个值
2. 1. 内置有__iter__方法，执行该方法会拿到迭代器本身
3. 文件本身就是迭代器对象。
   缺点：
4. 取值麻烦，只能一个一个取，并且只能往后取，值取了就没了
5. 无法使用len()方法获取长度

for循环原理

for循环称为迭代器循环，in后必须是可迭代的对象。

lis = [1, 2, 3]
for i in lis:
    print(i)

1
2
3

转载于:https://www.cnblogs.com/Wunsch/p/11340279.html