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-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 >>> 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 >>> a.stdout ', 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 found Traceback (most recent call last): File " ", line 1, in 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-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()