函数

闭包：
1.一个嵌套函数
2.在嵌套函数的内部函数使用外部(非全局的变量)


nonlocal   global


迭代器   生成器   （节省内存空间）

可迭代对象:

    可以被for的就是可迭代对象
    Python 协议
    具有.__iter__方法的就是可迭代对象
    a = 对象.__iter__ # 创建一个迭代器

    具有__iter__和__next__就是一个迭代器

li = [1,2,3]
a = li.__iter__()
print(a)
print(a.__iter__())
print(a.__next__())


li = [1,2,3]
a = li.__iter__()
print(a)
print(a.__next__())
print(a.__next__())  #一个一个取
print(a.__next__())


li = [1,2,3,4,6,7,87,8,9,90,0,0,0,0,8,7,7,67,]
em = li.__iter__()
while 1:
    try:
        print(em.__next__())

    except StopIteration:
        break

for i in range(10):
    print(i)

生成器：

生成器的本质---迭代器

生成器的产生有两种方式:生成器函数和生成器表达式。
只要含有yield关键字的函数都是生成器函数，yield只能用在函数里，且yield和return不能共用。
生成器函数
生成器函数：执行之后会得到一个生成器作为返回值
最简单的生成器：步骤1->4(generator)->4(ret)->5->6->2->3

1.def generator():
2.　　print(1)　　
3.　　yield
4.ret=generator()

5.print(ret)

6.print(ret.__next__())

yield：作为代码并不会结束一个函数


def func():
    print(1)
    yield 5  # 我的函数走到这了
    print(2)
    yield 9  # 我的函数走到这了

g = func()  # 生成一个生成器
print(g.__next__())
print(g.__next__())

def eat():
    for i in range(1, 10000):
        yield '包子' + str(i)
e = eat()
for i in range(200):
    a=next(e)
    print(a)

def func():
    print(1)
    a = yield 2  # 1.挂起 2.返回值 3.接受值
    print(a)   # '123'
    print(3)
    b = yield 4
    print(b)   #'234'
    c = yield 9

g = func()

print(g.__next__())   #1 2  g.send(None)
print(g.send('123'))  # send = next+传值
print(g.send('234'))  # send = next+传值
# # 第一次调用生成器的时候使用send里边的值必须是None
----》1  2  123  3  4  234  9

递归


推导式;
列表推导式   集合推导式   字典推导式   生成器推导式

列表推导式：【】
[i for i in range(10)]

[i for i in range(10) if i%2 == 0]

[j for i in range(10) for em in range(3) for j in range(5)]

集合推导式：{}

s = {i for i in range(10)}
字典推导式{}

{i:i+1 for i in range(10)}
生成器推导式：（）

(i for i in range(10))

装饰器

def warpper(f):  # 接受被装饰的函数内存地址
    def inner(*args,**kwargs):  # 接受被装饰函数的参数
        start_time = time.time() # 新功能
        ret = f(*args,**kwargs)  # 调用被装饰的函数,被装饰参数带上
        end_time = time.time()
        print('%s函数的运行时间:%s'%(f.__name__,end_time - start_time))
        return ret               # 被装饰的函数返回值
    return inner

@warpper   # func = warpper(func)  语法糖
def func(*args,**kwargs):
    print(args)   # 打印被装饰的函数参数
    print('这是主功能!')
    time.sleep(1)
    return '大妈'  # 返回值
ret = func(5)  #ret = func(5)  == inner(5)  返回值  func(5)
print(ret)  # 被装饰的函数返回值

def auto(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是auto')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是auto')
    return inner

def login_auot(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是login_auto')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是login_auto')
    return inner


@warpper      # func = warpper(func)
@login_auot   # func = login_auto(func)
@auto
def func(a):
    print(1)

func(1)

 

内置函数：
's'.format()  # 字符串的方法
print(format('a','>10'))      # 公用函数  右对齐
print(format('a','<10'))      # 公用函数  左对齐
print(format('a','^10'))      # 公用函数  居中

print(globals())  # 查看全局都哪些内容            **
print(b)
print(globals().get('b'))

print(hash([1,2,3]))  #求对象的哈希值             *

print(help(input))      # 不知道怎么用的时候可以使用help查看一下

print(hex(33))           #  将10进制转换成16进制  *

print(id('s'))             # 查看数据的内存地址   ***

print(input(">>>"))         # 获取用户输入的内容  *****

print(int())                  # 将数据转换成整型    *****

print(isinstance([1,2,3],str))   #判断这个数据时什么类型  ***
print(locals())  # 查看局部空间的内容 

print(max(1,2,3,4,5))   # 求最大值              ***

print(min(1,2,3,4))       # 求最小值            ***

print(memoryview(b'a'))        # 查看字节的内存地址

print(next())               # 迭代器中的取下一个值  ***

print(oct(9))                 # 将10进制转换成8进制  **

print(ord('中'))     # 输入的是unicode编码的内容    **
print(chr(20013))    # 输入的是unicode的内容        **

print(pow(2,3))  #两个参数的时候求幂运算
print(pow(2,3))    #三个参数的时候先求幂运算在取余

print(repr('123'))   # 显示的是原数据        ***

print(list(reversed()))  # 反转 元组,列表,字符串    ****

print(round(5.472343212,3))   #四舍五入      ***

print(sum({1:4,2:5}))   #求和     ***

print(type('aasas'))    # 获取数据类型

print(vars(str))
print(locals())

匿名函数：lamda  map(相当于for)  filter   from functools import reduce累加
lamda:
# lambda 关键字  x参数:x是返回值
# 一行函数 用于简单需求
# print((lambda x:x)(5))
# lambda 的返回值只能是一个

f = lambda x,y:x*y
#print(f.__name__)     #<lambda>
print(f(5,6))

# print(sorted([7,2,3,4],reverse=True))

# li = ['你好啊','我好','大家都挺好']

# def func(li):
#     return len(li)
# print(sorted(li,key=func)) # key指定一个排序的规则

# print(sorted(li,key=lambda x:len(x)))


# li = [
#     {'age':19},
#     {'age':52},
#     {'age':48},
#     {'age':30},
# ]

# def func(li):
#     return li['age']
# print(sorted(li,key=func))

# print(sorted(li,key=lambda x:x['age']))

# li = [1,2,3,4]
#
# def func(a):
#     if a > 2:
#         return a
# print(list(filter(func,li)))



# def func(li):
#     for i in li:
#         if i > 2:
#             print(i)
#
# func(li)

# li = [1,2,3,4]
#
# print(list(filter(lambda x:x>2,li)))

# li = [1,2,3,4,5]
#
# def func(i):
#     return i+10
# print(list(map(func,li)))  #映射


# li = [1,2,3,4,5]
# print(list(map(lambda x:x+10,li)))

# from functools import reduce
#
# li = [1,2,3,4,5]
#
# def func(x,y):        # x=12345
#     return x*10+y     # reduce 是做累计算的
# print(reduce(func,li))

 

json  pickle(python独有)  :dumps loads     dump load

s = json.dumps(dic)   # 将字典对象转换成字符串
d = json.loads(di)    # 将字符串转换成字典
# json.dump(d,open('a','w',encoding='utf-8'))

a=json.dump({"a":666},open('a','w',encoding='utf-8')) #字典转文件
d = json.load(open('a','r',encoding='utf-8'))  #文建筑按字典




print(pickle.dumps({'1':4}))   #将对象转换成类似二进制的东西
print(pickle.loads(b'\x80\x03}q\x00X\x01\x00\x00\x001q\x01K\x04s.'))  #二进制转
pickle.dump({'2':4},open('b','wb'))
d = pickle.load(open('b','rb'))

shelve

import shelve
f = shelve.open('c',writeback=True)  #创建文件  # writeback = True 回写

f['name'] = 'alex'

f['age'] = 18

print(f['name'],f['age'])

f['name'] = ['alex','wusir']

print(f['name'])

print(f)  # 这样是查看不了字典

for i in f:
    print(i)   #获取到所有的键

print(f.keys())  #keys也不行

for i in f:
    print(f[i])

#dump load   咱们不用写,自动帮咱们写的

f['name'] = {'2':4}

print(f['name'])

for i in f:
    print(i)

#注意:以后你们会出现一个问题,咱们对字典的操作内容,有时候写不进去.在open

print(f['name'])

f['name'] = 'wusir'
print(f['name'])   # {'2':4}

f['name'] = [1,2,34]

print(list(f.keys()))

random

random
random.random()  0-1
random.randint(1,10)
random.randrange(1,21,2)
random.choice(['alex','wusir','eva_j']])# 从有序数据结构中随机选择一个
# print(random.choices(['wusir','tialaing','taihei','ritian'],k=2))
# 随机选择两个,但是有重复
# print(random.sample(['wusir','tialaing','taihei','ritian'],k=2))
# 随机选择两个,没有重复
# li = [1,2,3,4,6]
# random.shuffle(li)  # 洗牌 打乱顺序



随机数  验证码  微信红包

print(chr(65),chr(90),chr(97),chr(122))

U = chr(random.randrange(65,91))
L = chr(random.randrange(97,123))
n1 = random.randrange(0,10)
n2 = random.randrange(0,10)
print(U, L,n1,n2)

 

os:模块和当前电脑操作系统做交互

os.makedirs('app/a/b/c')   # 递归创建文件       ***
# os.removedirs('app/a/b/c') # 递归删除文件, 当这个要删除的目录有文件就停止删除
 os.mkdir('app')   # 创建单个目录                ***
# os.rmdir('app')     # 删除单个目录,目录如果有东西就报错不进行删除    ***
# print(os.listdir('D:\PyCharmProject\s20\day14'))    ****
# 查看某个目录下的内容

# 文件:
# os.remove() #删除这个文件,删除了就不能恢复了    *****
# os.rename()   #修改文件的名字 


data_dir = os.sep.join(['hello', 'world'])    
操作系统:
# print(repr(os.sep))  #\\
# C:\Users\lucky\Documents\Tencent Files\932023756\FileRecv
# 路径符号

# print(repr(os.linesep))
# 换行符

# print(repr(os.pathsep))
# 环境变量的分割

# print(repr(os.name))

# print(os.system('dir'))

# print(os.popen('dir').read())               ***
# 在写程序的时候可以下发一些操作系统的指令
# 在linux系统上相当于发shell命令

# print(os.environ) 查看 高级 -- 环境变量 -- path   *

# 路径:
# print(os.path.abspath('b'))      ****
# 获取当前文件的绝对路径
# print(os.path.split(r'D:\PyCharmProject\s20\day14\b'))
# 将这个文件的绝对路径分成目录和文件2
# print(os.path.basename(r'D:\PyCharmProject\s20\day14\b'))  **
# 获取的是这个文件的名字
# print(os.path.dirname(r'D:\PyCharmProject\s20\day14\b'))   ***
# 获取的是这个文件的目录路径
# print(os.path.exists(r'D:\PyCharmProject\s20\day10\07 今日总结.py')) **
# 判断这个文件是否存在
# print(os.path.isabs(r'D:\PyCharmProject\s20\day14\b'))
# 判断是否是绝对路径

# print(os.path.join('C:\\','app','a','b'))                 *****
# #路径拼接的  软件开发规范 框架

# os.stat()

# print(os.stat('b').st_size)    os.path.getsize #获取文件大小 ,坑目录目录为0        ***
# print(os.getcwd())  # 获取工作路劲                         ***

# os.chdir('D:\PyCharmProject\s20\day13')  # 路劲切换        *
# print(os.getcwd())

sys

import sys

print(sys.argv[-1])       #***
# 接受cmd方式调用 后边的参数会传递进来
#linux系统上  -- 后端开发 -- 数据库(文件) ip + 端口

# print(sys.path)   # 添加自定义模块路劲的                 # ******
#
# print(sys.version)  # 版本  获取解释的版本号
#
# print(sys.platform)   #获取当前操作系统的平台位数          # 不是定死的
# #
print(sys.exit(1))

 

 

hashilib

# import hashlib
# md5 = hashlib.md5('盐'.encode('utf-8'))  # 选择加密方式  加盐
# md5.update('alex3714'.encode('utf-8')) # 将明文转成字节然后进行加密
# print(md5.hexdigest()) # 生成密文

# md5 = hashlib.md5()  # 选择加密方式  加盐
# md5.update('alex3714'.encode('utf-8')) # 将明文转成字节然后进行加密
# print(md5.hexdigest()) # 生成密文

# sha512 = hashlib.sha512()
# sha512.update('alex3714'.encode('utf-8'))
# print(sha512.hexdigest())

 

time

 

 

print(time.time()) # 浮点型(小数)  给计算机看 计算   时间戳

print(time.localtime())    ---》time.struct_time(tm_year=2020, tm_mon=2, tm_mday=17, tm_hour=21, tm_min=19, tm_sec=14, tm_wday=0, tm_yday=48, tm_isdst=0)

{
 print(time.strftime('%Y-%m-%d %X'))
print(time.strftime('%Y-%m-%d %H:%M:%S')) 


 f = time.strptime('2018-11-30 12:30','%Y-%m-%d %H:%M')}结构化
print(time.strftime('%Y-%m-%d %H:%M:%S',f))
print(time.strftime('%Y-%m-%d %X',f))  结构转字符串

f = time.localtime()
print(time.strftime('%X %Y-%m-%d',f))

t = '2019-03-20 10:40:00'
# 这个时间向后退一个月
# # 1.转成结构化
f = time.strptime(t,'%Y-%m-%d %X')
print(f)
# # 2.结构化时间转成时间戳
# ts = time.mktime(f)
# # 3.将时间戳向大变
# new_ts = ts + 86400 * 30
# # 4.将最新的时间戳转成结构化时间
# new_f = time.localtime(new_ts)
# # 5.将结构化时间转成字符串时间
# print(time.strftime('%Y-%m-%d %X',new_f))

# 获取当前时间求前一月的现在时间
# 1.获取时间戳进行减法计算
# new_ts = time.time() - 30*86400
# # 2.最新的时间戳转成结构化时间
# new_f = time.localtime(new_ts)
# # 3.将结构化时间转成字符串时间
# print(time.strftime('%Y-%m-%d %X',new_f))

# time.strftime()

 

datatime

from datetime import datetime

print(datetime.now())  #2019-03-20 11:35:25.(471359)毫秒
# 时间对象

f = datetime.timestamp(datetime.now())  # 将时间对象转换成时间戳
print(datetime.fromtimestamp(f))        # 将时间戳转成时间对象


print(datetime.strptime('2018-11-30','%Y-%m-%d'))
# 将字符串转成时间对象
f = datetime.now()
print(datetime.strftime(f,'%Y-%m-%d'))
#将时间对象转成字符串

from datetime import datetime,timedelta  # 从xx导入 建议
print(datetime.now() - timedelta())

collection

from collections import deque
# 双端队列

d = deque([1,2,3,4])
d.append(5)      #右边添加
print(d)
d.appendleft(10) # 左边添加
print(d)
d.insert(2,99)


print(d)
d.remove(3)
print(d)


print(d.pop())   # pop()有返回值
print(d)
print(d.popleft())
print(d)

setdefault

from collections import defaultdict
# 默认字典


li = [
    {'name':'alex','hobby':'抽烟'},
    {'name':'alex','hobby':'喝酒'},
    {'name':'alex','hobby':'烫头'},
    {'name':'alex','hobby':'撩妹'},
    {'name':'wusir','hobby':'小宝剑'},
    {'name':'wusir','hobby':'游泳'},
    {'name':'wusir','hobby':'打牌'},
    {'name':'太白','hobby':'烫头'},
    {'name':'太白','hobby':'洗脚'},
    {'name':'太白','hobby':'开车'},
]

d = defaultdict(list)

for i in li:
    d[i['name']].append(i['hobby'])
print([dict(d)])  #合并同类项
-->[{'alex': ['抽烟', '喝酒', '烫头', '撩妹'], 'wusir': ['小宝剑', '游泳', '打牌'], '太白': ['烫头', '洗脚', '开车']}]



2：
D.setdefault(key[,default=None（可更改）])   字典查找如果指定键的值不存在时，返回该值，默认为 None。