#列表生成式:一句代码更加简洁

a=[i*2 for i in range(10)]

print(a)

b=[i*i for i in range(20)]

print(b)

#上面的列表生成式等同于

res=[]

for i in range(10):

    res.append(i*2)

print(res)

#列表生成式的更加高级的用法：

#[funv(i) for i in range(10)]

def fun(n):#定义一个求阶乘的函数

    if n>1:

        return n*fun(n-1)

    else:

        return 1

#利用函数生成10以内的阶乘

c=[fun(i) for i in range(10)]

print(c)

#斐波那契数列

#输出斐波那契数列的前m个数

def fibnacci(m):

    n,a,b=0,0,1

    while n<m:

         print(b)

         a,b=b,a+b #这一句相当于：t=(b,a+b)  a=t[0]  b=t[1]

         n+=1

    return 'done'

fibnacci(10)

上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

#斐波那契数列

#输出斐波那契数列的前m个数

def fibnacci(m):

    n,a,b=0,0,1

    while n<m:

         yield b #这一句很关键

         a,b=b,a+b #这一句相当于：t=(b,a+b)  a=t[0]  b=t[1]

         n+=1

    return ' well done'#异常的时候显示的信息

f=fibnacci(10)

for i in f:

    print(i)

g=fibnacci(6)

#捕获异常并处理

while True:

    try:

        x=next(g)

        print("g:",x)

    except StopIteration as e:

        print("Generator return value :",e.value)

        break

在上面fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

#生产者消费者问题

import time

def consumer(name):

    print("%s,准备好吃汉堡包了"%name)

    while True:

        hamburg=yield

        print("第[%s]个汉堡包来了，被[%s]吃了"%(hamburg+1,name))

def producer(name):

    c1=consumer('Alice')

    c2=consumer('Bob')

    #生产者生产的时候需要通知消费者前来吃

    c1.__next__()

    c2.__next__()

    print("%s,开始做汉堡包了"%name)

    for i in range(10):

        time.sleep(1.5)

        print("做好了1个汉堡包，可以吃了")

        c1.send(i)

        c2.send(i)

producer("Jean")

#迭代器 range(10)表示一个可迭代对象,不是迭代器

from collections import Iterable

from collections import Iterator

a=range(10)

print(a)

print(type(a))

print(isinstance(a,Iterable))

print(isinstance(range(20),Iterator))

for x in a:

    print(x)

#for循环其实就是__next__函数不断迭代出来的

#内置函数

#all（Iterable）,当所有的元素都是为true，则返回true；0为false，非零为true

print(all([1,2]))#True

print(all([0,1,2]))#false

print(any([0,1,2]))#True

print(ascii([1,2,"hello","你好世界"]))#[1, 2, 'hello', '\u4f60\u597d\u4e16\u754c']

print(bin(128))#十进制转二进制#0b10000000

#字符串不能修改，只是生成一个新的字符串；二进制的字符串更不可以修改

a=bytes("abcde",encoding="utf8")#二进制类型

print(a)

print(a.capitalize())

b=bytearray("abcde",encoding="utf-8")

print(b[0])#

b[2]=54#在bytearry 中可以修改

print(b)

print(chr(97))#'a'

print(ord('a'))#

print(divmod(5,2))#返回商和余数

#filter过滤器

#编写过滤器，把奇数过滤掉，打印剩下剩下偶数

res=filter(lambda n:n%2==0,range(100))

for x in res:

    print(x)

#map函数,映射函数

res2=map(lambda n:n*n,range(10))

for x in res2:

    print(x)

import functools

#reduce 函数，求累加

res3=functools.reduce(lambda x,y:x+y,range(10))

print(res3)

#利用reduce求阶乘

res4=functools.reduce(lambda x,y:x*y,range(1,10))

print(res4)

#打印当前页面中的变量利用《key，values》的字典样式

print(globals())#全局变量

print(locals())#局部变量

#hex()转成十六进制，oct转八进制

print(hex(361))

print(oct(361))

#python中一切皆对象，python是一门面向对象的解释性语言

print(pow(2,8))#2的八次方

print(round(3.555412,2))#四舍五入法，3.56

a={5:12,3:14,-51:25,45:98,100:23,56:78}

print(sorted(a.items()))#将字典进行排序,默认采用key进行排序

print(sorted(a.items(),key=lambda x:x[1]))#将字典进行排序,使用的value进行排序

print(a)

#zip()将两个对象的元素对应起来

A=[1,2,3,4]

B=['a','b','c','d','e','f']

for i in zip(A,B):

    print(i)

#内置函数中的compile()方法

#把fibnacci函数进行编译并执行

code='''#输出斐波那契数列的前m个数

def fibnacci(m):

    n,a,b=0,0,1

    while n<m:

         yield b #这一句很关键，yield返回当前状态，保存当前状态

         a,b=b,a+b #这一句相当于：t=(b,a+b)  a=t[0]  b=t[1]

         n+=1

    return ' well done'#异常的时候显示的信息

f=fibnacci(10)

for i in f:

    print(i)

    '''

# py_obj=compile(code,"err.log","exec")

# exec(py_obj)

exec(code)

#json 序列化

#pickle序列化：与接送序列化相似，只是更高级而已

#将信息写入到硬盘上

import json

import pickle

def sayhi(name):

    print("name",name)

info={

    'name':'Jean_V',

    'age':22,

    'time':'2017-10-11',

    'func':sayhi

}

#f=open("json_test.txt",'b')

f=open("json_test.txt",'wb')#使用pickle时要使用二进制编码格式，wb，rb等

# f.write(json.dumps(info))

f.write(pickle.dumps(info))

# f.write(str(info))也是ok

f.close()

#json反序列化

#pickle反序列化：与json序列化相似，支持更高级的

#从硬盘上把信息加载到内存中

import json

import pickle

def sayhi(name):

    print("name",name)

    print("name2:",name)

f=open("json_test.txt","rb")

# f=open("json_test.txt",'r')

#print(eval(f.read())['age'])也可以ok

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

data=pickle.loads(f.read())

print(data)

print(data['age'])

print(data['func'])

print(data['func']("Jean_Name"))

#pickle 序列化

#dump多次，只是复制了新的版本，原来的版本信息还在，因此：

#建议dump一次，load一次，保持最新的

import pickle

info={

    'name':"Jean_V",

    'age':22,

    'hello':'hello friends'

}

f=open("json_test2.txt",'wb')

pickle.dump(info,f)

f.close()

#pickle反序列化

import pickle

f=open("json_test2.txt","rb")

data=pickle.load(f)#等同于data=pickele.loads(f.read())

print(data['name'])

f.close()