什么是模块
在 Python 中, 模块其实也就是包含 python 代码的文件, 我们为什么要使用模块? 在我们以后写代码的时候, 我们会发现有很多功能需要经常使用, 那我们想要使用这些功能怎么办, 要再把那些代码在敲一遍吗, 这样不但增加了代码量, 还浪费了时间, 有人说我们可以写在函数里, 是的, 我们可以把一些功能写在函数里, 使用的时候调用函数就行了, 但是我们每次新建一个文件的时候, 都需要再次将那些功能函数写一遍, 还是有些麻烦, 这时候, 模块的便捷就体现出来了, 我们将大量功能函数写在一个 py 文件里, 当我们需要用到部分功能的时候, 将这个文件 (模块) 导入一下, 就可以轻松地调用里面的函数了. 当然模块中不仅可以写函数, 也可以写类.
模块的调用
1.import 语句, 用于导入整个模块
- import module1
- import module as module_a
- # 给导入的模块自定义一个别名
- import sys
- import time as ti
2.form..import, 用于导入模块的某一部分功能或模糊导入
- from module import name
- from random import *
- # 导入 random 中所有属性
使用 import 导入模块内部机制
import 语句导入指定的模块时会执行 3 个步骤
1. 找到模块文件: 在模块搜索路径下搜索模块文件
程序的主目录
PYTHONPATH 目录
标准链接库目录
2. 编译成字节码: 文件导入时会编译, 因此, 顶层文件的. pyc 字节码文件在内部使用后会被丢弃, 只有被导入的文件才会留下. pyc 文件
3. 执行模块的代码来创建其所定义的对象: 模块文件中的所有语句从头至尾依次执行, 而此步骤中任何对变量名的赋值运算, 都会产生所得到的模块文件的属性
注意: 模块只在第一次导入时才会执行如上步骤, 后续的导入操作只不过是提取内存中已加载的模块对象, reload()可用于重新加载模块
自定义模块
所谓的自定义模块就是自己创建一个 python 文件, 在里面写入了一些函数或者类, 在自己定义文件名的时候, 注意不能把自己文件的名字定义和已经存在的模块的名字重复, 否则导入模块的时候可能导入的模块不是你想要的模块.
先在一个. py 文件内写一个函数, 然后再另一个文件内 import 文件名, 然后再写使用文件名. 函数名调用函数.
import 文件名
文件名. 函数名()
导入模块时需要根据 sys.path 的路径找, 为了我们自定义的模块可以成功导入, 我们需要把自己写的 py 文件的路径添加到 sys.path.
- import sys
- sys.path.append("d:")
- # 这个 "d:" 是你 py 文件放置的位置
查看模块搜索路径有哪些, 自己添加的路径是否在搜索路径中.
- import sys
- for i in sys.path:
- print(i)
内置模块
内置模块是 python 自带功能, 使用的时候直接使用 import 或者 from..import 导入模块即可.
python 中有哪些内置模块, 接下来就介绍一下:
一, OS
用于提供操作系统级别的操作
os.getcwd() 获取当前工作目录, 即当前 python 脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录; 相当于 shell 下 cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名:('..')
os.makedirs('dir1/dir2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空, 则删除, 并递归到上一级目录, 如若也为空, 则删除, 依此类推
os.mkdir('dirname') 生成单级目录; 相当于 shell 中 mkdir dirname
os.rmdir('dirname') 删除单级空目录, 若目录不为空则无法删除, 报错; 相当于 shell 中 rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录, 包括隐藏文件, 并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","new") 重命名文件 / 目录
* os.stat('path/filename') 获取文件 / 目录信息
- import os
- info = os.stat("D:\\ 文件名, 需带后缀")
- print(info)
os.sep 操作系统特定的路径分隔符, win 下为 "\\",Linux 下为 "/"
os.linesep 当前平台使用的行终止符, win 下为 "\t\n",Linux 下为 "\n"
os.pathsep 用于分割文件路径的字符串
os.name 字符串指示当前使用平台. win->'nt'; Linux->'posix'
os.system("bash command") 运行 shell 命令, 直接显示
- import os
- os.system("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[, ...]])** 将多个路径组合后返回, 第一个绝对路径之前的参数将被忽略
- import os
- str1 = "D:"
- str2 = "home"
- str3 = "index"
- n = os.path.join(str1,str2,str3)
- print(n)
- #结果 #自己根据顺序添加分割符
- D:home\index
os.path.getatime(path) 返回 path 所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回 path 所指向的文件或者目录的最后修改时间
二, 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 错误相关
三, hashlib
用于加密相关的操作, 代替了 md5 模块和 sha 模块, 主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法.
- import hashlib
- ########md5#########
- hash = hashlib.md5()
- 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())
- # 以上加密算法虽然依然非常厉害, 但时候存在缺陷, 即: 通过撞库可以反解. 所以, 有必要对加密算法中添加自定义 key 再来做加密.
- 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())
- # 加盐值的加密(加密两次的加密)
- import hashlib
- # 自己加的加密规则
- hash = hashlib.md5(bytes("admafasdin", encoding="utf-8"))
- hash.update(bytes("admin", encoding="utf-8"))
- print(hash.hexdigest())
四, re
python 中提供了正则表达式相关操作
- re.match()
- # 从头匹配
- # 最开始哪个字符 (或字符串) 开始匹配上后面的全部忽略
- # 简单
- # 分组
无分组
- # 无分组
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.match("h\w+", origin)
- print(r.group()) # 获取匹配到的所有结果
- print(r.groups()) # 获取模型中匹配到的分组结果
- print(r.groupdict()) # 获取模型中匹配到的分组结果
结果
hello
()
{}
分组
- # 分组
- # 分组的用处: 从已经匹配到的字符串里在获取其中的某个字符
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.match("h(\w+)", origin)
- print(r.group()) # 获取匹配到的所有结果
- print(r.groups()) # 获取模型中匹配到的分组结果 (括号(组) 里的内容)
- print(r.groupdict()) # 获取模型中匹配到的分组结果
结果:
- hello
- ('ello',)
- {}
- # 有组 (括号) 只有 groups 可以匹配到, 有 key 只有 gruopdict 可以匹配到
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.match("(h)\w+", origin)
- print(r.groups()) # 获取模型中匹配到的分组结果
结果:('h',)
- r = re.match("?P<n1>h(\w+)", origin) # ?P<x> x 为 key 字典类型
- print(r.groupdict()) # 获取模型中匹配到的分组结果
- r = re.match("?P<n1>h(?P<n2>\w+)", origin) # key ?P<> 的值为后面的字符串
- print(r.groupdict()) # 获取模型中匹配到的分组结果
结果:
- {'n1': 'h'}
- {'n1': 'h', 'n2': 'ello'}
- re.search()
浏览全部字符串, 匹配第一个符合规则的字符串
和 match 用法差不多, search 只不过这个全部浏览, 一个一个字符的匹配
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.search("a\w+", origin)
- print(r.group()) # 获取匹配到的所有结果
- print(r.groups()) # 获取模型中匹配到的分组结果
- print(r.groupdict()) # 获取模型中匹配到的分组结果
结果:
- alex
- ()
- {}
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.search("a(\w+).*(?P<name>\d)$", origin)
- print(r.group()) # 获取匹配到的所有结果 #上下两个也相同
- print(r.groups()) # 获取模型中匹配到的分组结果 #显示组的结果, 忽略掉自己不匹配的比如? P<name>
- print(r.groupdict()) # 获取模型中匹配到的分组结果
结果:
alex bcd alex lge alex acd 19
- ('lex', '9')
- {'name': '9'}
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- n = re.search("(a)(\w+)",origin)
- print(n.group())
- print(n.groups())
结果:
- alex
- ('a', 'lex')
- re.findall()
在字符串中找到正则表达式所匹配的所有子串, 并返回一个列表, 如果没有找到匹配的, 则返回空列表.
- import re
- re.findall("\d+\w\d+","a2b3c4d5")
- # 匹配时是逐个匹配, 匹配到之后, 下一轮匹配时就从他的后面开始匹配
结果:['2b3', '4d5']
findall 特别
print(re.findall("","asdfasdf"))
结果:
['','', '','', '','', '','', '']
当元素处理时, 有几个括号就有几个组, 就要分几个, 如果第一个匹配了, 第二个, 没有匹配但是第二个可有可无, 但是在第二个的位置上第三个匹配了, 就会生成三个, 其中一个留给没有匹配的, 留的那个为空.
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- print(re.findall("a\w+",origin))
- print(re.findall("(a\w+)",origin))
- print(re.findall("a(\w+)",origin))
- # 加括号以后, 就行当于把按照规则匹配后, 把括号里的输出, 不在括号里的就不输出
结果:
- ['alex', 'alex', 'alex', 'acd']
- ['alex', 'alex', 'alex', 'acd']
- ['lex', 'lex', 'lex', 'cd']
- origin = "hello alex bcd alex lge alex acd 19"
- n = re.search("(a)(\w+)", origin)
- print(re.findall("(a)(\w+)",origin))# 在规则都匹配过一次时, 先把这些放在一个括号里, 之后一次匹配放在一个括号里, 再匹配再放
- print(n.groups()) #结果第一个
结果:
- [('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]
- ('a', 'lex')
- #origin 为上面的
- print(re.findall("(a)(\w+(e))(x)",origin))
结果:# 先找到 a 放进组里, 再找到 le 放进组里, 再从 le 里找到 e 放进组里, 在找到 x 放进组里
- [('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x'), ('a', 'le', 'e', 'x')]
- # 括号的意思是从提取到的内容里再次提取内容, 有几个括号提取几次
例子:
- origin = "hello alex bcd alex lge alex acd 19"
- print(re.findall("(a)((\w+)(e))(x)",origin))
- [('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x')]
- # 详情请看 199
- import re
- a = "alex"
- n = re.findall("(\w){4}",a)# 理论上它输出了四次, 但是它只有一个括号, 所以取一个, 而且默认去最后一个
- n1 = re.findall("(\w)(\w)(\w)(\w)",a)
n3 = re.findall("(\w)*",a)详解 199 24
- print(n)
- print(n1)
- print(n3)
结果
- ['x']
- [('a', 'l', 'e', 'x')]
- ['x', '']
- #findall 其实就是 search 的 groups 组合而来
- # 当加有 * 时, 前面那个可有可无所以当匹配不到或匹配到最后时, 会以空的再匹配一次????
- import re
- n = re.findall("(\dasd)*","1asd2asdp3asd98kif")
- print(n)
- # 结果 #那么多空, 因为贪婪匹配 #连续两次匹配到就去后面那个, 带括号情况下
- ['2asd', '','3asd','', '','', '','', ''] #详解 200 6 or 7
- re.finditer()
和 findall 类似, 在字符串中找到正则表达式所匹配的所有子串, 并把它们作为一个迭代器返回.
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- r = re.finditer("(a)((\w+)(e))(?P<n1>x)",origin)
- print(r)
- for i in r:
- print(i,i.group(),i.groups(),i.groupdict())
结果:
- <callable_iterator object at 0x0000000687374C50>
- <_sre.SRE_Match object; span=(6, 10), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
- <_sre.SRE_Match object; span=(15, 19), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
- <_sre.SRE_Match object; span=(24, 28), match='alex'> alex ('a', 'le', 'l', 'e', 'x') {'n1': 'x'}
- re.split()
方法按照能够匹配的子串将字符串分割后返回列表
- import re
- origin = "hello alex bcd alex lge alex acd 19"
- ddd = "hello alex bcd alex ddaf lge alex acd 19"
- n = re.split("a\w+", origin, 1) # 1 为分割次数
- n1 = re.split("a\w+", ddd)
- print(n)
- print(n1)
结果
- ['hello', 'bcd', 'lge', '',' 19']
- ['hello', 'bcd', 'dd', 'lge', '',' 19']
- origin = "hello alex bcd alex lge alex acd 19"
- n = re.split("a(\w+)", origin, )
- print(n)
结果 # 因为被分割了, 所以 n 有三个部分, 就像下面, n[1]第一部分 n[2]第二部分 n[3]第三部分
- ['hello', 'lex', 'bcd alex lge alex acd 19']
- # 中括号里面的字符无需转意, 但是正则表达式里的括号有特殊意义, 所以正常情况下需要转意
- re.sub()
替换匹配成功的指定位置的字符串
- sub(模型, 替换成什么, 所要替换的字符串, 替换到前几个, 模式)
- origin = "jhasdjas4dg564jskdbf5s41g56asg"
- str_n = re.sub("\d+","KKK",origin,5)
- print(str_n)
结果
- jhasdjasKKKdgKKKjskdbf5s41g56asg
- subn() #subn 返回两个元素
- origin = "jhasdjas4dg564jskdbf5s41g56asg"
- new_str,count = re.subn("\d+","KKK",origin)
- print(new_str,count)
结果: #5 为匹配个数
jhasdjasKKKdgKKKjskdbfKKKsKKKgKKKasg 5
五, json 模块
用于字符串和 python 基本数据类型之间转换
json 模块中提供了四个功能: dumps,dump,loads,load
- import json
- result = json.loads(s)# 将字符串类型转换为一种类型 (看起来像什么转什么) 但是需要完全符合那种类型的条件
- print(result,type(result))
- #json.loads 用于将字典, 列表, 元组形式的字符串, 转换为相应的字典, 列表, 元组
- #json.dumps 将基本数据类型转换为字符串
- json.dump()
- json.load()# 这两个基本不用, 可以不记
- import json
- dic = {"k1":123,"k2":"asd"}
- json.dump(dic,open("hp","w"))# 将 dic 字符串写到 hp 文件里面来
- r = json.load(open("hp","r"))# 将 hp 文件里的字符串读出, 转为相应的类型
json 是通用的数据传输, 可以和多种语言转换, 在用元组转换时可能出现错误, 因为这种类型是 python 里特有的所以, 别的可能无法识别.
六, pickle 模块
用于 python 特有的类型和 python 基本数据类型间进行转换
pickle 模块提供了四个功能: dumps,dump,loads,load
pickle 模块用于将内存中的 python 对象序列化成字节流, 并可以写入任何类似文件对象中; 它也可以根据序列化的字节流进行反序列化, 将字节流还原为内存中的对象.
- #pickle 使用 dump 方法将内存对象序列化:
- import pickle
- li = list(range(1,3))
- dbfile = open('pickle_list', 'wb') #必须以 2 进制打开文件, 否则 pickle 无法将对象序列化只文件
- pickle.dump(li, dbfile)
- dbfile.close()
- # 以上代码即将 list 对象 li 序列化至文件 "pickle_list" 中, 下次再次运行时, 可以通过 pickle 的 load 方法恢复 list 对象:
- import pickle
- dbfile = open('pickle_list', 'rb')
- li = pickle.load(dbfile)
- dbfile.close()
json 模块和 pickle 模块的区别
- #pickle 可以将任何数据类型序列化, json 只能列表字典字符串数字等简单的数据类型, 复杂的不可以
- # 但是 pickle 只能在 python 中使用, json 可以支持多个语言
六, time 模块
时间相关的操作
- print(time.time())
- # 时间戳 从 1970 年 1 月 1 号开始到现在一共过去了多少秒
- print(time.ctiem())
- # 输出当前系统时间
- print(time.ctime(time.time() - 86640))
- # 将时间戳转为字符串格式
- print(time.gmtime(time.time() - 86640))
结果
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=7, tm_hour=7, tm_min=32, tm_sec=49, tm_wday=0, tm_yday=219, tm_isdst=0)
- time_obj = time.gmtime(time.time() - 86640)
- print(time_obj) # 根据上面的输出内容进行格式化输出
- print(str(time_obj.tm_year) + "-" + str(time_obj.tm_mon) + "-" + str(time_obj.tm_mday))
结果
2018 - 6 - 17 # 加上 str 是因为他们原来是整形的
用字符串格式化输出
print("%s-%s-%s" % (time_obj.tm_year, time_obj.tm_mon, time_obj.tm_mday))
结果为
2018 - 6 - 17
格林威治时间
- time.locatime(time.time() - 86640)
- # 本地时间(本机时间)
- time.strftime("%Y-%m=%d %H:%M:%S", time.localtime())
- # 格式化输出时间可以将 time.localtime 替换为其他时间
- # strftime 将给定对象转成给定格式
- time.strptime("2016/05/22", "%Y/%m/%d")
- # 将 日期字符串 转成 struct 时间对象格式
- # 就是上面那个反过来
- # 表明时间格式转换成 struct 时间格式
七, datatime 模块
datatime 模块重新封装了 time 模块, 提供更多接口
- print(datetime.date.today())
- # 输出格式 2016-01-26
- print(datetime.date.fromtimestamp(timetime()-86400))
- #2016-01-26 将时间戳转换为日期格式
- current_time = datetime.datetime.now()
- print(current_time)
- # 输出 2017-08-08 20:33:12.870346
- print(current_time.timetuple)
- # 返回 struct_time 格式
- print(current_time.replace())# 输出现在时间
- print(current_time.replace(1996,5,20))# 输出给定时间
- print(datetime.datetime.now() )# 当前时间
- print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间 + 3 天
- print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间 - 3 天
- print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间 + 3 小时
- print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间 + 30
- # 这里可以进行的操作
- #days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None,
- #hours=None, weeks=None
第三方开源模块
python 有很丰富的模块库, 我们以后编写代码是的时候可以直接下载别人的模块, 简化我们的代码, 那么怎么下载模块, 接下来我们就介绍一些.
我们使用 pip 进行安装, pip 是一个 Python 包管理工具, 我们安装的 python3.6 中自带 pip3, 我们需要找到 python 根目录下的 scripts 添加到环境变量中.
首先右击我的电脑 ==>属性 ==>高级系统设置 ==>在高级下找到下面的环境变量点击 ==>在系统变量中找到 path 点开 ==>将 pip 的目录 (python 根目录下的 scripts 文件路径) 添加到 path 中. 注意每个路径之间需要用 ";" 分开.
打开命令提示符, 使用 pip3 进行安装, 我们演示一下, 格式就是: pip3 install 你要安装的模块名字.
今天主要对三方面进行了介绍
模块的调用
内置模块(今天介绍了几个常用的模块, 以后我们用到模块继续介绍)
第三方模块下载
今天所讲的重点就在前两个, 需要多练习的是内置模块中的方法, 今天就到这里就结束了, 明天见.
来源: https://www.cnblogs.com/liudi2017/p/9194253.html