os模块：
os.getcwd() 获取当前工作目录，即当前Python脚本工作的目录路径
os.chdir(‘dirname’) 改变当前脚本工作目录；相当于shell下的cd
os.curdir 返回当前目录：（‘.’）
os.pardir 获取当前目录的父目录字符串名：（‘..’）
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空也删除，以此类推
os.mkdir('dirname') 生单级目录；相当于shell中mkdir
os.rmdir('dirname') 删除单级目录，若目录不为空则无法删除
os.listdir('dirname') 列出指定目录下的所有文件和子目录
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定路径分隔符，win下为“\”，linux下为‘’
os.linesep 输出当前平台使用的行终止符，win下为“ ”,linux下为“ ”
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最后的文件名
os.path.exists(path) 如果path存在，返回True，不存在返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件返回True，如果不存在返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True
os.path.join(path1[,path2[,...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
os.popen(dir).read() popen 相当于打开一个临时文件把执行结果存下来，并打印出来
sys模块
sys.argv 命令行参数list，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit（0）
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的int值
sys.path 返回模块的搜索路径，初始化是使用Pythonpath环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc,fdst[,length])
将文件内容拷贝到另一个文件中，可以部分内容
shutil.copyfile(src,dst) 文件的复制
shutil.copymode(src,dst) 仅拷贝权限，内容、组、用户均不变
shutil.copystat(src,dst) 拷贝状态的信息，包括：mode bits,atime,mtime
shutil.copy(src,dst) 拷贝文件和权限
shutil.copy2(src,dst) 拷贝文件和状态信息
shutil.ignore_patterns(*patterns)
shutil.copytree(src,dst,symlinks=False,ignore=None) 递归的去拷贝文件
shutil.rmtree(path[,ignore_errors[,onerror]]) 递归的去删除目录/文件
shutil.move(src,dst) 递归的去移动目录/文件
shutil.make_archive(base_name,format,...) 创建压缩包并返回文件路径，例如：zip、tar
base_name:压缩包的文件名，也可以是压缩包的路径。否则保存至指定路径。
如：www =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format:压缩包种类，“zip”,"tar","bztar","gztar"
root_dir:要压缩的文件夹路径（默认当前目录）
owner:用户，默认当前用户
group：组，默认当前组
logger:用于记录日志，通常是logging.Logger对象
pickle 模块提供了四个功能：dumps、dump、loads、load
import pickle #pickle 用来序列化，几乎可以序列化所有的Python类型
pickle是Python独有的序列化模块，所谓独有就是不能和其他语言进行交互，因为pickle将数据对象转化为bytes
dumps、dump是进行序列化 loads、load进行反序列化
dumps 、dump序列化示例：
>>> import pickle
>>> d=[1,2,3,4]
>>> pickle.dumps(d)
b'x80x03]qx00(Kx01Kx02Kx03Kx04e.'
dumps将所传入的变量的值序列化为一个bytes，然后，就可以将这个bytes写入磁盘或者进行传输。
而dump则更加一步到位，在dump中可以传入两个参数，一个为需要序列化的变量，另一个为需要写入的文件。
f=open('file_test','wb')
>>> d=[1,2,3,4]
>>> pickle.dump(d,f)
>>> f.close()
>>> f=opem('file_test','rb')
f=open('file_test','rb')
>>> f.read()
b'x80x03]qx00(Kx01Kx02Kx03Kx04e.'
loads当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用loads方法反序列化出对象，也可以直接用load方法直接反序列化一个文件。
例如：
>>> d=[1,2,3,4] >>> r=pickle.dumps(d) >>> print(r) b'x80x03]qx00(Kx01Kx02Kx03Kx04e.' >>> pickle.loads(r) [1, 2, 3, 4]
>>> d=[1,2,3,4]
>>> f=open('file_test','wb')
>>> pickle.dump(d,f)
>>> f.close()
>>> f=open('file_test','rb')
>>> r=pickle.load(f)
>>> f.close()
>>> print(r)
[1, 2, 3, 4]
json模块
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
json中的方法和pickle中差不多，也是dumps，dump，loads，load。使用上也没有什么区别,区别在于，json中的序列化后格式为字符。
json示例：
shelve 模块
shelve模块是一个简单的K，v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的Python数据格式
例如：
#!/usr/bin/env python
# encoding: utf-8
import shelve
d = shelve.open('shelve_test')#打开一个文件
class Test(object):
def __init__(self,n):
self.n = n
t = Test(123)
t2 = Test(123213213)
name = ["alex","shidong","test"]
d["test"] = name #持久化列表
d["t1"] = t #持久化类
d["t2"] = t2
d.close()
xml处理模块
（修改和删除xml文档内容）xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单
YAML模块
configparser 模块 ：用于生成和修改常见配置文档，当前模块的名称在Python3.x版本中变更为configparser
#!/usr/bin/env python
# encoding: utf-8
import configparser
#1、获取所有节点
config = configparser.ConfigParser()
config.read('shidong', encoding='utf-8')
ret = config.sections()
print(ret)
#2、获取指定节点下所有的键值对
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
ret = config.items('section1')
print(ret)
#3、获取指定节点下所有的键
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
ret = config.options('section1')
print(ret)
#4、获取指定节点下指定key的值
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
res = config.get('section1','k1')
print(res)
#5、检查、删除、添加节点
config = configparser.ConfigParser()
config.read('shidong',encoding='utf-8')
has_opt = config.has_option('section1','k1')
print(has_opt)
#6、删除
config.remove_option('section1','k1')
config.add_section('shidong')
config['shidong']['age'] = '29'
config.write(open('shidong','w'))
#7、设置
config.set('section3','k10','123')
config.write(open('shidong','w'))
#8、创建配置文件
#!/usr/bin/env python
# encoding: utf-8
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'] = '5002'
topsecret['ForwardX11'] = 'no'
topsecret['Value'] ='1024'
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini','w') as configfile:
config.write(configfile)
hashlib模块
用于加密相关的操作，3.X里代替了md5模块和sha模块，主要提供SHA1，SHA224，SHA256，SHA384，SHA512
,MD5算法
import hashlib
>>> a = hashlib.md5() #先声明一下，用什么方法加密
>>> a.update("Hello")
>>> a.update("It's me")
>>> a.digest
<built-in method digest of _hashlib.HASH object at 0x7f968ef70468>
>>> a.digest() #二进制
']xdexb4{/x92Zxd0xbf$x9cRxe3Brx8a'
>>> a.hexdigest() #十六进制
'5ddeb47b2f925ad0bf249c52e342728a'
还不够？Python还有一个hmac模块，它内部对我们创建爱你key和内容在进行处理然后在加密
（在原有算法上再加一层）多用于消息加密
例如：
>>> import hmac
>>> a = hmac.new("secret_key")
>>> a.update("test")
>>> a.hexdigest()
'067a732507f937494b66aea19ce9bfa3'
Subprocess 模块
Python 3.5之后才会有run()方法,run()方法用来执行命令
在Python 2.7版本，无法使用run（）方法，但是可以使用call方法代替
call 命令：执行命令，返回状态码（0代表执行成功）
例如：
>>> import subprocess
>>> subprocess.call("ifconfig")
或者
>>> subprocess.call(["df","-h"])
再或者用源生的shell去执行
>>> subprocess.call("ls",shell=True)
示例：返回执行结果，并不是状态码，这时候就不能用call方法了，改用Popen方法加管道
>>> a = subprocess.Popen("df -h",shell=True,stdout=subprocess.PIPE)
>>> a
<subprocess.Popen object at 0x7f968ef6fc50>
>>> a.stdout
<open file '<fdopen>', mode 'rb' at 0x7f96887880c0>
>>> a.stdout.read()
'Filesystem Size Used Avail Use% Mounted on /dev/sda2
48G 32G 14G 70% / tmpfs
91M 228K 491M 1% /dev/shm /dev/sda1
291M 34M 242M 13% /boot .host:/
362G 360G 1.8G 100% /mnt/hgfs '
check_call 执行命令，如果执行状态码是0，则返回0，否则抛异常
例如：
>>> subprocess.check_call("ll -th",shell=True)
/bin/sh: ll: command not found
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib64/python2.6/subprocess.py", line 505, in check_call
raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command 'll -th' returned non-zero exit status 127
subprocess.Popen() :用于执行复发的系统命令
用于两个进程之间的交互，示例：
import subprocess
a = subprocess.Popen(["python"],stdin=subprocess.PIPE,stdout=subprocess.PIPE
,stderr=subprocess.PIPE)
a.stdin.write("print(Hello)
")
a.stdin.write("print(Hello2)
")
a.stdin.write("print(Hello3)
")
a.communicate()
logging模块
logging日志可以分为五个级别，分别为：debug(),info(),warning(),error(),critical()
#!/usr/bin/env python
# encoding: utf-8
import logging
#打印到屏幕上
#logging.warning("user attempted wrong password")
#logging.critical("server is down")
#把日志写到文件里
logging.basicConfig(filename='shidong.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this ,too')
#把日志写入到文件并加入执行时间
logging.basicConfig(filename='shidong.log',level=logging.DEBUG,format='%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this ,too')
#如果想把日志输出到文件并打印到屏幕上，就需要一点点复杂的知识了需要用到handler
#创建logging对象
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG)
#创建handler，handler的作用是输出到指定目标
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
#创建file handler,并设置级别
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
#创建时间格式formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
#规定好格式后，把格式赋给对象
ch.setFormatter(formatter)
fh.setFormatter(formatter)
logger.addHandler(ch)
logger.addHandler(fh)
#'application' code 进行输出
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
面向对象编程：的特性：
1、封装
封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的
信息进行隐藏。
2、继承
面向对象编程（OOP）语言的一个主要功能就是“继承”。继承是指这样一种能力：他可以使用现有类的所有功能，
并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（inheritance）和“组合”（Composition）来实现 。
在某些OOP语言中，一个子类可以继承多个基类，但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过
多级继承来实现
继承概念的实现方式有三类：实现继承、接口继承和可是继承。
%%实现继承是指使用基类的属性和方法而无需额外编码的能力；
%%接口继承是指仅使用属性和方法的名称，但是子类必须提供实现的能力；
%%可是继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
抽象类（指基类/父类）仅定义将由子类创建的一般属性和方法
OOP开发范式大致为：划分对象-->抽象类-->将类组织成为层次化结构（继承和合成）-->用类与实例进行设计和实现
多态：
多态就是父类（基类/抽象类）在特定的情况下可以访问子类
object是Python中的顶级父类
#!/usr/bin/env python
# encoding: utf-8
class Role(object):
def __init__(self,name,role,weapon,life_value):
#self初始化
self.name = name
self.role = role
self.weapon = weapon
self.life_val = life_value
def buy_weapon(self,weapon):
print("%s is buying[%s]" % (self.name,weapon))
self.weapon = weapon
#p1 称为实例
#把一个抽象的类变成一个具体的对象的过程叫实例化
p1 = Role("SanJiang",'Police',"B10",90)
t1 = Role("ChunYun",'Terrorist',"B11",100)
p1.buy_weapon("AK47")
t1.buy_weapon("B51")
print("P1:",p1.weapon)
print("T1:",t1.weapon)
类变量与实例变量
实例：
#!/usr/bin/env python
# encoding: utf-8
class Role(object):
# members = 0
def __init__(self,name,role,weapon,life_value):
#self初始化
self.name = name
self.role = role
self.weapon = weapon
self.life_val = life_value
# Role.members +=1
def buy_weapon(self,weapon):
print("%s is buying[%s]" % (self.name,weapon))
self.weapon = weapon
# print(self.ac)
#p1 称为实例
#把一个抽象的类变成一个具体的对象的过程叫实例化
p1 = Role("SanJiang",'Police',"B10",90)
t1 = Role("ChunYun",'Terrorist',"B11",100)
t2 = Role("T2",'Terrorist',"B17",100)
t3 = Role("T3",'Terrorist',"B19",100)
p1.buy_weapon("AK47")
t1.buy_weapon("B51")
p1.ac = "China Brand"#实例中设置ac
t1.ac = "US Brand"#实例中设置ac
Role.ac = "Janpanese Brand" #在类中设置ac，并且ac为全局变量
#实例中设置变量，那么则会在实例的内存地址添加一个实例，实例
#中不设置那么则用全局变量
print("P1:",p1.weapon,p1.ac)
print("T1:",t1.weapon,t1.ac)
print("T2:",t2.ac,t2.weapon)
print("T3:",t3.ac,t2.weapon)
类的继承
#!/usr/bin/env python
# encoding: utf-8
class SchoolMember(object):
member_nums = 0
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
self.enroll()
def enroll(self):
SchoolMember.member_nums+=1
print("The [%s] school member [%s] is enrolled!" % (self.member_nums,self.name))
def tell(self):
print("Hello,my name is %s" %(self.name))
class Teacher(SchoolMember):#继承父类SchoolMember
def __init__(self,name,age,sex,course,salary):#如果不写则直接继承父类
super(Teacher,self).__init__(name,age,sex)
#SchoolMember.__init__(self,name,age,sex)这是旧式写法
self.course = course
self.salary = salary
def teaching(self):
print("Teacher [%s] is teaching [%s]" %(self.name,self.course))
class Student(SchoolMember):
def __init__(self,name,age,sex,course,tuition):
super(Student,self).__init__(name,age,sex)
self.course = course #self 代表的意思为实例
self.tuition = tuition
def pay_tuition(self):
print("cao,student [%s] paying tuition [%s]" %(self.name,self.tuition))
t1 = Teacher("shidong",28,"F","PY",1000000)
t2 = Teacher("Alex",28,'N/A',"PY",100000)
s1 = Student("SanJiang",23,"Female","python",20000)
s2 = Student("BaoAn",23,'Femle',"python",9000)
t1.tell()#继承后，可以调用父类的方法
t1.teaching()
s1.tell()
s1.pay_tuition()