pickle反序列化

一、装饰器

什么是装饰器?
简单点理解,能将一个已有的函数包装到新的函数里面来,并且还是调用原函数的方式来执行,这类的就叫装饰器
装饰器：
定义：（器）本质就是函数，（装饰其它函数）就是为其它函数附加功能
原则：
1、不能修改被装饰的函数的源代码
2、调用的时候必须是写上原函数名的方式调用，不改变原有的调用方式，只是在原函数中添加新功能

实现装饰器知识储备
   1.函数即"变量",我们可以把函数也理解为一个变量
   2.高阶函数
       a:把一个函数名，当做实参（实际参数）传给另外一个函数(在不修改被装饰函数源代码的情况下为其添加功能)
       b:返回值中包括函数名（装饰器）就是这样子的形式的
       b.返回值中包含函数名(不修改函数的调用方式)
　 3.嵌套函数
我们可以通过变量名的方式来确定函数与变量的加载方式

1 # 定义一个foo函数
2 def foo():
3     print("in the foo")
4     bar()  #调用bar但在这个函数上面没有定义会报错
5 
6 # foo()  #调用直接报错  NameError: name 'bar' is not defined
7 # 未定义会报错

变量的调用方式如果未定义也是一样与函数一样报错

1 string = 'abcdefg'
2 print(string)
3 print(xiaofei)  #NameError: name 'xiaofei' is not defined

我们知道了函数与变量的方式是一样先定义再执行的我们将程序修改成为如下的方式

 1 def bar():
 2     print("in ther bar")
 3 
 4 def foo():
 5     print('in the foo')
 6     bar()
 7 
 8 foo()
 9 
10 # in the foo
11 # in ther bar

至于函数内部是不需地考虑先加载的只需要在调用处已经预加载进内存就行了

 1 def foo():
 2     print('in the foo')
 3     bar()
 4 
 5 def bar():
 6     print("in ther bar")
 7 
 8 foo() #这里只需要是上面的函数加载到了内存在调用前加载了都不会报错
 9 # in the foo
10 # in ther bar

将上面的代码修改为下面的，先调用再声明会报错

1 def foo():
2     print('in the foo')
3     bar()
4 
5 # foo()  #NameError: name 'bar' is not defined
6 def bar():
7     print("in ther bar")
8 
9 # NameError: name 'bar' is not defined

什么是高阶函数?
高阶函数是指一个函数可以将另外一个函数做为参数传进去的调用方式
在数学和计算机科学中，高阶函数是至少满足下列一个条件的函数:
1.接受一个或多个函数作为输入
2.输出一个函数

理解高阶函数的时候需要理解匿名函数

什么是匿名函数?

匿名函数可以理解为一个函数只使用一次然后以后不在使用或者以后很少使用的时候,匿名函数只能实现一些简单的功能

calc = lambda x:x*x
print(calc(3)) #9

View Code

高阶函数

1 def f(x):
2     return x * x
3 
4 def h(func, x):
5     return func(x) * func(x)
6 
7 print(h(f, 2)) # 打印结果是: 16
8 # 这段代码中函数h就是一个高阶函数，因为它的第一个参数是一个函数（即接受一个函数作为输入，满足高阶函数的第一个条件）。

b.返回值中包含函数名(不修改函数的调用方式)

 1 def bar():
 2     print("in the bar")
 3 
 4 def test1(func):
 5     print(func)
 6 
 7 
 8 test1(bar)
 9 #<function bar at 0x031E9660> 内存地址
10 # bar() #调用函数
11 
12 fun = bar #将bar 这个函数的内存地址,用一个新的fun来指向
13 fun()  #in the bar  通过fun()的方式来调用相当于bar()的方式来调用的

假如将上面的修改一下,返回的是一个函数的,就可以见接的调用函数了

 1 def bar():
 2     print('in the bar.....!!!!')
 3 
 4 
 5 def xiaofei(func):
 6     print("funct 做的事")
 7     return func
 8 
 9 
10 xiaofei(bar)()
11 
12 # funct 做的事
13 # in the bar.....!!!!

通过上面的我们简单的修改一下,写一个计算函数的运行时间的程序

 1 import time
 2 def bar():
 3     print("in the bar..........")
 4     time.sleep(3) #让这个函数等待3秒
 5 
 6 def test(func):
 7     start_time = time.time()
 8     func() #执行run 
 9     stop_time = time.time()
10     print("the func run time is %s"%(stop_time-start_time))
11 
12 test(bar)
13 # in the bar..........
14 # the func run time is 3.000422477722168

上面实现了在不修改原始的情况下修改调用程序,基本上与高阶原理类似了

高阶函数实现不修改函数名的方式调用原函数名

 1 import time
 2 def test1():
 3     time.sleep(3)
 4     print('in the test1')
 5 
 6 def test2():
 7     time.sleep(3)
 8     print('in the test2')
 9 
10 # 统计函数传入函数的调用时间
11 def deco(func):
12     start_time = time.time()
13     func()
14     stop_time = time.time()
15     print("the func run time is %s"%(stop_time-start_time))

#通过调用deco的方式可以统计这个test的执行时间

deco(test1)
#in the test1
# run time 3.0000481605529785

deco(test2)
#in the test2
# run time 3.000458240509033

假如现在我们需要不修改函数名的方式调用原函数并且添加一些新功能具体怎么实现呢?
    我们将deco修改一下，返回函数的内存地址就行了
嵌套函数+高阶函数==》装饰器

 1 import time
 2 def test1():
 3     print("in ther test1 function ........")
 4 
 5 def timer(func):
 6     def deco():
 7         start_time = time.time()
 8         func()
 9         stop_time = time.time()
10         print("the func run time is %s"%(stop_time-start_time))
11 
12     return deco
13 
14 # print(timer(test1))  #<function timer.<locals>.deco at 0x02B59618>
15 test1 = timer(test1)
16 test1() #这样子就实现了不改变原函数名的调用方式
17     # in ther test1 function ........
18     # the func run time is 0.0

上面虽然实现了在不修改原函数的名字的情况下面添加新的功能的功能，但是这样子太麻烦了需要来回的转，与替换这类的。

python提供了内制的装饰器，实现的功能就是在不修改原函数名的情况下给原函数添加新功能。

 1 import time
 2 def warpper(func):
 3     def bar():
 4         start_time = time.time()
 5         func()
 6         stop_time = time.time()
 7         print("the func run time is %s"%(stop_time-start_time))
 8     return bar
 9 
10 
11 
12 @warpper # bar = warpper(bar) 这样子的形式
13 def bar():
14     time.sleep(3)
15     print('in the bar')
16 
17 bar()
18 # 执行结果:
19     # in the bar
20     # the func run time is 3.0000414848327637

上面虽然实现了装饰器的功能,但是比较简单,如果函数带有参数就会出错

 1 import time
 2 def warpper(func):
 3     def bar(arg):  #这里定义接收参数,可以是单个,多个或者元组,字典类型的参数与普通函数接收的参数类型一样
 4         start_time = time.time()
 5         func(arg) #传入上面带的以数
 6         stop_time = time.time()
 7         print("the func run time is %s"%(stop_time-start_time))
 8     return bar
 9 
10 @warpper
11 def test(name):
12     print('your name:%s'%name)
13 
14 test('xiaofei')

除了上面的单个参数还有可能是带多个参数或者不带参数的方式

 1 import time
 2 def warpper(func):
 3     def bar(*args,**kwargs):  #这里定义接收参数,可以是单个,多个或者元组,字典类型的参数与普通函数接收的参数类型一样
 4         start_time = time.time()
 5         func(*args,**kwargs) #传入上面带的参数
 6         stop_time = time.time()
 7         print("the func run time is %s"%(stop_time-start_time))
 8     return bar
 9 
10 @warpper
11 def bar():
12     print('in the bar....')
13 
14 @warpper
15 def test(name):
16     print('your name:%s'%name)
17 
18 test('xiaofei')
19 bar()

假如我们有一个公司需要写一个网站,一个功能代表一个页面,我们需要在每一个页面加一个登陆验证的功能,怎么样实现?

1 def index():
2     print("this is index page\n welcome to my index page!!!")
3 
4 def home():
5     print("welcome to home page!!!")
6 
7 def bbs():
8     print("welcome to bbs page!!!")

现在要给一部分函数加验证功能,bbs/home添加新功能

 1 user,password = 'king','123456'
 2 def auth(func):
 3     def wrapper(*args,**kwargs):
 4         user_name = input("userNmae:").strip()
 5         user_password = input("Passwrod:").strip()
 6         if user == user_name and password == user_password:
 7             print("\033[32;1m登陆成功!!!\033[1m")
 8             func(*args,**kwargs)
 9             print("执行结束!!!")
10         else:
11             exit("\031登陆失败!!!\033[1m")
12 
13     return wrapper
14 
15 
16 
17 def index():
18     print("this is index page\n welcome to my index page!!!")
19 
20 @auth
21 def home():
22     print("welcome to home page!!!")
23 
24 @auth
25 def bbs():
26     print("welcome to bbs page!!!")
27 
28 
29 index()
30 home()
31 bbs()

this is index page
 welcome to my index page!!!
userNmae:king
Passwrod:123456
登陆成功!!!
welcome to home page!!!
执行结束!!!
userNmae:king
Passwrod:123456
登陆成功!!!
welcome to bbs page!!!
执行结束!!!

现在面对另外一个问题,假如我们将home的验证用文件的方式验证,而bbs用网络数据库的方式验证,怎么样实现呢?

迭代器&生成器
列表生成式,快速生成列表,使代码很简洁更容易阅读

 1 li = [i*2 for i in range(10)]
 2 print(li)  
 3 #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 4 
 5 
 6 # 上面一句话的代码相当于下面的
 7 a = []
 8 for i in range(10):
 9     a.append(i*2)
10 print(a)
11 #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

生成器

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

1 >>> L = [x * x for x in range(10)]
2 >>> L
3 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4 >>> g = (x * x for x in range(10))
5 >>> g
6 <generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

 1 >>> next(g)
 2 0
 3 >>> next(g)
 4 1
 5 >>> next(g)
 6 4
 7 >>> next(g)
 8 9
 9 >>> next(g)
10 16
11 >>> next(g)
12 25
13 >>> next(g)
14 36
15 >>> next(g)
16 49
17 >>> next(g)
18 64
19 >>> next(g)
20 81
21 >>> next(g)
22 Traceback (most recent call last):
23   File "<stdin>", line 1, in <module>
24 StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

 1 >>> g = (x * x for x in range(10))
 2 >>> for n in g:
 3 ...     print(n)
 4 ...
 5 0
 6 1
 7 4
 8 9
 9 16
10 25
11 36
12 49
13 64
14 81

总结：
生成器只有在调用时才会生成相应的
除了for可以一次次的调用生成,只记录当前位置。只有一个__next()__() 方法
python2.*里面用的是next()

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
这个是从小往最大推

 1 def fib(max):
 2     n, a, b = 0, 0, 1
 3     while n < max: #n <10
 4         print(b)
 5         a, b = b, a + b  #注意这一段
 6              # 注意，赋值语句：
 7             # a, b = b, a + b
 8             # 相当于：
 9             # t = (b, a + b) # t是一个tuple
10             # a = t[0]
11             # b = t[1]
12         n = n + 1
13     return 'done'
14 
15 ret = fib(10)
16 print(ret) #done
17     # 1
18     # 1
19     # 2
20     # 3
21     # 5
22     # 8
23     # 13
24     # 21
25     # 34
26     # 55
27     # done

将上面的这个函数修改为生成器只需要一部就可以实现

 1 def fib(max):
 2     n, a, b = 0, 0, 1
 3     while n < max: #n <10
 4         # print(b)
 5         yield b
 6         a, b = b, a + b  #注意这一段
 7              # 注意，赋值语句：
 8             # a, b = b, a + b
 9             # 相当于：
10             # t = (b, a + b) # t是一个tuple
11             # a = t[0]
12             # b = t[1]
13         n = n + 1
14     return 'done'  #这个是取到没有值的情况下就会抛出的异常,只能在__next__()里面实现
15 
16 f = fib(10)
17 print(f) #<generator object fib at 0x01AC3F30>
18 print(f.__next__()) #1
19 print(f.__next__())    #1
20 print(f.__next__()) #2
21 print(f.__next__()) #3

利用生成器可以实现单线程下并发

还可通过yield实现在单线程的情况下实现并发运算的效果

 1 # 还可通过yield实现在单线程的情况下实现并发运算的效果　　
 2 
 3 import time
 4 def consumer(name):
 5     print("%s 准备吃包子啦!" %name)
 6     while True:
 7        baozi = yield
 8 
 9        print("包子[%s]来了,被[%s]吃了!" %(baozi,name))
10 
11 
12 c = consumer("小飞哥")
13 c.__next__()  #小飞哥 准备吃包子啦!
14 # c.__next__()  #包子[None]来了,被[小飞哥]吃了! 
15 # yield里面有一个特殊的函数可以实现next的功能还能传值
16 b1 = "牛肉"
17 c.send(b1)  #包子[牛肉]来了,被[小飞哥]吃了!
18 # send实现了将值传给 yield 并调用.__next__()的功能
19 
20 
21 # exit()
22 
23 def producer(name):
24     c = consumer('A')
25     c2 = consumer('B')
26     c.__next__()
27     c2.__next__()
28     print("老子开始准备做包子啦!")
29     for i in range(10):
30         time.sleep(1)
31         print("做了2个包子!")
32         c.send(i)
33         c2.send(i)
34 
35 producer("alex")

迭代器与迭代对象的区别

可以使用isinstance()判断一个对象是否是Iterable对象：

1 from collections import Iterable
2 print(isinstance([], Iterable)) #True 列表是可以被迭代
3 print(isinstance({}, Iterable)) #True  字典也可以被迭代
4 print(isinstance('abc', Iterable)) #True
5 print( isinstance((x for x in range(10)), Iterable)) #True 这个循环的对象也是一个迭代器
6 print(isinstance(100, Iterable))  #False   数字是不可以被迭代的

可以使用isinstance()判断一个对象是否是Iterator对象：

1 from collections import Iterator
2 print( isinstance((x for x in range(10)), Iterator)) #True
3 print(isinstance([], Iterator))#False
4 print(isinstance([1,3,5], Iterator))#False
5 print(isinstance({}, Iterator))#False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
可以通地iter 将一个可迭代对象转换为可迭代对象
isinstance(iter([]), Iterator)

凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

python内制方法

abs()    dict()    help()    min()    setattr()
all()    dir()    hex()    next()    slice()
any()    divmod()    id()    object()    sorted()
ascii()    enumerate()    input()    oct()    staticmethod()
bin()    eval()    int()    open()    str()
bool()    exec()    isinstance()    ord()    sum()
bytearray()    filter()    issubclass()    pow()    super()
bytes()    float()    iter()    print()    tuple()
callable()    format()    len()    property()    type()
chr()    frozenset()    list()    range()    vars()
classmethod()    getattr()    locals()    repr()    zip()
compile()    globals()    map()    reversed()    __import__()
complex()    hasattr()    max()    round()     
delattr()    hash()    memoryview()    set()

# abs()绝对值
print(abs(-11)) #11

# all() 全部为真时才为真
fl = ['a',None,False]
print(all(fl))  #False 
f2 = ['a','b',111]
print(all(f2))  #True

# bin() #转二进制
print(bin(10)) #0b1010

# bool()布尔，真假，非0/none都为真
print(bool(None)) #False
print(bool(0)) #False
print(bool(-1)) #True
print(bool([])) #False 空列表也为假
print(bool([1])) #True 空列表也为假
print(bool({})) #False 空字典也为假
print(bool({'name':'xiaofei'})) #True 字典里面有数据就为真

bytearray() #字节数组,可修改的二进制数组
a = bytes('abcdefg',encoding='utf-8')
print(a.capitalize(),a)  #b'Abcdefg' b'abcdefg'
# 上面可以看出不能修改，会生成一个新的字节数组


b = bytearray('abcdefg',encoding='utf-8')
print(b[1]) #98 这个输出的是字母对应的ascii码数字
b[1] = 100 #d的编码是100
print(b) #bytearray(b'adcdefg')  这里将b修改成了d

bytes() 字节

 1 # bytes是Python 3中特有的，Python 2 里不区分bytes和str。
 2 b = bytes('abcdefg',encoding='utf-8')
 3 print(type(b),b)  #<class 'bytes'> b'abcdefg'
 4 
 5 string = "abcdefg"
 6 print(type(string),string)  #<class 'str'> abcdefg
 7 
 8 
 9 # bytes是byte的序列，而str是unicode的序列。
10 # str 使用encode方法转化为 bytes
11 # bytes通过decode转化为str
12 # str转换成bytes：

callable() 可不可以被调用

1 print(callable([])) #False 列表不可以被调用，可以加上括号的就可以被调用
2 
3 def sayhi():pass
4 print(callable(sayhi)) #True这个函数是可以被调用的，类也是可以加括号被调用的

chr() 将一个ASCII数字编码转成字符

# print(chr(100)) #d 
for i in range(1000):
    print(chr(i),i)

执行结果如下

View Code

ord() 将一个ascii字符转为数字

1 print(ord('b')) #98
2 print(ord('d'))  #100

compile() 用于底层的把代码编译的过程

1 code = 'for i in range(10):print(i)'
2 print(type(code)) #<class 'str'>
3 co = compile(code,'','exec')
4 print(co)
5 exec(co) #这个就可以执行了

上面这个功能实现上可以动态加载一个模块来执行

dir()可以查看一个对象可以用的一些方法

1 string = 'abcadafadsf'
2 print(dir(string)) #会显示字符串中可以用的方法
3 # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

divmod() 这个可以返回两个数的除数与余数,这个用在分页中比较多

1 ret = divmod(10,3)
2 print(ret) #(3, 1)
3 print(divmod(5,3)) #(1, 2)

enumerate 在循环的时候给一个数加序号

1 li = [1,3,5,6,8]
2 for n,i in enumerate(li):
3     print(n,i)
4 # 0 1
5 # 1 3
6 # 2 5
7 # 3 6
8 # 4 8

eval() 把一个字符串变成字典

a=1
g={'a':20}
eval("a+1",g)
#21

exec() 可以将一段字符串的python代码用来执行

 1 string = 'for i in range(10):print(i)'
 2 exec(string) #执行上面的string
 3     # 0
 4     # 1
 5     # 2
 6     # 3
 7     # 4
 8     # 5
 9     # 6
10     # 7
11     # 8
12     # 9

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

1 def is_odd(x):
2     return x % 2 == 1

然后，利用filter()过滤掉偶数：

 1 def is_odd(x):
 2     return x %2 == 1
 3 
 4 ret = filter(is_odd,[1,3,4,58,99,88])
 5 print(type(ret),ret)  #返回的是一个迭代对象
 6 #<class 'filter'> <filter object at 0x02AC12D0>
 7 
 8 for i in ret:
 9     print(i)
10     # 1
11     # 3
12     # 99

lambda 匿名函数

def sayhi(name):
    print(name)
sayhi('xiaofei')

#上面的函数对应的匿名函数是下面的形式
# print((lambda name :print(name))('xiaofei'))
# 但上面这种写法比较难看
sayhi = lambda name:print(name)
sayhi('xiaofei') #xiaofei 这样子调用

filter() 一组数据里面过滤出想要的

1 fi = filter(lambda n:n>5,range(10)) #过滤出大于5的数
2 # print(fi) #<filter object at 0x006D6390>
3 for i in fi:
4     print(i)
5 # 6
6 # 7
7 # 8
8 # 9

map() 这个返回的是一个迭代器

 1 ret = map(lambda n:n*n,range(10)) # [i*2 for i in range(10)] 是一样的，没有区别
 2 ret2 = [lambda i:i*2 for i in range(10)]
 3 for i in ret:
 4     print(i)
 5     # 0
 6     # 1
 7     # 4
 8     # 9
 9     # 16
10     # 25
11     # 36
12     # 49
13     # 64
14     # 81
15 for i in ret2:
16     print(i)

reduce 这个在python3里面从基础库移到了标准库中

1 import functools
2 # ret = functools.reduce(lambda x,y:x+y,range(10))
3 # print(ret) #45 所有值累计
4 
5 def add(x,y):
6     return x+y
7 li = [1,3,5,6,8,9,10]
8 ret = functools.reduce(add,li)
9 print(ret)#42

frozenset() 冻结的不可变的集合，跟元组一样不可变列表

1 a = frozenset([1,4,5,69])
2 # a.pop() #没有这个方法
3 
4 b =set ([1,3,5,69])
5 b.pop()
6 print(b) #{3, 69, 5}

globals() 这个是返回当前这个程序所有的变量的key,value值

1 abc = '123'
2 print(globals())
3 
4 # 'F:\\Design\\git\\gitlab\\python\\oldpythons14\\s4\\test.py', '__cached__': None, 'abc': '123'}

hash() 散列

# 假如一个数据有500万个，用字典的方式来就会造成至少2分钟以上才能取出来
# print(hash('xiaofei'))
# print(hash("xiaofei"))

折半算法

help()查看帮助

1 # hex() 把一个数字转换成为16进制
2 print(hex(20)) #0x14

id()返回内存地址

1 string = 'abc'
2 print(id(string)) #3305024 内存中的地址

int() 整型

isinstance() 迭代器

len() 长度

1 string = 'abcdefg'
2 print(len(string)) #7

locals() 打印本地变量

1 a = '456'
2 def test():
3     local_var = 333
4     print(locals()) #打印出当前局部变量 {'local_var': 333}
5 
6 test()
7 print(locals())  #打印出当前作用局变量
8 # 'a': '456', 'test': <function test at 0x03819618>}

max()返回列表中的最大值

1 li = [1,365,8,99]
2 print(max(li)) #365

min()返回列表中的最小值

li = [1,365,8,99]
print(min(li))    #1

reversed() 反转

 1 li = [1,3,55,5,56]
 2 ret = reversed(li)
 3 print(type(ret),ret)
 4 for x in ret:
 5     print(x)
 6     # 56
 7     # 5
 8     # 55
 9     # 3
10     # 1

round() 将小数转换为字符四舍五入，可以保留多少位

1 print(round(1.33428)) #1
2 print(round(1.3348,3)) #1.335 保留小数点后3位

slice() 切片用得比较少

1 li = [3,3,65,688,1,9]
2 print(li[3:5]) #[688, 1]
3 myslice = slice(3)    # 设置截取3个元素的切片
4 print(li[myslice]) #[3, 3, 65] 切出来也是一个新的切片
5 
6 
7 # 这个与上面的功能实现的是一样，所以很少用单独的切片
8 print(li[:3]) #[3, 3, 65]

sorted() 字典排序,并变成列表,可以按key排序也可以按value来排序

1 a = {6:2,8:0,1:4,-5:6,99:11,44:22}
2 print(a) #{6: 2, 8: 0, 1: 4, -5: 6, 99: 11, 44: 22}
3 print(sorted(a.items())) #按key来排序的
4 #[(-5, 6), (1, 4), (6, 2), (8, 0), (44, 22), (99, 11)]
5 
6 # 我们也可以按value来排序
7 print(sorted(a.items(),key=lambda x:x[1]))
8 # [(8, 0), (6, 2), (1, 4), (-5, 6), (99, 11), (44, 22)]

type() 查看数据类型

1 string = 'abadasdfadsf'
2 i = 55
3 print(type(string),string)
4 print(type(i),i)
5 # <class 'str'> abadasdfadsf
6 # <class 'int'> 55

zip() 拉链,将两个值合并,合并按最少的那个长度来确定合并后的长度

 1 a = [1,2,3,4,5,6]
 2 b = ['a','b','c','d']
 3 
 4 z = zip(a,b)
 5 for i in z:
 6     print(i)
 7 # (1, 'a')
 8 # (2, 'b')
 9 # (3, 'c')
10 # (4, 'd')

map()可以按最长的来合并

# __import__ 这个导入模块名

# import time #这个是导入模块
# import 'time' #出错
# __import__('time') #这样子可以直接按字符串的方式导入

json序列化

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯(包括C、C++、Java、JavaScript、Perl、Python等)。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。

JSON在python中分别由list和dict组成。

一、python类型数据和JSON数据格式互相转换

python 中str类型到JSON中转为unicode类型，None转为null,dict对应object

二、数据encoding和decoding

1、简单类型数据编解码

所谓简单类型就是指上表中出现的python类型。

dumps:　　将对象序列化

 1 #coding:utf-8
 2 import json
 3 
 4 # 简单编码===========================================
 5 print json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
 6 # ["foo", {"bar": ["baz", null, 1.0, 2]}]
 7 
 8 #字典排序
 9 print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
10 # {"a": 0, "b": 0, "c": 0}
11 
12 #自定义分隔符
13 print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=(',',':'))
14 # [1,2,3,{"4":5,"6":7}]
15 print json.dumps([1,2,3,{'4': 5, '6': 7}], sort_keys=True, separators=('/','-'))
16 # [1/2/3/{"4"-5/"6"-7}]
17 
18 #增加缩进，增强可读性，但缩进空格会使数据变大
19 print json.dumps({'4': 5, '6': 7}, sort_keys=True,indent=2, separators=(',', ': '))
20 # {
21 #   "4": 5,
22 #   "6": 7
23 # }
24 
25 # 另一个比较有用的dumps参数是skipkeys，默认为False。
26 # dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True的话，会忽略这个key。
27 data = {'a':1,(1,2):123}
28 print json.dumps(data,skipkeys=True)
29 
30 #{"a": 1}

dump:　　将对象序列化并保存到文件

1 #将对象序列化并保存到文件
2 obj = ['foo', {'bar': ('baz', None, 1.0, 2)}]
3 with open(r"c:\json.txt","w+") as f:
4     json.dump(obj,f)

loads:　　将序列化字符串反序列化

1 import json
2 
3 obj = ['foo', {'bar': ('baz', None, 1.0, 2)}]
4 a= json.dumps(obj)
5 print json.loads(a)
6 # [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]

load:　　将序列化字符串从文件读取并反序列化

1 with open(r"c:\json.txt","r") as f:
2     print json.load(f)

pickle模块

python的pickle模块实现了python的所有数据序列和反序列化。基本上功能使用和JSON模块没有太大区别，方法也同样是dumps/dump和loads/load。cPickle是pickle模块的C语言编译版本相对速度更快。

与JSON不同的是pickle不是用于多种语言间的数据传输，它仅作为python对象的持久化或者python程序间进行互相传输对象的方法，因此它支持了python所有的数据类型。

pickle反序列化后的对象与原对象是等值的副本对象，类似与deepcopy。

dumps/dump序列化

 1 from datetime import date
 2 
 3 try:
 4     import pickle as pickle    #python 2
 5 except ImportError as e:
 6     import pickle   #python 3
 7 
 8 
 9 src_dic = {"date":date.today(),"oth":([1,"a"],None,True,False),}
10 det_str = pickle.dumps(src_dic)
11 print det_str
12 # (dp1
13 # S'date'
14 # p2
15 # cdatetime
16 # date
17 # p3
18 # (S'\x07\xe0\n\x1b'
19 # tRp4
20 # sS'oth'
21 # p5
22 # ((lp6
23 # I1
24 # aS'a'
25 # aNI01
26 # I00
27 # tp7
28 # s.
29 with open(r"c:\pickle.txt","w") as f:
30     pickle.dump(src_dic,f)

loads/load反序列化

 1 from datetime import date
 2 
 3 try:
 4     import cPickle as pickle    #python 2
 5 except ImportError as e:
 6     import pickle   #python 3
 7 
 8 
 9 src_dic = {"date":date.today(),"oth":([1,"a"],None,True,False),}
10 det_str = pickle.dumps(src_dic)
11 with open(r"c:\pickle.txt","r") as f:
12     print pickle.load(f)
13 # {'date': datetime.date(2016, 10, 27), 'oth': ([1, 'a'], None, True, False)}

JSON和pickle模块的区别

1、JSON只能处理基本数据类型。pickle能处理所有Python的数据类型。

2、JSON用于各种语言之间的字符转换。pickle用于Python程序对象的持久化或者Python程序间对象网络传输，但不同版本的Python序列化可能还有差异。

# 今天的作业,写目录结构
# 5.本节作业
# 作业需求：

# 模拟实现一个ATM + 购物商城程序

#     额度 15000或自定义
#     实现购物商城，买东西加入 购物车，调用信用卡接口结账
#     可以提现，手续费5%
#     每月22号出账单，每月10号为还款日，过期未还，按欠款总额 万分之5 每日计息
#     支持多账户登录
#     支持账户间转账
#     记录每月日常消费流水
#     提供还款接口
#     ATM记录操作日志 
#     提供管理接口，包括添加账户、用户额度，冻结账户等。。。
#     用户认证用装饰器

# 示例代码 https://github.com/triaquae/py3_training/tree/master/atm　

# 简易流程图：https://www.processon.com/view/link/589eb841e4b0999184934329  


# shopping.py
    # buy
    # ....

# # atm.py
    #     提款
    #     还款
    #     查余额
    #     查帐单
    #         1
    #         2
    #         3
    #         4
    #         5
    #

View Code

posted @ 2017-11-03 02:25 fullvip Views(1046) Comments(0) 收藏举报

刷新页面返回顶部

fullvip

s14_day04_装饰器/高阶函数/迭代器/生成器/yield生成器内置方法/json序列化/json反序列化/pickle序列化/pickle反序列化

生成器

python内制方法

json序列化

一、python类型数据和JSON数据格式互相转换

二、数据encoding和decoding

pickle模块

JSON和pickle模块的区别

公告