模块的研究

本文主要对模块的初步识别，以及re模块、sys模块、time模块，os模块的初步介绍。

1.模块的介绍

'''
整体说明：
01 模块是一系列常用功能的集合体，一个py文件就是一个模块。主要是将一些相同功能的封装到一个py文件中，谁有谁拿。
02 为什么要使用模块。
    （1）从文件级别组织程序，更方便管理。不仅可以把这些文件当做脚本去执行，还可以把他们当做模块导入到其他的模块中，实现了
         功能的重复利用。
    （2）拿来主义，提高开发效率。避免了重复造轮子。
03 import的使用
    （1）模块中包含的可执行语句和函数，只在模块名第一次遇到导入import语句时才执行。
    （2）import语句可以在程序中的任意位置使用，且针对同一模块可以重复使用import进行多次导入。
    （3）但是，第一次模块名加载到内存后，后续的import语句仅是对已经加载到内存中的模块增加了一次引用，不会重复执行模块中
         的语句和函数。
    （4）执行文件和被引用模块：
        （a）执行文件：解释器运行的文件。
        （b）被引用文件：import
04 模块被引用的时候发生了三件事
    （1）为源文件创建新的名称空间。
    （2）引用模块中的所有内容都加载到内存中。
    （3）通过模块名+“.”的方式去引用模块中的对象（可执行的语句和函数）
05 为模块起别名的作用。
    （1）将模块名较长的变成较短的。
    （2) 拓展代码。
06 多个模块导入
07 模块的引用顺序：内存 ---> 内置模块（os,time sys..） ---> sys.path
    （1）python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看。
08 可以使用__all__来控制*（用来发布新版本），在源文件中指定两个变量即__all__=['money','read1']，其他导入的时候只能导入该两个变量
09 py文件的两种功能。
    （1）一：脚本，一个文件就是整个程序，用来被执行。
    （2）二：模块，文件中存放着一堆功能，用来被导入执行。
10 python中我们内置了全局变量：__name__
    （1）当文件被当做脚本执行时：__name__等于“__main”
    （2）当文件被当做模块导入时：__name__等于模块名。
    （3）作用：用来控制py文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）

'''


# 01 第一次模块名加载到内存后，后续的import语句仅是对已经加载到内存中的模块增加了一次引用，不会重复执行模块中的语句和函数。
import mayugang
import mayugang
import mayugang

'''
执行结果：只打印一次
from the mayugang.py
'''

# 02 为模块起别名
# （1）将模块名较长的变成较短的。

import mayugang as myg
myg.read1()

# （2）有利于代码的拓展和优化。

import mysql1
import oracle1

sql = input("请输入：").strip()
if sql == 'mysql1':
    import mysql1 as db
elif sql == 'oracle1':
    import oracle1 as db

db.sentence()

# (3)多模块导入的形式
import os
import time
import pickle

(4)from ...import ...
# 优点：方便使用。
# 缺点：可能会与执行文件产生冲突。
# 不建议使用，或者可以在一定条件下使用。
name = '李苹'
from mayugang import read1, name  # 将模块中的name = '马玉刚' 覆盖了name = '李苹'。
read1()  #
print(name)
print(name)

'''
运行结果：name被覆盖。
mayugang模块： 马玉刚
马玉刚
马玉刚
'''

# （5）from 模块名 import *：代表引用全部对象（可执行对象和函数）
# 不建议使用以上方法进行全部引用。

# （6）模块的查询顺序：内存中已经加载的模块->内置模块->sys.path路径中包含的模块
'''
模块的查找顺序
1、在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用
    ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
2、如果没有，解释器则会查找同名的内建模块
3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。
'''
import sys

print(sys.path)  # 打印自定义模块
print(sys.modules)  #  python解释器运行时自动加载到内存的一些模块
sys.path.append("module.zip")  # 增加自定义模块，增加后尽可以引用模块中的对象（可执行程序和函数）
print(sys.path)

# windows下的路径需要加r开头，否则会语法错误。
sys.path.insert(0,r'C:UsersAdministratorPycharmProjectsa')

# （7）找到m1文件的两种方式：
# 方式一：
import sys
sys.path.append("D:pythonweekend24day07mk")
import m1
m1.func1()
# 方式二：
from mk import m1
m1.func1()

 2.re模块

'''
整体说明：
01 什么是正则？
    正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一
    类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C
    编写的匹配引擎执行。
02 匹配规则说明：
    （1）w     匹配字母（包含中文）或数字或下划线
    （2）W     匹配非字母（包含中文）或数字或下划线
    （3）s     匹配任意的空白符
    （4）S     匹配任意非空白符
    （5）d     匹配数字
    （6）D     匹配非数字
    （7）A     从字符串开头匹配
    （8）z     匹配字符串的结束，如果是换行，只匹配到换行前的结果
    （9）     匹配字符串的结束
    （10）
     匹配一个换行符
    （11）	     匹配一个制表符
    （12）^     匹配字符串的开始
    （13）$     匹配字符串的结尾
    （14）.     匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
    （15）[...]     匹配字符组中的字符
    （16）[^...]     匹配除了字符组中的字符的所有字符
    （17）*     匹配0个或者多个左边的字符。
    （18）+     匹配一个或者多个左边的字符。
    （19）？     匹配0个或者1个左边的字符，非贪婪方式。
    （20）{n}     精准匹配n个前面的表达式。
    （21）{n,m}     匹配n到m次由前面的正则表达式定义的片段，贪婪方式
    （22）a|b     匹配a或者b。
    （23）()     匹配括号内的表达式，也表示一个组

03 正则表达式测试工具：http://tool.chinaz.com/regex/
'''

import re
# w     匹配字母（包含中文）或数字或下划线
# W     匹配非字母（包含中文）或数字或下划线
print(re.findall('w','太白alex 123  _ *'))  # ['太', '白', 'a', 'l', 'e', 'x', '1', '2', '3', '_']
print(re.findall('ww','太白alex 123 _ *'))  # ['太白', 'al', 'ex', '12']
print(re.findall('Ww','太白alex 123 _ *'))  # [' 1', ' _']

# s     匹配任意的空白符:(
和	属于空白符)
# S     匹配任意非空白符
print(re.findall('s','太白  123*	
'))  # [' ', ' ', '	', '
']
print(re.findall('S','太白  123*	
'))  # ['太', '白', '1', '2', '3', '*']
print(re.findall('sS','太白  123*	
')) #[' 1']

# d     匹配数字
# D     p匹配非数字
print(re.findall('d', '太白  123*'))  # ['1', '2', '3']
print(re.findall('D', '太白  123*'))  # ['太', '白', ' ', ' ', '*']
print(re.findall('Dd', '太白  123*'))  #[' 1']

# A    从字符串开头匹配  # 只匹配开头  相当于startswith
# ^    匹配字符串的开始  只匹配开头  相当于startswith
print(re.findall(r'A太白', '** 太白 太白 123*'))  # []
print(re.findall(r'^太白', '太白 太白 123*'))  # ['太白']


# 
    匹配一个换行符
# 	    匹配一个制表符
print(re.findall('
','** 太白 太白 
123'))  # ['
']
print(re.findall('	','** 太白 太白 
123		'))  # ['	', '	']

# $ 匹配一个字符串的结尾
print(re.findall('123$','** 太白 太白 123 '))   #[]
print(re.findall('123$','** 太白 太白 123'))  # ['123']

# 重复匹配： . ? * + {m,n} .* .*?
# . 任意字符   re.DOTALL 可以匹配换行符
print(re.findall('a.b', 'ab aab abb a*b a6b a b aaaab'))
print(re.findall('a.b', 'ab aab abb a*b a6b a3b a
b', re.DOTALL))

# ? 匹配0个或者1个由左边字符定义的片段。 贪婪匹配
print(re.findall('a?b', 'aab'))  # ['ab']
print(re.findall('a?b', 'ab aab abb a*b'))  # ['ab', 'ab', 'ab', 'b', 'b']

# *匹配0个或者多个左边字符表达式。 满足贪婪匹配 @@
print(re.findall('a*b', 'ab aab aaaaaaaaaab abbb'))

# + 匹配1个或者多个左边字符。 满足贪婪匹配
print(re.findall('a+b', 'ab aab aaab abbb'))


# {m,n}  匹配m个至n个左边字符表达式。 满足贪婪匹配  @@
print(re.findall('a{2,4}b', 'ab aab aaaab abbb'))


# 纯贪模式 .* 一般不用
print(re.findall('a.*b', 'ea*b ab aab aaaaaaaaaab abbb'))  #  ['a*b ab aab aaaaaaaaaab abbb']

# 贪婪模式 .*?   .* 纯贪  ? 作为限制 满足我就取出
# .*? 常用模式
print(re.findall('a.*?b', 'a*b ab aab aaaaaaaaaab abbb'))  # ['a*b', 'ab', 'aab', 'aaaaaaaaaab', 'ab']

# [] 代表一个字符  # erw 任意选一个
print(re.findall('a[erw][erw]b', 'ab aab aeb arb arwb arewb'))
str1 = 'a1b a2b a3b aab aeb a9b'
str2 = 'a1b aTb a3b aAb aeb a_b ayb'
str3 = 'a1b aTb a3b a-b a%b a!b a&b'
print(re.findall('a[0-9]b',str1))  # ['a1b', 'a2b', 'a3b', 'a9b']
print(re.findall('a[a-z]b',str2))  # ['aab', 'aeb', 'ayb']
print(re.findall('a[a-z,A-Z]b', str2))
print(re.findall('a[-!&]b', str3))  # [] 想匹配"-" 一定要放到最前面
print(re.findall('a[^0-9]b', str3))  # "^" 中括号代表取反

# 分组 () 制造了一个模板(.*?)_sb
print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))
print(re.findall('http.*?com','<a href="http://www.baidu.com">点击</a><a href="http://www.baidu2.com">登录</a>'))
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))

# | 左边右边都可以
# print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb'))  # ['alex', '太白', 'wusir', '太白']

print(re.findall('compan(ies|y)','Too many companies have gone bankrupt, and the next one is my company'))  # ['ies', 'y']
# 但是我想将 companies  company ?: 对分组进行一个应用，全部都取出来
print(re.findall('compan(?:ies|y)','Too many companies have gone bankrupt, and the next one is my company'))

# re模块的操作方法
# findall 找到全部
print(re.findall('a.b', 'abaabb'))

# search 相当于 in  （注意与group（）联合使用）
print(re.search('sb|alex', 'alex sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 4), match='alex'>
print(re.search('aaa', 'alex sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 4), match='alex'>
print(re.search('sb|alex', ' 666 sb alex sb barry 日天').group())  # group相当于输出可视文件。

'''1 + 2*(3/5) + 2**3 - (2/3 + 3*(4-2))'''
#
# match 匹配的就是开始
print(re.match('aaa', 'aaa sb sb barry 日天'))  # <_sre.SRE_Match object; span=(0, 3), match='aaa'>
print(re.match('aaa', 'aa sb sb barry 日天'))  # None
print(re.findall('^aaa', 'aa sb sb barry 日天'))  # []

# split  ***
s1 = 'alex wusir 日天 太白'
s1 = 'alex wusir,日天;太白|二狗'
# print(s1.split())
# # 对字符串按照不同分隔符进行分割  # |是将|进行转义。
print(re.split(' |,|;||',s1))
print(re.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。'))
print(re.sub('(alex)( )(is)( )(sb)', r'52341', r'alex is sb'))

'''
需求：
1，"1-2*(60+(-40.35/5)-(-4*3))"
'''
# 1.1 匹配所有的整数  (pass)
s1 = "1-2*(60+(-40.35/5)-(-4*3))"
# print(re.findall('d+', s1))  # ['1', '2', '60', '40', '35', '5', '4', '3']

# 1.2 匹配所有的数字（包含小数）  # 0也是整数
print(re.findall('d+.?d*', s1))

# 1.3 匹配所有的数字，包括负号
print(re.findall('-?d+.?d*', s1))  # ['1', '-2', '60', '-40.35', '5', '-4', '3']


# 需求：找到所有的P标签
s1 = '''
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7459977.html" target="_blank">python基础一</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7562422.html" target="_blank">python基础二</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/9439483.html" target="_blank">Python最详细，最深入的代码块小数据池剖析</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7738630.html" target="_blank">python集合,深浅copy</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8183203.html" target="_blank">python文件操作</a></p>
<h4 style="background-color: #f08080;">python函数部分</h4>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8241942.html" target="_blank">python函数初识</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8259929.html" target="_blank">python函数进阶</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8305011.html" target="_blank">python装饰器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423526.html" target="_blank">python迭代器,生成器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423937.html" target="_blank">python内置函数,匿名函数</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8743408.html" target="_blank">python递归函数</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/8743595.html" target="_blank">python二分查找算法</a></p>
'''
print(re.findall('<p>.*?</p>', s1))

3.sys模块

'''
整体说明：
01 sys模块是与python解释器交互的一个接口。
02 sys.argv           命令行参数List，第一个元素是程序本身路径
03 sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
04 sys.version        获取Python解释程序的版本信息
05 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
06 sys.platform       返回操作系统平台名称
'''
import sys

# 01 sys常用的模块
print(sys.path)
# sys.exit()  # 终止程序
print(666)
print(sys.version)
print(sys.platform)  # 返回windows系统名称
print(sys.modules)  # 解释器自动加载到内存的模块和包
sys.exit(0)

# 02 sys的异常处理和status

try:
    sys.exit(1)
except SystemExit as e:
    print(e)

4.time模块

'''
整体说明：
01 和时间有关系的我们就要用到时间模块。在使用模块之前，应该首先导入这个模块。
02 常用方法
    （1）time.sleep(secs)  ：(线程)推迟指定的时间运行。单位为秒。
    （2）time.time()  ：获取当前时间戳
03 表示时间的3种方式：时间戳、元组(struct_time)、格式化的时间字符串
    （1）方式一：时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。
                我们运行“type(time.time())”，返回的是float类型。
    （2）方式二：格式化的时间字符串(Format String)： ‘1999-12-06’
    （3）方式三：元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
'''

# 01 导入时间模块
import  time

# 02 时间戳
print(time.time())  # 1543240463.5829234

# 03 时间字符串
print(time.strftime('%Y-%m-%d'))

# 04 时间元祖：localtime将一个时间戳转换为当前时区的struct_time
print(time.localtime())

'''
运行结果：
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=26, tm_hour=21, tm_min=58, tm_sec=27, tm_wday=0, tm_yday=330, tm_isdst=0)
'''

5.os模块

'''
整体说明：
01 os模块是与操作系统交互的一个接口。
'''

import os
# 复制代码#当前执行这个python文件的工作目录相关的工作路径

os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  #改变当前脚本工作目录；相当于shell下cd
os.curdir  #返回当前目录: ('.')
os.pardir  #获取当前目录的父目录字符串名：('..')

#和文件夹相关
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
os.removedirs('dirname1')    #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

# 和文件相关
os.remove()  #删除一个文件
os.rename("oldname","newname")  #重命名文件/目录
os.stat('path/filename')  #获取文件/目录信息

# 和操作系统差异相关
os.sep    #输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    #输出当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep    #输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

# 和执行系统命令相关
os.system("bash command")  #运行shell命令，直接显示
os.popen("bash command").read()  #运行shell命令，获取执行结果
# os.environ  获取系统环境变量

#path系列，和路径相关
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所指向的文件或者目录的最后修改时间
os.path.getsize(path)  #返回path的大小