第4天学习

递归算法

递归算法是一种直接或间接的调用自身算法的过程。
（1）递归就是在过程或函数里调用自身
（2）在使用递归过程中必须有一个明确的递归结束条件，称之为递归出口。
（3）递归算法很简洁，但是效率很低。
（4）递归次数过多会造成溢出。

#这就是一个简单的递归调用本身的函数
def calc(n):
    a = n/2
    if a > 1:
        return calc(a)
#利用递归计算斐波拉契数列
def func(arg1,arg2,arg):
    arg3 = arg1 + arg2
    print(arg3)
    if arg3 < arg:
        return func(arg2,arg3)

二分算法原理

假如有一个有序列表有6000W的数字，现在你需要确认这个数字是否在这个列表当中，如果用遍历的方法去找这个数字速度会慢的让人发指，这个时候你需要用另外一种方式，如果这个数字在这个列表当中，那么去一个中间值，这个数字如果比中间值小，肯定在中间值的左边，如果比中间值大，肯定在中间值右边，那么如此循环下去，最后肯定能匹配到这个数字。一个列表的1/2,1/4,1/8,1/16这种方式去匹配，

list = range(600000) #生成一个60W数字的列表
def calc(data,find_number):
    if int(len(data)) > 1:
    list_width = int(len(data)/2)
    if find_number < data[list_width]:
        return calc(data[0:find_width],find_number)
    elif find_number > data[list_width]:
        return calc(data[find_width:],find_number)
    elif find_number == data[list_width]:
        print('find ok')
    elif int(len(data)) == 1:
        if find_number == data[0]:
            print('find ok')
        else:
            print('not find')

反转列表

将一个4*4的二维数组进行反转

#生成一个4*4的二维数组
list = [[width for width in range(4) for heigh in range(4)]
#打印列表 for i in list:print(i)
[0,1,2,3]
[0,1,2,3]
[0,1,2,3]
[0,1,2,3]
#在不生成新的列表的情况下将这个二维数组反转90度
[0,0,0,0]
[1,1,1,1]
[2,2,2,2]
[3,3,3,3]
#实现思路第一次循环可以让第一个列表的所有参数和所有列表的第一个参数替换，以此类推
for m in range(len(data)):
    for i in range(m,len(data)):
        a = data[i][m]
        b = data[m][i]
        data[m][i] = a
        data[i][m] = b
        return data
#这样无论是多少维数组，都可以进行反转

正则表达式

正则表达式其实就是匹配字符串

import re #导入模块
p = re.compile("^[0-9]") #生成要匹配的正则对象
m = p.match('234afdaf') #根据正则对象匹配字符串
    print(m.group()) #输出返回值，如果没有匹配到为none,匹配到则输出匹配内容
m = re.match("^[0-9]",'414sdfasf') #可以合成一行
match 为从头开始匹配
findall 为全字符串匹配返回列表
search 全文开始找，找到一个就返回

#^  匹配字符串的开头
re.findall('^abc',string)
#$     匹配字符串的末尾。
re.findall('abc$','string')
#.  匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
re.findall('a.s','afsfsdf')
re.findall('a..s','admsfweqr')
#* 任意
#+ 一个或多个
re.findall('.*','asdfasdf')
re.findall('.+','adsfs3242adf') 
#匹配数字
re.findall('[0-9]','14dsf234')
#匹配字母
re.findall('[a-zA-Z]','324fasdf')
#匹配特殊字符
re.findall('\%\#','dsfas%#')
#取出字符串最后3个数字
str = 'aa5nihao4ma3hello2af1'
obj01 = re.compile('(\d)\D+(\d)\D+(\d)\Z')
obj01.findall(str)
1.当给出的正则表达式中带有多个括号时，列表的元素为多个字符串组成的tuple，tuple中字符串个数与括号对数相同，字符串内容与每个括号内的正则表达式相对应，并且排放顺序是按括号出现的顺序。
2.当给出的正则表达式中带有一个括号时，列表的元素为字符串，此字符串的内容与括号中的正则表达式相对应（不是整个正则表达式的匹配内容）。
3.当给出的正则表达式中不带括号时，列表的元素为字符串，此字符串为整个正则表达式匹配的内容。
举个例子：
 s = "adfad asdfasdf asdfas asdfawef asd adsfas "  

reObj1 = re.compile('((\w+)\s+\w+)')  
reObj1.findall(s)  
[('adfad asdfasdf', 'adfad'), ('asdfas asdfawef', 'asdfas'), ('asd adsfas', 'asd')]  

reObj2 = re.compile('(\w+)\s+\w+')  
reObj2.findall(s)  
['adfad', 'asdfas', 'asd']  

reObj3 = re.compile('\w+\s+\w+')  
reObj3.findall(s)  
['adfad asdfasdf', 'asdfas asdfawef', 'asd adsfas']  
模式  描述
^   匹配字符串的开头
$  匹配字符串的末尾。
.   匹配任意字符，除了换行符，当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.S #支持\n
#  边界匹配
这几天实际使用当中经常会遇到只想获取想要的内容，但是却连边界也一块取出来了。
废话不多说直接上代码
string = 'aaaa wwwww aaaa'
re.findall('(?<=aaaa )(.+?)(?= aaaa)', string)

这样匹配出来的结果只是wwwww了