（1-8）上周知识知识回顾：
1.文件操作
文件操作步骤：
a.打开文件，得到句柄。
b.通过句柄操作文件
c.关闭文件
文件操作：
a.增
b.删
c.改
d.查
文件打开方式：
"r","w","a","r+","w+","a+"
"rb","wb","ab"
用这"w"模式打开文件会把原来同名的文件覆盖。
"r+"读追加模式打开文件。
常用方法：
seek() #位置的跳跃
tell() #打印出位置
truncate() #截断字符
flush() #强制把缓存里的东西写到硬盘
2.字符编码转换
python2.x上程序的默认编码为ascⅡ，python3.x上程序的默认编码为Unicode
Unicode识别GBK，Utf-8识别Unicode，所以在转换之前先把字符转换成Unicode编码格式，然后才能转化为其它编码格式。
字符串编码转换步骤：
a.通过decode()方法把字符串解码成Unicode格式。
b.再通过encode()方法把Unicode格式的字符编码为需要的格式。
3.函数
a.函数定义
def func_name(arg1,arg2):
pass
b.位置参数传参
函数调用时，传入的参数要与形参一一对应，与位置有关。
例如：func_name(1, 2)
b.关键字参数传参
函数调用时，通过给形参赋值要传入的参数，与关键字有关。
例如：func_name(arg2= 2，arg1=1)
c.非固定参数
定义函数时，对需要设置的形参个数不确定。
例如：
def func_name(arg1,arg2，*args):
pass
def func_name(arg1,arg2，*args,**kwargs):
pass
给非固定参数传参：
func_name(1,2,4,5,arg5=7,arg6=8):
args接收N个位置参数，并转换为元组形式。
kwargs接N个收关键字参数，并转换为字典形式。
传参时位置参数必须在关键字参数之前
4.全局变量与局部变量
例如：
name="liu chen" #全局变量
def change_name():
name="wjb" #局部变量
print(name)
a.在子程序中（函数）定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
b.全局变量作用域是整个程序，局部变量作用域是定义该变量的函数。
c.当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用，在其它地方全局变量起作用。
d.字符串、数字这类全局变量是不能用局部变量直接更改的，列表、字典、集合、类这类全局变量是能够用局部变量直接更改的
e.可以用global这个关键字来定义一个全局变量。
例如：
name="liu chen"
def change_name():
global age #定义一个全局变量
name="wjb"
print(name)
5.返回值
def func_name():
return False,24
a.返回值的个数为0，则返回None
b.返回值的个数为1，则返回object
c.返回值的个数为>1，则返回元组（tuple）
d. return 语句代表着函数的结束
if func_name(): #表示函数func_name()，如果有返回值就为真，无返回值就为假。
print(func_name)
res=func_name()
if res[0]: #表示函数func_name()返回元组中的第一分元素为True就为真，否则为假。
print(res[0])
6.递归
定义：如果一个函数在内部调用自己本身，这个函数就是递归函数。
特性：
a.必须有一个明确的结束条件。
b.问题规模每次都应该比上一次递归问题规模有所减少。
c.效率不高。
例如：
def calc(n):
print(n)
if int(n/2)>0:
return calc(int(n/2))
print("->",n)
calc(10)
7.高级函数
定义：一个函数把另一个函数当做参数调用，那么这个函数就叫做高阶函数 。
8.函数式编程
a.函数式编程是没有副作用的（知道输入，肯定知道了输出。）
b.函数式不是指函数
9.迭代器&生成器
列表生成式
列表生成式一次生成所有数据(浪费内存)
a.列表生成式例子：a=[i*2 for i in range(10)]
等价于以下代码
a=[]
for i in range(10)
a.append(i*2)
输出结果为[0,2,4,6,8,10,12,14,16,18]
b.列表生成式作用：简化代码，生成列表。
生成器
a.生成器例子：b=( i*2 for i in range(10))
b.生成器特性：1.只有在调用时生成相应的数据，调用后该数据消失(节省内存)。
2.只记住当前位置(不能取当前位置之前的数据，只能取当前位 置之后的数据)。
3.只有一个__next__()方法取当前位置的下一个值。
4.可以通过for循环取所有数据。
c.把函数改成生成器
1.斐波拉契函数：
def fib(max):
n,a,b=0,0,1
while n<max:
print(b)
a,b=b,a+b
n=n+1
return "done" #异常时打印的内容
#函数执行完毕才能干其它事
2.用斐波拉契函数改成的生成器：
def fib(max): #生成器函数
n,a,b=0,0,1
while n<max:
yield b #程序暂停并返回b(程序执行的状态点)
a,b=b,a+b
n=n+1
return "done" #异常时打印的内容
g=fib(6) #创建生成器函数对象
print(g.__next__()) #g._next_()方法执行生成器函数直到yield暂停
print("=====我干其它的====")#跳出生成器干其它的事
print(g.__next__()) #又回来取生成器生成的下一个数据
for i in f:
print(i)
#把函数改成生成器的作用：
#1.不必等这个生成器执行完，就能干其它事，而且想进就进想出就出
yield作用：设置函数暂停点。
_next_()方法两个连用：
例如g1._next_()
g1._next_()
1.运行生成器函数直到yield停止。
2.从yield暂停点开始执行到yield停止。
通过yield实现在单线程的情况下实现并发运算效果
def consumer(name1): #生成器函数
print("%s准备吃包子了" %name1)
while True:
baozi=yield
print("%s包子来了，被%s吃了"%(baozi,name1))
def producer(name2):
c1=consumer("刘晨") #创建生成器函数对象
c2=consumer("刘东晨") #创建生成器函数对象
c3=consumer("郑浩") #创建生成器函数对象
c1.__next__() #运行生成器函数到yield停止
c1.__next__() #从yield暂停点开始执行到yield停止
c2.__next__() #运行生成器函数到yield停止
c3.__next__() #运行生成器函数到yield停止
print(name2,"开始做包子了")
for i in range(10):
print("做3个包子")
c1.send("韭菜") #给yield传值并从yield暂停点继续运行直到yield停止
c2.send("大蒜") #给yield传值并从yield暂停点继续运行直到yield停止
c3.send("大肉") #给yield传值并从yield暂停点继续运行直到yield停止
producer("温建斌")
_next_()方法两个连用
1.运行生成器函数直到yield停止。
2.从yield暂停点开始执行到yield停止。
send()方法作用
给yield传值并从yield暂停点继续运行直到yield停止
迭代器
可直接作用于for循环的数据类型有以下几种：
1.集合数据内型，如list、tuple、dict、set、str 、byte等
2.生成器，包括生成器和带yield的生成器函数。
可迭代(可循环) 对象：这些可以直接作用于for循环的对象。iterable对象
可以使用isinstance()判断一个对象是否是Iterable对象：
from collections import Iterable
isinstance({},Iterable) #判断字典是否可迭代
生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出stopiterable错误表示无法继续返回下一个值了。
迭代器对象：可以被next()调用并不断返回下一个值的对象。Iterator对象
可以使用isinstance()判断一个对象是否是Iterator(迭代器)对象：
from collections import Iterator
isinstance({},Iterator) #判断字典是否是迭代器对象
生成器都是Iterator(迭代器)对象,但是list、dict、str虽然是iterable但是不是Iterator。
把list、dict、str等iterable变成iterable可以使用iter()函数：
a=[1,2,3]
iter(a)
iterator计算是惰性的，只有在需要返回下一个数据时它才会计算。
小结
凡是可作用于for循环的对象都是Iterable对象（可迭代对象）。
凡是可作用于next()函数的对象都是Iterator对象（迭代器对象），它们表示一个惰性计算的序列。
集合数据内型如list、dict、str等是Iterable对象（可迭代对象）但不是Iterator对象（迭代器对象），不过可以通过iter()函数得到一个Iterator对象（迭代器对象）。
python中的for循环本质上就是通过不断的调用next()函数实现的
10.装饰器
装饰器作用：不改变被装饰函数的代码和调用方式的前提下，给被装饰函数添加功能。
a.装饰器
例子：
import time
def timmer(func):
def warpper(*args,**kwargs):
star_time=time.time()
func()
end_time=time.time()
print("the func run time is %s" %(end_time-star_time))
return warpper
@timmer #装饰器
def test1():
time.sleep(3)
print("in the test1")
test1()
1.概念：本质是函数（装饰其它函数），为函数添加其它附加功能。
2.原则：a.不能修改被装饰函数的源代码。
b.不能修改被装饰函数的调用方式。
3.实现装饰器知识储备：
a.函数即“变量”
也就是函数体赋值给函数名，函数使用先定义再调用
b.高阶函数
满足以下条件之一就为高阶函数
1.把一个函数名当做实参传给另一个函数
例子：
def bar():
print("in the bar")
def foo(func):
print("in the foo")
foo(bar)
2.返回值中包含函数名
例子：
def foo():
print("in the foo")
return foo
c.嵌套函数
例子：
def foo():
print("in the foo")
def bar():
print("in the bar")
bar()
foo()
嵌套函数定义：在一个函数体中定义一个函数。
高阶函数+嵌套函数=装饰器（即可实现装饰器的效果）
例子：
#高阶函数+嵌套函数实现的装饰器
import time
def timmer(func):
def deco():
star_time=time.time()
func() #运行test1
end_time=time.time()
print("the func run time is %s" %(end_time-star_time))
return deco
@timmer #进行这个操作test1=timmer(test1)
def test1():
time.sleep(3)
print("in the test1")
# test1=timmer(test1)
test1()
#高阶函数+嵌套函数实现的带非固定参数的装饰器
import time
def timmer(func):
def deco(*args,**kwargs):
star_time=time.time()
func(*args,**kwargs)
end_time=time.time()
print("the func run time is %s" %(end_time-star_time))
return deco
@timmer #等价于test1=timmer(test1)
def test1():
time.sleep(1)
print("in the test1")
@timmer #等价于test2=timmer(test2)也就是说把deco函数的内存地址给了test2
def test2(name,age):
time.sleep(1)
print(name,age)
test1()
test2("oil",23) #调用test2相当调用deco函数
decorator 装饰器
装饰器应用实例：网页的登录验证
#给页面添加登录认证，只有登录了才能做其它事情
usnm="xiao"
pswd="123"
def auth(func):
def wrapper(*args,**kwargs):
username=input("username:")
password=input("password:")
if usnm==username and pswd==password:
print("authentication has passed,welcome ",username)
res=func(*args,**kwargs)
return res
else:
print("invalid password or username")
exit()
return wrapper
def index():
print("welcome to index page")
@auth
def home():
print("welcome to home page")
return "home!!!!"
@auth
def bbs():
print("welcome to bbs page")
index()
print(home())
bbs()
应用实例：根据不同的验证方式进行不同的验证
usnm="xiao"
pswd="123"
def auth(auth_type):
def outer_wrapper(func):
def wrapper(*args, **kwargs):
if auth_type=="local":
username = input("username:")
password = input("password:")
if usnm == username and pswd == password:
print("authentication has passed,welcome ", username)
res = func(*args, **kwargs)
return res
else:
print("invalid password or username")
exit()
elif auth_type=="ldap":
print("是ldap验证！不会！")
return wrapper
return outer_wrapper
def index():
print("welcome to index page")
@auth(auth_type="local")
def home():
print("welcome to home page")
return "home!!!!"
@auth(auth_type="ldap")
def bbs():
print("welcome to bbs page")
index()
print(home())
bbs()
总结：
最终的万能装饰器函数结构为
def timmer(func): #外层函数必须有参数func
def deco(*args,**kwargs): #必须有嵌套函数deco()和非固定参数
func(*args,**kwargs) #必须有func()函数和非固定参数
return deco #必须返回deco()函数的地址
11.内置方法
abs() #取绝对值
all() #可迭代对象中的所有元素为真,则返回True, 空返True否则返回false
any() #可迭代对象中的任一元素为真,则返回True,否则返回false,空返false
bin() #把一个整数转为二进制数
bool() #判断真假
bytearray() #把某个对象转为可更改的字节数组
bytes() #把某个对象转为字节
callable() #判断是否可调用
chr() #返回ascii码对应的对象（数字或者字母或者其它字符）
ord() #返回对象（数字或者字母或者其它字符）码对应的ascii
exec() #运行一段(复杂)代码
例如：
code="for i in range(5):print(i)"
exec(code)
dir() #显示对象的所有方法
eval() #函数只能运行简单的代码
例如：
a=1
eval("a+20")
运行结果为：21
exec() #函数可以动态运行代码段
filter() #过滤掉不符合条件的元素，返回由符合条件元素组成的新list
例如：
res=filter(lamda:n>5,range(10))
for i in res:
print(i)
输出:6,7,8,9
map() #根据提供的函数对指定序列做映射(把传入的数处理后返回,python3中返回迭代器)
例如：
res=map(lambda n:n*2,range(2))
for i in res:
print(i)
输出:0,2
divmod() #返回商和余数
例如：
divmod(5,2)
返回(2,1)
enumerate() #顺序返回对象的索引及对象
例如：
enumerate([a,b,c])
返回(0,a), (1,b) ,(2,c)
formate() #格式化输出字符串
frozenset() #返回一个不可变的集合
globals() #以字典形式返回当前位置的全部全局变量
hash() #用于获取一个对象的哈希值
help() #查看帮助
hex() #把一个整数转为十六进制数
id() #返回内存地址
input() #接收用户输入并转换为字符串
int() #把一个字符串或者数字转换成整型
instance() #判断一个对象是否是某个类型
iter() #生迭代器(转化成迭代器)
len() #返回对象的长度或者项目(元素)个数
list() #把对象转化为列表
local() #以字典的形式返回当前位置的所有局部变量
long() #将字符串或者数字转为长整型
max() #返回给定参数的最大值
memoryview() #返回给定参数的内存查看对象
min() #返回给定参数的最小值
next() #返回迭代器的下一个项目(元素)
oct() #将一个整数转换为八进制的字符串
open() #打开文件，并创建一个file对象
pow() #返回x的y次方
property() #在新式类中返回属性值
range() #创建一个整数列表，一般用在for循环中
reduce() #函数会对参数序列中元素进行累积(计算列表中元素之和)
例如：
reduce(lambda x, y: x+y, [1,2,3,4,5])
结果：15
repr() #讲对象转化为供解释其读取的形式
reverse() #反向列表中的元素
round() #保留到小数点某一个位
set() #将对象转成集合
slice() #返回切片对象
sorted() #对可迭代的对象进行排序
staticmethod 返回函数的静态方法
类可以不用实例化就可以调用该方法 C.f()，当然也可以实例化后调用 C().f()
sun() #求和
super() #用于调用父类(超类)的一个方法
tuple() #将对象转换为元组
str() #把对象转成字符串
type() #判断对象的类型
vars() #以字典的形式返回对象的属性和属性值
zip() #将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
(相当于拉链式拼接)
例如：
a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)
结果：[(1, 4), (2, 5), (3, 6)]
__import__() #用于动态加载类和函数
12.Jison & pickle数据序列化
json序列化和反序列化
json序列化和反序列化概念：
json序列化是将python对象编码成json字符串。
json反序列化是将json字符串解码为python对象。
json序列化和反序列化作用：
1.只能对简单的数据进行序列化和反序列化，如列表，字典，元组，字符串等
2.可以实现是把内存中的数据存到文件中，json反序列化是把存到文件中的数据读出来存到内存中，最终实现程序的挂起和恢复。
json序列化
import json
info={"name":"zhang","age":25}
f=open("test.text","w")
f.write(json.dumps(info)) #json序列化
f.close()
json反序列化
import json
f=open("test.text","r")
data=json.loads(f.read()) #json反序列化
print(data["age"])
f.close()
json.dumps() #将python对象编码成json字符串
json.loads() #将json字符串解码为python对象
json的序列化和反序列化只能对简单的数据进行，如列表，字典，元组，字符串等
文件中只能存字符串或者二进制码，所以存列表，字典，元组，字符串等须把它们转换为字符串或者二进制码。
json作用就是实现不同程序平台之间数据的交互
xml 作用就是实现不同程序平台之间数据的交互
pickle序列化和反序列化
pickle序列化和反序列化概念：
pickle序列化将python对象编码成pickle二进制码
pickle反序列化将pickle二进制解码成python对象
pickle序列化和反序列化作用：
1.可对任意数据可以进行序列化和反序列化，如函数等
pickle序列化
import pickle
def sayhi(name):
print("hello",name)
info={"name":"zhang","age":25,"func":"sayhi"}
f=open("test.text","wb")
f.write(pickle.dumps(info)) #pickle序列化
f.close()
pickle序列化2
import pickle
def sayhi(name):
print("ni hao",name)
info={"name":"zhang","age":23,"func":sayhi}
f=open("test3.text","wb")
pickle.dump(info,f) #等价于f.write(pickle.dumps(info))#pickle序列化
f.close()
pickle 可以把python中的任意类型数据序列化
pickle反序列化
import pickle
def sayhi(name): #pickle反序列化需要把sayhi函数复制过来
print("ni hao",name)
data=open("test2.text","rb")
info=pickle.loads(data.read()) #pickle反序列化
print(info["func"]("刘东"))
data.close()
pickle反序列化2
import pickle
def sayhi(name):
print("ni hao",name)
info={"name":"zhang","age":23,"func":sayhi}
f=open("test3.text","wb")
pickle.dump(info,f) #等价于f.write(pickle.dumps(info))#pickle反序列化
f.close()
13.软件目录结构规范化
Foo项目
1.bin/:存放项目的一些可执行文件，当然可以起名script/之类。
2.conf/:
3.foo/:或者core/:存放项目的所有源代码。(1)源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2)其子目录tests/存放单元测试代码；(3)程序的入口最好命名为mai.py。
4.logs/:
5.docs/:存放一些文档
6.setup.py:安装、部署、打包的脚本。
7.requirements.text:存放软件依赖的外部python包列表。
8.README:项目说明文件。
如何在atm中调用core包中main文件中的函数或者方法
import os
import sys
print(__file__) #__file__获取当前文件的相对路径
print(os.path.abspath(__file__)) #os.path.abspath(__file__)获取当前文件的绝对路径并打印出
print(os.path.dirname(os.path.abspath(__file__)))#获取当前文件上一级目录的绝对路径并打印出
print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))#获取当前文件上上一级目录的绝对路径并打印出
base_dirname=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(base_dirname) #把这个绝对路径添加到系统环境变量中
from conf import setting
from core import main
main.login()
14.作业：ATM项目开发
模拟实现一个ATM+购物商城程序
1.额度15000或者自定义
2.实现购物商城，买东西加入购物车，调用信用卡接口结账
3.可以提现，手续费5%
4.支持多账户登录
5.支持账户间转账
6.记录每月消费流水
7.提供还款接口
8. ATM记录操作日志
9.提供管理接口，包括添加账户、用户额度、冻结账户等
10.用户认证用装饰器
扫一扫
428
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
