python study to 6 基础篇

递归

递归阶乘1*2*3*4...7案例

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

反射

反射定义：

利用字符串的形式去对象（模块）中操作（寻找/检查/设置、删除）成员，叫做反射

反射：基于实例伪造web框架的路由系统。访问url然后定位到相应的函数上去。

反射使用到的方法：

• getattr ()  获取模块中的某个某个成员
• hasattr()   判断某个成员是否在这个模块中，成立为Ture,否则为False
• setattr()   设置模块中的某个成员
• delattr()   删除模块中的某个成员

反射中针对某个模块中的函数的操作案例：

import commons
def run():
    inp = input("请输入要访问的url:")
    # 利用字符串的形式去对象（模块）中操作（寻找/检查/设置、删除）成员，叫做反射
    delattr()删除模块中的某个成员；setattr设置模块中的某个成员。delattr 和 setattr都是基于内存的操作
    if hasattr(commons,inp):
       func=getattr(commons,inp)
       func()
    else:
        print("404")
if __name__ =="__main__":
    run()

反射中针对模块使用字符串形式的导入案例：

def run():
    inp = input("请输入要访问的url:")
    m , f = inp.split("/")
    obj = __import__(m)
    if hasattr(obj,f):
       func=getattr(obj,f)
       func()
    else:
        print("404")


if __name__ =="__main__":
    run()

模块

内置模块是python自带的模块，使用时需要先“导入”再“使用”

一、SYS模块

用于提供对python解释器的相关操作

Sys.argv        命令行参数List, 第一个元素是程序本身路径
Sys.exit(n)     退出程序，正常退出时exit(0)
Sys.version     获取Python解释程序的版本信息
Sys.maxint      最大的Int值
Sys.path        返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
Sys.platform    返回操作系统平台名称
Sys.stdin       输入相关
Sys.stdout      输出相关
Sys.stderror    错误相关

进度条：

import time
def view_bar(num, total):
    rate = num / total
    rate_num = int(rate*100)
    r = "\r%s%d%%" % ("="*num,rate_num)

    sys.stdout.write(r) #不加换行符
    sys.stdout.flush() #输出清空


if __name__ == '__main__' :
    for i in  range(0,101):
        time.sleep(0.1)
        view_bar(i,100)

二、OS模块

os模块用于提供系统级别的操作

s.getcwd()   获取当前工作目录，即当前python脚本工作目录路径
os.chdir(“dirname”) 改变当前脚本工作目录，相当于shell下cd
os.curdir   返回当前目录：(‘.’)
os.pardir  获取当前目录的父目录字符串名：(‘..’)
os.makedirs(‘dir1/dir2’)可生成多层递归目录
os.removedirs(‘dirname1’)  若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推
os.listdir(‘dirname’) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename(“oldname”,”newname”) 重命名文件/目录
os.stat(‘path/filename’)  获取文件/目录信息
os.sep   操作系统特定的路径分隔符，win下为”\\”,linux下为”/”
os.linesep   当前平台使用的行终止符，win下为”\t\n”,linux下为”\n”
os.pathsep   用于分割文件路径的字符串
os。Name   字符串指示当前使用平台。Win下 “nt”;linux下 “posit”
os.system(“bash command”)  运行shell命令，直接显示
os.environ   获取系统环境变量
os.path.abspath(path)   返回path规范化的绝对路径
os.path.split(path)  将path分割成目录和文件名二元祖返回
os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  返回path最后的文件名。如何path 以 /或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果存在返回True;如果不存在，返回False
os.path.isabs(path)   如果path是绝对路径，返回True
os.path.isfile(path)  如果path存在的文件，返回True,否则返回False
os.path.isdir(path)   如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[,path2[,…]])将多个路径组合后返回，第一个绝对路径之前的参数被忽略
os.path.getatime(path)   返回path所指向的文件或者目录的最后存取时间
注：常用需要记住的为红色字体部分的方法

特殊模块

• __name__
• __doc__
• __file__
• __package__
• __cached__

__doc__列举：

"""
my name is wanggang
"""
print(__doc__)

输出:
my name is wanggang

__file__列举：

__file__
print(__file__) 获取运行当前.py文件的目录

import sys
import os
# sys.path.append(os.path.dirname(os.path.dirname(__file__))) 把一个文件上一级、上一级添加的环境变量中
# os.path.abspath() 获取某个文件的绝对路径
# os.path.dirname() 获取上一级目录

 __name__列举：

__name__ == "__main__ "只有执行当前文件时，当前文件的特殊__name__ == "__main__" ,
通过其他文件来调用，此文件中的函数是不会被执行的。

def run():
    print("run")
if __name__ == "__main__":
    run()

__package__列举：

判断一个模块中的成员是否在这个模块中

from bin import admin
print(__package__)
print(admin.__package__)

hashlib 加密模块

import hashlib  #MD5加密

obj = hashlib.md5(bytes("kdalfkjakdljl",encoding="utf-8"))
obj.update(bytes('123',encoding='utf-8'))
result = obj.hexdigest()
print(result)

RE模块

字符：

　　. 匹配除换行符以外的任意字符

　　\w    匹配字母或数字或下划线或汉字

　　\s     匹配任意的空白符

　　\d    匹配数字

　　\b    匹配单词的开始或结束

　　^     匹配字符串的开始

　　$     匹配字符串的结束

 

次数：

　　* 重复零次或更多次

　　+     重复一次或更多次

　　?      重复零次或一次

　　{n}  重复n次

　　{n,} 重复n次或更多次

　　{n,m}     重复n到m次

正则分组

在提取的数据中再提取数据

match() 方法

# 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, \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, \B, dependent on the current locale.
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.

正则表达式match案例：

import re
origin = "has jdlkakjlkpoki0pe"
r = re.match("h(?P<name>\w+)",origin)
print(r.group()) #获取匹配到的所有结果
print(r.groups()) #获取模型中匹配到的分组结果
print(r.groupdict()) #获取模型中匹配到的分组结果


执行结果：

has
('as',)
{'name': 'as'}

search()

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

search(pattern,string,flags=0)

# 无分组

r = re.search("a\w+", origin)
print(r.group())     # 获取匹配到的所有结果
print(r.groups())    # 获取模型中匹配到的分组结果
print(r.groupdict()) # 获取模型中匹配到的分组结果

# 有分组

r = re.search("a(\w+).*(?P<name>\d)$", origin)
print(r.group())     # 获取匹配到的所有结果
print(r.groups())    # 获取模型中匹配到的分组结果
print(r.groupdict()) # 获取模型中匹配到的分组中所有执行了key的组

findall()

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

findall(pattern,string,flags=0)

# 无分组
r = re.findall("a\w+",origin)
print(r)

# 有分组
origin = "hello alex bcd abcd lge acd 19"
r = re.findall("a((\w*)c)(d)", origin)
print(r)

sub()

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

sub(pattern,repl,string,count,flags)

# 与分组无关

origin = "hello alex bcd alex lge alex acd 19"
r = re.sub("a\w+", "999", origin, 2)
print(r)

split()

split根据正则匹配分割字符串

split(pattern,string,maxsplit,flags=0)

# 无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r)

# 有分组

origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)
print(r1)
r2 = re.split("(al(ex))", origin, 1)
print(r2)