Python--day6

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()