python123作业第四周_python3学习第四周

(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

print(b)

a,b=b,a+b

n=n+1

return  "done" #异常时打印的内容

#函数执行完毕才能干其它事

2.用斐波拉契函数改成的生成器：

def fib(max):   #生成器函数

n,a,b=0,0,1

while n

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.用户认证用装饰器