s22day5笔记

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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__)

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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()

# 多个装饰器装饰一个函数

def wrapper1(func): # func = f函数名
def inner1():
print('wrapper1 ,before func') # 2
func() # f函数名()
print('wrapper1 ,after func') # 4
return inner1

def wrapper2(func): # func = inner1
def inner2():
print('wrapper2 ,before func') # 1
func() # inner1()
print('wrapper2 ,after func') # 5
return inner2

def wrapper3(func):
def inner3():
print('wrapper3 ,before func')
func()
print('wrapper3 ,after func')
return inner3

# @wrapper3
# @wrapper2 # f = warpper2(f) 里面的f是inner1 外面的f是inner2
# @wrapper1 # f = warpper1(f) 里面的f函数名 外面的f 是inner1
# def f():
# print('in f') # 3
#
# f() # inner2()

# wrapper2 ,before func
# wrapper1 ,before func
# in f
# wrapper1 ,after func
# wrapper2 ,after func
l = ['您好', '3.64',
'请问您是刘晓宇同学的家长吗', '6.25',
'是的有什么事情吗', '6.15',
'您好我是学大教育的刘老师', '5.06',
'这次给给您打电话主要是想了解一下孩子上学期的协议情况',
'5.86', '针对于上学期的学习状况', '5.37', '我们学校邀请您和孩子周末过来听一下针对性的辅导课好吧好吧', '5.36', '可以我想问一下都有什么课程呢', '5.65', '呃主要是有英语和语文', '4.35', '你看', '3.77', '到时候咱们再联系好吧', '6.10', '好的', '6.45', '恩再见', '4.84']
# [{"onebest":"您好", "speed":"6.060606"},
# {"onebest":"我这是中国电信的客户代表请问您是幺五幺幺零幺五六六六幺号码的长期使用者吗", "speed":"5.479452"},
# {"onebest":"是的", "speed":"5.405406"},
# {"onebest":"为啥谢谢您长期以来的支持", "speed":"5.529954"},
# {"onebest":"交银退掉", "speed":"4.938272"},
# {"onebest":"考虑了解生活小贴士服务美元四月","speed":"4.672897"},
# {"onebest":"你们可以收到天气情况活动", "speed":"5.529954"},
# {"onebest":"我建议", "speed":"4.347826"},
# {"onebest":"生活中了就是周转现在开通后","speed":"4.024768"},
# {"onebest":"发到您的", "speed":"8.510638"},
# {"onebest":"都会","speed":"4.255319"},
# {"onebest":"现在","speed":"6.451613"},
# {"onebest":"可以享有就是看吗", "speed":"5.161290"},
# {"onebest":"可以","speed":"6.451613"},
# {"onebest":"改天先生那是的", "speed":"4.046243"},
# {"onebest":"另外再见", "speed":"5.479452"}
# ]

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-

# 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))
# 第一种方法：
# 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))

# 迭代器 内部含有__iter__ 且含有__next__方法的对象就是迭代器，遵循迭代器协议。
# with open('01 今日内容大纲',encoding='utf-8') as f1:
# print(f1) # <_io.TextIOWrapper name='01 今日内容大纲' mode='r' encoding='utf-8'>
s1 = 'abc'
# obj_s = s1.__iter__() # 可迭代对象转化成迭代器
# obj_s = iter(s1) # 可迭代对象转化成迭代器
# print(obj_s) # <str_iterator object at 0x0000000001F4A128>
# print(obj_s.__next__())
# print(obj_s.__next__())
# print(obj_s.__next__())
# print(obj_s.__next__())

# 第一种方法：
# 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))
#迭代器的好处
# 1,节省内存
# 2，惰性机制
# 3，单向执行，不可逆。

s1 = 'fkdsafhdskfhsdklfjdslfksd'
s1_obj = s1.__iter__()
while True:
try:
print(s1_obj.__next__())
except StopIteration:
break

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 生成器本质就是迭代器，他是自定义的迭代器（自己用python代码写的迭代器）

#1 函数方式的构建一个生成器。
#，生成器表达式。

# def func1():
# print(111)
# return 666
# ret = func1()
# print(ret)

# def func1():
# print(111)
# yield 666
# g_obj = func1() # 生成器对象
# # print(g_obj) # <generator object func1 at 0x0000000001E21E60>
# # 凡事函数中见到yield 他就是生成器
# print(g_obj.__next__())

# 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__())
# print(g_obj.__next__())

# 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__())

# 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__())

 

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 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)
# 列表推导式：简单，一行搞定。
# 特别复杂的数据列表推导式无法实现，只能用其他方式实现。
# 列表推导式不能排错。
# 列表推导式与生成器表达式区别
# 1 ,列推直观能看出，但是占内存
# 2，生成器表达式不易看出，但是节省内存。

# 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])

l = ['您好', '3.64',
'请问您是xxx同学的家长吗', '6.25',
'是的有什么事情吗', '6.15',
'您好我是学大教育的x老师', '5.06',
'这次给给您打电话主要是想了解一下孩子上学期的协议情况', '5.86',
'针对于上学期的学习状况', '5.37',
'我们学校邀请您和孩子周末过来听一下针对性的辅导课好吧好吧', '5.36',
'可以我想问一下都有什么课程呢', '5.65',
'呃主要是有英语和语文', '4.35',
'你看', '3.77',
'到时候咱们再联系好吧', '6.10',
'好的', '6.45',
'恩再见', '4.84']
# 上面这个列表帮我转成下面这种格式
# [{"onebest":"您好", "speed":"6.060606"},
# {"onebest":"我这是中国电信的客户代表请问您是幺五幺幺零幺五六六六幺号码的长期使用者吗", "speed":"5.479452"},
# {"onebest":"是的", "speed":"5.405406"},
# {"onebest":"为啥谢谢您长期以来的支持", "speed":"5.529954"},
# {"onebest":"交银退掉", "speed":"4.938272"},
# {"onebest":"考虑了解生活小贴士服务美元四月","speed":"4.672897"},
# {"onebest":"你们可以收到天气情况活动", "speed":"5.529954"},
# {"onebest":"我建议", "speed":"4.347826"},
# {"onebest":"生活中了就是周转现在开通后","speed":"4.024768"},
# {"onebest":"发到您的", "speed":"8.510638"},
# {"onebest":"都会","speed":"4.255319"},
# {"onebest":"现在","speed":"6.451613"},
# {"onebest":"可以享有就是看吗", "speed":"5.161290"},
# {"onebest":"可以","speed":"6.451613"},
# {"onebest":"改天先生那是的", "speed":"4.046243"},
# {"onebest":"另外再见", "speed":"5.479452"}
# ]
# print([{"onebest":l[i],"speed":l[i+1]} for i in range(len(l)) if i % 2 == 0])
# 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]]

 

 

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
'''
len()
print()
input()
range()
list()
tuple()
str()
int()
set()。。。。。
'''
# 1 作用域相关
# locals golbals
# 1.2其他相关
# 1.2.1 ***eval exec
# print(eval('1 + 2 +3'))
# print(eval("{'name':'alex'}"),type(eval("{'name':'alex'}")))
# exec:执行字符串类型的代码。
# print(exec('1 +2 +3'))
#
s1 = '''
for i in range(5):
print(i)
'''
# print(exec(s1))

# 　compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
# 1.2.2 输入输出相关 ***input，print
# print(1, 2, 3, sep='****') # 分隔符
# print(1111,end='') # 换行
# print(222)
# with open('练习',encoding='utf-8', mode='w') as f1:
# print('今天天气还可以',file=f1)
# *hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

# print(hash('alex'))
# print(hash('alex1'))
# print(hash((1,2,3)))
# print(hash(10))
# print(hash(99))
# print(hash(True))

# ** id:用于获取对象的内存地址。
# 1.2.5
# * 帮助help：函数用于查看函数或模块用途的详细说明。
# print(help(str))

# 1.2.6调用相关
# ** callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败
# ；但如果返回False，调用对象ojbect绝对不会成功。
# name = 'alex'

# def func1():
# print(111)
# print(callable(name))
# print(callable(func1))

# **1.2.7查看内置属性dir
# 1.4 基础数据类型相关
# 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

# 匿名函数

# def func(x,y): return x + y
# print(func(3,4))
# func1 = lambda x,y: x + y
# print(func1(3,4))
# # def func1(x): return x**2
# res = map(lambda x: x**2,[1,5,7,4,8])
# for i in res:
# print(i)

# 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']))