一、函数即变量
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的内存地址没有人知道，因此当作垃圾清楚掉了。
二、高阶函数、嵌套函数
满足下列条件之一就可成函数为高阶函数
-
某一函数当做参数传入另一个函数中
-
函数的返回值包含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'