常用模块

Posted 2020-09-28

1、import讲解
#本质就是.py 文件，用来从逻辑上组织pyhton代码(变量、函数、类、逻辑，实现一个功能)

1.1、导入方法
导入多个模块，以逗号隔开

例如 module模块：
name = "kangkang"
def fun(num):
    print("num",num)
1）
import module
print(module.name) #调用模块下的参数
module.fun(23)    #调用模块下的方法
结果为：
kangkang
num 23
2）#是将module下的方法导入，若有相同的变量名、方法 会被覆盖

from module import *  
print(name)
fun(23)
结果为：
kangkang
num 23

3）#as关键字，将导入的模块底下的方法取个别名
from module import fun as fun_mod
fun_mod(23)
结果为：
num 23

1.2、import 本质

import module  这种方式是将导入的模块先解释一遍，统一赋值给模块名，调用时用模块名.变量名（方法名）

from module import fun  这种方式是将对应的变量放到当前位置执行一遍

 

1.3导入包

导入包实际就是在跑 __init__.py 文件

#导入包的下的模块
1、在__init__.py文件下导入包
包（package）
包下的文件：
name = "lily"
print(name)

在包下的__init__.py文件导入模块
print("包下的__init__文件")
#import test
from .import test

2、在模块下导入包下对应的模块名
import package
print(package.test.name)

结果为：
包下的__init__文件
lily
lily

1.4导入优化

在当前函数多次调用了模块，直接用from导入运行一次模块

常用模块分三大块：1、标准库（Python解释器自带的） 2、第三方模块 3、自定义模块

 1、time()模块

#time 模块，表示方式有 1）时间戳 2）元组(struct_time) 3)格式化字符串
import time
print(time.time())#返回时间戳 秒为单位
#结果：1496244459.139784
print(time.localtime())#struct_time  ，可传入值
#结果：time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=23, tm_min=27, tm_sec=39, tm_wday=2, tm_yday=151, tm_isdst=0)时区 夏令时
print(time.gmtime())#返回的是UTC时区的时间，是struct_time(tuple)格式  ，可传入值
#结果：time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=16, tm_min=2, tm_sec=10, tm_wday=2, tm_yday=151, tm_isdst=0)

print(time.timezone)  #-28800 ,-28800/3600=8,当前时间和UTC时间的差值
print(time.altzone)  #-32400  当前时间和DST时间的差值
print(time.daylight)  # 是否使用了夏令时
print(time.time())
print(time.sleep(3))


x = time.localtime()#获取该时间的年、月、日等
print(x)
#结果：time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=23, tm_min=27, tm_sec=39, tm_wday=2, tm_yday=151, tm_isdst=0)时区 夏令时
print(x.tm_year)  #结果：2017 其他的获取以此类推

#将struct_time 转化成时间戳  用mktime(元组)
print(time.mktime(x))  #1496247520.0

#将struct_time转格式化字符串，用strftime("格式",元组)
print(time.strftime("%Y-%m-%d %H:%M:%S",x))  #2017-06-01 00:23:00

#将字符串格式转换truct_time，用striptime("字符串","格式")
print(time.strptime("2017-06-01 00:23:00","%Y-%m-%d %H:%M:%S"))
#结果为：time.struct_time(tm_year=2017, tm_mon=6, tm_mday=1, tm_hour=0, tm_min=23, tm_sec=0, tm_wday=3, tm_yday=152, tm_isdst=-1)

print(time.asctime()) #  传入的是元组  Thu Jun  1 00:41:16 2017
print(time.ctime()) #传入的是秒  Thu Jun  1 00:42:46 2017

 

 

2、datetime()

import datetime
#获取当前时
print(datetime.datetime.now()) #2017-06-01 00:48:45.418119
print(datetime.datetime.now()+datetime.timedelta(3)) #往后推3天2017-06-04 00:48:45.418119
print(datetime.datetime.now()+datetime.timedelta(hours=3)) #往后推3个小时  2017-06-01 03:50:02.344519

 

 3、random模块

import random
print(random.random())  #获取随机数 随机一个0~1的浮点数  0.2989567744701819
print(random.uniform(1,6))#获取随机数，也是获得一个随机的浮点数  但可以指定范围
print(random.randint(1,6)) #随机获取1~6的值  2
print(random.randrange(1,3)) #随机获取1~2的值 顾头不顾尾  1
#help(random.randrange)
print(random.choice("Dhjceret6768skd"))# 从序列中随机取一个  k
print(random.sample("dujfdk",2)) #从序列中随机取2个数  [‘f‘, ‘d‘]

#打乱顺序
I = [123,3,3,5,6,2,66]
random.shuffle(I)
print(I)            #[5, 123, 3, 6, 3, 2, 66]

random应用实例

import random
random_num = ""
for i in range(7):
    num = random.randrange(1,7)
    if i == num:
        tmp =chr(random.randint(65,90))
    else:
        tmp = random.randint(0,9)
    random_num = random_num+str(tmp)
print(random_num)
结果：
随机获取的验证码  429G580

4、os模块

提供对操作系统调用接口

#提供对操作系统调用模块
import os
print(os.getcwd())  #E:\\python_3.5\\second\\常用模块   获取当前pyhton脚本的工作路劲

os.chdir(r"E:\\python_3.5")#建议使用这个
#或者 os.chdir("E:\\\\python_3.5")
print(os.getcwd())  #已切换到上一层目录  E:\\python_3.5

os.curdir #是一个属性  不是方法  返回当前路劲  E:\\python_3.5
print(os.getcwd())

os.pardir
print(os.getcwd())  #E:\\python_3.5

#os.makedirs(r"E:\\a\\b\\c") #递归创建目录
#os.removedirs(r"E:\\a\\b\\c") #递归删除目录

#os.mkdir(r"E:\\A")  #只能创建1个目录
#os.remove(r"E:\\A")

os.listdir(r".") #列出当前目录的文件

# os.remove() #删除一个文件
# os.rename("旧文件名","新文件名")
os.stat(r".")  #获取文件/目录信息

#重要
print(os.sep) #获取操作系统的路劲分割符 \\
print(os.linesep) #获取当前平台的终止分隔符 \\t\\n ,linux是\\n
print(os.pathsep) # :输出分隔文件路劲字符串

print(os.name) #nt 当前系统名  nt表示windows
print(os.system("dir"))  #执行当前系统的命令
print(os.environ) #获取系统环境变量

#剩下几个用到再写

 5、sys模块

 6、shutil模块

高级文件、文件夹、压缩包、处理模块

直接参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html 

 

import shutil
#copyfileobj  从一个源文件对象copy到另一个源文件对象
f1 = open("f_shutil",encoding="utf-8")
f2 = open("笔记2","w")
shutil.copyfileobj(f1,f2)

import shutil
#从一个源文件对象copy到另一个源文件对象
f1 = open("f_shutil",encoding="utf-8")
f2 = open("笔记2","w")
shutil.copyfileobj(f1,f2)

#拷贝文件
shutil.copyfile("笔记2","笔记3")#copy了一份笔记2

#shutil.copymode仅copy权限。内容、组、用户均不变，

#shutil.copystat拷贝状态的信息，包括：mode bits, atime, mtime, flags

#shutil.copy 拷贝文件和权限

#shutil.copy2拷贝文件和状态信息

#shutil.copytree() 递归copy文件

#shutil.rmtree()  删除目录

#shutil.remove 移动文件

#打包文件
#shutil.make_archive("文件名","压缩格式","压缩路劲")  压缩路劲若是没写，默认当前目录

#shuitle是调用ZipFile 和 TarFile 2个模块的
import zipfile
# 压缩
z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
z.write(‘a.log‘)
z.close()

# 解压
z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
z.extractall()
z.close()

7、shelve模块

#shelve模块是简单的k,v  将内存数据通过文件持久化的模块，可持久化任何pickle可支持的pyhton的数据格式
import shelve
import datetime
info = {"age":22,"job":"IT"}
name = ["Mike","Heny"]
d["info"] = info
d["name"] = name
d["date"] = datetime.datetime.now()

#获取数据
d = shelve.open("shelve_file")
print(d.get("info"))
print(d.get("name"))
print(d.get("date"))
结果为：
{‘job‘: ‘IT‘, ‘age‘: 22}
[‘Mike‘, ‘Heny‘]
2017-06-02 23:23:20.580868

 8、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>

xml文件数据

#处理xml格式的文件
import xml.etree.ElementTree as ET
tree = ET.parse("xml_test.xml") #写上要处理的文件名
root = tree.getroot() #获取标签地址
print(root)
print(root.tag)  #获取标签名
#遍历整个xml文档
for child in root:
    print(child.tag,child.attrib)
    for i in child:
        print(i.tag,i.text,i.attrib)

#有筛选性的遍历出自己要的数据
for node in root.iter("year"):  #只遍历year节点
    print(node.tag,node.text)

处理xml文件数据

#修改
for node in root.iter("year"):
    new_year = int(node.text)+1 #在year的值增加1
    node.text = str(new_year)
    node.set("updated","yes") #增加属性
tree.write("xml_test2.xml")

#删除
for country in root.findall(‘country‘):
    rank = int(country.find(‘rank‘).text)
    if rank > 50:
        root.remove(country)

增加、删除

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

 9、pyyaml（配置文件）

参考文档：http://pyyaml.org/wiki/PyYAMLDocumentation 

 10、configparser模块

configerparser用于生成和修改配置文件  ConfigerParser 是pyhton2.0的写法

import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {
    "ServerAliveInterval":‘45‘,
    "Compression":"yes",
    "CompressionLevel":‘9‘
}
config["DEFAULT"]["ForwardX11"] = "yes"
config["bitbucket.org"] = {}
config["bitbucket.org"]["User"] = "hg"

config["topsecret.server.com"] = {}
config["topsecret.server.com"]["Port"] = ‘50022‘
config["topsecret.server.com"]["ForwardX11"] = "no"

with open ("example.ini","w") as f:
    config.write(f)

配置文件生成

import configparser
#读取
conf = configparser.ConfigParser()
conf.read("example.ini")
print(conf.sections())  #[‘bitbucket.org‘, ‘topsecret.server.com‘],不打印出default
print(conf.defaults())
#OrderedDict([(‘compressionlevel‘, ‘9‘), (‘serveraliveinterval‘, ‘45‘), (‘compression‘, ‘yes‘), (‘forwardx11‘, ‘yes‘)])全部读取

print(conf["bitbucket.org"]["User"]) #hg  读取单个配置文件

#改写
sec = conf.remove_section("bitbucket.org")
conf.write(open("example2.cfg","w"))

配置文件读取、修改

11、hashlib模块

#hashlib 用于加密操作
import hashlib
m = hashlib.md5()
m.update(b"Hello")
m.update(b"It‘s me")
print(m.digest())  #输出的是hello+It‘s me 合起来的十六进制

hash = hashlib.md5()
hash.update(b"hello")
print(hash.hexdigest())#以十六进制显示

#sha1~sha512值越大算法越复杂，hash256用的多一些
hash2 = hashlib.sha1()
hash2.update(b"hello")
print(hash2.hexdigest())

hash3 = hashlib.sha512()
hash3.update(b"hello")
print(hash3.hexdigest())

hash4 = hashlib.sha256()
hash4.update(("你好，太阳！".encode(encoding="utf-8")))
print(hash4.digest())

#hmac 运行快
import hmac
msg = hmac.new(b"123","拉阿拉蕾".encode(encoding="utf-8"))
print(msg.hexdigest())

hashlib

12、res

 常用的匹配方式：

re.match 从头开始匹配

re.search 匹配包含

re.findall 把所有匹配到的字符放到以列表中的元素返回

re.splitall 以匹配到的字符当做列表分隔符

re.sub      匹配字符并替换

#常用正则表达式符号
"."  #匹配任意含糊的1个字符，除了换行符\\n之外
"+"  #匹配1次或多次
"?"  #匹配前1个字符1次或0次
"^"  #匹配开头字符
"$"  #匹配字符结尾
"{M}"#匹配前个字符n次
"{n,m}"#匹配前1个字符 n~m次
"|" #或

‘\\A‘    #只从字符开头匹配，re.search("\\Aabc","alexabc") 是匹配不到的
‘\\Z‘    #匹配字符结尾，同$
‘\\d‘    #匹配数字0-9
‘\\D‘    #匹配非数字,包括特殊字符
‘\\w‘    #匹配[A-Za-z0-9]
‘\\W‘    #匹配非[A-Za-z0-9]
‘s‘     #匹配空白字符、\\t、\\n、\\r , re.search("\\s+","ab\\tc1\\n3").group() 结果 ‘\\t‘

#正则表达式，用来动态模糊的匹配字符串
#1、match 匹配是从头开始匹配
# 2、search 全部包含 
# 3、findall 匹配所有 
# 4、split以匹配到的字符当做列表分隔符  
# 5、sub匹配到字符去替换
import re
res = re.match("chen","chen123456jinjin")  #参数1 写格式，参数2 写字符串
print(res)  #<_sre.SRE_Match object; span=(0, 4), match=‘chen‘>

res2 = re.match("chen\\d+","chen123456jinjin") #匹配到数字
print(res2)  #<_sre.SRE_Match object; span=(0, 10), match=‘chen123456‘>



print(re.match(".","Hello明天"))
print(re.match(".+","Hello明天"))
print(re.search("d$","hello word"))
print(re.search("h[a-zA-Z]","hello word")) #只匹配到1个字符
print(re.search("h[a-zA-Z]+o","hello word123hehehello")) #匹配以h开头 o结尾，有多个情况只返回第一个
print(re.match("aal?","aalexaaa")) #match=‘aal‘  匹配0个或1个l
print(re.match("aal?","aaexaaa"))  #match=‘aa‘
print(re.search("[0-9]{2}","sk1sk1232sk33"))  # match=‘12‘ 匹配2个数字
print(re.search("[0-9]{1,3}","sk1sksk33")) #match=‘1‘ 匹配1~3个数字
print(re.findall("[0-9]{1,3}","aax2ahh4566jj"))  #[‘2‘, ‘456‘, ‘6‘]
print(re.search("abc|ABC","ABCabcdk").group()) #ABC
print(re.findall("abc|ABC","ABCabcdk")) #[‘ABC‘, ‘abc‘]  ,注：findall没有group方法了
print(re.search("(abc){2}a(123|456)c", "abcabca456cvbh").group())


print(re.search("(?P<id>[0-9]{4})","hdjsk12737").groupdict())   #{‘id‘: ‘1273‘}
print(re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city"))#{‘birthday‘: ‘1993‘, ‘city‘: ‘81‘, ‘province‘: ‘3714‘}

print(re.split("[0-9]","abc123hkl990kkk"))#[‘abc‘, ‘‘, ‘‘, ‘hkl‘, ‘‘, ‘‘, ‘kkk‘]
print(re.split("[0-9]+","abc123hkl990kkk"))#[‘abc‘, ‘hkl‘, ‘kkk‘]

print(re.sub("[0-9]+","d","abc123abc12abc")) #abcdabcdabc  将数字替换为d
print(re.sub("[0-9]+","d","abc123abc12abc123",count=2))#abcdabcdabc123  替换前面2组数字

仅需轻轻知道的几个匹配模式

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）

M(MULTILINE): 多行模式，改变‘^‘和‘$‘的行为（参见上图）

S(DOTALL): 点任意匹配模式，改变‘.‘的行为

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

os模块

 

shelve模块

 是简单的k,v模块，将内存数据进行持久化，可持久化任何pickle支持的数据格式  是对pickle更上一层的封装

#是个简单k,v数据类型，将内存数据持久化，可持久化任何的pickle数据类型
import shelve
import datetime
d = shelve.open("shelve_test")
date = ["kangkang","mike","jack"] #持久化列表
dic = {"name":"lily","age":18}#持久化字典
def fun(num):
    print(num)
f_num = 88888888
d["date"] = date
d["dic"] =dic
d["d_time"] = datetime.datetime.now()
d["f_num"] = f_num
d.close()


#读取文件数据
print(d.get("date"))
print(d.get("dic"))
print(d.get("d_time"))
print(d.get("f_num"))
结果为：
[‘kangkang‘, ‘mike‘, ‘jack‘]
{‘age‘: 18, ‘name‘: ‘lily‘}
2017-05-30 20:03:13.964083
88888888

 

configparser

#生成配置文件（写）
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‘  # mutates the parser
topsecret[‘ForwardX11‘] = ‘no‘  # same here

config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
with open(‘example.ini‘, ‘w‘) as configfile:
    config.write(configfile)

 

#读
import configparser
conf = configparser.ConfigParser()
conf.read("example.ini")
print(conf.sections())#只有default不打印出来
print(conf.defaults())
print(conf["bitbucket.org"]["user"])

for line in conf["bitbucket.org"]:
    print (line)

#增删改查
[section1]
k1 = v1
k2:v2
  
[section2]
k1 = v1
 
import ConfigParser
  
config = ConfigParser.ConfigParser()
config.read(‘i.cfg‘)
  
# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options(‘group2‘)
#print options
  
#item_list = config.items(‘group2‘)
#print item_list
  
#val = config.get(‘group1‘,‘key‘)
#val = config.getint(‘group1‘,‘key‘)
  
# ########## 改写 ##########
#sec = config.remove_section(‘group1‘)
#config.write(open(‘i.cfg‘, "w"))
  
#sec = config.has_section(‘wupeiqi‘)
#sec = config.add_section(‘wupeiqi‘)
#config.write(open(‘i.cfg‘, "w"))
  
  
#config.set(‘group2‘,‘k1‘,11111)
#config.write(open(‘i.cfg‘, "w"))
  
#config.remove_option(‘group2‘,‘age‘)
#config.write(open(‘i.cfg‘, "w"))