python第五课

怼烎@ 2022-06-01 09:57 195阅读 0赞

1. 定义：  
模块：用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），本质就是.py结尾的python文件（文件名:test.py,对应的某块名：test）  
包：用来从逻辑上组织模块的，本质就是一个目录（必须带有一个\_\_init\_\_.py文件）  
  
  
2.导入方法  
import module\_name  
import module1\_name,module2\_name  
from module\_alex import \*  
from module\_alex import m1,m2,m3  
  
from module\_alex import logger as logger\_alex  
  
3.import本质（路径搜索和搜索路径）  
导入模块的本质就是把python文件解释一遍  
（import test test='test.py all code'）  
(from test import m1 m1='code')  
import module\_name-->module\_name.py-->module\_name.py路径-->sys.path  
  
导入包的本质就是执行该包下的\_\_init\_\_.py文件  
  
4. 导入优化  
from module\_test import test  
  
  
5.模块的分类：  
  
a:标准库  
b:开源模块  
c:自定义模块  
  
标准库：

1.time与datatime

\--moudule\_alex.py--  
name = 'alex'  
def say\_hello():  
    print("hello alex")  
def logger():  
    print('in the logger alex')  
def running():  
    pass  
\--main.py--  
\# from module\_alex improt \*   不建议使用，当导入函数存在重复的时候，会有问题  
from module\_alex import logger as logger\_alex  
import module\_alex  
from module\_alex import name  
  
def logger():  
    print('in the main')  
print(module\_alex.name)  
module\_alex.logger()  
logger()  
logger\_alex()  
\------package\_test-------  
\--\_\_init\_\_.py--  
print('from the package package\_test')  
from . import test1  
\--test1.py--  
def test():  
    print('in the test1')  
\--p\_test.py--  
\# import package\_test  
from module\_test import test  
def logger():  
    module\_test.test()  
    print("in the logger")  
package\_test.test1.test()

import random  
random.random()  \# 取随机浮点型\[0,1)  
random.randint(1, 3)  \# 取指定范围的随机整数 包含1和3  
random.randrange(1, 3)  \# 取指定范围的随机整数 包含1,不包含3  
random.choice('hello')  
random.choice(\[1, 3, 4\])  \# 从传入的值随机选择  
random.sample('hello', 2)  \# 从传入的值随机选择2个  
random.uniform(1, 3)  \# 指定范围取浮点型  
l = \[1, 2, 3, 4, 5, 6, 7\]  
random.shuffle(l)  \# 打乱顺序  
\# --------------------------  
checkcode = ''  
for i in range(4):  
    current = random.randrange(0, 4)  
    if current == i:  
        tmp = chr(random.randint(65, 90))  \# 字母  
    else:  
        tmp = random.randint(0, 9)  \# 数字  
    checkcode += str(tmp)  
print(checkcode)  
  
import os  
os.getcwd()   \# 获取当前操作目录  
os.chdir("C:\\\\Users")    \# 修改路径到指定的路径  
os.chdir(r"c:\\Users")    \# 修改路径到指定的路径  
os.curdir()  \# 返回当前目录  
os.pardir()  \# 返回上一级目录  
os.mkdir(r"C:\\a\\b\\c\\d")   \# 递归的创建一个目录，即当a不存在会创建a到d  
os.removedirs(r"C:\\a\\b\\c\\d")  \# 删除一个目录  
os.mkdir(r'D:\\a\\b')  \# 不能递归，只能逐层建目录  
os.rmdir(r'D:\\a\\b')  \# 删指定文件夹  
os.listdir('.')      \# 返回指定目录的文件名称  
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-->'posix'  
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)   \# 如果path存在，返回True;如果path不存在，返回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所指向的文件或者目录的最后存取时间  
os.path.getmtime(path)   \# 返回path所指向的文件或者目录的最后修改时间  
  
import sys  
sys.argv  命令行参数list，第一个元素是程序本身路径  
sys.exit(n) 退出程序，正常退出时exit（0）  
sys.version 获取python解释程序的版本信息  
sys.maxint 最大的int值  
sys.path   返回模块的搜索路径，初始化时使用pythonpath环境变量的值  
sys.platform 返回操作系统平台名称  
sys.stdout.write('please:')  
val - sys.stdin.readline()\[:-1\]  
  
import shutil  高级的文件、文件夹、压缩包 处理模块  
f1 = open("本节笔记", encoding="utf-8")  
f2 = open("笔记2", "w", encoding="utf-8")  
shutil.copyfileobj(f1, f2)  
  
shutil.copyfile("笔记2", "笔记3")

import shelve  
import datetime  
d = shelve.open('shelve\_test')  
info = \{'age': '22', 'job': 'it'\}  
name = \['alex', 'rain', 'test'\]  
d\['name'\] = name  \# 持久化  
d\['info'\] = info    
d\['date'\] = datetime.datetime.now()  
d.close()  
\# 读取  
print(d.get('name'))  
print(d.get('info'))  
print(d.get('date'))  
  
\# xmltest.xml /  
<?xml version="1.0"?>  
<data>  
    <country name="Liechtenstein">  
        <rank updated="yes">2</rank>  
        <year>2008</year>  
        <gdppc>141100</gdppc>  
        <neighbor name="Austria" direction="E"/>  
        <neighbor name="Switzerland" direction="W"/>  
    </country>  
    <country name="Singapore">  
        <rank updated="yes">5</rank>  
        <year>2011</year>  
        <gdppc>59900</gdppc>  
        <neighbor name="Malaysia" direction="N"/>  
    </country>  
    <country name="Panama">  
        <rank updated="yes">69</rank>  
        <year>2011</year>  
        <gdppc>13600</gdppc>  
        <neighbor name="Costa Rica" direction="W"/>  
        <neighbor name="Colombia" direction="E"/>  
    </country>  
</data>  
\# xmltest.xml /  
import xml.etree.ElementTree as ET  
tree = ET.parse('xmltest.xml')  \# 当前路径下要有xmltest.xml文件  
root = tree.getroot()  
print(root.tag)  
\# 遍历xml文档  
for child in root:  
    print(child.tag, child.attrib)  
    for i in child:  
        print(i.tag, i.text)  
\# 只遍历year节点  
for node in root.iter('year'):  
    print(node.tag, node.text)

\# 修改/增加xml  
for node in root.iter('year'):  
    new\_year = int(node.text) + 1  
    node.text = str(new\_year)  
    node.set("updated", "yes")  
tree.write('xmltest.xml')  
\# 删除node  
for country in root.findall('country'):  
    rank = int(country.find('rank').text)  
    if rank > 50:  
        root.remove(country)  
tree.write("output.xml")

import xml.etree.ElementTree as ET  
new\_xml = ET.Element('personinfolist')  
personinfo = ET.SubElement(new\_xml, "personinfo", attrib=\{"enrolled": 'yes'\})  
name = ET.SubElement(personinfo, "name", attrib=\{"checked": "NO"\})  
age = ET.SubElement(personinfo, "age", attrib=\{"checked": "NO"\})  
sex = ET.SubElement(personinfo, "sex")  
name.text = 'alex'  
age.text = '56'  
sex.text = 'M'  
personinfo2 = ET.SubElement(new\_xml, "personinfo2", attrib=\{"enrolled": 'yes'\})  
name = ET.SubElement(personinfo2, "name", attrib=\{"checked": "NO"\})  
age = ET.SubElement(personinfo2, "age", attrib=\{"checked": "NO"\})  
sex = ET.SubElement(personinfo2, "sex")  
name.text = 'oldboy'  
age.text = '19'  
sex.text = 'M'  
et = ET.ElementTree(new\_xml)  \# 生产文档对象  
et.write("test.xml", encoding="utf-8", xml\_declaration=True)  
ET.dump(new\_xml)  \# 打印生成的格式  
\# 打印的内容并没有结构化，需要结构化模板。

正则 re

`'.'`     `默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行`

`'^'`     `匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r` `"^a"` `,` `"\nabc\neee"` `,flags` `=` `re.MULTILINE)`

`'$'`     `匹配字符结尾，或e.search(` `"foo$"` `,` `"bfoo\nsdfsf"` `,flags` `=` `re.MULTILINE).group()也可以`

`'*'`     `匹配` `*` `号前的字符` `0` `次或多次，re.findall(` `"ab*"` `,` `"cabb3abcbbac"` `)  结果为[` `'abb'` `,` `'ab'` `,` `'a'` `]`

`'+'`     `匹配前一个字符` `1` `次或多次，re.findall(` `"ab+"` `,` `"ab+cd+abb+bba"` `) 结果[` `'ab'` `,` `'abb'` `]`

`'?'`     `匹配前一个字符` `1` `次或` `0` `次`

`'{m}'`   `匹配前一个字符m次`

`'{n,m}'` `匹配前一个字符n到m次，re.findall(` `"ab{1,3}"` `,` `"abb abc abbcbbb"` `) 结果` `'abb'` `,` `'ab'` `,` `'abb'` `]`

`'|'`     `匹配|左或|右的字符，re.search(` `"abc|ABC"` `,` `"ABCBabcCD"` `).group() 结果` `'ABC'`

`'(...)'` `分组匹配，re.search(` `"(abc){2}a(123|456)c"` `,` `"abcabca456c"` `).group() 结果 abcabca456c`

`'\A'`    `只从字符开头匹配，re.search(` `"\Aabc"` `,` `"alexabc"` `) 是匹配不到的`

`'\Z'`    `匹配字符结尾，同$`

`'\d'`    `匹配数字` `0` `-` `9`

`'\D'`    `匹配非数字`

`'\w'`    `匹配[A` `-` `Za` `-` `z0` `-` `9` `]`

`'\W'`    `匹配非[A` `-` `Za` `-` `z0` `-` `9` `]`

`'s'`     `匹配空白字符、\t、\n、\r , re.search(` `"\s+"` `,` `"ab\tc1\n3"` `).group() 结果` `'\t'`

`'(?P<name>...)'` `分组匹配 re.search(` `"(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})"` `,` `"371481199306143242"` `).groupdict(` `"city"` `) 结果{` `'province'` `:` `'3714'` `,` `'city'` `:` `'81'` `,` `'birthday'` `:` `'1993'` `}`

`re.match 从头开始匹配`

`re.search 匹配包含`

`re.findall 把所有匹配到的字符放到以列表中的元素返回`

`re.splitall 以匹配到的字符当做列表分隔符`

`re.sub      匹配字符并替换`