一、函数即变量
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:第一类对象,我们不需要像命令式语言中那样借助函数指针,委托操作函数),函数可以作为另一个函数的参数或返回值,可以赋给一个变量。函数可 以嵌套定义,即在一个函数内部可以定义另一个函数,有了嵌套函数这种结构,便会产生闭包问题。如:
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'