Python基础

Posted 2020-08-30

迭代器

iter（）

然后在print（x）x后面加.__next__()

name = iter([‘a‘,‘b‘,‘c‘])
print(name.__next__())
print(name.__next__())
print(name.__next__())

def cash_money(money):
    while money>0:
        money -= 100
        yield 100
        print("又来取钱了！")
atm =cash_money(500)
print(atm.__next__())
print(atm.__next__())
print("可以中断并还会保持状态")
print(atm.__next__())

生成器

一个函数调用时返回一个迭代器，那这个函数就叫做生成器generator，如果这个函数中包含yield语法，那这个函数就会变成生成器

可以保持函数的中断状态

yield 不但可以返回值，他也可以接收值

我觉得这个函数返回的是一个生成器对象，它是可以输出值的，也可以迭代的

通过.__next__()返回值

通过.send() 接收值

import time
def comsumer(name):
    print("%s准备吃包子了！" %name)
    while True:
        baozi = yield

        print("包子来了[%s]个,被[%s]吃了"%(baozi,name))
def producer(name):
    c = comsumer(‘A‘)
    c1 = comsumer(‘B‘)
    c.__next__()
    c1.__next__()
    print("老子开始做包子了！~")
    for i in range(10):
        i += 1
        time.sleep(1)
        print("做了两个包子")
        c.send(i)
        c1.send(i)
producer(‘su‘)

装饰器

给已经实现的功能扩展新的功能

def login(f):
    def inner(*a,**b):
        print("input your passwd and user")
        return f(*a,**b)
    return inner
def home(name):
    print("Welcome %s to home page"%name)
@login
def tv(name):
    print("Welcome %s to tv page"%name)
    return 3
def movie(name):
    print("Welcome %s to movie page" % name)
#tv=login(tv)#等于@login

z=tv("su")
print(z)

def w1(main_func):
    def outer(request,kargs):
        print(‘before‘)

        main_func(request,kargs)

        print(‘after‘)
    return outer
@w1
def show(request,kargs):
    print("show")
show(‘s‘,‘u‘)
‘‘‘
执行过程
@w1: show=w1(show)
     main_func = show
outer = w1(show)             
outer = show(‘s‘,‘u‘)

‘‘‘

多参数装饰器

def login(request,kargs):
    print(‘before‘)
def ErrorHandle(request,kargs):
    print(‘after‘)
def Filter(before_func,after_func):
    def outer(main_func):
        def wrapper(request,kargs):
            before_func(request,kargs)

            main_func(request,kargs)

            after_func(request,kargs)

        return wrapper
    return outer
@Filter(login,ErrorHandle)
def Index(request,kargs):
    print(‘index‘)
    return "home page..."
Index(‘req‘,‘s‘)
‘‘‘
过程
执行Filter(login,ErrorHandle)
before_func=login
after_func=ErrorHandle
然后@outer
Index = outer(Index)
wrapper= outer(Index)
Index=wrapper
Index(‘req’,’ s’)?= wrapper(‘req’,’ s’)?
执行函数login(‘req’,’ s’)?
    print
    Index(‘req’,’ s’)?
    print
    ErrorHandle(‘req’,’ s’)?
    print

‘‘‘

递归

递归是在函数中实现的

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def func(arg1,arg2,stop):
    if arg1==0:
        print(arg1,arg2)
    arg3=arg1+arg2
    print(arg3)
    if arg3<stop:
        func(arg2,arg3,stop)
func(0,1,800)           #斐波那契数列

二分法检索

binary_search

又称折半检索，二分法检索的基本思想是设字典中的元素从小到大有序地存放在数组（array）中。

def binary_search(data_source,find_n):
    mid = int(len(data_source)/2)
    if len(data_source)>=1:
        if data_source[mid]>find_n:  #[mid]是下标   0为1
            print("data in left of [%s]"%data_source[mid])
            binary_search(data_source[:mid],find_n)
        elif data_source[mid]<find_n:
            print("data in right of [%s]"%data_source[mid])
            binary_search(data_source[mid:], find_n)
        else:
            print("found find_s",data_source[mid])
    else:
        print("cannot find ..")
if __name__==‘__main__‘:
    data =list(range(1,600))
    binary_search(data,31)

二维数组的90度旋转

b=[a for a in range(4)]

=                  b= []  #建一个空列表

                    for a in range(4):b.append(a)

data = [[col for col in range(4)] for row in range(4)]
for row in data :
    print(row)
print(‘----------------------------‘)

for r_index,row in enumerate(data): #r_index 是第几行
                                #c_index是第几列
    for c_index in range(r_index,len(row)):
        tmp = data[c_index][r_index]
        data[c_index][r_index] = row[c_index]
        print(row[c_index],‘:row[c_index]‘)
        print(row,‘:row‘)
        data[r_index][c_index] = tmp
    print(‘-------------------------------------------‘)
    for  r in data : print(r)

正则表达式

re.match：只从字符串的开头与正则表达式匹配，匹配成功返回matchobject，否则返回none；

print(xx.group())       打印出匹配的内容

re.findall

findall函数返回的总是正则表达式在字符串中所有匹配结果的列表，此处主要讨论列表中“结果”的展现方式，即findall中返回列表中每个元素包含的信息。

匹配格式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当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个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

re.search 和match有一个不同，就是match只从字符串的开头与正则表达式匹配，他可以不从头

re.sub       替换

import re
m = re.match("abc","abcdse")
m = re.match("[0-9][0-9]","75757abcdse")
m = re.match("[0-9]{0,10}","75757abcdse")
m = re.match("[0-9]{10}","75757abcdse")
m = re.findall("[0-9]{1,10}","75757abc4dse")
m = re.findall("[a-zA-Z]{1,10}","75757abc4dse")
m = re.findall(".*","75757abc4dse")     #.*匹配任意字符
m = re.findall(".+","75%7!ab#c4dse")
m = re.search("\d+","[email protected]!_safnk.21441hjg")

if m:
    print(m)