python之文件操作、OS模块、CSV、 面向对象

一 文件操作

1 文件系统和文件

在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以，读写文件就是请求操作系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）。
文件是计算机中由OS管理的具有名字的存储区域，在Linux中，文件是被看做字节序列.

2 python内置的打开文件的方式open读取

1 文件打开open

open(文件目录（可以是绝对路径和相对路径）[文件打开模式][文件输出缓存])
后面两项是可选参数。默认返回是一个文件对象的内存，其默认的读写模式是只读模式，

可以通过赋值进行输出结果read（输出的字节数）默认是全部


通过参数指定读取的范围：

2 文件操作的模式

3 文件的其他属性

1 文件的常用操作

A seek([文件偏移量][文件指针位置])
文件指针的返回
为0表示文件的起始，为1 表示当前位置，为2表示末尾位置。
通过指定文件的指针可以重复读取文件的第一行内容，

偏移量的大小表现为文件的字节数，当为正时，表示向右读取，当为负时，表示向左读取，当为0时，表示不偏移

B tell（）显示指针目前所处位置

C close()表示关闭当前文件

D closed 检查当前文件是否关闭，若为True ，则表示已关闭，若为False，则表示未关闭

E name 查看文件名称

F mode 查看当前文件的打开模式

G flush 将当前文件的内容刷新到磁盘上，其目的是为了防止断电而保存。

H next() 用于读取文件内容，每次读取一行，其指针位置不发生变化

2 文件的读取

A readline（）每次读取一行文件内容

B readlines() 每次读取文件的所有内容

C read （） 指定读取文件的字节数，默认是全部读取

3 文件的写入

A write()其可以写入字符串，

B writelins()用于传入多个参数

4 总结如下

1 编码问题

编码：用一个字节代表什么，两个字节代表什么，
编码问题：
1 Windows的默认编码规则是cp936国标，cp936是GBK 的一种，GBK不是国际标准，GB2312是国际标准。
2 Linux的默认编码规则是utf-8，Unicode传输编码，其一个汉字是3个字节，偶尔可能是4个字节，其总共占6个字节
Gbk 是 a0 开始的，在utf-8中不能识别
GBK 是顺序的中文编码，GBK是两个字节。utf-8大多是3个字节，可能是4个字节
换行符问题：

2 nowline 换行问题

可使用newline进行指定换行符，文本模式中，换行的转换可以为None，"",'\r','\n','\r\n'
读取时，None 标识'\r'，'\n'，'\r\n'都被转换为'\n'， ""（空字符串）表示、
不会自动转换通用换行符,其他合法字符表示换行符就是指定字符，就会按照自定字符分行，重新定义分割符。

写入时，None 表示"\n"都会被替换为系统缺省分割符os.linsep,'\n'或"" 表示"\n"不替换，其他合法字符表示
换行符"\n"都会被替换为指定分割符。
文件描述符：
默认的三种，0 标准输入， 1 标准输出， 2 错误输出
文件描述符可表示打开文件的数量，当打开文件数量达到系统打开文件数量上限时，则会报错

3 seek 问题

seek(offset[,whence])
offset默认是针对于起始位置开始，表示从头测试
文本模式下：
whence=0 缺省值,表示从头开始，offset只能接受正整数
whence=1 表示从当前位置开始，offset 只接受0
whence=2 表示从EOF 开始，offset 只接受0
二进制模式：
whence=0 缺省值，表示从头开始offset只能是正整数
whence=1 表示从当前位置开始，offset可正可负
whence=2 表示从EOF开始，offset可正可负
二进模式支持任意起点的偏移，从头，从尾，从中间位置开始向后seek可以超界，但是向前seek的时候，不能超界，否则会报异常。
size 表示读取多少个字符或字节，负数或None表示读取到EOF

4 字节和字符

流对象，字符序列，字节序列，网络流至没有边界 ，都指的是序列，
网络流：和时间有关，也是一个序列
文本流，字符流，
二进制流，字节流： 将文件就按照字节理解，与字符编码无关，二进制模式操作时，字节操作使用bytes类型

f=open('test2','wb')
f.write("爱国".encode())  #此处使用字节输入，其默认编码是utf-8，
print  (f)
f.close()
f=open('test2') # 此处读取，默认编码是utf-8
print  (f)
print (f.read(1))
print  (f.read(1))
f.close()

结果如下：

5 上下文管理

1 问题引出

在Linux 中，执行

查看打开文件情况

由于打开文件未关闭，导致打开文件数过多，每次打开文件都会产生文件表述符，则导致问题，Linux默认的打开文件数量是1024，其由于未关闭而导致有如上报错。
解决方式1

通过异常处理进行关闭。

2 通过上下文管理进行处理

with  open('test2')  as  f:
    f.write("zhongguo")

print (f.closed)

结果如下

二 OS 模块

作用：用于将python与文件系统更加紧密连接的一种模块

1 常用os模块方法

1 目录相关目录相关

os.Chdir() 改变目录/通过文件描述改变工作目录
os.chroot（） 设定当前进程的根目录
os.listdir（） 列出指定目录下的所有文件名
os.Mkdir（）创建指定目录，默认为一级
os.makedirs('x/y/z')
os.getcwd（）获取当前目录
os.Rmdir()删除目录
os.Removedirs() 删除多级目录
os.removedirs('/mnt/aaa/bbb/ccc') 必须制定所有的目录才可以删除

2 文件相关

os.mkfifo() 创建先进先出管道（命名
os.mknod() ：创建设备文件
os.Remove() 删除文件
os.Unlink( ) 删除链接
os.Rename() 文件重命名
os.rename('passwd','aaa')
os.Stat() 返回文件状态信息
os.Symlink() 创建文件链接，符号链接
In [33]: os.symlink('text2.txt','text2.syslink')
text2.syslink
os.utime（） 更新文件的事件戳 updatetime
os.tmpfile() 创建并打开一个新的临时文件，打开模式是(w+b)

3 访问权限相关

os.access（） 检验权限模式
In [42]: os.access('/tmp/text2.txt',0) UID 管理员的访问权限
os.Out[42]: True
In [43]: os.access('/tmp/text2.txt',100) 普通用户的访问权限
Out[43]: False
os.Chmod() 修改权限
In [44]: os.chmod('text2.txt',0640) os.chmod('aaa',0777)为四位
os.Chwon 修改属主 ，属组
In [47]: os.chown('text2.txt',1000,1000)
[root@www tmp]# id admin
uid=1000(admin) gid=1000(admin) 组=1000(admin)
[root@www tmp]# ll text2.txt
-rw-r-----. 1 admin admin 2525 11月 19 20:35 text2.txt
os.Umask() 设置默认权限模式

4 文件描述符相关

os.Open():打开一个文件，底层操作系统的open
os.Read() 较低io的读取操作
os.Write() 较低IO的写操作

5 设备文件相关

os.Mkdev() 根据指定的主设备号，次设备号创建文件

In [48]: help(os.makedev)
Help on built-in function makedev in module posix:

makedev(...)
makedev(major, minor) -> device number
Composes a raw device number from the major and minor device numbers.
(END)
os.Major() 从指定的设备获取主设备号
os.Minor() 从指定的设备获取次设备号

6 其他常用属性：

1 os.system 用于python 与shell之间的交互命令，如果存在，则返回0，否则返回其他


os.popen(命令).read()

os.uname() 获取当前模块的详细信息

2 os.path模块

1 文件路径相关

In [55]: import os.path
A.os.path.Basename()：路径基名
In [58]: file1=os.path.basename('/etc/sysconfig/netw')
/etc/sysconfig/network /etc/sysconfig/network-scripts/

B.os.path.irname() 路径目录名

C.os.path.join（） 将路径基名和目录名整合成一个名字
In [60]: os.path.join(dir1,file1)
Out[60]: '/etc/sysconfig/network-scripts/'
In [63]: for filename in os.listdir('/tmp'):
....: print os.path.join('/tmp',filename)

C. os.path.splist()分割文件名和文件，返回dir和basename()元组
In [64]: os.path.split('/etc/sysconfig/')
Out[64]: ('/etc/sysconfig', '')

D os.path.Splitext() 返回（filename，extension） 元组
6]: os.path.splitext('/tmp/')
Out[86]: ('/tmp/', '')

2 文件信息：

A os.path.getatime（） 返回文件最近一次的访问记录
B os.path.Getctime()
C os.path.Getmtime()
D os.path.Getsize() 返回文件的大小

3 判断查询类的操作

A os.path.Exists（） 判断指定文件是否存在，档不存在时，以只读方式打开文件是错误的。
B os.path.Isabs() 判断指定的路径是否是绝对路径
C os.path.isdir（） 判断指定路径是否为目录
D os.path.Isfiel() 判断指定文件是否为文件
E os.path.Islink() 判断时否为符号链接
F os.patj.Ismount() 是否为挂载点
G os.path.Sanefiek() 两个路径是否执行了同一个文件

3 IO 模块中的类

简介： 在内存中开辟一个文本模式的buffer，可以像文件一样操作它，当close方法被调用时，这个buffer被释放，此处没有持久化

1 StrinIO

#!/usr/local/bin/python3.6
#coding:utf-8
from  io   import   StringIO
sio=StringIO()
sio.write("MySQL数据库")
print (sio.readline(),1)   # 此处由于指针在写入时的原因，导致指针指在了最后，因此导致其读取不能完成
sio.seek(0)   # 指针归零
print (sio.readline(),2)  # 进行读取
print (sio.readline(),3)  #由于指针到最后，因此导致其不能读取
print  (sio.read(),4)  #由于指针到最后，因此导致其不能读取
print  (sio.getvalue(),5)  # 此方法不会在乎指针
sio.close()  #文件关闭

查看显示结果

优点：一般来说，磁盘操作比内存慢，内存足够的情况下，一般的优化思路是减少落地，减少磁盘IO的过程，可以大大提高程序的运行效率，单台机器可以使用StringIO,多台设备之间使用redis来实现

2 BytesIO

#!/usr/local/bin/python3.6
#coding:utf-8
from  io  import   BytesIO
bio=BytesIO()
bio.write("MYSQL数据库".encode('utf-8'))  # 写入汉字需要指定编码格式
print  (bio.getvalue())  # 读取数据，不管指针
bio.write(b'mysql database')
bio.seek(0)
print (bio.readline())   # 读取一行
bio.seek(0)
print  (bio.read())
bio.close()

结果如下

3 file-like 对象
类文件对象，可以像文件一样操作

from sys  import   stdout
f=stdout
print (type(f))
f.write('51cto.com')  #直接输出到屏幕上

结果如下

4 pathlib模块

1 介绍

3.4 版本开始，支持使用pathlib模块提供对Path对象的操作，包括文件和目录

2 操作简介

p=Path() # 类初始化，初始化成实例
p.absolute() # 查看p的绝对路径
p # 查看p的路径，相对路径
p=p.joinpath('/etc','a','b','c') # 此处第一个若有/表示绝对路径，也表示重新创建路径，若此处无/ 则表示在p的当前路径下进行增加，及拼接
p=p /'c'/'d' # 对p进行增加路径'c'/'d'，也成为路径拼接

p1=Path('/a','b','/c') # 若指定多个绝对路径，则以后面覆盖前面的路径
p1.parts # 返回一个元组，打印其跟和相对路径
p1.parent # 返回当前路径的父路径
p1.parent.parent #返回当前父路径的父路径，依次类推，但若不存在则会报错，因此不建议这样使用
list(p1.parents) # 此处返回一个可迭代对象，可用for循环进行遍历，并逐步取出其父路径，其父路径的父路径，依次类推

list(p2.absolute().parents) # 对于相对路径获取其父路径的方式
list(p2.absolute().parents)[0] # 获取其父路径

p3=Path('/etc/sysconfig/network/51.cfg')
p3.name # 获取目录的最后一部分，及51.cfg
p3.stem # 获取目录最后一部分的扩展名
p3.suffix # 获取目录最后一部分，没有扩展名

p4=Path('/etc/sysconfig/network/51.cfg.gz')
p4.suffix # 获取扩展名后缀 .gz
p4.suffixes # 返回多个扩展名列表 及 [.cfg,.gz]
p4=p4.with_suffix('.sz') # 修改扩展名后缀 结果为 /etc/sysconfig/network/51.cfg.sz
p4=p4.with_name('52.cfg.gz') # 修改名字，结果如下 /etc/sysconfig/network/52.cfg.gz

p.iterdir()

列出该目录下的文件，默认是一个生成器对象，其默认返回是一个PosixPath，其支持的方法有很多

l1[0].stat() 获取文件的基本信息

此处有获取其模式，硬链接，uid，gid，以及大小，日期等信息

此处有判断其类型，有块，字符，目录，管道，文件，socket等，其返回是一个布尔类型

此处使用stat 可获取如同Linux一般的权限列表

获取属主和属组

2 习题实例

要求 实现ls命令功能
1 实现显示路径下的文件列表
2 -a 和-all 显示包含.开头的文件
3 -l 显示详细列表信息
4 -h和 -l 配合，人性化显示文件大小，如1k,1M,1G等
5 按照文件名排序输出，可以和ls的顺序不同，但要求按照文件名进行排序

#!/usr/bin/poython3.6
#conding:utf-8
from  pathlib  import  Path
import   datetime
import stat
import  argparse
def  showDir(path:Path='.',all=False,lis=False,detailed=False):
    def  _showSize(size:int):  # 此处用于格式化文件大小
        unit=" KMGTP"
        depth=0
        while  size>=1000:
            size=size //1000
            depth+=1
        return "{}{}".format(size,unit[depth])
    def  _showDir(path:Path='.',all=False,lis=False,detailed=False):
        p=Path(path)
        for  file  in   p.iterdir():
            if  str(file.name).startswith('.')  and not  all:# 此处用于判断文件是否需要列出隐藏文件
                continue
            if  lis:  #此处用于判断是否需要列出详细信息
                st=file.stat()  # 此处返回一个文件详细信息表
                # -rw-r--r-- 1 root root  430 6月   3 14:02 char.py
                h=st.st_size  
                if detailed:  # 此处用于判断是否
                    h=_showSize(st.st_size)
                    yield (stat.filemode(st.st_mode),st.st_nlink,file.owner(),file.group(),h,
                       datetime.datetime.fromtimestamp(st.st_atime).strftime("%Y-%m-%d %H:%M:%S"),
                                   file.name)
            else:
                yield file.name
    yield  from  sorted(_showDir(args.path,args.all,args.l,args.h),key=lambda x:x[-1])  # 此处用于对文件最后文件名进行排序

# 此处用于定义参数，
parsent=argparse.ArgumentParser(prog='ls',description='list  file',add_help=False) # prog表示提示usage为ls，add_help为False表示取消默认的-h显示
parsent.add_argument('path',nargs='?',default='.',help="Incoming path information")  #path 位置参数，nargs表示其参数的个数，'?'表示可有可无，若无，则启用默认参数
parsent.add_argument('-a','--all',action='store_true')  # action='store_true'  此处若不填，则后面有大写的选项参数
parsent.add_argument('-l',action='store_true',help='list file info')
parsent.add_argument('-h',action='store_true',help='list  file detailed')

if __name__ == "__main__":
    args=parsent.parse_args(('/root','-lh'))
    for file  in  showDir(args.path,args.all,args.l,args.h): #此处的作用在于遍历
        print  (file)

结果如下

三 CSV

1 简介

csv 是一个被行分隔符，列分隔符划分成行和列的文本文件，没有特定的字符编码，可压缩，大大节约空间

行分割符 \r \n ，最后一行可以没有换行符
列分割符常常用逗号或制表符进行处理
每一行成为一个record
字段可以使用双括号括起来，也可以不使用，如果字段中出现了双引号，逗号，换行符必须使用双引号括起来，如果字典中的值是双引号，则使用功能两个双引号表示一个转义

2 参数简介

reader(csvfile,dialect='excel',**fmtparams) # 返回DictReader 的实例，是个行迭代器
delimiter #列分割符 逗号
lineterminator # 行分割符 \r\n
quotechar # 字段的引用符号，缺省为双引号
双引号的处理：
doublequote 双引号的处理，默认为True，如果和quotechar为同一个，True则使用2个双引号表示，False表示转义字符将作为双引号的前缀
escapechar 一个转义字符，默认为None
quoting 指定双引号的规则，QUOTE_ALL 所有字段，QUOTE_MINIMAL 特殊字符字段
QUOTE_NONNUMERIC非数字字段，QUOTE_NONE 都不使用引号。

writer(csvfile,dialect='excel',**fmtparams)
返回DictWriter的实例
主要方法有writerow,writerows

3 实例

#!/usr/local/bin/python3.6
#coding:utf-8
from  pathlib  import  Path
import   csv
p=Path('/root/test.csv')

if  not  p.parent.exists():  # 判断其父路径是否存在，若不存在，则创建
    p.parent.mkdir(parents=True)   #创建其父路径
line1=[1,2,3,4,576]
with  open(p,'w')  as  f:
    writer=csv.writer(f)   #写入文件系统
    writer.writerow(line1)  #进行写入一行操作

结果如下

#!/usr/local/bin/python3.6
#coding:utf-8
from  pathlib  import  Path
import   csv
p=Path('/root/test.csv')

if  not  p.parent.exists():  # 判断其父路径是否存在，若不存在，则创建
    p.parent.mkdir(parents=True)   #创建其父路径
line1=[1,2,3,4,576]
line2=[10,22,'3',40,'576']

with  open(p,'w')  as  f:
    writer=csv.writer(f)   #写入文件系统
    writer.writerow(line1)  #进行写入一行操作
    writer.writerow(line2)  #写入下一行操作

写入结果如下

同时写入多行

#!/usr/local/bin/python3.6
#coding:utf-8
from  pathlib  import  Path
import   csv
p=Path('/root/test.csv')

if  not  p.parent.exists():  # 判断其父路径是否存在，若不存在，则创建
    p.parent.mkdir(parents=True)   #创建其父路径
line1=[1,2,3,4,576]
line2=[10,22,'3',40,'576']
line3=[line1,line2]

with  open(p,'w')  as  f:
    writer=csv.writer(f)   #写入文件系统
    writer.writerow(line1)  #进行写入一行操作
    writer.writerow(line2)  #写入下一行操作
    writer.writerows(line3)  #同时写入多行操作

结果如下

读取操作

#!/usr/local/bin/python3.6
#coding:utf-8
from  pathlib  import  Path
import   csv
p=Path('/root/test.csv')

if  not  p.parent.exists():  # 判断其父路径是否存在，若不存在，则创建
    p.parent.mkdir(parents=True)   #创建其父路径
line1=[1,2,3,4,576]
line2=[10,22,'3',40,'576']
line3=[line1,line2]

with  open(p,'w')  as  f:
    writer=csv.writer(f)   #写入文件系统
    writer.writerow(line1)  #进行写入一行操作
    writer.writerow(line2)  #写入下一行操作
    writer.writerows(line3)  #同时写入多行操作

with   open(p)  as f:
    reader=csv.reader(f)  #由于其返回的是一个迭代器，因此可通过for循环方式进行读取操作
    for line  in reader:
        if  line:  #判断读取到的行是否存在
            print (line)

结果如下

Dictreader 和 DictWriter 对象

使用 dictreader可以向操作字典那样获取数据，把表的第一行（一般是表头）作为key，可访问每一行中的那个key对应的数据

#!/usr/local/bin/python3.6
#coding:utf-8
import   itertools
import  pymysql
import   csv
filename='/root/test1.csv'
with  open(filename)  as  f:
    reader=csv.DictReader(f)
    for row  in reader:
        max_tmp=row['passwd'],row['name'],row['createtime']
        print (max_tmp)

结果如下

DictWriter 类，可以写入的字典形式的数据，同样键也是表头

#!/usr/local/bin/python3.6
#coding:utf-8
import   csv
headers=['name','age']
datas=[
    {'name':'zhang1','age':25},
    {'name': 'zhang2', 'age': 26},
    {'name': 'zhang3', 'age': 27},
]
with  open('/root/test2.csv','w+')  as  f:
    writer=csv.DictWriter(f,headers)  # 写入表的形式
    writer.writeheader()  # 写入表头数据
    for row  in datas:
        writer.writerow(row)  # 写入真实数据，逐条写入
    writer.writerows(datas)  # 写入真实数据，一次性写入

结果如下

四 ini 文件处理

1 简介

.ini 文件时initalization file 的缩写，及就是初始化文件，是windows的系统配置文件所采用的存储格式，统一管理Windows的各项配置，一般用户就用Windows提供的各项图形化管理工具变可实现相同配置，如今的mysql依然采用这种方式实现配置文件的初始化操作。

格式
INI 文件由节（区域），键，值组成
节及就是 section 其中是由key=value的形式保存，key成为option选项

2 configparser

configparser 模块的ConfigParser类就是用来操作的
方法

1 读取方法

read(filenames,encoding=None)
读取ini文件，可以是单个文件，也可以是文件列表，可以指定文件编码
optons(section) 返回section下的所有option
get(section,option,*,raw=False,vars=None[,fallback])
从指定的段的选项上取值，如果找到则返回，如果没找到，则取DEFAULT段中查找
getint(section,option,*,raw=False,vars=None[,fallback])
从指定的字段选项上取值，返回×××，相当于做了int() 进行转型，默认是str字符串类型
getfloat(section,option,*,raw=False,vars=None[,fallback])
同上
getboolean(section,option,*,raw=False,vars=None[,fallback])
同上 布尔类型
items(raw=False,vars=None) #对所有进行遍历，返回键值对，不指定段，默认返回所有段中的key和value的值，若中途存在相同的key=value再不同的段中出现，则可能发生冲突，建议使用下面的方式进行处理
items(section,raw=False,vars=None) # 指定返回段的key和value
sections()返回section列表，缺省section不包括在内[DEFAULT]

2 判断方法

has_section(section_name) 判断section是否存在
has_option(section,option) 判断section 是否存在这个option

3 修改方法

add_section(section_name) 增加一个section
set(section,option,value)#section 存在的情况下，写入option=value，要求option，value 必须是字符串
remove_section(section) #移除section及其所有的option
remove_option(section,option) # 移除section下的option
write(fileobject,space_around_delimiters=True) # 将当前config的所有内容写入到flieobject中，一盘open函数使用w模式。

3 应用

1 基本读取

#!/usr/local/bin/python3.6
#coding:utf-8
from  configparser  import ConfigParser
cfg=ConfigParser()   # 初始化操作
cfg.read('/etc/my.cnf')  # 读取文件内容
print (cfg.sections())  # 打印其区，并返回列表
for  sections  in  cfg.sections():   #遍历section
    for  opt  in  cfg.options(sections):  # 遍历其中的值
        print (sections,opt)  # 打印section和option
for  i in  cfg.items('mysqld'):  #指定section，返回其下面的key和value，以元组的方式返回
    print (i)

结果如下

2 写入和移除

#!/usr/local/bin/python3.6
#coding:utf-8
from  configparser  import ConfigParser
from  pathlib  import  Path
p=Path('/root/my.cnf')  # 定义一个文件
parent=p.parent  # 获取其父目录
if not parent.exists():  # 判断其父目录是否存在。若不存在则创建
    parent.mkdir(parent=True)
with  open(p,'w+')  as  f:  # 以写的方式创建父目录
    f.write("")

cfg=ConfigParser()  # 定义初始化
cfg.read('/root/my.cnf')  # 定义读取
if  not  cfg.has_section('test'):  # 查看section是否存在，若不存在，则创建
    cfg.add_section('test')
if not  cfg.has_option('test','test1'):  #查看test下的test1是否存在，若不存在，则创建
    cfg.set('test','test1','2')#其value必须是字符串
with  open(p, 'w')  as  f:
    cfg.write(f)  # 将数据持久化存储至文件中
print (cfg.items('test'))  # 查看
print (type(cfg.get('test','test1')),cfg.get('test','test1'))  # 获取key对应的value
print (type(cfg.getint('test','test1')),cfg.getint('test','test1')+1)  # 获取key对应的value,并以×××输出
cfg.remove_option('test','test1')  #移除其中的key和value
print (cfg.sections())
cfg.remove_section('test')  #移除这个段
print (cfg.sections())

查看结果

五 面向对象的编程

1 编程的分类：

1 面向过程的编程
以指令为核心：围绕“正在发生什么”进行编写
面向过程：程序= 算法+ 数据结构
面向过程编程：程序具有一系列线性步骤，主体思想是代码作用于数据，以指令为核心，核心是设计算法，
2 面向函数的编程
3 面向对象的编程
面向对象编程--object oriented programming ，简称OOP，把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数
面向过程把函数继续切分称为子函数，来降低系统的复杂度。
面向对象编程（OOP）
程序 = 指令 + 数据/算法 + 数据结构
以数据为核心： 围绕“将影响谁”进行编写
面向对象编程（OOP）：围绕数据以及为数据严格定义的接口来组织程序，用数据控制对代码的访问，面向数据，以及能够对这些数据采取的操作进行，代码执行过成，不能跳过数据
面向对象编程的核心概念：
所有编程语言的最终目的都是提供一种抽象方法
在机器模型（“解空间”或“方案空间”）与实际解决问题的问题模型（“问题空间”）之间，程序员必须建立一种联系
将问题空间中的元素以及他们在解空间中的标识物抽象为对象，并允许通过问题来描述问题而不是通过方案来描述问题
可以把实例（某个类的实例）想象成一种新型变量，他保存这数据，但可以对自身数据执行操作，实例可以对自身数据做操作

2 类和实例

1 类：

定义了被多个同一类型对象共享的结构和行为（数据和代码）
类是抽象的，实例是具体的，类是（概念，抽象的概念模型），类本身是不能被操作的，须有实例化的对象才能操作
类的数据和代码，及类的成员
类内部有两个核心成员：代码和数据，都叫类成员
数据：成员变量或实例变量
成员方法： 简称为方法，是操作数据的代码，用于定义如何使用成员变量，因此一个类的行为和接口是通过方法来定义的
类：将同一种具体的物事的共同特性抽想出来的表现
状态和方法组成（转换这些状态的操作组成）类
状态：数据
方法：操作
类对象： 类的定义就会生成一个类对象
类的属性： 类定义中的变量和类中定义的方法都是类的属性
类变量：类中的赋值

2 实例：

实例是类的具体表现形式，类存在的目的就是为了实例化。类是抽象的，实例是具体的

3 操作

1 类的定义

calss 类名（父类）:
类的内容
类后面有括号的称为新式类，没有括号称为经典类。
括号里面的内容是父类的名称，程序中，所有父类都是object

类的查看：

2 类的数据属性（类变量）

当类的实例化后，类的属性是不变的

类的数据属性是可变的，当在实例处修改类的数据属性时，其类本身的数据属性不变。

当类的数据属性发生改变时，原本已经改变的实例的数据属性不会再次改变，而新创建的实例的数据属性会发生改变

#!/usr/local/bin/python3.6
#coding:utf-8
class  MyClass:
    '''is  example class'''
    x='abc'  # 类的属性
    def  foo(self):  # 类的属性，也是方法
        return (self,'MyClass')

myclass=MyClass()  # 进行实例化操作
print (myclass.x)  #调用类的属性
print (MyClass.x) # 类调用类属性
print (MyClass.foo(1))  # 类调用类方法
print (myclass.foo())  # 调用类的方法
print (type(myclass))  # 打印类型
print (id(MyClass))  # 打印类的实例地址
print (id(myclass))  # 打印类的内存地址

结果如下

其实例化都的内存地址和类本身的内存地址不同，且实例可以调用类的属性和方法，类自身也可以进行相关的调用处理

3 类的方法===函数

在类中定义的函数教方法，类的方法中，要求第一个形参必须是self，而self实际上是类实例化后的对象本身
实例化后获得的实例，是不同的实例，即使使用相同的参数实例化，也得到不一样的对象，其会先调用new 进行实例化，然后调用init 进行初始化
实例化后，会自动调用init方法，这个方法的第一个参数必须留给self,其他参数随意

类方法的定义

类方法的调用

#!/usr/local/bin/python3.6
#coding:utf-8
class  MyClass:
    '''is  example class'''
    x='abc'  # 类的属性
    y='cbd'
    def  __init__(self): # 初始化时进行打印，并显示结果，其__init__方法中不能return，其只能用做初始化
        print ('init')
    def  foo(self):
        return (self.x)
    def  foo1(self):
        return  (self.y)
myclass=MyClass()  # 对象实例化
print (myclass.foo())
print (myclass.foo1())

结果如下

#!/usr/local/bin/python3.6
#coding:utf-8
class  Person:
    def  __init__(self,name,age=20):
        self.name=name  # 此处的name始终和上述的self后面的name相对应，下面相同
        self.x=age
    def  showage(self):
        print  ('{} is {}'.format(self.name,self.x))  # 此处self.x 始终和上面的相同，其中age相当于形参
tom=Person('tom')  #对参数进行实例化操作
jerry=Person('jerry',10)  # 对参数进行实例化
tom.showage() #打印其方法
jerry.showage()

a=Person('a') # 其获取到的参数完全相同
b=Person('a')
print (a is  b) # 其内存地址不同
print  (a==b) # 其获取结果不同，

结果如下

#!/usr/local/bin/python3.6
#coding:utf-8
class  Person:
    x='abc'
    def  __init__(self,name,age=18):
        self.name=name
        self.age=age
    def show(self,x,y):  # 通过此处的参数，可修改类中的属性
        self.name=x  # 修改name的属性
        self.age=y
        Person.x=x  # 修改类属性
        print   (self.name,self.age,x)

tom=Person('tom')
tom.show('jerry',20)
print  (Person.x)  # 其返回结果为修改类属性后的结果

结果如下

特殊属性

4面向对象的三大特性

1 封装

组装： 将数据和操作组装到一起
隐藏数据：对外只暴露一些接口，通过接口访问对象
封装实际上是把数据封装到摸个地方，以后再去调用在某处的内容或者数据
调用封装数据的方式
通过对象直接调用
其中init表示的是一个构造器，当类的实例化过程时会调用其方法，由于其是必选参数，因此在传值时必须与对应的个数相同，当然可以实例化多个对象

通过self在类内部对类中的数据进行调用

类的实例化

2 继承

1 父类和子类

多复用，继承来的就不用自己写了
多继承少修改，OCP，使用继承来改变，来提现个性

基类和派生类
其中父类也叫基类
子类也叫派生类

父类

子类，其中没有定义类的属性和方法，只是继承了Class1 的属性

子类的实例化和结果，其完全继承和父类的属性和方法：

当子类中有自己的构造函数时，以子类中的构造函数为准

2 重写父类的构造函数

1 通过 父类名.init(self，父类参数) 进行重写构造函数

2 通过super(自己类名称,self).init(形参)
优点： 不需要明确告诉父类的名称，如果父类改变，只需修改class 语句后面的继承关系即可，不用修改父类名称

实例化调用

多重继承
对于新式类，是广度优先
对于经典类，是深度优先

对于新式类，当调用D实例时，其结果是执行D的输出，当D中为pass 占位，其继承了B的输出，当B中的结果为pass 时，其会继承C中的输出，

对于经典类，当调用D实例时，其结果是执行D的输出，当D中为pass 占位，其继承了B的输出，当B中的结果为pass 时，其会继承A中的输出，因为B继承了A，因为其是深度优先。

3 多态：

面向对象编程最灵活的地方，动态绑定
当父类和子类有相同的方法时，调用优先执行子类的方法：

4 新式类和经典类

python2.x 里面支持经典类和新式类
python3.x 里面仅支持新式类
经典类,其可以不写父类。

新式类，其如果没有继承的父类则直接写object，必须写父类，如果有父类，则直接写父类

只有新式类支持mro（） 方法

5 类的特殊属性

1 class.name 类的名称显示

2 class.doc 类的帮助文档

3 class.base 类的父类/基类

4 class.module 类的模块，当不是导入的模块的类时，其执行结果为main，当为模块导入时，其执行结果为模块名

6 类的私有属性

通过在类的构造时使用self.__x=x 来 获取类的私有属性。

1 简介

默认的类的私有属性不能访问：

通过将其私有属性包装成方法进行使用，其是可以访问的。

通过此装饰器@property： 定义一个类方法为私有属性的名称;让用户可以直接访问， 但不能任意修改;

通过其装饰器的方法进行重新定义一个接受隐藏属性的范围来进行修改其值。

@属性名.seeter: 给属性赋值时先做判断; 当属性名=value会自动调用该函数

通过deleter 方法可以使得当del 属性名, 会自动调用该函数并执行高函数下面的操作~~

@property应用：
用于分页显示，此处传入两个值，一个值是第几页，另一个是每页的数量，通过@property 可以进行对列表的操作。

2 私有属性的继承

默认的，私有属性不能直接调用，需要伪装成方法方可调用。

在类中，以双下划綫开始的方法称为私有方法：私有方法不能继承。

7 类的方法与静态方法

1 类方法

在类中调用类本身的方法：
传统的输入年、月、日、的方法：

通过函数进行格式化的结果，通过在函数中调用类的方式实现

通过类方法@classmethod 进行将类本身调用，其中cls 关键字就是表示类本身，
可以使用类名.类方法（参数） 的形式进行调用。并使用return 返回结果

2 静态方法

通过@staticmethod 进行装饰并以return 的模式返回，调用方式也是类名.类方法(参数)进行调用，

3 类方法总结：

类方法：默认第一个参数是类本身，其可以被类调用，不能被实例调用
普通方法：默认第一个参数是实例本身，可以被类和实例进行调用
静态方法：默认第一个参数数传入的参数。只能被类本身进行调用，不能被实例调用

4 在类中的应用：

扩展：

9 类方法扩展

迭代：
判断一个对象是否可迭代，看类是否有iter方法

其他的方法
__getitem__(self,item)：
用于查看某个key对应的vlaues
__setitem__(self,key.values) 用于当导入某个key，values时修改当前的values为指定传入的vlaues
__delitem__(self,key)用于通过指定键，来删除值的过程.
__getslice__(self,i,j) 用以查看切片的结果，传入的分别是切片的起始和结束
__setslice__(self,i,j,squence)： 用以将切片的值修改，传入切片的起始，结束和要修改成为的字段
__delslice__(self,i,j)： 用以将接片的结果删除