python学习之路基础篇(第六篇)

一、算法

• 冒泡排序

　　两两比较 打的沉下去，小的浮上来  从而把数字从小到大排列出来

• 选择排序

　　随机取一个索引作为最大值，然后和列表中的其他索引进行比较，如果l[0]<l[1]，则将l[1]修改为最大值，继续和其他索引元素比较，将最大值排在最后，完成排序

• 插入排序

　　使用维护一个有序的集合，获取第一个元素作为最大值，然后去列表中的第二个元素，两两比较，如果比第二个元素大于第一个元素则排在第一个元素后面，如果小于第一个元素则排在第一个元素前面，然后依次取列表中的元素按照此方法进行比较，最终完成列表元素从小到大的排序　

冒泡排序

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(3):     # 等价于 #for m in range(len(li)-2):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(2):     # 等价于 #for m in range(len(li)-3):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp

for m in range(1):     # 等价于 #for m in range(len(li)-4):
    if li[m]> li[m+1]:
        temp = li[m+1]
        li[m+1] = li[m]
        li[m] = temp
print li

li = [13, 22, 6, 99, 11]

for i in range(1,5):
    for m in range(len(li)-i): 
        if li[m] > li[m+1]:
            temp = li[m+1]
            li[m+1] = li[m]
            li[m] = temp

二、递归函数的应用

求7的阶乘　

def func(num):
    if num == 1:
        return 1
    return num * func(num-1)

x = func(7)
print(x)

# 程序运行结果如下：
# 5040

三、反射　

1.反射必知必会

def f1():
    print('f1')

#f1和“f1”二者的区别
# f1  #函数名，是一个变量，代指整个函数
# "f1"    #字符串对象

#s1.py
def func():
    print('func')

#index.py
import s1
s1.func()

#程序运行结果：func
#程序的返回值为None
#如果函数中没有显示的return，则默认的返回值为None

2.需求：根据用户的输入的不同来展示不同页面

#commons.py
def login():
    print('login')

def logout():
    print('logout')

def home():
    print('home')

#index.py
import commons

def run():
    inp = input('请输入你要访问的页面:')
    # inp = login，假设用户输入的是字符串是login，则inp = login
    # commons.inp() # commons.login
    if inp == 'login':
        commons.login()

if __name__ == "__main__":
    run()

#程序运行结果如下：
请输入你要访问的页面:login
login

从上面的输出可以看到，程序可以根据用户的输入来显示不同的内容，而用户的输入都是以字符串的形式存在的，我们是否可以利用用户输入的字符串对模块进行相关的操作呢？当然可以，在python中，反射就是利用字符串的实行去对象（默认）中操作（寻找）成员

#反射:getattr hasattr
#commons.py
def login():
    print('login')

def logout():
    print('logout')

def home():
    print('home')

#index.py
import commons
def run():
    inp = input('请输入你要访问的页面:')
    if hasattr(commons,inp):
        func = getattr(commons,inp)
        func()
    else:
        print('404 ERROR page!')

if __name__ == "__main__":
    run()

#程序执行结果如下：
请输入你要访问的页面:403
404 ERROR page!

3.补充知识

__main__        #只有执行当前文件时，当前文件的特殊变量__name__=="__main__"
__file__        #当前py文件所在的路径
__cached__      #字节码存放的位置
__package__     #py文件所在的软件包

4.反射和__import__的应用

__import__：模块的导入  
#manager.py
def order():
    print('订单页面')

#commons.py
def home():
    print('首页面')

#index.py
def run():
    #account/login
    inp = input('请输入要访问的URL:')

    m, f = inp.split('/')  #将用户输入的内容使用/进行分隔，将模块名赋值给m，方法赋值给f
    #obj = __inport__('lib.' + m,fromlist = True),如果要导入的模块和index不是同级目录，则需要对模块进行拼接，并且设置fromlist=True
    obj = __import__(m)
    if hasattr(obj,f):
        func = getattr(obj,f)
        func()
    else:
        print('404 error page')

if __name__ == '__main__':
    run()

#程序运行结果如下：
请输入要访问的URL:commons/order
404 error page

请输入要访问的URL:account/login
登录页面

请输入要访问的URL:commons/home
首页面

四、加密模块hashlib

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib
 
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
 
######## sha1 ########
 
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha256 ########
 
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha384 ########
 
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha512 ########
 
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib
######### md5 ########
hash = hashlib.md5(bytes('898oaFs09f',encoding="utf-8"))
hash.update(bytes('admin',encoding="utf-8"))
print(hash.hexdigest())

python内置还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密

import hmac
h = hmac.new(bytes('898oaFs09f',encoding="utf-8"))
h.update(bytes('admin',encoding='utf-8'))
print(h.hexdigest())

五、正则表达式

python中re模块提供了正则表达式相关操作

字符：

.           匹配除换行符以外的任意字符
w	    匹配字母或数字或下划线或汉字
s	    匹配任意的空白符
d	    匹配数字
	    匹配单词的开始或结束
^	    匹配字符串的开始
$	    匹配字符串的结束    

次数：

*          重复零次或更多次
+	    重复一次或更多次
?	    重复零次或一次
{n}	    重复n次
{n,}	    重复n次或更多次
{n,m}	    重复n到m次

match：从气势位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
 
 match(pattern, string, flags=0)
 # pattern： 正则模型
 # string ： 要匹配的字符串
 # falgs  ： 匹配模式
     X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
     I  IGNORECASE  Perform case-insensitive matching.
     M  MULTILINE   "^" matches the beginning of lines (after a newline)
                    as well as the string.
                    "$" matches the end of lines (before a newline) as well
                    as the end of the string.
     S  DOTALL      "." matches any character at all, including the newline.
 
     A  ASCII       For string patterns, make w, W, , B, d, D
                    match the corresponding ASCII character categories
                    (rather than the whole Unicode categories, which is the
                    default).
                    For bytes patterns, this flag is the only available
                    behaviour and needn't be specified.
      
     L  LOCALE      Make w, W, , B, dependent on the current locale.
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.

import re

#match：从字符串的开头进行匹配
#匹配成功
res = re.match(".","abc123def")
#匹配不成功
res1 = re.match("adf","abc123def")
#显示匹配的字符
res2 = re.match(".","abc123def").group()
print(res)
print(res1)
print(res2)

程序输出结果如下：
<_sre.SRE_Match object; span=(0, 1), match='a'>
None
a

search:浏览整个字符串去匹配第一个，未匹配成功返回None

# search,浏览整个字符串去匹配第一个，未匹配成功返回None
# search(pattern, string, flags=0)
#从整个字符串中进行查找一旦匹配就输出结果
res3 = re.search("d+","abc123def456ghi")
程序执行结果入如下：
<_sre.SRE_Match object; span=(3, 6), match='123'>
#实例2
name = "Chong li"
res = re.search("(w+)s(w+)",name).group()
res1 = re.search("(w+)s(w+)",name).groups()
print(res)
print(res1)
# 程序执行结果：
Chong li
('Chong', 'li')

#实例3
res = re.search("(?P<name>w+)s(?P<last_name>w+)",name)
name = res.group("name")
xing = res.group("last_name")
print(name)
print(xing)
#程序执行结果：
Chong
li　　

findall：获取非重复的匹配列表，如果有一个组则以列表形式返回，且每一个匹配均是字符串，如果模型中有多个组，则以列表形式返回，且每一个匹配都是元组，空的匹配也会包含在结果中

# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
# 空的匹配也会包含在结果中
#findall(pattern, string, flags=0)
#实例
#匹配字符串中所有的数字
res4 = re.findall("d+","abc123def456ghi*sdf3_def")
#匹配除数字以外的所有内容，也即针对res4取反
res5 = re.findall("[^d+]","abc123def456ghi*sdf3_def")
res6 = re.findall("[^d]","abc123def456ghi*sdf3_def")
print(res4)
print(res5)
print(res6)

程序执行结果如下：
['123', '456', '3']
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', '*', 's', 'd', 'f', '_', 'd', 'e', 'f']
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', '*', 's', 'd', 'f', '_', 'd', 'e', 'f']

sub：替换匹配成功的指定位置字符串

# sub，替换匹配成功的指定位置字符串
 
sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串或可执行对象
# string ： 要匹配的字符串
# count  ： 指定匹配个数
# flags  ： 匹配模式

#字符串内容的替换
res9 = re.sub("ab","LI","abc123def456ghi*sdf3_abdef")
res10 = re.sub("ab","LI","abc123def456ghi*sdf3_abdef",count=1)
print(res9)
print(res10)

程序运行结果如下：
LIc123def456ghi*sdf3_LIdef
LIc123def456ghi*sdf3_abdef

split:根据正则匹配分隔字符串

# split，根据正则匹配分割字符串
#语法
split(pattern, string, maxsplit=0, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# maxsplit：指定分割个数
# flags  ： 匹配模式
#实例
#把字符串按照数字进行分隔
res7 = re.split("d+","abc123def456ghi*sdf3_def")
#把字符串按照数字或者*进行分隔
res8 = re.split("[d,*]","abc123def456ghi*sdf3_def")
print(res7)
print(res8)
#程序运行结果如下：
['abc', 'def', 'ghi*sdf', '_def']
['abc', '', '', 'def', '', '', 'ghi', 'sdf', '_def']