模块

import cal          #直接调用，当执行文件和cal属同级目录下时，可以直接调用，若要用到cal包里的sub函数，使用时需要 cal.sub（1,3），不能直接使用功能函数，解释器只认识调用过来的变量名，无法识别被调用的变量名包中的函数变量名，但import以后会执行cal中的逻辑函数，比如print。优先执行一遍所有逻辑函数，然后再执行被调用的功能函数。
from cal import sub #从cal文件夹中调用其中的sub函数，此时cal中的函数都已经被拿到，就不需要cal.sub,可以直接使用了。.

解释器能将执行文件(test)的路径添加到sys.path中，若调用文件(cal)和执行文件在同一包中则解释器可以找到，否则需要from  my_module import cal（即cal属于认识路径下的文件，sub属于cal文件中的函数）

#若所需要调用的文件（sub）和被识别的文件存在多级目录关系，则可用.隔开，从最外到里依次，如
from cal.cal2 import sub #sub文件包在cal2中，cal2在cal1中
#也可以调用sub包中的某一个函数,from cal import * #可以调用cal中所有的函数，但不推荐。

if __name__ == "__main__":          #一般存在于主要逻辑函数包中（bin），若调用bin，则__name__ 会变成文件名，可以防止别人测试时被调用，只有在bin内做运行，__name__ == “__main__”，满足条件后才会执行下面的逻辑，也可以达到测试的效果。

time 模块 

 在Python中，通常有这几种方式来表示时间：

1. 时间戳(timestamp) ：         通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
2. 格式化的时间字符串
3. 元组(struct_time)   ：         struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

#time(),返回当前时间的时间戳
time.time()#1550912578.4687386

#localtime([secs]),将一个时间戳转换为当前时区的struct_time.若secs参数为提供，则以当前时间为准
time.localtime()#time.struct_time(tm_year=2019, tm_mon=2, tm_mday=23, 
                 tm_hour=17, tm_min=5, tm_sec=21, tm_wday=5, tm_yday=54, tm_isdst=0)
time.localtime(1550912578.4687386)

#gmtime([secs])，和lacaltime()方法类似，gmtime()是将一个时间戳转换为UTC时区（0时区）的struct_time

#mktime(t)将一个struct_time转化为时间戳
print(time.mktime(tim.localtime()))

#asctime([t])把一个表示时间的元组或者struct_time表示为这种形式：
print(time.asctime())#Sat Feb 23 17:12:05 2019

#ctime([secs])把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())#Sat Feb 23 17:20:18 2019
print(time.ctime(time.time()))#Sat Feb 23 17:20:18 2019

#strftime(format[, t])把一个代表时间的元组或者struct_time如由time.localtime()和
time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个
#元素越界，ValueError的错误将会被抛出。
print(time.strftime('%Y-%M-%d %X',time.localtime()))#2019-25-23 17:25:26

#time.strptime(string[, format])把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime('2019-2-23 17:25:26','%Y-%m-%d %X'))
#time.struct_time(tm_year=2019, tm_mon=2, tm_mday=23, tm_hour=17, tm_min=25, 
tm_sec=26, tm_wday=5, tm_yday=54, tm_isdst=-1)
#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"

#sleep(secs)线程推迟指定时间运行，单位为秒

#clock()不同系统含义不同。
在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。
#而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。
而第二次之后的调用是自第一次调用以后到现在的运行时间，即两次时间差。

random 模块

import random
print(random.random())              #(0,1)中随机浮点数
print(random.randint(1,3))          #任意范围内中取整数
print(random.randrange(1,3))        #[1,3)随机整数，取左不取右
print(random.choice([12,13,14]))    #在可迭代对象中随机取
print(random.sample([12,13,14],2))  #在可迭代对象中随机取，可以设置取的个数
print(random.uniform(1,3))          #在任意范围取浮点数
print(random.shuffle([2,3,5,8]))    #打乱顺序

验证码

def v_code():
    ret = ""
    for i in range(5)                     #选择出现几位数
        num = random.randint(0,9)         #0,9中随机抽取整形
        alf = chr(random.choice(65,122))  #chr可以通过数字找出对应的阿斯克码的字母。
                                          #此处chr(65) = a,chr(122) = z
        s = str(random.choice([num,alf])) #将随机抽取出的数字与字母随机组合生成一个列表，因为
                                           有数字的缘故，将其转化为字符串格式
        ret += s                          #生成新的字符串，字符串之间可以+，直接合并
    return ret

---

BASE_DIR介绍

#还是在bin.py中，解决拷贝到其他电脑之后路径不同的问题
import sys,os
#sys.path.append(路径) 可以将路径添加到sys.path中，让解释器认识，但其他电脑无法使用
#sys.path.dirname(os.path.dirname(os.path.dirname(__file__)))__file__，
#是当前文件的路径，即bin.py，此处在pychram中，会添加bin.py之前的路径，但在终端不会
BASE_DIR = sys.path.dirname(os.path.dirname(os.path.abspath(__file__))) #os模块，
此时可以拿到绝对路径，可以在终端中运行
sys.path.append(BASE_DIR) #将绝对路径添加到sys.path中，完美解决

 https://www.cnblogs.com/yuanchenqi/articles/5732581.html

os模块

#os模块
os.getcwd() #获取当前python脚本工作的路径
os.chdir("test") #将当前脚本路径改为test，相当于shell下的cd
os.curdir(.) #返回当前目录
os.pardir(..)#返回当前目录的父目录字符串名
os.makedirs('dirname1/dirname2')#可生成多层递归目录
os.removedirs('dirname1/dirname2')#若dirname2为空则删除，若上级为空也删除，以此类推，
                                   此处只能找到dirname1,只能找到dirname2
os.mkdir('dirname')  #生成单级目录，相当于shell中的mkdir dirname
os.rmdir('dirname')  #删除单级空目录，若目录不为空，则报错，无法删除。相当于shell中的rmdirname
os.listdir('dirname')#列出指定目录下的全部文件，包括隐藏文件，以列表的形式打印出来
os.remove()          #删除一个文件
os.rename("oldname","newname") #给一个文件重命名
os.stat("sss")       #获取文件详情信息
os.sep               #输出当前系统的路径分隔符，win是"\\",Linux是"/"
os.linesep           #输出当前系统的行分隔符，win是"\r\n",Linux是"\n"
os.pathsep           #输出用于分割文件路径的字符串，win是";",Linux是":"
os.path.abspath(a)   #返回a规范化的绝对路径
os.path.split(a)     #将a分割成目录和文件名的元组形式返回
os.path.dirname(a)   #返回a的目录。实际是split返回元组中的第一个元素
os.path.basename(a)  #返回a的文件名
#一般很少使用split，直接拿目录或者文件名
os.path.exits(a)     #判断a是否存在，返回布尔值
os.path.isabs(a)     #判断a是否是绝对路径，返回布尔值
os.path.isfile(a)    #判断a文件是否是一个存在的文件，返回布尔值
os.path.isdir(a)     #判断a是否是一个存在的路径，返回布尔值
os.path.join(a,b)    #路径拼接，不需要对系统的分隔符进行判断选择，最好不用加号直接拼接
os.path.getatime(a)  #返回a所指向的文件或目录的最后存储时间
os.path.getmtime(a)  #返回a所指向的文件或目录的最后修改时间

sys模块

import sys
sys.argv          #返回一个列表，第一个元素是程序的本身路径（文件名）
print(sys.avgv) 
command == sys.argv[1]
path == sys.argv[2]
if command == "命令1":
    ...
elif command == "命令2":
    ...           #直接打印可以获取当前程序路径，也可以获取input用户输入的内容，
                  #第一个元素可能是用户要执行的命令，可以把命令拿出来表示从而做判断。

#进度条
import time
for i in range(10):
    sys.stdout.write("#")    #print的主要是借用的此方法来打印
    time.sleep(0.5)          #每0.5秒拿一个
    sys.stdout.flush()       #刷新缓存，若无此步骤，缓存会等到运行结束才一次性显示

json、pickle模块

#序列化，将文件转化为json模式的字符串，可以被不同的语言所识别，相当于流通型字符串
#经过dumps处理后的字符串成为json字符串，但只要符合json规则的字符串，都可以被序列化
import json
json.dumps(dic)            #dic后以此类推
dic = {'name' : 'harvey'}  #第一步转化为{"name" : "harvey"}第二步转化为'{"name" : "harvey"}'
i = 8                      #转化为'8'
s = 'hello'                #第一步"hello"，第二步'"hello"'
l = [22,33]                #转化为'[22,33]'
#最外层无所谓单双引，目的是字符串即可，里面的需要变成双引号

#将json数据放入磁盘中
#dumps
dic_str = json.dumps(dic)    #序列化
f_w = open("new_hello","w")  #选择或新建处理json字符串的位置
f.write(dic_str)             #将json字符串存入磁盘
#dump（只能用于文件操作）
f_w = open("new_hello","w")
json.dump(dic,f_w)

#将磁盘中的json数据拿出来
#loads
f_r = open("new_hello","r")  #选择要拿出的数据的位置
data = json.loads(f_r.read())#将被json封装的数据恢复成原数据
#load（只能用于文件操作）
data = json.load(f_w)

#pickle模块和json同样属于序列化，不同的是pickle序列化成字节(bytes)
#而且可以支持函数和类的序列化，但通常序列化函数或类的意义不大，故一般使用json.

shelve模块

import shelve
#作用是将一个字典写入文本，后期操作时可以把被shelve封装的文件作为字典的形式进行操作
f = shelve.open(r 'shelve_text')   #将一个字典写入文本
f['stu1'] = ['name' : 'harvey','age' : '20']
f['stu2'] = ['name' : 'Tom','age' : '20']
f['school'] = ['city' : 'Beijing']
f.close()
print(f.get('stu1')['age'])        #用字典的方式取所需的值即可

xml模块

import xml.etree.ElemenTree as ET   #import..as..相当于以下统称为
tree = ET.parse("xml_lesson")       #将xml_lesson用parse方法拿出来
root = tree.getroot()
print(root.tag)                     #可以获取到根节点的名称

for i in root:
    print(i.tag)                    #获取root中的子标签名
    print(i.attrib)                 #获取子标签属性
    print(i.text)                   #获取内容
#修改，所有year节点中年份+1并加新属性
for node in root.iter('year'):
    new_year = int(node.text) + 1   #将year的原内容整型化后做修改然后拿出
    node.text = str(new_year)       #将新内容字符串化后作为node的内容
    node.set('updated','yes')       #加入一个新属性"updated = yes"
#删除，所有country节点中排名大于50的删掉
for country in root.findall('country'):  #直接找出所有的country标签进行遍历
    rank = int(country,find('rank').text)#用find找到每一个country的rank拿出来
    if rank > 50:
        root.remove(country)
tree.write('output.xml')                 #可以将删除后的文件放在新文件中，也可覆盖原文件
#做了解：创建一个xml

re模块（正则表达式） 

就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言。对字符串的模糊匹配
字符匹配：
1、普通字符：大多数字符和字母都会和自身匹配
>>> ret = re.findall('harvey','woqunidayeharveyde')
>>> print(ret)
['harvey']

2、元字符：.   ^   $   *   +   ?   { }   [ ]   |   ( )   \

import re
#元字符之 . ^ $ * + ? {}
ret = re.findall('h....y','woqunidayeharveyde')
print(ret)#['harvey'] 通配符

ret = re.findall('^h....y','harveywoqunidayede')
print(ret)#['harvey'] 从开头第一个找，不符合则匹配失败

ret = re.findall('h....y$','woqunidayedeharvey')
print(ret)#['harvey'] 从皆为最后一个找，不符合则匹配失败

ret = re.findall('abc*','abcccc')
print(ret)#['abcccc'] [0,+∞]匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。

ret = re.findall('abc+','abcccc')
print(ret)#['abcccc'] [1,+∞]匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。

ret = re.findall('abc?','abcccc')
print(ret)#['abc'] [0,1]
ret = re.findall('abc?','ab')
print(ret)#['ab']匹配零次或一次。

ret = re.findall('abc{1,4}','abcccc')
print(ret)#['abcccc']匹配1-4次，有多少拿多少，若{n}，则匹配指定个数，后面多余的舍去

#当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。
#非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。
ret = re.findall('abc*?','abcccc')
print(ret)#['ab']尽可能少的匹配
ret = re.findall('abc+?','abcccc')
print(ret)#['abc']+的特性是必须要拿一个，所以与*的区别体现在此

 字符集[ ]，有功能的字符：- ^ \

ret = re.findall('a[bc]d','acd')
print(ret)#['acd']字符集合。匹配所包含的任意一个字符。

ret = re.findall('[a-z]','abg')
print(ret)#['abg']字符范围。匹配指定范围内的任意字符。

ret = re.findall('[.*+]','a.cd+')
print(ret)#['.', '+']在字符集中原本有特殊意义的符号全部失效

ret = re.findall('[1-9]','45gh6j7l')
print(ret)#['4','5','6','7']

ret=re.findall('[^ab]','45bdha3')
print(ret)#['4', '5', 'd', 'h', '3']负值字符集合。匹配未包含的任意字符,取反，可以和-结合使用

元字符之转义符\

反斜杠后边跟元字符去除特殊功能,比如\.
反斜杠后边跟普通字符实现特殊功能,比如\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  匹配一个特殊字符边界，比如空格 ，&，＃等，例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

import re
ret = re.findall('I\b','I am LIST')#想拿第一个I怎么办
print(ret)#[]
ret = re.findall(r'I\b','I am LIST')#加r可以让后边字符串的内容不作任何转义，否则\b会运行re之前被解释器转义
print(ret)#['I']

ret=re.findall('c\l','abc\le')     #python解释器会将'\l'转义，然后放入re中时已经物是码非
print(ret)#[]
ret=re.findall('c\\l','abc\le')    #python解释器会将'\\l'转义为'\l',在re中已变成特殊字符
print(ret)#[]
ret=re.findall('c\\\\l','abc\le')  #python解释器会将'\\\\l'转义为'\\l',re会转义为'\l',此时'\'为普通字符
print(ret)#['c\\l']
ret=re.findall(r'c\\l','abc\le')   #r直接使字符串跳过python解释器的转义，以'\\l'的形式传给re
print(ret)#['c\\l']

#之所以选择\b是因为\b在ASCII表中是有意义的
m = re.findall('\bblow', 'blow')
print(m)#[]
m = re.findall(r'\bblow', 'blow')
print(m)#['blow']

元字符之分组()

import re
ret = re.findall(r'ad+','add')
print(ret)#['add']
ret = re.findall(r'(ad)+','add')#圆括号优先级强，所以并没有贪婪匹配
print(ret)#['ad']

元字符之 |

#search方法找第一个满足的就终止匹配不再找了
ret=re.search('(ab)|\d','rabhdg8sd') #匹配ab或\d，匹配成功即中止匹配。
print(ret.group())#ab

#search可以用来分组匹配，即给匹配条件自定义分组：
#ret = re.search('(?p<分组1>\d{2})/(?p<分组2>\w{3})','分组1匹配的内容/分组2匹配的内容')
ret = re.search('(?P<id>\d{2})/(?P<name>\w{3})','23/com')
print(ret.group())#23/com            #用group拿所有分组的内容
print(ret.group('id'))#23            #用group拿id组的内容

3、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,不过尽在字符串开始处进行匹配，相当于search加^
 
#4分割
ret=re.split('[ab]','abcd')     #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
 
#5替换
ret = re.sub('\d','abc','alvin56yuan67',1) #只替换一次，\d替换为'abc'
print(ret)#alvinabcyuan6
ret = re.sub('\d','abc','alvin56yuan67')   #每一个\d替换
print(ret)#alvinabcabcyuanabcabc
ret = re.sub('\d+','abc','alvin56yuan67')  #连续的\d作为整体替换
print(ret)#alvinabcyuanabc

ret = re.subn('\d','abc','alvin5yuan6')    #输出一个元组，输出匹配结果以及匹配次数
print(ret)#('alvinabcyuanabc', 2)
 
#6
rules = re.compile('\d{3}')                #提前定义匹配规则，后面可以直接调用
ret = rules.search('abc123eeee')           #用定义好的规则直接调用
print(ret.group())#123

##注意

import re 
ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)#['oldboy']     findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)#['www.oldboy.com']

configparser模块

大多数软件的常见文档

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

如何用python建立一个这样的文档

import configparser
config = configparser.ConfigParser()
config['DEFAULT'] = {'ServerAliveInterval' : '45',
                     'Compression : 'yes',
                     'CompressionLevel : '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022'
topsecret['ForwardX11'] = 'no'
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini','w')as configfile:
    config.write(configfile)

增删改查

import configparser
config = configparser.ConfigParser()

#--------------------------------查--------------------------------
print(config.sections())   #[]没打开所以为空
config.read('example.ini')
print(config.sections())   #['bitbucket.org','topsecret.server.com']
print('bytebong.com' in config) #False判断文件中是否存在
print(config['bitbucket.org']['User'])#获取bit...中的User的值，是以字典形式存在的
print(config['DEFAULT']['Compression']) #yes
print(config['topsecret.server.com']['FrowardX11'])#no

for key in config['bitbucket.org']:
    print(key)
#user
#serveraliveinterval
#compression
#compressionlevel
#forwardx11

print(config.options('bitbucket.org'))
#['user','serveraliveinterval','compression','compressionlevel','forwardx11']
print(config.items('bitbucket.org')) 
#[('serveraliveinterval','45'),('compression','yes'),
('compressionlevel','9'),('forwardx11','yes'),('user','hg')]
print(config.get('bitbucket.org','compression')) #yes

#-----------------增删改(config.write(open('i.cfg','w'))-----------------------
config.add_section('hy')
config.remove_section('topsecresct.server.com')
config.remove_option('bitbucket.org','user')
config.get('bitbucket.org','k1','111111')
config.write(open('i.cfg','w'))

hashlib模块

用于加密相关操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法

import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
m.update('hello'.encode('utf8'))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
m.update('alvin'.encode('utf8'))
 
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
 
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

import hashlib
#####256#####
hash = hashlib.sha256('456asd123qwe,encode('utf8')')
hash.update('alvin',encode('utf8'))
print(hash.hexdigest())