生成器
集合
无序的，不可随机访问的，不可重复的元素集合
与数学中的集合类似，可以进行集合的交、并、差、补等操作。
分为可变集合和不可变集合
set: 可以进行增、删、改操作
frozenset: 创建好之后，无法再做修改。
可变集合的表示
# 直接表示s = {1, 2, 3, 4}
print(s, type(s)) # {1, 3, 4, 2} <class 'set'># set(Iterable)s1 = set("abc")
s2 = set([1, 2, 3])
print(s1, s2) # {'a', 'b', 'c'} {1, 2, 3}# 集合推导# 参考列表推导s = {x for x in range(3)}
print(s) # {1, 0, 2}不可变集合
# frozenset(iterable)fs = frozenset("abc")
print(fs) # frozenset({'a', 'c', 'b'})# 集合推导fs = frozenset(x**2 for x in range(1, 6) if x % 2)
print(fs) # frozenset({1, 25, 9})注意事项
创建空集合
# 错误做法s = {} # 实际上构建了一个空字典s = set() # 空集合集合中的元素必须是可哈希的值（不可变类型）。
集合中元素若出现重复，则会被合并成一个。
# 多用于给列表元素进行去重li = {1, 2, 2, 3, 3} li = list(set(li)) print(li) # [1, 2, 3]
集合的操作
单集合操作
s = {1, 2, 3}#-----------------------------------------# 新增元素# 1.集合可变 2.新增元素可哈希s.add(4) print(s) # {1, 3, 2, 4}#-----------------------------------------# 删除元素# 1.remove(element)# 删除指定的元素，若无该元素，报错s.remove(2) print(s) # {1, 3}# 2.discard(element)# 删除指定的元素，若无该元素，passs.discard(2) print(s) # {1, 3}s.discard(666) print(s) # {1, 3}# 3.pop(element)# 删除并返回指定元素，若无该元素，报错# 省略 element，不指定删除元素，进行随机删除；集合为空，报错s.pop(1) print(s) # {2, 3}s.pop() print(s) # {2}s.pop() print(s) # set() //空集合的意思# 4.clear()# 清空集合，集合依然存在s.clear() print(s) # set()#-----------------------------------------# 遍历集合# 1.for infor v in s: print(s, sep=' ') # 1 2 3 # 2.迭代器its = iter(s) print(next(its)) # 1print(next(its)) # 2print(next(its)) # 3多集合操作
intersection(iterable):
# 求交集，参数是可迭代类型s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4} res = s1.intersection(s2) print(res) # {4, 5}# s1也可以是frozenset，返回结果也是frozenset# 可以使用逻辑运算符来完成print(s1 & s2) # {4, 5}intersection_update(iterable)
# 更新调用该方法的对象s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4} s1.intersection_update(s2) print(s1) # {4, 5}union(iterable):
# 求并集，参数是可迭代类型s1, s2 = {1, 2, 3}, {2, 3, 4} res = s1.union(s2) print(res) # {1, 2, 3, 4}# 可以使用逻辑运算符来完成print(s1 | s2) # {1, 2, 3, 4}update(iterable)
s1, s2 = {1, 2, 3}, {2, 3, 4} s1.update(s2) print(s1) # {1, 2, 3, 4}difference(iterable)
# 求差集s1, s2 = {1, 2, 3}, {2, 3, 4} res = s1.difference(s2) print(res) # {1}# 逻辑运算符print(s1 - s2) # {1}difference_update(iterable):
s1, s2 = {1, 2, 3}, {2, 3, 4} s1.difference_update(s2) print(s1) # {1}判定操作
# isdisjoint() 两个集合是否不相交# isuperset() 一个集合是否包含另一个集合# issubset() 一个集合是否包含于另一个集合
时间日历
time模块
获得当前时间戳
# 获得从 1970年1月1日到现在的时间秒数import time t = time.time() yearSpan = t / (60 * 60 * 24 * 365) print(yearSpan) # 48.6441059296045
获得时间元组
# 根据所给的时间戳，返回当时的时间信息import time t = time.time() res = localtime(t) print(res) # time.struct_time(tm_year=2018, tm_mon=8, tm_mday=12, tm_hour=10, tm_min=22, tm_sec=4, tm_wday=6, tm_yday=224, tm_isdst=0)
获得格式化的时间
# 根据所给定的时间戳，返回一个更加可读的时间import time t = time.time() res = time.ctime(t) print(res) # Sun Aug 12 10:33:58 2018
获得格式化的时间字符串
# time.strftime(格式字符串, 时间元组)res = time.strftime("%y-%m-%d %H:%M:%S", time.localtime()) print(res) # 18-08-12 10:39:28res = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) print(res) # 2018-08-12 10:39:50获取当前cpu时间
# 常用来统计一段代码的执行时间import time# IDLE环境测试start = time.clock()for i in range(0, 10) print(i, end=' ') end = time.clock() print(end - start) # 0.02806393769252448
休眠
# 线程休眠# 每隔一秒打印一个数字import time n = 0while True: print(n) time.sleep(1) # 参数单位是秒
datetiem模块
模块内部有多个类：datetime、date、time。使用时选择合适的类进行操作就行了
获取当天的日期
import datetime t = datetime.datetime.now() print(type(t)) # <class 'datetime.datetime'>print(t) # 2018-08-12 11:04:12.982890print(t.year) # 2018print(t.month) # 8
计算n天之后的日期
import datetime t = datetime.datetime.today() res = t + datetime.timedelta(days=7) print(t, res, sep='|') # 2018-08-12 11:10:31.995501|2018-08-19 11:10:31.995501
获得两个日期的时间差
import datetime first = datetime.datetime(2018, 9, 10, 12, 0, 0) second = datetime.datetime(2018, 10, 1, 0, 0, 0) res = second - first print(res) # 20 days, 12:00:00
函数
将一段代码集中到一块，起一个名字，下次可以根据这个名字再次使用这个代码块。
作用
方便代码重用
分解任务，简化程序逻辑
使代码更加模块化
函数的参数
所有的传参方式都是传引用，注意列表做参数和数值做参数容易出现的问题。
单个参数
多个参数
# 定义方式def funName(arg1, arg2, arg3...):# 调用方法funName(arg1, arg2, arg3...) # 形参和实参一一对应funName(arg2=v1, arg3=v3, arg1=v1) # 指明形参的名称，不用严格按照顺序
不定长参数
# 1. 利用元组的拆包装包def mySum(*args): print(type(args)) # <class 'tuple'> print(args) # (1, 2, 3, 4) print(*args) # 拆包操作 1, 2, 3, 4 for v in args: # todo ...# 装包，将传入的参数装入一个元组中，args就成了一个元组对象# 拆包，将一个元组中的元素拆分出来，*args就成了参数序列 # 2. 利用字典的键值对def myInfo(**args): print(type(args)) # <class 'dict'> # todo ...myInfo(name="rity", age=12)
默认参数
# 调用某些函数时，可以省略某些参数，采用定义时指定的值# 若不省略，则以调用时输入的为准def sorted(iterable, reverse=False): # todo...sorted([1, 3, 2, 5], reverse=True)
返回值
返回语句标志着函数的结束，一个函数最好只有一处返回语句
如果想返回多个数据，可以把数据包装成一个集合，整体返回（列表，元组，字典...）
def funName(): # todo... return data
偏函数
对于一个默认值较多的函数，有时我们需要重复用到其中的部分默认值，每次指定默认值比较麻烦。
可以将其中的默认值先赋值好，然后封装成一个新的函数，这就是偏函数。
import functools numStr = "100010"res = int(numStr, base=2) print(res) # 34int2 = functools.partial(int, base=2) # 重新封装,构成偏函数print(int2(numStr)) # 34
高阶函数
一个函数的参数可以是另外一个函数
def calculate(a, b, cal_fun): print(cal_fun(a, b))def sum(a, b): return a + b def sub(a, b): return a - b calculate(2, 3, sum) # 5calculate(2, 3, sub) # -1
匿名函数
lambda表达式
没有名字的函数
res = (lambda x, y : x + y)(1, 2) print(res) # 3fun = lambda x, y : x + y print(fun(2, 3)) # 5# 更多的是配合 map(), reduce()等函数进行使用
闭包
在函数嵌套定义的前提下
内层函数引用了外层函数的变量
外层函数把内层函数当做返回值
def line_config(content, length):
define line():
print(content * length)
return line
line1 = line_config("-", 5);
line2 = line_config("*", 6)
line1(); # -----line2(); # ******作用域问题：内层函数要修改外层函数的变量，要使用nonlocal进行声明，否则变量属于内层函数。
def test(): num = 10 def test2(): nonlocal num # test中的 num被修改 num = 666 return test2
当内层函数使用外层的变化量时，注意值得情况
def test(): funs = [] for i in range(1, 4): def test2(): print(i) funs.append(test2) return funs myFuns = test() myFuns[0]() # 3 // 函数在运行时才会去确定变量的值myFuns[1]() # 3 // 运行时，索引 i的值已经发生变化了myFuns[2]() # 3
装饰器
在调用目标函数之前，对这个函数对象进行装饰（增加一些其他功能）。
函数的名字不能改变。
函数体内部的代码不能发生改变。
def check(func):
def inner():
print("登录验证...")
func()
return inner()
# 在 fss()和 ftp()执行之前，都会送入 check()进行包装@check def fss():
print("发说说")# 上面三行等价于 fss = check(fss)@checkdef ftp():
print("发图片")# 上面三行等价于 ftp = check(ftp)
# 主业务逻辑如下：flag = 1if flag == 1:
fss() # 登录验证...else: # 发说说
ftp()多个装饰器的调用顺序
def one(func):
print('----1----') def two():
print('----2----')
func() return twodef a(func):
print('----a----') def b():
print('----b----')
func() return b@one@adef demo():
print('----3----')
demo()# 运行结果 //从下到上装饰，从上到下执行，分析略# 装饰的过程就相当于你把一件礼物一层一层的进行包装，先包装内层# 执行的过程就是把礼物拆开，最外面的包装先被拆开----a----
----1----
----2----
----b----
----3----对带有参数的函数进行装饰
def zsq(funcs):
def inner(*args, **kwargs): # 装包
print("-" * 5)
func(*args, **kwargs) # 拆包
return inner@zsqdef fun1(n1, n2, n3):
print(n1, n2, n3)
@zsqdef fun2(n):
print(n)
fun1(1, 2, n3=8) # 1 2 8fun2(3) # 3对带有返回值的函数进行装饰
def zsq(funcs):
def inner(*args, **kwargs): # 装包
print("-" * 5)
res = func(*args, **kwargs) # 拆包
return res
@zsqdef fun1(n1, n2, n3):
return sum(n1, n2, n3)
fun1(1, 2, 3)带有参数的装饰器
def getzsq(char):
def zsq (func):
def inner():
print(char * 5)
func()
return inner
return zsq
@getzsq("*")def f(): # *****
print("666") # 666
@getzsq("-")def f1(): # -----
print("666") # 666生成器
是一个特殊的迭代器
特性：
惰性计算数据，节省内存
能够记录状态，通过
next()函数，访问下一个状态
使用方式
# 生成器表达式l = (i for i in range(1, 10000000) if i % 2) print(type(l)) # <class 'generator'> // 不是元组推导，没有元组推导式print(next(l)) # 1print(next(l)) # 3for i in l: print(i) # 循环打印出所有满足条件的值 # 生成器函数def test(): for i in range(1, 9): yield i g = test() print(next(g)) # 1print(next(g)) # 2
作者：房顶上的喵
链接：https://www.jianshu.com/p/ba8b9bdea10a
随时随地看视频
