本节内容：装饰器、迭代器、生成器、内置函数、匿名函数
1.函数的有用信息
2.装饰器的升级
3.迭代器
4.生成器
5.生成器表达式、列表推导式
6.内置函数、匿名函数
1、函数的有用信息
from functools import wraps def logger(f): @wraps(f) def inner(*args, **kwargs): """ :param args: 函数名，密码 :param kwargs: 备用 :return: True """ ret = f(*args, **kwargs) return ret return inner @logger def login(username,password): """ 此函数是完成登录功能的函数，需要用户名，和密码两个参数，返回True 登陆成功 :return: True """ print(666) return True # login(1,2) #inner() # # login('alex', 123) print(login.__doc__) print(login.__name__) =====》输出 此函数是完成登录功能的函数，需要用户名，和密码两个参数，返回True 登陆成功 :return: True login
2、装饰器的升级
2.1 什么是装饰器
装饰器本质上就是一个python函数，他可以让其他函数在不需要做任何代码变动的前提下，
增加额外的功能，装饰器的返回值也是一个函数对象。
装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。
2.2 装饰器的形成过程
import time def func1(): print('in func1') def timer(func): def inner(): start = time.time() func() print(time.time() - start) return inner func1 = timer(func1) func1()
但是如果有多个函数，我都想让你测试他们的执行时间，你每次是不是都得func1 = timer(func1)?这样
还是有点麻烦，因为这些函数的函数名可能是不相同，有func1，func2,graph,等等，所以更简单的方
法，python给你提供了，那就是语法糖。
import time def timer(func): def inner(): start = time.time() func() print(time.time() - start) return inner @timer #==> func1 = timer(func1) def func1(): print('in func1') func1()
def timer(func): def inner(a): start = time.time() func(a) print(time.time() - start) return inner @timer def func1(a): print(a) func1(1)
现在给大家整一个能够hold住所有参数的装饰器
import time def timmerout(flag1): # flag1 =flag def timmer(f): def inner(*args,**kwargs): if flag1: start_time = time.time() ret = f(*args,**kwargs) end_time = time.time() print('此函数的执行效率%s' % (end_time - start_time)) return ret else: ret = f(*args, **kwargs) return ret return inner return timmer flag = False @timmerout('alex','nan',1000) # 1,将@ 与函数分开@ timmerout(flag) 返回了timmer 2，将@timmer结合。 def func1(): time.sleep(0.3) print('非常复杂......') return 666 @timmerout(flag) def func2(): time.sleep(0.3) print('非常复杂......') return 666 @timmerout(flag) def func3(): time.sleep(0.1) print('非常复杂......') return 666 1,将@ 与函数分开@ timmerout(flag) 返回了timmer 2，将@timmer结合 def timmerout(flag1): # flag1 =flag def timmer(f): def inner(*args,**kwargs): if flag1: start_time = time.time() ret = f(*args,**kwargs) end_time = time.time() print('此函数的执行效率%s' % (end_time - start_time)) return ret else: ret = f(*args, **kwargs) return ret return inner return timmer @timmerout('京东') # 1,将@ 与函数分开@ timmerout(flag) 返回了timmer 2，将@timmer结合。 def JDshop(): time.sleep(0.3) print('非常复杂......') return 666 @timmerout('京东') def JD(): time.sleep(0.3) print('非常复杂......') return 666 @timmerout('淘宝') def taobao(): time.sleep(0.1) print('非常复杂......') return 666 @timmerout('淘宝') def taobaoshop(): time.sleep(0.1) print('非常复杂......') return 666 func1() func2() func3()
2.3 开放封闭原则
1.对扩展是开放的
为什么要对扩展开放呢？
我们说，任何一个程序，不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改。所以我们必须允许代码扩展、添加新功能。
2.对修改是封闭的
为什么要对修改封闭呢？
就像我们刚刚提到的，因为我们写的一个函数，很有可能已经交付给其他人使用了，如果这个时候我们对其进行了修改，很有可能影响其他已经在使用该函数的用户。
装饰器完美的遵循了这个开放封闭原则。
2.4 装饰器的固定结构
def timer(func): def inner(*args,**kwargs): '''执行函数之前要做的''' ret = func(*args,**kwargs) '''执行函数之后要做的''' return ret return inner
from functools import wraps def deco(func): @wraps(func) #加在最内层函数正上方 def wrapper(*args,**kwargs): return func(*args,**kwargs) return wrapper
2.5 多个装饰器装饰一个函数
def wrapper1(func): def inner(): print('wrapper1 ,before func') func() print('wrapper1 ,after func') return inner def wrapper2(func): def inner(): print('wrapper2 ,before func') func() print('wrapper2 ,after func') return inner @wrapper2 @wrapper1 def f(): print('in f') f()
3、迭代器
3.1 什么是可迭代对象
字符串、列表、元组、字典、集合都可以被for循环，说明他们都是可迭代的。
s1 = 'asvdcsdgfds' for i in s1: print(i) l2 = [1, 2, 3] for i in l2: print(i) i1 = 123 # 不可迭代 'int' object is not iterable for i in i1: print(i) str, list tuple dict set range 文件句柄 该对象中，含有__iter__方法的就是可迭代对象，遵循可迭代协议。 print(dir(str))
3.2 判断该对象是不是可迭代对象
1,判断该对象是不是可迭代对象 '__iter__' in dir(对象) print('__iter__' in dir(str)) print('__iter__' in dir(list)) 2,判断该对象是不是可迭代对象 isinstance('abc',Iterable) from collections import Iterable print(isinstance('abc',Iterable)) print(isinstance('abc',str))
3.3 什么叫迭代器
迭代器遵循迭代器协议：必须拥有__iter__方法和__next__方法。
for循环，能遍历一个可迭代对象，他的内部到底进行了什么？
- 将可迭代对象转化成迭代器。（可迭代对象.__iter__()）
- 内部使用__next__方法，一个一个取值。
- 加了异常处理功能，取值到底后自动停止。
s1 = 'abc' obj_s = s1.__iter__() # 可迭代对象转化成迭代器 obj_s = iter(s1) # 可迭代对象转化成迭代器 print(obj_s) print(obj_s.__next__()) print(obj_s.__next__()) print(obj_s.__next__()) ====》输出 <str_iterator object at 0x000000000250F0B8> a b c =================== s1 = 'fkdsafhdskfhsdklfjdslfksd' s1_obj = s1.__iter__() while True: try: print(s1_obj.__next__()) except StopIteration: break =====》输出 f k d s a f h d s k f h s d k l f j d s l f k s d
3.4 判断该对象是不是迭代器
1,判断该对象是不是迭代器 s1 = 'abc' print('__iter__' in dir(s1)) print('__next__' in dir(s1)) 2,判断该对象是不是可迭代器 from collections import Iterator l1 = [1,2,3] print(isinstance(l1,Iterator)) l1_obj = l1.__iter__() print(isinstance(l1_obj,Iterator))
3.5 迭代器的好处
1.节省内存
2.惰性机制
3.单向执行，不可逆。
4、生成器
生成器本质就是迭代器，他是自定义的迭代器（自己用python代码写的迭代器）
Python中提供的生成器：
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，
在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
生成器Generator：
本质：迭代器(所以自带了__iter__方法和__next__方法，不需要我们去实现)
特点：惰性运算,开发者自定义
4.1 生成器函数
一个包含yield关键字的函数就是一个生成器函数。yield可以为我们从函数中返回值，
但是yield又不同于return，return的执行意味着程序的结束，调用生成器函数不会得
到返回的具体的值，而是得到一个可迭代的对象。每一次获取这个可迭代对象的值，
就能推动函数的执行，获取新的返回值。直到函数执行结束。
def func1(): print(111) yield 666 g_obj = func1() # 生成器对象 print(g_obj) # 凡事函数中见到yield 他就是生成器 print(g_obj.__next__()) =====》输出 <generator object func1 at 0x0000000001E21E60> 111 666 =================== def func1(): print(111) yield 666 print(222) print(333) yield 'alex' print(888) g_obj = func1() # 生成器对象 #__next__() 和 yield 必须一一对应 print(g_obj.__next__()) print(g_obj.__next__()) =====》输出 111 666 222 333 alex
4.2 生成器的好处
就是不会一下子在内存中生成太多数据
def cloth(): for i in range(1,5001): print('衣服%s' %i) cloth() def cloth1(): for i in range(1,5001): yield '衣服%s' %i g_obj = cloth1() # 生成器对象 for i in range(50): print(g_obj.__next__()) for i in range(150): print(g_obj.__next__())
4.3 send
def func1(): count = yield 666 print(count) yield 'alex' yield 'abc' g_obj = func1() # 生成器对象 print(g_obj.__next__()) print(g_obj.__next__()) send 和next 都是对生成器取值。 send 会给上一个yield 发送一个值。 send 不能用在第一次取值。 最后一个yield 不能得到值 print(g_obj.send('taibai')) print(g_obj.send('taibai')) print(g_obj.__next__())
5、生成器表达式、列表推导式
l1 = [] for i in range(1,23): l1.append('python%s期' % i) print(l1) l = [i for i in range(1,11)] # [变量（加工后的变量) for 变量 in iterable] 遍历模式 print(l) l2 = ['python%s期' % i for i in range(1,23)] print(l2) [变量（加工后的变量) for 变量 in iterable] 遍历模式 l1 = [] for i in range(1,31): if i % 3 ==0: l1.append(i) print(l1) [变量（加工后的变量) for 变量 in iterable] 遍历模式 [变量（加工后的变量) for 变量 in iterable if 条件] 筛选模式 l2 = [i for i in range(1,31) if i % 3 == 0] print(l2) l2_obj = (i for i in range(1,31) if i % 3 == 0) print(l2_obj) for i in l2_obj: print(i) print(l2)
5.1 列表推导式练习
1.构建列表： 十以内的所有的元素的平方。 print([i*i for i in range(1,11)]) 2.30以内所有能被3整除的数的平方 print([i*i for i in range(1,31) if i % 3 == 0]) 3.[3,6,9] 组成的列表M = [[1,2,3],[4,5,6],[7,8,9]] print([[i-2, i-1, i] for i in [3,6,9]]) 4.names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'], ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']] print([i for l in names for i in l if i.count('e') == 2]) 5.x = { 'name':'alex', 'Values':[{'timestamp':1517991992.94, 'values':100,}, {'timestamp': 1517992000.94, 'values': 200,}, {'timestamp': 1517992014.94, 'values': 300,}, {'timestamp': 1517992744.94, 'values': 350}, {'timestamp': 1517992800.94, 'values': 280} ],} # 将上面的数据通过列表推导式转换成下面的类型： [[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]] ====>列表推导式 get = (x['Values']) l2 = [[i['timestamp'],i['values']] for i in get] print(l2) 精简版 print([[i.get('timestamp'), i.get('values')] for i in x.get('Values')])
6、内置函数、匿名函数
6.1 内置函数
我们一起来看看python里的内置函数。什么是内置函数？就是Python给你提供的，拿来直接用
的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内
置函数。它们就是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() |
6.2 作用域相关
locals ：函数会以字典的类型返回当前位置的全部局部变量。
globals：函数以字典的类型返回全部全局变量。
a = 1 b = 2 print(locals()) print(globals()) # 这两个一样，因为是在全局执行的。 ########################## def func(argv): c = 2 print(locals()) print(globals()) func(3) #这两个不一样，locals() {'argv': 3, 'c': 2} #globals() {'__doc__': None, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000024409148978>, '__spec__': None, '__file__': 'D:/lnh.python/.../内置函数.py', 'func': <function func at 0x0000024408CF90D0>, '__name__': '__main__', '__package__': None}
6.3 其他相关
6.3.1 字符串类型代码的执行 eval，exec，complie
eval：执行字符串类型的代码，并返回最终结果。
eval('2 + 2') # 4 n=81 eval("n + 4") # 85 eval('print(666)') # 666
exec:执行字符串类型的代码
s = ''' for i in [1,2,3]: print(i) ''' exec(s)
compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
''' 参数说明： 1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。 2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。 3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。 ''' >>> #流程语句使用exec >>> code1 = 'for i in range(0,10): print (i)' >>> compile1 = compile(code1,'','exec') >>> exec (compile1) >>> #简单求值表达式用eval >>> code2 = '1 + 2 + 3 + 4' >>> compile2 = compile(code2,'','eval') >>> eval(compile2) >>> #交互语句用single >>> code3 = 'name = input("please input your name:")' >>> compile3 = compile(code3,'','single') >>> name #执行前name变量不存在 Traceback (most recent call last): File "<pyshell#29>", line 1, in <module> name NameError: name 'name' is not defined >>> exec(compile3) #执行时显示交互命令，提示输入 please input your name:'pythoner' >>> name #执行后name变量有值 "'pythoner'"
有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile。
6.3.2 输入输出相关 input，print
input:函数接受一个标准输入数据，返回为 string 类型。
print:打印输出。
''' 源码分析 def print(self, *args, sep=' ', end='\n', file=None): # known special case of print """ print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件 sep: 打印多个值之间的分隔符，默认为空格 end: 每一次打印的结尾，默认为换行符 flush: 立即把内容输出到流文件，不作缓存 """ ''' print(111,222,333,sep='*') # 111*222*333 print(111,end='') print(222) #两行的结果 111222 f = open('log','w',encoding='utf-8') print('写入文件',file=f,flush=True)
6.3.3内存相关 hash id
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
print(hash(12322)) print(hash('123')) print(hash('arg')) print(hash('alex')) print(hash(True)) print(hash(False)) print(hash((1,2,3))) ''' -2996001552409009098 -4637515981888139739 1 2528502973977326415 '''
id:用于获取对象的内存地址。
print(id(123)) # 1674055952 print(id('abc')) # 2033192957072
6.3.4文件操作相关
open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
6.3.5模块相关__import__
__import__：函数用于动态加载类和函数 。
6.3.6帮助
help：函数用于查看函数或模块用途的详细说明。
print(help(list)) Help on class list in module builtins:
6.3.7调用相关
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；
但如果返回False，调用对象ojbect绝对不会成功。
name = 'alex' def func1(): print(111) print(callable(name)) print(callable(func1)) =====》输出 False True
6.3.8查看内置属性
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的
属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法
将最大限度地收集参数信息。
>>>dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] >>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
6.4 迭代器生成器相关
range：函数可创建一个整数对象，一般用在 for 循环中。
next：内部实际使用了__next__方法，返回迭代器的下一个项目。
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break
iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。
from collections import Iterable from collections import Iterator l = [1,2,3] print(isinstance(l,Iterable)) # True print(isinstance(l,Iterator)) # False l1 = iter(l) print(isinstance(l1,Iterable)) # True print(isinstance(l1,Iterator)) # True
6.5 基础类型数据相关
1.4.1数字相关（14） 数据类型（4）： bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。 int：函数用于将一个字符串或数字转换为整型。 ============== **int：函数用于将一个字符串或数字转换为整型。 print(int()) # 0 print(int('12')) # 12 print(int(3.6)) # 3 ============== *float：函数用于将整数和字符串转换成浮点数。 i = 2.456 print(i,type(i)) print(float(1.1)) ============== complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。 如果第一个参数为字符串，则不需要指定第二个参数。。 i = 1 + 2j print(type(i)) import math print(math.pi) =============== 进制转换（3）：* bin：将十进制转换成二进制并返回。 oct：将十进制转化成八进制字符串并返回。 hex：将十进制转化成十六进制字符串并返回。 print(bin(19)) print(oct(9)) print(hex(15)) =============== 数学运算（7）： abs：函数返回数字的绝对值。 print(abs(-1.2)) *** divmod：计算除数与被除数的结果， 返回一个包含商和余数的元组(a // b, a % b)。 print(divmod(100,7)) # （商，余数） *round：保留浮点数的小数位数，默认保留整数。 print(round(3.43543656,4)) *pow：求x**y次幂。（三个参数为x**y的结果对z取余） print(pow(2,3)) print(pow(2, 3, 3)) *** sum：对可迭代对象进行求和计算（可设置初始值）。 l1 = [i for i in range(100)] print(sum(l1)) print(sum(l1,100)) l2 = [2, 5, 6, -7] ***min：返回可迭代对象的最小值（可加key，key为函数名， 通过函数的规则，返回最小值）。 print(min(l2)) print(min(l2,key=abs)) *** max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 print(max(l2,key=abs)) reversed：将一个序列翻转，并返回此翻转序列的迭代器。 l3 = [2, 3, 9, 8, 7, 4] l3.reverse() print(l3) l_obj = reversed(l3) print(l_obj) for i in l_obj: print(i) ================= * slice：构造一个切片对象，用于列表的切片。 l3 = [2, 3, 9, 8, 7, 4] rule = slice(0,3) print(l3[rule]) * format 科学计算 print(format('test', '<30')) print(format('test', '>20')) print(format('test', '^20')) bytes 将unicode 转化成bytes s = 'alex' b1 = s.encode('utf-8') print(b1) print(bytes(s, encoding='utf-8')) ret = bytearray('alex',encoding='utf-8') print(id(ret)) print(ret) print(ret[0]) ret[0] = 65 print(ret) print(id(ret)) ret = memoryview(bytes('你好',encoding='utf-8')) # [xe31,x312,x3 ] print(len(ret)) print(ret) print(bytes(ret[:3]).decode('utf-8')) print(bytes(ret[3:]).decode('utf-8')) ord 输入字符找该字符编码的位置 unicode print(ord('a')) print(ord('中')) chr 输入位置数字找出其对应的字符 print(chr(97)) print(chr(20013)) 是ascii码中的返回该值，不是就返回/u... print(ascii('a')) print(ascii('中')) **repr:返回一个对象的string形式（原形毕露）。 print(repr('{"name":"alex"}'),type(repr('{"name":"alex"}'))) print('{"name":"alex"}') print('python%s期' % '22') print('python%r期' % '22') l3 = [2, 3, 9, 8, 7, 4] l3.sort() print(l3) *** sorted：对所有可迭代的对象进行排序操作。 ll = sorted(l3) print(ll) sorted() def func(x): return x[1] L = [('a', 3), ('d', 4), ('b', 2), ('c', 1), ] print(sorted(L, key=func)) *** enumerate:枚举，返回一个枚举对象。 l1 = ['alex', 'laonanhai', 'taibai'] for index,content in enumerate(l1): print(index,content) for index,content in enumerate(l1,10): print(index,content) **all：可迭代对象中，全都是True才是True **any：可迭代对象中，有一个True 就是True l1 = [1, 'alex', 3] l2 = [0, '', False,(), 1] print(all(l1)) print(any(l2)) ***zip 拉链方法 l1 = [1,2,3,] l2 = ['a','b','c',5] l3 = ('*','**',(1,2,3),666,777) for i in zip(l1, l2, l3): print(i) ***map:会根据提供的函数对指定序列做映射。返回的是迭代器 def square(x): return x ** 2 print(map(square, [1,2,3,4,5]) ) for i in map(square, [1,2,3,4,5]): print(i) print((i**2 for i in [1,2,3,4,5])) 类似于[i for i in range(1,8) if i % 2 == 0 ] def func(x):return x%2 == 0 ret = filter(func,[1,2,3,4,5,6,7]) print(ret) for i in ret: print(i) min max sorted map filter
6.6 匿名函数
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。
#这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10)) ============== def func1(x): return x**2 res = map(lambda x: x**2,[1,5,7,4,8]) for i in res: print(i) =====》输出 1 25 49 16 64
6.6.1 匿名函数举例
l1 = [ {'sales_volumn': 0},
{'sales_volumn': 108},
{'sales_volumn': 337},
{'sales_volumn': 475},
{'sales_volumn': 396},
{'sales_volumn': 172},
{'sales_volumn': 9},
{'sales_volumn': 58},
{'sales_volumn': 272},
{'sales_volumn': 456},
{'sales_volumn': 440},
{'sales_volumn': 239}]
print(sorted(l1,key= lambda x:x['sales_volumn']))
======》输出
[{'sales_volumn': 0}, {'sales_volumn': 9}, {'sales_volumn': 58}, {'sales_volumn': 108}, {'sales_volumn': 172}, {'sales_volumn': 239}, {'sales_volumn': 272}, {'sales_volumn': 337}, {'sales_volumn': 396}, {'sales_volumn': 440}, {'sales_volumn': 456}, {'sales_volumn': 475}]