Python-开发之路-模块

这篇来介绍一下模块相关

模快

模块类似于函数式编程、面向对象式编程，模块简单来讲就是很多python的文件组成的集合，
这个集合一般都是一类的python代码，或者说是对某一种类型数据处理的方法的集合。
比如：os：是系统操作相关，re:是正则表达式相关，time：时间处理相关，logging：日志处理相关，等等

模块分类

一般分为 自定义模块，第三方模块，内置模块

---

自定义模块：就是自己创建的一些方法、代码

一般分为两种情景：1.平级目录创建，2.特定目录创建

---

导入模块：

#分为三种方式引用：
#平级目录中直接引用模块文件名
import module      
#在平级目录中，可以引用整个目录，“.”作为层级的分隔符
from module.XX.XX import func as ret   
#也可以模糊倒入，*模块下所有方法（文件中所有函数、目录下所有文件等等）     
from mudole.xx.xx import *

---

在实际生产中经常会遇到代码被打包移植的情况，那么怎样才能保证不管在哪里自定义的模块都能被准确引用呢，这里简要介绍一下，这个方法很重要，经常会用到，sys.path, os

#__doc__ 获取注释内容
#__file__ 获取当前文件的路径
#__name__ 当前函数被执行时，__name__=main,当被调用时，不为main，只有为main时才执行，相当于一个标签
#os.path.abspath  获取文件的绝对路径，os.path.dirname 获取上级目录
print(__file__)

import os,sys
a1 = os.path.abspath(__file__)
a2 = os.path.dirname(os.path.abspath(__file__))
a3 = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
print(a1)
print(a2)
print(a3)

>D:/python/Project-13/20160611/path.py
>D:\python\Project-13\20160611\path.py
>D:\python\Project-13\20160611
>D:\python\Project-13

模块

（由于时间原因，先列个提纲，本周补充）
内置模块是Python自带的功能，在使用内置模块相应的功能时，需要【先导入】再【使用】

一、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 错误相关

---

二、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’) 获取文件/目录信息
os.sep 操作系统特定的路径分隔符，win下为”\”,Linux下为”/”
os.linesep 当前平台使用的行终止符，win下为”\t\n”,Linux下为”\n”
os.pathsep 用于分割文件路径的字符串
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所指向的文件或者目录的最后修改时间

---

三、hashlib

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

提供一个小案例：

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
import hashlib


def hash_md5(*args):
    """
    md5加密
    :param args:
    :return:
    """
    reg = hashlib.md5(bytes('allen',encoding='utf-8'))
    reg.update(bytes(*args,encoding='utf-8'))
    return reg.hexdigest()

---

四、random

用于产生随机数

具体使用可参考如下
验证码实例

---

五、re

re是python中处理正则的模块，里面集成了很多处理正则的方法

一、正则简介

就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，
（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被
编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
二、字符分类

普通字符、元字符
普通字符：数字、字母
元字符: . ^ $ * + ? {} [] | () \ ,元字符有特殊含义

[] : 用来指定一个集合，比如一个字符集、字符区间有两种方式，连续的或者使用符号‘-’。
例如：
[abcde]，将匹配‘a’’b’ ‘c’ ‘d’ ‘e’，；
相同效果的:
[a-e],也将匹配 ‘a’’b’ ‘c’‘d’ ‘e’,；
但是想要匹配不连续的字符集只能用，只能用第一种，比如[qwersdfgg23435]

除了管道符‘|’、‘^’、‘]’、‘\’、负号‘-’外，其他特殊字符在[]中将失去特殊意义
例如:“[asdf ]”中′ ’ 将作为一个普通字符

|:管道符，在‘[]’中表示或的逻辑关系，比如：[a|e|d|c]表示aedc中的一个

-：表示范围

^ : 表示非

\：表示转义
反斜杠后边跟元字符去除特殊功能，
反斜杠后边跟普通字符实现特殊功能。

\d  匹配任何十进制数；它相当于类 [0-9]。
\n  是换行，ASCLL码是10
\r  是回车，ASCLL码是13
\D  匹配任何非数字字符；它相当于类 [^0-9]。
\a  是转义字符 007，响铃符 BEL
\s  匹配任何空白字符；它相当于类  [ \t\n\r\f\v]。
\S  匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
\w  匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
\W  匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
\b  匹配一个单词边界，也就是指单词和空格间的位置。
匹配单词边界（包括开始和结束），这里的“单词”，是指连续的字母、数字和
下划线组成的字符串。注意，\b的定义是\w和\W的交界，
这是个零宽界定符（zero-width assertions）只用以匹配单词的词首和词尾。
单词被定义为一个字母数字序列，因此词尾就是用空白符或非字母数字符来标
示的。 

>>> re.findall(r"abc\b","dzx &abc sdsadasabcasdsadasdabcasdsa")
['abc']
>>> re.findall(r"\babc\b","dzx &abc sdsadasabcasdsadasdabcasdsa")
['abc']
>>> re.findall(r"\babc\b","dzx sabc sdsadasabcasdsadasdabcasdsa")
[]

例如， ‘er/b’ 可以匹配”never” 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\b只是匹配字符串开头结尾及空格回车等的位置, 不会匹配空格符本身
例如”abc sdsadasabcasdsadasdabcasdsa”,
\sabc\s不能匹配,\babc\b可以匹配到”abc”

>>> re.findall("\babc\b","abc sdsadasabcasdsadasdabcasdsa")
[]
>>> re.findall(r"\babc\b","abc sdsadasabcasdsadasdabcasdsa")
['abc']

字符

. ：匹配除换行符意外的所有字符
^ ：匹配字符串的开始
$ ：匹配字符串的结束

---

重复匹配

* ：       重复 零 次  或 多次
+ :        重复 一 次  或 多次
?  :       重复 零 次  或 一次
{n}:       重复 n  次
{n,}:      重复 n  次  或 更多次
{n,m}:     重复 n 到 m 次
*?,+?,??,{m,n}? ： 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配，策略变成尽量少的匹配

>>> re.findall(r"a(\d+?)","a23b") # 非贪婪模式
        ['2']
>>> re.findall(r"a(\d+)","a23b")
        ['23']

举几个例子：

#ipv4的地址正则表达式
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
#手机号的正则表达式
^1[3|4|5|8][0-9]\d{8}$
#邮箱地址的正则表达式
[a-zA-Z0-9_-]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9_-]+)+

关于rawstring以及\

re.findall("\","abc\de")
f=open("C:\abc.txt") #\a是 转义字符 007，响铃符 BEL。
f=open(r"D:\abc.txt") #python自己也需要转义，也是通过\转义,括号中的‘r’及声明使用原始字符来表达

>>> re.findall(r"\d","ww2ee")
['2']
>>> re.findall("\d","ww2ee")
['2']

强烈建议用raw字符串来表述正则

你可能已经看到前面关于原始字符串用法的一些例子了。原始字符串的产生正是由于有正则表达式的存在。原因是ASCII 字符和正则表达式特殊字符间所产生的冲突。比如，特殊符号“\b”在ASCII 字符中代表退格键，但同时“\b”也是一个正则表达式的特殊符号，代表“匹配一个单词边界”。为了让RE 编译器把两个字符“\b”当成你想要表达的字符串，而不是一个退格键，你需要用另一个反斜线对它进行转义，即可以这样写：“\b”。但这样做会把问题复杂化，特别是当你的正则表达式字符串里有很多特殊字符时，就更容易令人困惑了。原始字符串就是被用于简化正则表达式的复杂程度。事实上，很多Python 程序员在定义正则表达式时都只使用原始字符串。
下面的例子用来说明退格键“\b” 和正则表达式“\b”(包含或不包含原始字符串)之间的区别：

>>> m = re.search('\bblow', 'blow') # backspace, no match #退格键,没有匹配
>>> re.search('\\bblow', 'I blow').group() # escaped \, now it works 用\转义后，现在匹配了
>>>  re.search(r'\bblow', 'I blow').group() # use raw string instead #改用

原始字符串

你可能注意到我们在正则表达式里使用“\d”，没用原始字符串，也没出现什么问题。那是因为
ASCII 里没有对应的特殊字符，所以正则表达式编译器能够知道你指的是一个十进制数字

推荐：http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html

---

六、序列化

json、pickle
pass

---

七、configparser

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7

import configparser

#获取所有节点
config = configparser.ConfigParser()
config.read('fileinfo',encoding='utf-8')
ret = config.sections()
print(ret)

#获取指定节点下所有的键值对
config = configparser.ConfigParser()
config.read('fileinfo',encoding='utf-8')
ret = config.items('section1')
print(ret)

#获取指定节点下所有的键
ret = config.options('section1')
print(ret)

#获取指定节点下指定key的值

ret = config.get('section1','k1')
# v = config.getint('section1', 'k1')
# v = config.getfloat('section1', 'k1')
# v = config.getboolean('section1', 'k1'
print(ret)

#检查、删除、添加节点
#检查
ret = config.has_section('section1')
print(ret)
#添加节点
config.add_section('section9')
config.add_section('section10')
config.add_section('section22')
config.write(open('fileinfo','w'))
ret = config.sections()
print(ret)
#删除节点
config.remove_section('section22')
config.write(open('fileinfo','w'))
ret = config.sections()
print(ret)
#检查、删除、设置指定组内的键值对
#检查
ret = config.has_option('section1','k2')
print(ret)
#设置
config.set('section4','k4','324')
config.set('section4','k3','654')
config.write(open('fileinfo'),'w')
ret = config.options('section4')
#删除
config.remove_option('section4','k3')
config.write(open('fileinfo'),'w')
ret = config.options('section4')

---

八、XML

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
from xml.etree import ElementTree as ET
from xml.dom import minidom

def prettify(elem):
    """将节点转换成字符串，并添加缩进。
    """
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="\t")


#打开文件，读取xml内容
str_xml = open('xo.xml','r').read()

#将字符串解析成xml特殊对象，root代指xml文件的根节点
root1 = ET.XML(str_xml)
#直接解析xml文件
tree = ET.parse('xo.xml')
root2 = tree.getroot()

##创建根节点
root = ET.Element('famliy')

#创建节点大儿子
son1 = ET.Element('son',{'name':'son1'})
#创建节点小儿子
son2 = ET.Element('son',{'name':'son2'})
#创建孙子
grandson1 = ET.Element('gandson',{'name':'grand1'})
grandson2 = ET.Element('gandson',{'name':'grand2'})
son1.append(grandson1)
son2.append(grandson2)

#把儿子添加到根节点中(以上都是在内存中操作的)
root.append(son1)
root.append(son2)

raw_str = prettify(root)
with open('ooo.xml','w',encoding='utf-8') as f:
    f.write(raw_str)

#将内存写入硬盘
# tree = ET.ElementTree(raw_str)
# tree.write('ooo.xml',encoding='utf-8',xml_declaration=True,short_empty_elements=True)

---

九、requests

pass

---

十、logging

pass

---

十一、系统命令

syscmd

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
import subprocess

#call
ret = subprocess.call(['ls','-l'],shell=False)
ret = subprocess.call("ls -l",shell=True)

#check_call
subprocess.check_call(['ls','-l'])
subprocess.check_call('exit 1',shell=True)

#check_output
subprocess.check_output(["echo","Hello World!"])
subprocess.check_output('exit 1',shell=True)

#subprocess.Popen
import subprocess

obj = subprocess.Popen('mkdir t3',shell=True,cwd='/home/dev')

pjt = subprocess.Popen(["python"],stdin = subprocess._PIPE,
                       stdout = subprocess.PIPE,
                       stderr = subprocess.PIPE,
                       universal_newlines=True)
pjt.stdin.write('print(1)\n')

tarfile

#!/usr/bin/env python
# -- coding = 'utf-8' --
# Author Allen Lee
# Python Version 3.5.1
# OS Windows 7
import zipfile,tarfile
#压缩
z = zipfile.ZipFile('laxi.zip','w')
z.write('fileinfo')
z.write('ooo.xml')
z.close()
#解压
z = zipfile.ZipFile('laxi.zip','r')
z.extractall()
z.close()

#压tar = tarfile.open('your.tar','w')
tar.add('xo.xml',arcname='xo.xml')
tar.add('laxi.zip',arcname='laxi.zip')
tar.close()

#解压
tar = tarfile.open('your.tar','r')tar.extractall()
tar.close()
obj = tar.getmember('xo.xml')
tar.extract(obj)
tar.close()

---

十二、shutil

pass

---

十三、paramiko

pass

---

十四、time

pass

---