Python学习：9.模块的安装以及调用模块

import module1
import module as module_a
#给导入的模块自定义一个别名import sys
import time as ti

from module import name
from random import *
#导入random中所有属性

import 文件名 文件名.函数名()

import sys
sys.path.append("d:")
#这个"d:"是你py文件放置的位置

import sys
for i in sys.path:
print(i)

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.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 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 hmach = 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())

# 无分组
import reorigin = "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 reorigin = "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',)
{}

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'}

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', '')
{'name': ''}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')

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')]
#详情请看199import 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

import reorigin = "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'}

import reorigin = "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 ', ' ', '']
['hello ', ' bcd ', ' dd', ' lge ', ' ', '']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']# 中括号里面的字符无需转意，但是正则表达式里的括号有特殊意义，所以正常情况下需要转意

origin = "jhasdjas4dg564jskdbf5s41g56asg"
str_n = re.sub("\d+","KKK",origin,5)
print(str_n)

结果
jhasdjasKKKdgKKKjskdbf5s41g56asgsubn() #subn返回两个元素
origin = "jhasdjas4dg564jskdbf5s41g56asg"
new_str,count = re.subn("\d+","KKK",origin)
print(new_str,count)

结果： #5为匹配个数
jhasdjasKKKdgKKKjskdbfKKKsKKKgKKKasg 5

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文件里的字符串读出，转为相应的类型

#pickle使用dump方法将内存对象序列化：
import pickleli = 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 pickledbfile = open('pickle_list', 'rb')
li = pickle.load(dbfile)
dbfile.close()

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时间格式

print(datetime.date.today())
#输出格式2016-01-26print(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