day19

[i for i in range(10)]

g_l=(i for i in range(10))

def test():
　　yield 1
　　yield 2
　　yield 3
　　yield 4
res=test()
print(res.__next__())

def test():
　　print('开始生孩子啦啦啦')
　　print('开始生孩子啦啦啦')
　　print('开始生孩子啦啦啦')
　　yield '我'
　　yield '儿子'
　　yield '孙子'
　　yield 4
res=test()
print(res)
print(res.__next__())


def product_baozi():
　　ret=[]
　　for i in range(100)
　　　　ret.append('包子%i' %i)
　　return ret
baozi_list=product_baozi()
print(baozi_list)

def product_baozi():
　　for i in range(10):
　　　　print('正在生产包子')
　　　　yield '包子%s' %i
　　　　print('开始卖包子')
res=product_baozi()
print(res.__next__())



def xiadan():
　　ret=[]
　　for i in range(100):
　　　　ret.append('鸡蛋%s' %i)
　　return ret
res=xiadan()
print(res)

#缺点1：占空间大
#缺点2：效率低

def xiadan():

　　for i in range(100):
　　　　yield '鸡蛋%s' %i

alex_lmj=xiadan()
alex_lmj.__next__()

for jidan in alex_lmj:
　　print(jidan)

 

生成器总结
语法和函数类似：生成器函数和常规函数几乎是一样的，他们都是使用def语句定义，差别在于，
生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
自动实现迭代器协议：
状态挂起：生成器使用yield语句返回一个值，yield语句挂起该生成器函数的状态，保留足够的信息，
以便之后从他离开的地方继续执行

优点一：生成器的好处是延迟计算，一次返回一个结果，也就是说，他不会一次生成所有的结果，
这对于大数据处理，将会非常有用

优点二：生成器还能有效提高代码可读性

 

注意事项：生成器只能遍历一次（母鸡一生只能下一定数量的蛋，下完了就会死掉了）

 

人口普查.txt
{'name':'北京','population':10}
{'name':'山东','population':20}
{'name':'山西','population':30}
{'name':'河北','population':40}
{'name':'台湾','population':50}

 

def get_population():
　　with open('人口普查', 'r',encoding='utf-8') as f:
　　for i in f:
　　　　i=eval(i) #取出来的都是字符串，需要转为字典
　　　　yield i['population']
g=get_population()
s=0
for p in g: #sum(g)
s+=p
print(s)
def cal():
　　with open('人口普查', 'r', encoding='utf-8') as f:
　　for i in f:
　　　　i=eval(i)
　　　　yield i['population']/s
res=cal()
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())
print(res.__next__())

def producer():
　　ret=[]
　　for i in range(100):
　　　　time.sleep(0.1)
　　　　ret.append('包子%s' %i)
　　return ret

def consumer(res):
　　for index,baozi in enumerate(res):
　　　　time.sleep(0.1)
　　　　print('第%s个人，吃了%s' %(index,baozi))
res=producer()
consumer(res)

#yield相当于return 控制的是函数的返回值
#x=yield接收send传过来的值 赋值给x
def test():
　　print('开始啦')
　　first=yield 1
　　print('第一次',first)
　　yield 2
　　print('第三次')

t=test()
res=t.__next__()
print(res)
#res=t.send(None) #把None穿给first send也能触发生成器
res=t.send('函数停留在first那个位置，我就是给first赋值的')
print(res)

#自己所想的
# def test():
#　　 for i in range(10):
#　　　　 yield '包子%s' %i
# t=test()
# for i,baozi in enumerate(t):
# 　　 print(baozi)
# 　　 print('第%s个人，吃了%s' %(i,baozi)

def cunsumer(name): #需要好好思考 生产者 消费者模型
　　print('我是%s,我开始吃包子了' %name)
　　while True:
　　　　baozi=yield
　　　　time.sleep(1)
　　　　print('%s 很开心的把%s吃掉了' %(name,baozi))

def producer():
　　c1=consumer('wupeiqi')
　　c2=consumer('yuanhao')
　　cl.__next__()
　　c2.__next__()
　　for i in range(10):
　　　　time.sleep(1) #识别不了 需要先import time
　　　　c1.send('包子%s' %i)
　　　　c2.send('包子%s' %i)

producer()

1、列举布尔值为False的值
空 None 0

2、写函数
根据范围获取其中3和7整除的所有数字的和，并返回调用者
符合条件的数字个数以及符合条件的数字的总和，如def func(start,end):

def func(start,end):

　　s=0
　　n=0
　　l=[]
　　while start<=end:
　　　　if start%7==0 and start%3==0:
　　　　　　s+=start
　　　　　　n+=1
　　　　　　l.append(start)
　　　　start+=1
　　return s,n,l
s,n,l=func(1,100)
print(s)
print(n)
print(l)

def func(start,end):

　　s=0
　　n=0
　　l=[]
　　for i in range(start,end):
　　　　if i%7==0 and i%3==0:
　　　　　　s+=i
　　　　　　n+=1
　　　　　　l.append(i)
　　return s,n,l
s,n,l=func(1,100)
print(s)
print(n)
print(l)

def func(start,end,s=0,n=0,li=[]):
　　if start==end:
　　　　return s,n,l
　　if start%3==0 and start%7==0:
　　　　s+=start
　　　　n+=1
　　　　li.append(start)
　　start+=1
　　return func(start,end,s,n,li)
(s,n,l)=funs(1,100)
print(s,n,l)

3、函数的默认返回值是什么
None

4、简述break continues return 的区别

5、函数传递参数时，是引用还是复制值？并证明

6、简述三元运算书写格式及应用场景
变量=值一 if 条件 else 值二
把简单的条件判断精简写

7、简述lambda表达式书写及应用场景
函数名=lambda 形参：返回值
将简单的函数书写成匿名函数，减少代码

8、使用set集合获取两个列表l1=[11,22,33] l2=[22,33,44]中相同元素集合
ll1=set(l1)
ll2=set(l2)
l3=ll1&ll2
print(l3)


9、定义函数统计一个字符串中大写字母，小写字母，数字的个数，并以字典的形式返回给调用者

def ca(s)
　　dic={'大写字母个数':0,'小写字母个数':0,'数字个数':0}
　　for i in s:
　　　　if 'A'<=i<='Z'：
　　　　　　dic['大写字母个数']+=1
　　　　elif 'a'<=i<='z':
　　　　　　dic['小写字母个数']+=1
　　　　elif '0'<=i<='9':
　　　　　　dic['数字个数']+=1
　　　　else:
　　　　　　pass
　　return dic
dic=ca('asd13h3jj')
print(dic)


10、简述函数的位置参数，关键字参数 默认参数，可变长参数的特点以及注意事项

11、检查代码，如有错误请改正
a.
def func(x,y,z):
　　print(x,y,z)
func(1,2,3)
输出结果为：
1 2 3

b.
def func(x,z,y=5):
　　print(x,y,z)
func(1,3,3)
输出结果为：
1 3 3

c.
def func(x,y,*z):
　　print(x,y,z)
func(1,2,3,4,5,6)
输出结果为：1 2 (3,4,5,6)

d.
def func(x,y,*z):
　　print(x,y,z)
func(1,2,3,4,5,6,6)
1 2 (3,4,5,6,6)

e.
def func(x,*z,**y):
　　print(x,y,z)
func(1,2,3)
1 {} (2,3)

f.
def func(x,*y,**z):
　　print(z,y,z)
func(1,name=2,age=3)
1 () {'name':2,'age':3}

g.
def func(x,*y,**z):
　　print(x,y,z)
func(1,2,3,4,name=2,age=3)
1 (2,3,4) {'name':2,'age':3}

h.
def func(x=2,*y,**z):
　　print(x,y,z)
func(name=2,age=3)
2 () {'name':2,'age':3}

13书写输出结果
a.
def func(*y,**z):
　　print(y,z)
func(1,2,3,4,5)
(1,2,3,4,5) {}

b.
def func(*y,**z):
　　print(y,z)
func([12345])
([1,2,3,4,5]) {}

c.
def func(*y,**z):
　　print(y,z)
func(*[1,2,3,4,5])
(1,2,3,4,5) {}

d.
def func(*y,**z):
　　print(y,z)
func(*[1,2,3,4,5],name='alex',age=19)
(1,2,3,4,5) {'name':'alex','age':19}

e.
def func(*y,**z): #**********************************
　　rint(y,z)
func(*[1,2,3,4,5],{'name':'alex','age':19})
(1,2,3,4,5,{'name':'alex','age':19}) {}

f.
def func(*y,**z):
　　print(y,z)
func(*[1,2,3,4,5],**{'name':'alex','age':19})
(1,2,3,4,5) {'name':'alex','age':19}

14、书写执行结果
def func1(x=1,*y,**z)
　　print(x,y,z)
　　return y
　　print(x)
def func2(arg):
　　ret=fun1(name=arg)
　　print(ret)
result=func2('fuck')
print(result)

1 () {'name':'fuck'}
()
None

15、书写执行结果
def func(arg):
　　arg.append(55)
　　li=[11,22,33,44]
func(li)
print(li)
li=func(li)
print(li)

[11,22,33,44,55] ################*********注意
None

16、书写执行结果
def f1(arg):
　　print(arg+100)
def f2(arg):
　　ret=f1(arg+1)
　　print(arg)
　　print(ret)
ret=f2(7)
print(ret)
108
7
None
None

17、简述Python3中的range函数和python2.7中range函数有什么区别

3 range 不会生成值，只有用的时候才会生成
2.7会直接生成一个列表，值已经产生

18、书写执行结果
a='oldboy%'
print(a)

oldboy%

b='oldboy%d%%' %(12,)
print(b)
oldboy12%

19、简述对象和类的关系
如果值是某对象，那这个值就只这个类的对象

20、书写执行结果
def func(al):
　　return al+100
func=lambda al:al+200
ret=func(10)
print(ret)

210

21、内置函数all和any的区别
all是如果是空的，返回True，如果非空，全真为真否则为假
any是有一个为真就为真

22、简述文件打开模式'r'和'rb'的区别
r 是只读模式打开
rb 以二进制格式打开

23、将字符串'老男孩'转换成utf-8编码的字节类型
bytes('老男孩',encoding='utf-8')

 

24、利用内置函数将十进制数字12，分别转换成二进制，八进制，十六进制表示的字符串
bin(12)
oct(12)
hex(12)

25、简述内置函数globals(),locals()作用
globals()获取全部的全局变量
locals()获取所有的局部变量

26、利用内置函数zip()，实现功能 ############
l1=['alex',22,33,44,55] l2=['is',22,33,44,55]
l3=['good',22,33,44,55] l4=['guys',22,33,44,55]
请获取字符串s='alex_is_good_guys'
print('_'.join(list(zip(l1,l2,l3,l4))[0]))

27、判断输出结果是否相同，并可得到什么结论
def f1(arg):
　　print(id(arg))
n=11
print(id(n))
f1(n)

相同
执行函数是调用变量值不是复制

28、书写执行结果
a.
NAMELIIST=['alex','eric']
def func():
　　NAMELIST=123
func()
print(NAMELIST)

['alex','eric']

b.
NAMELIIST=['alex','eric']
def func():
　　global NAMELIST=123
func()
print(NAMELIST)

123

c.
NAMELIIST=['alex','eric']
def func():
　　NAMELIST.append('seven')
func()
print(NAMELIST)

['alex','eric','seven']

d.
NAMELIIST=['alex','eric']
def func():
　　NAMELIST=123
　　global NAMELIST
func()
print(NAMELIST)

提醒

29、书写执行结果

a.

name="root"
def func():
　　name='seven'
　　def outer():
　　　　name='eric'
　　　　def inner():
　　　　　　global name
　　　　　　name='蒙蔽了把'
　　　　print(name)
　　print(name)
ret=func()
print(ret)
print(name)

seven
None
root

b.

name="root"
def func():
　　name='seven'
　　def outer():
　　　　name='eric'
　　　　def inner():
　　　　　　global name
　　　　　　name='蒙蔽了把'
　　　　print(name)
　　o=outer()
　　print(o)
print(name)
ret=func()
print(ret)
print(name)
eric
None
seven
None
root

c.
name="root"
def func():
　　name='seven'
　　def outer():
　　　　name='eric'
　　　　def inner():
　　　　　　global name
　　　　　　name='蒙蔽了把'
　　　　print(name)
　　　　inner()
　　o=outer()
　　print(o)
　　print(name)
ret=func()
print(ret)
print(name)

eric
None
seven
None
蒙蔽了把

d.
name="root"
def func():
　　name='seven'
　　def outer():
　　　　name='eric'
　　　　def inner():
　　　　　　nonlocal name
　　　　　　name='蒙蔽了把'
　　　　　　print(name)
　　　　inner()
　　o=outer()
　　print(o)
　　print(name)
ret=func()
print(ret)
print(name)

蒙蔽了把
None
seven
None
root

30、书写执行结果并解释每一步操作
a. ###########注意########注意
name='苍老师'
def outer(func):
　　name='alex'
　　func()
def show():
　　print(name)
outer(show)

b.
name='苍老师'
def outer():
　　name='波多'
　　def inner():
　　　　print(name)
　　return inner()
ret=outer()
print(ret)

波多
None

c.
name='苍老师'
def outer():
　　name='波多'
　　def inner():
　　　　print(name)
　　return inner
ret=outer()
ret()
print(ret)
result=ret()
print(result)

波多
地址
波多
None

d.
name='苍老师'
def outer():
　　name='波多'
　　def inner():
　　　　print(name)
　　return inner
ret=outer()

print(ret)
result=ret()
print(result)

33、利用递归实现
1*2*3*4*5*6*7=5040

def cal(x,s=1):

　　if x==1:
　　　　return s
　　s=x*s
　　x-=1
　　return cal(x,s)
res=cal(7)
print(res)

reduce(lambda x,y:x*y,[i for i in range(8)])

def cal(x): ##############注意注意

　　if x==1:
　　　　return 1

　　return x*cal(x-1)
res=cal(7)
print(res)

37、猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾多吃了一个，第二天早上起来又将剩下的桃子吃了一半，
还是不过瘾有多吃了一个，以后每天都吃前一天的一半再加一个，到第十天刚好还剩一个，问猴子第一天刚好摘了几个

x=x-1/2*x-1
def cal():

　　y=1
　　while True:
　　　　x=y
　　　　for i in range(9):
　　　　　　x=x-(1/2*x)-1
　　　　if x==1:
　　　　　　break

　　　　y+=1
print(y)

###########反推

 

 

2018-08-23