迭代器
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件
特点：
- 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
- 不能随机访问集合中的某个值 ，只能从头到尾依次访问
- 访问到一半时不能往回退
- 便于循环比较大的数据集合，节省内存
a=iter([1,2,3,4,5])
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
print(a.__next__())
迭代器
运行代码：
D:\Python34\python.exe C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py
1
2
3
4
5
生成器generator
定义：一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator），如果函数中包含yield语法，那这个函数就会变成生成器
def cash_out(amount):
while amount >0:
amount -= 1
yield 1
print("擦，又来取钱了。。。败家子！")
ATM = cash_out(5)
print("取到钱 %s 万" % ATM.__next__())
print("花掉花掉!")
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__())
print("花掉花掉!")
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__())
print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了
print("取到钱 %s 万" % ATM.__next__())
生成器
运行代码：
取到钱 1 万
花掉花掉!
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
取到钱 1 万
花掉花掉!
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
取到钱 1 万
擦，又来取钱了。。。败家子！
Traceback (most recent call last):
File "C:/Users/AMTF/PycharmProjects/S12/day1/ifelse.py", line 18, in <module>
print("取到钱 %s 万" % ATM.__next__()) #到这时钱就取没了,再取就报错了
StopIteration
作用：
这个yield的主要效果呢，就是可以使函数中断，并保存中断状态，中断后，代码可以继续往下执行，过一段时间还可以再重新调用这个函数，从上次yield的下一句开始执行。
import time
def consumer(name):
print("%s 准备吃包子了！"%name)
while True:
baozi=yield
print(("包子【%s】来了，被[%s]吃了")%(baozi,name))
def producer(name):
c=consumer("a")
c2=consumer("b")
c.__next__()
c2.__next__()
print("老子开始做包子了！")
for i in range(1,4):
time.sleep(1)
print("做了两个包子！")
c.send(i)
c2.send(i)
producer("alex")
使用yield实现单线程的一部并发效果
运行代码：
a 准备吃包子了！
b 准备吃包子了！
老子开始做包子了！
做了两个包子！
包子【1】来了，被[a]吃了
包子【1】来了，被[b]吃了
做了两个包子！
包子【2】来了，被[a]吃了
包子【2】来了，被[b]吃了
做了两个包子！
包子【3】来了，被[a]吃了
包子【3】来了，被[b]吃了
装饰器
def login(canshu):
print("已经通过验证")
return canshu
def tv():
print("%s已经进入tv模式")
tv=login(tv)
tv()
装饰器
运行代码：
已经通过验证
%s已经进入tv模式
a=[[x for x in range(4)] for y in range(4)]
for i in a:print(i)
jishu2=0
for jishu1 in range(4):
jishu2=jishu1+1
for jishu2 in range(jishu2,4):
a[int(jishu1)][int(jishu2)],a[int(jishu2)][int(jishu1)]=a[int(jishu2)][int(jishu1)],a[int(jishu1)][int(jishu2)]
print("\n")
for y in a:print(y)
二维数组旋转90度
运行代码：
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 0, 0, 0]
[1, 1, 1, 1]
[2, 2, 2, 2]
[3, 3, 3, 3]
递归：
def digui(arg1,arg2,jieshu3):
arg3=arg1+arg2
if arg1==0:
print(arg1,arg2,end=' ')
print(arg3,end=" ")
if jieshu3>arg3:
return digui(arg2,arg3,jieshu3)
return
digui(0,1,30)
递归
运行代码：
0 1 1 2 3 5 8 13 21 34
正则表达式：
import re
f=re.sub("\d+","#","d12li3weig4u444o5555g&g66666&6EFss",count=5)
if f:
print(f) f1=re.match("[0-9]{0,10}","4334ge4325ftt&^%kjf35")
if f1:
print(f1.group()) f2=re.findall("[0-9]{1,10}","4334ge4325asdfa&*%ff35")
if f1:
print(f2) f3=re.findall("[a-zA-Z]+","4334ge4325asdfa&*%ff35")
if f1:
print(f3) f4=re.findall("[*]+","4334ge4**325asdfa&*%ff35")
if f1:
print(f4)
正则表达式
运行代码：
d#li#weig#u#o#g&g66666&6EFss
4334
['4334', '4325', '35']
['ge', 'asdfa', 'ff']
['**', '*']
匹配格式
模式描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*匹配0个或多个的表达式。
re+匹配1个或多个的表达式。
re?匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}
re{ n,}精确匹配n个前面表达式。
re{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b匹配a或b
(re)G匹配括号内的表达式，也表示一个组
(?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)类似 (...), 但是不表示一个组
(?imx: re)在括号中使用i, m, 或 x 可选标志
(?-imx: re)在括号中不使用i, m, 或 x 可选标志
(?#...)注释.
(?= re)前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)匹配的独立模式，省去回溯。
\w匹配字母数字
\W匹配非字母数字
\s匹配任意空白字符，等价于 [\t\n\r\f].
\S匹配任意非空字符
\d匹配任意数字，等价于 [0-9].
\D匹配任意非数字
\A匹配字符串开始
\Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z匹配字符串结束
\G匹配最后匹配完成的位置。
\b匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.匹配一个换行符。匹配一个制表符。等
\1...\9匹配第n个分组的子表达式。
\10匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。
正则表达式常用5种操作
re.match(pattern, string) # 从头匹配
re.search(pattern, string) # 匹配整个字符串，直到找到一个匹配
re.split() # 将匹配到的格式当做分割点对字符串分割成列表