Python模块
模块（module）
在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护
为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式.在Python中，一个.py文件就称之为一个模块（Module）
而在Python中的module分为三种：
- Python标准库
- 第三方模块
- 应用自定义模块
引用方法
import modname
##引用本地目录的module
from modname import name1[, name2[, ... nameN]]
from filename.filename… import modname
##引用那个指定目录下的module
from modname import *
##引用该module里面所有的函数
>>> import sys
>>> print(sys.path)
['', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36\\Lib\\idlelib', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36\\lib', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36', 'C:\\Users\\DELL\\AppData\\Roaming\\Python\\Python36\\site-packages', 'C:\\Users\\DELL\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']
##import的运行本质的在sys.path里面的路径找module
包（Package）
每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包.要避免与同级目录的Package重名.
print(__file__)##该结果是当前的文件
import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
##os.path.dirname() 返回上一级， os.path.abspath() 绝对路径
sys.path.append(BASE_DIR) ##把该路径暂时放到系统path里面，就能找到了
import hello
hello.hello1()
防止程序被引用
##写在这下面的程序，可以防止被其他调用运行，也可以用于被调用函数的测试
if __name__ == "main":
program
----time模块
import time # 1 time() :返回当前时间的时间戳 time.time() #1473525444.037215 #---------------------------------------------------------- # 2 localtime([secs]) # 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。 time.localtime() #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, # tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0) time.localtime(1473525444.037215) #---------------------------------------------------------- # 3 gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。 #---------------------------------------------------------- # 4 mktime(t) : 将一个struct_time转化为时间戳。 print(time.mktime(time.localtime()))#1473525749.0 #---------------------------------------------------------- # 5 asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。 # 如果没有参数，将会将time.localtime()作为参数传入。 print(time.asctime())#Sun Sep 11 00:43:43 2016 #---------------------------------------------------------- # 6 ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为 # None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。 print(time.ctime()) # Sun Sep 11 00:46:38 2016 print(time.ctime(time.time())) # Sun Sep 11 00:46:38 2016 # 7 strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和 # time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个 # 元素越界，ValueError的错误将会被抛出。 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56 # 8 time.strptime(string[, format]) # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')) #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, # tm_wday=3, tm_yday=125, tm_isdst=-1) #在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。 # 9 sleep(secs) # 线程推迟指定的时间运行，单位为秒。 # 10 clock() # 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。 # 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行 # 时间，即两次时间差。
----random模块
import random
print(random.random())
##返回[0,1）之间的任意浮点数
print(random.randint(1,10))
##返回[1,10]之间的任意整数
print(random.randrange(1,100,2))
##从指定范围内，按指定基数递增的集合中获取一个随机数
print(random.choice([1,'23',[4,5]]))
##在sequence里面选择一个
print(random.sample([1,'23',[4,5]],2))
##从指定序列中随机获取指定长度的片段，sample函数不会修改原有序列
print(random.uniform(1,3))
##用于生成一个指定范围内的随机浮点数
item=[1,3,5,7,9]
random.shuffle(item)
print(item)
##用于打乱序列
----os模块
import os 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下为"\t\n",Linux下为"\n" os.pathsep #输出用于分割文件路径的字符串 win下为;,Linux下为: 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所指向的文件或者目录的最后修改时间
----sys模块
import sys sys.argv #命令行参数List，第一个元素是程序本身路径 sys.exit(n) #退出程序，正常退出时exit(0) sys.version #获取Python解释程序的版本信息 sys.maxint #最大的Int值 sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.platform #返回操作系统平台名称
----json模块
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling；序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上；反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling
import json
dic = {"name":"Hermaeus",
"age":19,
"hometown":"MeiShan",
"hobby":"Coding"}
j_dic = json.dumps(dic) #===> json.dump(dic, f)
f = open("test.json","w")
f.write(j_dic)
f.close()
import json
f = open("test.json","r")
date = json.loads(f.read()) #===> json.load(f)
print(date)
输入结果为：
{'name': 'Hermaeus', 'age': 19, 'hometown': 'MeiShan', 'hobby': 'Coding'}
----pickle模块
import pickle
#----------------------序列化------------------------
dic = {"name":"Hermaeus",
"age":19,
"hometown":"MeiShan",
"hobby":"Coding"}
j_dic = pickle.dumps(dic)
f = open("test.json","wb") #必须输入二进制
f.write(j_dic) #===>pickle.dump(dic, f)
f.close()
#---------------------反序列化------------------------
f = open("test.json","rb") #输入的也一定是二进制
date = pickle.loads(f.read()) #===>pickle.load(f)
print(date)
----shelve模块
##类字典操作
import shelve
f = shelve.open(r"shelve.txt") #就一个open函数
f["info_1"] = {"name":"Hermaeus", "age":19}
f["info_2"] = {"name":"YuanMing", "age":20}
# f.close()
print(f["info_1"])
print(f["info_2"]["name"])
----xml模块
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>
操作如下：
import xml.etree.ElementTree as ET
tree = ET.parse("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)
#---------------------------------------
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
#修改
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')
创建一个xml文档：
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
ET.dump(new_xml) #打印生成的格式
结果如下：
<?xml version='1.0' encoding='utf-8'?>
<namelist>
<name enrolled="yes">
<age checked="no" />
<sex>33</sex>
</name>
<name enrolled="no">
<age>19</age>
</name>
</namelist>
configparser模块
##类字典操作
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'
}
config["bitbucket"] = {}
config["bitbucket"]["user"] = "hg"
config["topsecret.server.com"] = {}
topsecret = config["topsecret.server.com"]
topsecret["Host Port"] = '32204'
topsecret["Fowardx11"] = "no"
config["DEFAULT"]["Fowardx11"] = "yes"
with open("example.ini", "w") as configfile:
config.write(configfile)
得到结果：
[DEFAULT]
serveraliveinterval = 45
compression = yes
compressionlevel = 9
fowardx11 = yes
[bitbucket]
user = hg
[topsecret.server.com]
host port = 32204
fowardx11 = no
其他操作
import configparser
config = configparser.ConfigParser()
config.read("example.ini")
print(config.sections()) #sections()是获得非DEFAULT的值
['bitbucket', 'topsecret.server.com']
print("bytebong.com" in config)
False
print(config["bitbucket"]["user"])
hg
print(config["DEFAULT"]["Compression"])
yes
print(config["topsecret.server.com"]["Fowardx11"])
no
for key in config["bitbucket"]: #每一次打印都会把DEFAULT里面的值打印下来
print(key)
user
serveraliveinterval
compression
compressionlevel
fowardx11
print(config.options("bitbucket")) #返回键
['user', 'serveraliveinterval', 'compression', 'compressionlevel', 'fowardx11']
print(config.items("bitbucket")) #把键值对以元组方式输出
[('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('fowardx11', 'yes'), ('user', 'hg')]
print(config.get("bitbucket", "compression")) #返回bitbucket里面是否有compression
yes
config.add_section("answer") #建立一个section
config.remove_section("topsecret.server.com") #删除一个section
config.remove_option("bitbucket", "user") #删除一个键
config.set("bitbucket", "k1", "111") #增添一个键值对
config.write(open("i.cfg", "w")) #写入磁盘
----hashlib
用于加密相关的操作，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
import hashlib
m = hashlib.md5()
m.update("hello".encode("utf-8"))
print(m.hexdigest())
5d41402abc4b2a76b9719d911017c592
m.update("hello".encode("utf-8"))
m.update("world!".encode("utf-8")) ##等同于"helloworld!",这样是把它们两个拼接在一起
print(m.hexdigest())
420e57b017066b44e05ea1577f6e2e12
m.update("helloworld!".encode("utf-8"))
print(m.hexdigest())
420e57b017066b44e05ea1577f6e2e12
然后这种加密，可以通过撞库来反解，但是可以在加密算法里添加自定义key再来加密
import hashlib
m = hashlib.sha256("ok".encode("utf-8"))
m.update("hello".encode("utf-8"))
print(m.hexdigest())
ce9eba905e14b4f0dceb89f329280c10bb0403375d2a613c4bfb8aa726145c73
----logging模块
import logging
logging.debug("debug message")
logging.info("info message")
logging.warning("waring message")
logging.error("error message")
logging.critical("critical message")
WARNING:root:waring message
ERROR:root:error message
CRITICAL:root:critical message
##在默认情况下，输入显示的是大于等于warning级别的（critical>error>warning>info>debug)
import logging
logging.basicConfig(level = logging.DEBUG,
format = "%(asctime)s, %(filename)s[line:%(lineno)d] %(levelname)s %(message)s",
datefmt = "%a %d %b %Y %H:%M:%S",
filename = "test.log",
filemode = "w")
logging.debug("debug message")
logging.info("info message")
logging.warning("waring message")
logging.error("error message")
logging.critical("critical message")
输入结果如下，
Thu 16 Aug 2018 12:48:50, experiment.py[line:1762] DEBUG debug message
Thu 16 Aug 2018 12:48:50, experiment.py[line:1763] INFO info message
Thu 16 Aug 2018 12:48:50, experiment.py[line:1764] WARNING waring message
Thu 16 Aug 2018 12:48:50, experiment.py[line:1765] ERROR error message
Thu 16 Aug 2018 12:48:50, experiment.py[line:1766] CRITICAL critical message
可见在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,‘w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息
logger对象
import logging
logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')
# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
# 定义一个filter
filter = logging.Filter('mylogger')
fh.addFilter(filter)
ch.addFilter(filter)
# logger.addFilter(filter)
logger.addHandler(fh)
logger.addHandler(ch)
logger.setLevel(logging.DEBUG)
logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')
logger1 = logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)
logger2 = logging.getLogger('mylogger')
logger2.setLevel(logging.INFO)
logger1.addHandler(fh)
logger1.addHandler(ch)
logger2.addHandler(fh)
logger2.addHandler(ch)
logger1.debug('logger1 debug message')
logger1.info('logger1 info message')
logger1.warning('logger1 warning message')
logger1.error('logger1 error message')
logger1.critical('logger1 critical message')
logger2.debug('logger2 debug message')
logger2.info('logger2 info message')
logger2.warning('logger2 warning message')
logger2.error('logger2 error message')
logger2.critical('logger2 critical message')
----re模块
re的元字符
import re
ret = re.findall("e..a", "Hermaeus") #"."是模糊表示一个字符
print(ret)
['erma']
ret = re.findall("^H..m", "Hermaeus") #"^"表示开头必须是某个字符
print(ret)
['Herm']
ret = re.findall("a..s$", "Hermaeus") #"$"表示结尾必须是1某个字符
print(ret)
['aeus']
ret = re.findall("abc*", "abccccc") #贪婪匹配[0,+∞]
print(ret)
['abccccc']
ret = re.findall("abc+", "abccccc") #贪婪匹配[1,+∞]
print(ret)
['abccccc']
ret = re.findall("abc?", "abccccc") #惰性匹配[0,1]
print(ret)
['abc']
ret = re.findall("abc{1,3}", "abccccc") #贪婪匹配[1,3]
print(ret)
['abccc']
ret = re.findall("abc*?", "abccccc") #这样会让其变成惰性匹配
print(ret)
['ab']
字符集===>“[ ]”
即在字符集中任意匹配一个
import re
ret = re.findall("a[bc]", "abc")
print(ret)
['ab']
ret = re.findall("[a-z]", "ahfao")
print(ret)
['a', 'h', 'f', 'a', 'o']
ret = re.findall("[%$]", "ada%jf$") #在字符集里面除了：- ^ \以外都是普通字符
print(ret)
['%', '$']
##" - " 取在这之间的
ret = re.findall("[1-9]", "1jkah1k2k3j")
print(ret)
['1', '1', '2', '3']
##" ^ " 取反，即在这字符集里面没有的
ret = re.findall("[^ab]", "7ajkf2bfjab")
print(ret)
['7', 'j', 'k', 'f', '2', 'f', 'j']
##" \ " 转义符
ret = re.findall("[\d]", "45dhaf2")
print(ret)
['4', '5', '2']
转义符
反斜杠后边跟元字符去除特殊功能,比如\. 反斜杠后边跟普通字符实现特殊功能,比如\d \d 匹配任何十进制数；它相当于类 [0-9]。 \D 匹配任何非数字字符；它相当于类 [^0-9]。 \s 匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。 \S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。 \w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。 \W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_] \b 匹配一个特殊字符边界，比如空格 ，&，＃等
import re
ret = re.findall(r"I\b", "I am LIST") ##添加"r"，表示把需要匹配的字符集直接交给模块处理
print(ret)
分组 “( )”
import re
ret = re.search("(?P<id>\d{2})/(?P<name>\w{3})", "23/com") #"?P<id> 取名
print(ret)
<_sre.SRE_Match object; span=(0, 6), match='23/com'> #返回一个对象
print(ret.group())
23/com
print(ret.group("id"))
23
“|”符号
import re
ret = re.search("(ab)|\d", "rabjk4fk") #二选一
print(ret)
print(ret.group())
re下的常用方法
import re
#1
re.findall('a','alvin yuan') #返回所有满足匹配条件的结果,放在列表里
#2
re.search('a','alvin yuan').group() #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以;通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
#3
re.match('a','abc').group() #同search,不过尽在字符串开始处进行匹配
#4
ret=re.split('[ab]','abcd') #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
#5
ret=re.sub('\d','abc','alvin5yuan6',1)
print(ret)#alvinabcyuan6 #替代
ret=re.subn('\d','abc','alvin5yuan6')
print(ret)#('alvinabcyuanabc', 2) #替代，且可以选择次数
#6
obj=re.compile('\d{3}') #对象赋予
ret=obj.search('abc123eeee')
print(ret.group())#123
#7
ret=re.finditer('\d','ds3sy4784a')
print(ret) #<callable_iterator object at 0x10195f940>
#返回迭代器
print(next(ret).group())
print(next(ret).group())
注意：
import re
ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)['oldboy'] #这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
['oldboy']
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)
['www.oldboy.com']
6931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
