day4 高阶函数 嵌套函数 装饰器 内置函数 列表生成式 迭代器 生成器

一、函数即变量

　　1、赋值效果图

　　a = 1  b = a

　　def func():

　　　　print('hello')

　　func 是函数名，相当于变量名，print('hello')是函数体，相当于变量的值，func()这个表示函数的调用

　　

　　2、python垃圾回收机制

　　　　比如1，由于有a，b两个变量指向它，因此他的引用计数器是2，如果del a，删除变量a，则引用计数器位1，当引用计数器为0时相当于1的内存地址没有人知道，因此当作垃圾清楚掉了。

二、高阶函数、嵌套函数

　　满足下列条件之一就可成函数为高阶函数

1. 某一函数当做参数传入另一个函数中

2. 函数的返回值包含n个函数,n>0

　　嵌套函数

　　定义：在一个函数体内创建另外一个函数，这种函数就叫内嵌函数(基于python支持静态嵌套域)

def foo():
    def bar():
        print 'in the bar'

    bar()

foo()
# bar()

三、闭包　

在函数编程中经常用到闭包。闭包是什么，它是怎么产生的及用来解决什么问题呢。给出字面的定义先：闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)(想想Erlang的外层函数传入一个参数a, 内层函数依旧传入一个参数b, 内层函数使用a和b, 最后返回内层函数)。这个从字面上很难理解，特别对于一直使用命令式语言进行编程的程序员们。本文将结合实例代码进行解释。
函数是什么
地球人都知道：函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。在函数式编程语言中，函 数是一等公民（First class value：第一类对象，我们不需要像命令式语言中那样借助函数指针，委托操作函数），函数可以作为另一个函数的参数或返回值，可以赋给一个变量。函数可 以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。如：

>>> def ExFunc(n):
     sum=n
     def InsFunc():
             return sum+1
     return InsFunc

>>> myFunc=ExFunc(10)
>>> myFunc()
11
>>> myAnotherFunc=ExFunc(20)
>>> myAnotherFunc()
21
>>> myFunc()
11
>>> myAnotherFunc()
21
>>>

在这段程序中，函数InsFunc是函数ExFunc的内嵌函数，并且是ExFunc函数的返回值。我们注意到一个问题：内嵌函数InsFunc中 引用到外层函数中的局部变量sum，IronPython会这么处理这个问题呢？先让我们来看看这段代码的运行结果。当我们调用分别由不同的参数调用 ExFunc函数得到的函数时（myFunc()，myAnotherFunc()），得到的结果是隔离的，也就是说每次调用ExFunc函数后都将生成并保存一个新的局部变量sum。其实这里ExFunc函数返回的就是闭包。

引用环境
按照命令式语言的规则，ExFunc函数只是返回了内嵌函数InsFunc的地址，在执行InsFunc函数时将会由于在其作用域内找不到sum变量而出 错。而在函数式语言中，当内嵌函数体内引用到体外的变量时，将会把定义时涉及到的引用环境和函数体打包成一个整体（闭包）返回。现在给出引用环境的定义就 容易理解了：引用环境是指在程序执行中的某个点所有处于活跃状态的约束（一个变量的名字和其所代表的对象之间的联系）所组成的集合。闭包的使用和正常的函 数调用没有区别。

由于闭包把函数和运行时的引用环境打包成为一个新的整体，所以就解决了函数编程中的嵌套所引发的问题。如上述代码段中，当每次调用ExFunc函数 时都将返回一个新的闭包实例，这些实例之间是隔离的，分别包含调用时不同的引用环境现场。不同于函数，闭包在运行时可以有多个实例，不同的引用环境和相同 的函数组合可以产生不同的实例。

 一，定义
python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).这个定义是相对直白的，好理解的，不像其他定义那样学究味道十足（那些学究味道重的解释，在对一个名词的解释过程中又充满了一堆让人抓狂的其他陌生名词，不适合初学者）。下面举一个简单的例子来说明。

>>>def addx(x):  
>>>    def adder(y): return x + y  
>>>    return adder  
>>> c =  addx(8)  
>>> type(c)  
<type 'function'>  
>>> c.__name__  
'adder'  
>>> c(10)  
18  

结合这段简单的代码和定义来说明闭包：
如果在一个内部函数里：adder(y)就是这个内部函数，
对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域addx里面，但不在全局作用域里，
则这个内部函数adder就是一个闭包。

再稍微讲究一点的解释是，闭包=函数块+定义函数时的环境，adder就是函数块，x就是环境，当然这个环境可以有很多，不止一个简单的x。

四、装饰器

　　内嵌函数+高阶函数+闭包=》装饰器

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Glen

import time

def bar1(n, k = 6):
    time.sleep(1)
    print('in the bar1 n = %s, k = %s' % (n, k))
def bar2():
    time.sleep(1)
    print('in the bar2')
# 高阶函数
def foo2(func):
    start_time = time.time()
    func()
    end_time = time.time()
    print('bar2 run time is = {run_time}'.format(run_time=(end_time - start_time)))
# foo2(bar2)

# 嵌套函数
def func1(func):
    def func2():
        start_time = time.time()
        func()
        end_time = time.time()
        print('bar2 run time is = {run_time}'.format(run_time=(end_time - start_time)))
    return func2

# 原函数没有参数的装饰器
# bar2 = func1(bar2)
# bar2()  # bar2 的功能已经改变 但调用方式和原函数代码都没有修改

def func3(func):
    def func4(*args, **kwargs):
        func(*args, **kwargs)
        print('-----------------')
    return func4

# 适合所有函数的，自身不带参数的装饰器
#bar1 = func3(bar1)
#bar1(8, k=9)

@func3  # @func3是python的语法糖，相当于省略了bar3 = func3(bar3)这个赋值动作
def bar3():
    print('bar3')
bar3()

# 自身带参数的装饰器
def func5(par):
    def decorator(func):
        def wrapper(*args, **kwargs):
            func(*args, **kwargs)
            print('=========================func5 parameter = %s' % par)
        return wrapper
    return decorator

@func5('Glen')  # 相当于bar4 = func5('Glen')(bar4)
def bar4(n):
    print('n = %s' % n)
bar4('QQ')

五、python3内置函数

abs(-5)  # 求绝对值
all([1, -6, 0])  # 判断一个可迭代对象里面的对象是否全部为真
any([1, -6, 0])  # 如果一个可迭代对象里面有一个为真则为真
bin(255)  # 十进制转2进制
bool(0)  # 判断对象真假
# callable()  # 判断是否可调用，就是func()
print(chr(98))  # ASCII码转为字符
# compile()  # python 底层将代码进行编译，很少用到
eval()  # eval() 函数用来执行一个字符串表达式，并返回表达式的值。
exec()  # 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
filter(function, iterable)  # 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象
map(function, iterable, ...)  # 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
from functools import reduce
reduce()
float()
format()
frozenset()  # 不可变元组，没有clear等方法
globals()  # 返回程序里面所有的变量 key value 的键值对字典
hash()
hex(10)  # 转为16进制
len()
globals()  # 打印所有的全局变量
locals()  # 打印所有的本地变量(函数内部)
memoryview()
next()
oct(10)  # 转8进制
pow(2, 3)  # 2 的 3次方
repr()  # 把对象转为字符串
reversed([1, 2, 6])  # 反转
round(1.4434)  # 保留两位

a = {1: 4, 6: 8}
sorted(a.items(), key=lambda x: x[1])  # 对a进行排序，默认按key排序，这里使用lambda函数设置value排序,x是前面a.items,输出未列表
tuple()  # 元组
vars()  # 返回一个对象的所有属性名

a = [1, 2, 3]
b = ['a', 'b', 'c']
zip(a, b)   # 将a和b进行一一组合，(1,'a')  (2, 'b')...

__import__('model_str')   # 只知道模块的字符串名字的时候的导入方法

enumerate()  # for k,v in enumerate(iter):print(k,v) 同时遍历出index和value

　　

六、列表生成式、生成器、迭代器

1、列表生成式

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来

>>> [x * x for x in range(1, 11)]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]

[4, 16, 36, 64, 100]

还可以使用两层循环，可以生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']

['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：

>>> import os >>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录

['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures','Public', 'VirtualBox VMs', 'Workspace', 'XCode']

 

2、生成器

　　通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

　　所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]

>>> L

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> g = (x * x for x in range(10))

>>> g

<generator object <genexpr> at 0x1022ef630>

>>> next(g)

0

>>> next(g)

1

>>> next(g)

4

另一种就是通过函数创建

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b             # 在这里返回b的值并暂停，next(f)进行调用时继续往下执行
        a, b = b, a + b
        n = n + 1
    return "done"
f = fib(6)
print(f)
for v in f:
    print(v)
"""
输出：
<generator object fib at 0x000001F3F44043B8>
1
1
2
3
5
8
"""

　　

3、迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)

True

>>> isinstance(iter('abc'), Iterator)

True

 七、作业ATM

import json
'''
user_info_all = {
    'glen': {
        'password': '123456',
        'limit': 5000,
        'status': 0
    },
    'alex': {
        'password': '654321',
        'limit': 1200,
        'status': 0
    }
}
'''


def userinfo_mem():
    """
    读取存量的用户信息
    :return:
    """
    with open('C:/Users/zxd/PycharmProjects/s14/day4/Atm/atm/user_info.txt', 'r') as f1:
        data = f1.read()
        return json.loads(data)


def userinfo_persist(user_info_all):
    """
    将用户信息写入文件
    :param user_info_all:
    :return:
    """
    with open('user_info.txt', 'w') as f:
        f.write(json.dumps(user_info_all))


def login(func):
    """
    用户登陆验证装饰器
    :param func:
    :return:
    """
    def wapper(*args, **kwargs):
        user_info_all = userinfo_mem()
        username = kwargs['username']
        password = kwargs['password']
        if password == user_info_all[username]['password']:
            print('%s login successful' % username)
            return func(*args, **kwargs)
        else:
            print('login fail')
    return wapper


@login
def get_limit(username='username', password='password'):
    """
    用户获取额度接口
    :param username:
    :param password:
    :return:
    """
    user_info_all = userinfo_mem()
    limit = user_info_all[username]['limit']
    return limit


@login
def change_limit(username='username', password='password', change_money=0):
    """
    用户额度改变接口
    :param username:
    :param password:
    :param change_money:
    :return:
    """
    user_info_all = userinfo_mem()
    limit = user_info_all[username]['limit'] + change_money
    if limit < 0:
        data = {'status': 1, 'reason': 'lack of credit'}
        return json.dumps(data)
    else:
        user_info_all[username]['limit'] = limit
        userinfo_persist(user_info_all)
        data = {'status': 0, 'reason': 'change successful'}
        return json.dumps(data)


@login
def withdraw_deposit(username='username', password='password', withdraw_sum=0):
    """
    提现接口，扣除金额和手续费
    :param username:
    :param password:
    :param withdraw_sum:
    :return:
    """
    amount = withdraw_sum + withdraw_sum * 0.05
    result = json.loads(change_limit(username=username, password=password, change_money=int(amount)))
    if result['status'] == 0:
        data = {'status': 0, 'reason': 'withdraw deposit successful'}
        return json.dumps(data)
    else:
        data = {'status': 1, 'reason': 'withdraw deposit fail'}
        return json.dumps(data)


@login
def transfer(username='', password='', transfer_username='', transfer_money=0):
    """
    给其他用户转账
    :param username:
    :param password:
    :param transfer_username:
    :param transfer_money:
    :return:
    """
    if transfer_money < 0:
        data = {'status': 3, 'reason': "money can't be negative"}
        return json.dumps(data)
    money = 0 - transfer_money
    deduct_result = json.loads(change_limit(username=username, password=password, change_money=money))
    if deduct_result['status'] == 0:
        transfer_result = json.loads(change_limit(username=transfer_username, password='Starcor@123', change_money=transfer_money))
        if transfer_result['status'] == 0:
            data = {'status': 0, 'reason': 'transfer successful', 'transfer_username': transfer_username, 'transfer_money': transfer_money}
            return json.dumps(data)
        else:
            data = {'status': 2, 'reason': 'user info error', 'transfer_username': transfer_username, 'transfer_money': transfer_money}
            return json.dumps(data)
    else:
        data = {'status': 1, 'reason': 'transfer failure', 'transfer_username': transfer_username, 'transfer_money': transfer_money}
        return json.dumps(data)


def add_user(username='', user_password='', limit=0):
    """
    后台管理接口，添加用户
    :param username:
    :param user_password:
    :param password:
    :param limit:
    :return:
    """
    user_info_all = userinfo_mem()
    if username not in user_info_all:
        user_info = {'password': user_password, 'limit': limit, 'status': 0}
        user_info_all[username] = user_info
        userinfo_persist(user_info_all)
        return 'user add successful'


def change_user_status(username='',  status=0):
    """
    冻结用户
    :param username:
    :param status:
    :return:
    """
    user_info_all = userinfo_mem()
    if username in user_info_all:
        user_info_all[username]['status'] = status
        userinfo_persist(user_info_all)
        return 'status change successful'
    else:
        return 'user not exist'