一鼓作气 博客--第五篇 note5

一、迭代器

二、装饰器

三、生成器

1.生成列表的方式有几种

2、把列表每个数都加1

2.1

data =[1,2,3]

for i in map(lambda x:x+1,data):print(i)

2.1

data =[1,2,3]

for i in data:

i= i+1

print(i)

2.3

data=[348,33,33]

for index ,i in enumerate(data):

data[index] +=1

print(data[index])

2.4

data=[348,33,33,3939]

data=[i+1 for i in data]

print(data)

2.5

2.4列表生成式

data=[93939399,33,3,4,2,222]

data=[i+1 for i in data]

print(data)

2.5三元运算

data= [2,3,4,56,7,8,9]

data=[i*6 if i > 2 else -i for i in data]

print(data)

2.6 岁月是把杀猪刀

2.7 惰性运算--生成器即一边循环一边计算，generator

2.8列表生成式是中括号，生成器是小括号

#列表生成式

H=[h*h for h in range(29)]

print(H)

#生成器

H2=(h*h for h in range(29))

print(H2)

2.8.1生成器只能从第一个值开始推导，必须一个一个访问，不能跳着访问， 不能通过下标取到。如：

H2=(h*h for h in range(29))

print(H2)

H2[5]

output:<generator object <genexpr> at 0x0000000000697A40>

2.8.2生成器：依次计算，计算到第4个，前面三个数据就没了

H2=(h*h for h in range(29))

print(H2)

for i in H2:

print(i)

**********

output:

<generator object <genexpr> at 0x00000000006B7A40>

0

1

4

9

16

25

36

49

2.8.3生成器生成下一个：data.__next__()

H2=(h*h for h in range(29))

H2.__next__()

print(H2.__next__())

H2.__next__()

print(H2.__next__())

--->4

2.8.4 连续生成三次

H2=(h*h for h in range(29))

H2.__next__()

print(H2.__next__())

H2.__next__()

print(H2.__next__())

--->1 9

2.8.5只有print才能打印调用结果，否则每次调用的过程不能直接打印出来，因为这个过程并没有保存到内存里。

H2=(h*h for h in range(29))

H2.__next__()

print(H2.__next__())

H2.__next__()

----> 1

2.8.6生成器下一个 表示方法两种：

2.8.1.1data.__next__()

2.8.1.1.next(data)

H2=(h*h for h in range(29))

H2.__next__() #--->0

H2.__next__() #----1

next(H2) #----4

print(next(H2)) # --->9

output:9

2.斐波那契数列用列表生成式写不出来，但是，用函数很容易打印出来如：

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.10 一行赋值两个

a,b=0,9

print(a)

print(b)

2.11斐波那契中，yield 返回a给通过__next__()调用当前函数的人,不结束，同时挂起当前函数，__next__()取yield()的返回值。这代表通过yield实现了函数的中断，并且保存了函数中间执行的状态。

yield a #返回a, 同时挂起当前这个函数， a返回给了通过__next__()调用当前函数的人

def fib(num):

count = 0

a,b = 0,1

while count < num:

tmp =a

a = b

b = a + tmp

count +=1

yield a

print('done')

f=fib(13)

print(fib(13))

f.__next__()

print(f.__next__())

f.__next__()

print(f.__next__())

f.__next__()

print(f.__next__())

f.__next__()

print(f.__next__())

3、生成器对象，表示准备好，可以开始调用了

4、send相当于next,并且能传递数据给yield

import time

def consumer(name):

print('准备吃包子啦')

while True:

baozi = yield

print('eat %s baozi,baozi is eaten by %s'%(baozi,name))

def producer(name):

c=consumer('A')

c2=consumer('B')

c.__next__()

c2.__next__()

print('baozi come soon later')

for i in range(5):

print('2 baozi is ok')

c.send(i)

c2.send(i)

producer('alex')

5、列表可以被迭代，数字不可以被迭代

6、所有的生成器都是迭代器

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

迭代器不一定是生成器

通过iter 变成一个迭代器，带next方法

7、python3 做了优化，python2 保存过程数据

9、装饰器

8.1完全符合开发过程中开放-封闭原则。

8.2不改变原有代码，不改变原有调用方式，实现新的扩展功能。

9、QQ WEIXIN

user_staturs=False

def login(auth_type):

def outer(func):

def inner():

if auth_type == 'qq':

_username ='alex'

_password ='abc123'

global user_staturs

if user_staturs ==False:

username = input('user:')

password = input('password:')

if username == _username and password ==_password:

print('welcome vip')

user_staturs =True

else:

print('pls try again')

if user_staturs == True:

func()

else:

print('only support qq')

return inner #

return outer

def home():

print('----this is home')

def america():

print('---welcome to america')

@login('qq')

def japan():

print('---welcome to japan')

@login('weixin')

def china():

print('---welcome to china')

japan()

china()

10、 模块 import 时， 在同一级目录能找到，就优先当前目录，找不到就往后找。

寻找路径

import auth

@auth.login

from import import login

11、添加相对路径 os.path.dirname(__file__)

os.path.dirname( os.path.dirname(__file__))

__file__

12、把相对路径变为绝对路径

(__file__)--相对路径

os.path.abspath(__file__)把相对路径边位绝对路径

BaseDir =os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

BaseDir =os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

/// 都是pycharm加工过的。。  实际上Windows里是\\\\  加上abspath他就现出原形了

__file__也不是全路径 而是相对路径 就上上面那个一样 你pycharm里显示的全路径也是加工过的

在shell里执行就像上面一样了

13、一个模块导入多个方法

13.1from auth import *

如果自己的方法与auth里边重名，就把原来的覆盖

13.2import auth

auth.paycheck #调用方式写法

py2 没有_init_被当作目录，目录是不可以被导入的

有_init_,那这个目录就变成了package,包

no matter py2 or py3,only the package can be imported.

howerer,in py3,the directory will also be treated as package

_init_.py in py3,is not a mandatory

sys.stdout.flush() 强制刷新

sys.stdin.readline()接收屏幕标准输入

json:写入文件

文件只能接受字符串，二进制。

修改后可以保存：

把一个内存对象转成字符串形式就叫序列化

把一个字符串转成对应的内存对象就叫反序列化

序列化的作用就是持久化内存数据对象

json.dump

反序列化

json.decoder.JSONDecodeError: Extra data: line 1 column 40 (char 39)  

json.dump

json.load

14、json读写：

import json

data = {'name':'alex','age':10,'sex':'F'}

f=open("data.txt",'w',encoding='utf-8')

json.dump(data,f)

#dump 写到data.txt

import json

f=open("data.txt",encoding='utf-8')

data=json.load(f)

# data=json.loads(f.read())

print(data)

json，用于字符串 和 python数据类型间进行转换

pickle，用于python特有的类型 和 python的数据类型间进行转换