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下为“\r\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最后的文件名

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'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.'

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'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.'

loads当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用loads方法反序列化出对象，也可以直接用load方法直接反序列化一个文件。

例如：

>>> d=[1,2,3,4]
>>> r=pickle.dumps(d)
>>> print(r)
b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04e.' >>> 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-8import shelved = 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"] = t2d.close()

xml处理模块（修改和删除xml文档内容）xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单YAML模块

configparser 模块 ：用于生成和修改常见配置文档，当前模块的名称在Python3.x版本中变更为configparser

#!/usr/bin/env python# encoding: utf-8import 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-8import configparserconfig = 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()   #二进制']\xde\xb4{/\x92Z\xd0\xbf$\x9cR\xe3Br\x8a'>>> 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\n/dev/sda2 48G   32G   14G  70% /\ntmpfs           91M  228K  491M   1% /dev/shm\n/dev/sda1       291M   34M  242M  13% /boot\n.host:/         362G  360G  1.8G 100% /mnt/hgfs\n'

check_call 执行命令，如果执行状态码是0，则返回0，否则抛异常例如：>>> subprocess.check_call("ll -th",shell=True)/bin/sh: ll: command not foundTraceback (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)\n")a.stdin.write("print(Hello2)\n")a.stdin.write("print(Hello3)\n")a.communicate()

logging模块logging日志可以分为五个级别，分别为：debug(),info(),warning(),error(),critical()

#!/usr/bin/env python# encoding: utf-8import 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)

#创建时间格式formatterformatter = 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-8class Role(object):def __init__(self,name,role,weapon,life_value):#self初始化 self.name = nameself.role = roleself.weapon = weaponself.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-8class Role(object):# members = 0 def __init__(self,name,role,weapon,life_value):#self初始化 self.name = nameself.role = roleself.weapon = weaponself.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"#实例中设置act1.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-8class SchoolMember(object):    member_nums = 0 def __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sexself.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 = courseself.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 = tuitiondef 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()