python之面向对象设计、编程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　面向对象

一、编程三个范式

1、面向过程编程

2、函数式编程

数学层面的函数

python中的函数编程

3、面向对象编程

二、面向对象设计

1、类：把一类事物共同的特征和共同的动作整合在一起就是类；

2、对象：基于类而创建的一个具体的事物（具体存在的，也是特征和动作的结合）

def dog(name,type,gender):
    def chi(dog1):
        print("%s 正在嚼骨头！！！" %dog1["name"])
    def jiao():
        print("%s正在汪汪！！" %dog1["name"])
    def  init(name,type,gender):
        dog= {
            "name":name,
            "type":type,
            "gender":gender,
            "chi":chi,
            "jiao":jiao
        }
        return dog
    return init(name,type,gender)
 
first_dog= dog("alex","中华田园犬","母")
print(first_dog)
first_dog["chi"](first_dog)

三、面向对象编程

1、类：声明类和函数类似，类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

2、属性

（1）、数据属性：就是变量

（2）、函数属性：就是函数，在面向对象里通常称为方法

备注：类和对象都是通过点来访问自己的属性

class Dog:
    name = "alex"
    type = "中华田园犬"
    def chi():
        print("正在嚼骨头")
    def jiao(self):
        print("一直在犬吠")
dog1 =Dog()
print(dir(Dog))
Dog.chi()　　

3、实例化

class Dog:
    def __init__(self,name,type):
        self.mingzi = name
        self.leixing = type
    def chi(self):
        print("%s正在嚼骨头" %self.mingzi)
    def jiao(self):
        print("一只%s在犬吠" %self.leixing)
dog1 =Dog("alex","中华田园犬")  ###实例化
print(dir(Dog))
Dog.chi(dog1)
dog1.jiao()

四、备注

1、静态属性

静态属性的修饰为@property，对方法进行封装，隐藏内部逻辑，将类方法变为类属性

class sch:
    ###初始化参数
    def __init__(self,sch_name,sch_create_time,sch_add,sch_fee,sch_type,sch_level,sch_teach_type,sch_ward,sch_start_edu_time,sch_schedual):
        self.name = sch_name
        self.sch_name = sch_name
        self.sch_create_time = sch_create_time
        self.sch_add = sch_add
        self.sch_fee = sch_fee
        self.sch_type = sch_type
        self.sch_level = sch_level
        self.sch_teach_type = sch_teach_type
        self.sch_ward = sch_ward
        self.sch_start_edu_time = sch_start_edu_time
        self.sch_schedual = sch_schedual
    ###定义方法：这是常规的方法定义
    def sch_catch_fee(self):
        print ("%s本年度学费为%s" %(self.sch_name,self.sch_fee))
    ###对方法加上装饰器property，隐藏方法内部实现逻辑
    @property
    def sch_catch_fee(self):
        return ("%s本年度学费为%s" %(self.sch_name,self.sch_fee))

2、类方法

使用@classmethod进行修饰，类直接调用，bu用再进行传实例名，跟实例没有任何关系。

class sch:
    ###初始化参数
    def __init__(self,sch_name,sch_create_time,sch_add,sch_fee,sch_type,sch_level,sch_teach_type,sch_ward,sch_start_edu_time,sch_schedual):
        self.name = sch_name
        self.sch_name = sch_name
        self.sch_create_time = sch_create_time
        self.sch_add = sch_add
        self.sch_fee = sch_fee
        self.sch_type = sch_type
        self.sch_level = sch_level
        self.sch_teach_type = sch_teach_type
        self.sch_ward = sch_ward
        self.sch_start_edu_time = sch_start_edu_time
        self.sch_schedual = sch_schedual
    ###classmethod方法修饰的方法的哥参数为cls
    @classmethod
    def sch_edu(cls,x):
        print("这是类的方法，与实例没有任何关系",x)
###类可以直接调用
sch.sch_edu(1) #这是类的方法，与实例没有任何关系 1

3、静态方法

使用staticmethod方法进行修饰，不与类、实例绑定，是类的工具包，只是名义上归类管理

class sch:
    ###初始化参数
    def __init__(self,sch_name,sch_create_time,sch_add,sch_fee,sch_type,sch_level,sch_teach_type,sch_ward,sch_start_edu_time,sch_schedual):
        self.name = sch_name
        self.sch_name = sch_name
        self.sch_create_time = sch_create_time
        self.sch_add = sch_add
        self.sch_fee = sch_fee
        self.sch_type = sch_type
        self.sch_level = sch_level
        self.sch_teach_type = sch_teach_type
        self.sch_ward = sch_ward
        self.sch_start_edu_time = sch_start_edu_time
        self.sch_schedual = sch_schedual
    @staticmethod
    def post_message(message):
        print("本校通知如下:%s" %message)
sch.post_message("本校将于20191207放假")

5、python中关于oop的常用术语

（1）、抽象/实现

抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。

对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。

（2）、封装接口

封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。

注意：封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”

真正的封装是，经过深入的思考，做出良好的抽象，给出“完整且最小”的接口，并使得内部细节可以对外透明

（注意：对外透明的意思是，外部调用者可以顺利的得到自己想要的任何功能，完全意识不到内部细节的存在）

python不依赖语言特性去封装数据，而是通过遵循一定的数据属性和函数属性的命名约定来达到封装的效果：

任何以单下划线开头的名字都应该是内部的，私有的，实际上外部还是可以调用的；

class After_sch:
    _school = "tongnan middle school"
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def fangxue(self):
        if self.type == "老师":
            print("下班")
        else:
            print("放学")
class Stu(After_sch):
    pass
class Tea(After_sch):
    pass
stu1 = Stu("小二","学生")
tea1 = Tea("heaton","老师")
print(stu1.__dict__)   ###{'name': '小二', 'type': '学生'}
print(stu1._school)   ###tongnan middle school   单下划线的外部调用成功

以双下划线开头的名字也是内部的，私有的，是python的约定命名，实际上外部也是可以调用的；

class After_sch:
    __school = "tongnan middle school"
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def fangxue(self):
        if self.type == "老师":
            print("下班")
        else:
            print("放学")
class Stu(After_sch):
    pass
class Tea(After_sch):
    pass
stu1 = Stu("小二","学生")
tea1 = Tea("heaton","老师")
print(stu1.__dict__)   ###{'name': '小二', 'type': '学生'}
print(After_sch.__dict__)
# print(stu1.__school)   ###'Stu' object has no attribute '__school' 这样调用会报错
print(stu1._After_sch__school)   ###tongnan middle school 通过"_类名__属性"调用成功

封装有三个层面上的封装

a、第一个层面：类就是麻袋，这本身就是一种封装；

b、第二个层面：类中定义私有的，只有的类的内部可以使用，外部无法访问，该层面的封装就是上面提到的使用单下划线和双下划线实现的，实际上该中层面的封装外部也是可以调用的；

c、第三个层面：明确区分内外，内部的实现逻辑，外部无法知晓，并且为封装到内部的逻辑提供一个访问接口给外部使用，这才是真正的封装；

（3）、合成

合成扩充了对类的 述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。

（4）、派生/继承/继承结构

派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。
继承描述了子类属性从祖先类继承这样一种方式
继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。

（5）、泛化/特化

基于继承
泛化表示所有子类与其父类及祖先类有一样的特点。
特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。

（6）、多态与多态性

多态指的是同一种事物的多种状态：水这种事物有多种不同的状态：冰，水蒸气

多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

class After_sch:
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def fangxue(self):
        if self.type == "老师":
            print("下班")
        else:
            print("放学")
class Stu(After_sch):
    pass
class Tea(After_sch):
    pass
stu1 = Stu("小二","学生")
tea1 = Tea("heaton","老师")
stu1.fangxue()  ##放学
tea1.fangxue()   ##放学
####学生类对象stu1和老师类对象tea1调用同一方法呈现不同的结果

（7）、自省和反射

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__,

反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。

python中面向对象中的反射：通过字符串的形式操作对象相关的属性。有四个系统内置函数可以实现自省

a、hasattr

b、getattr

c、setattr

d、delattr

class After_sch:
    school = "tongnan middle school"
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def fangxue(self):
        if self.type == "老师":
            print("下班")
        else:
            print("放学")
class Stu(After_sch):
    pass
class Tea(After_sch):
    pass
stu1 = Stu("小二","学生")
tea1 = Tea("heaton","老师")
# print(After_sch.__dict__)
# # print(stu1._school)
# print(stu1.__dict__)  ###{'name': '小二', 'type': '学生'}
# stu1.fangxue()
# tea1.fangxue()
print(hasattr(stu1,"school"))   ###判断stu1对象是否有school属性   True
print(getattr(stu1,"school1","没有该条属性"))     ###获取对象的属性，如果没有返回自定义字符串：没有该条属性
setattr(stu1,"年级","一年级")   ###设置对象的属性    {'name': '小三', 'type': '学生', '年级': '一年级'}
delattr(stu1,"type")  ###删除stu1对象的属性
print(stu1.__dict__)   ###{'name': '小二', '年级': '一年级'}

在编程过程中，通过自省的方式，可以达到可插拔式设计

###这是ftp_client.py文件
class Ftp_client:
    def __init__(self,addr):
        print("正在连接服务器 %s" %addr)
        self.addr = addr
    ###还未实现功能
 
###这是ftp_call.py文件
 
from ftp_client import Ftp_client
 
f1 = Ftp_client("192.168.1.100")
if hasattr(f1,"get"):
    func_get = getattr(f1,"get")
    func_get()
else:
    print("ftp_client还未实现该方法！！！！")
 
###通过自省的方式可以在ftp_client在未实现的情况下继续后续工作

6、__getattr__,__setattr__,__delattr__

class animal:
    genernal = "冷血动物"
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def cay(self):
        print("%s一直在抽泣" %self.name)
    def __getattr__(self, item):   ####__getattr__调用不存在的属性时运行
        print("你调用的方法不不存在")
    def __setattr__(self, key, value):
        # self.key = value  该种调用的方式会出现无限递归
        self.__dict__[key] = value   ##这种方式直接操作底层字典
    def __delattr__(self, item):    ###__delattr__删除的时候调用该方法
        #del self.item 该种方式也会出现无限递归
        self.__dict__.pop(item)     ##这种方式直接操作底层字典
dog = animal("金毛","dog")
print(dog.__dict__)
 
dog.addr = "north america"   ###{'name': '金毛', 'type': 'dog', 'addr': 'north america'}
print(dog.gener)   ###你调用的方法不不存在:因为该属性不存在，触发__getattr__方法

7、二次加工标准类型（包装）

包装：python提供了标准数据类型，以及丰富的内助方法，其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型，新增、改写方法，可以通过继承和派生的相关知识；

class List(list):###继承父类list
    def show_middl(self):  ###派生show_middle的方法
        return self[int(len(self)/2)]
    def append(self, object):  ###派生append方法
        if type(object) is not str:
            print(type(object))
            print("添加的类型必须为字符串类型")
        else:
            super().append(object)
l1 = List()
print(l1.__dict__)
 
res = List("string") ###继承方法
print(res,type(res))   ###['s', 't', 'r', 'i', 'n', 'g'] <class '__main__.List'>
# print(res.show_middl())
res.append("helloworld")
res.append(1234)   ###在调用的append方法是对数据类型对了判断
print(res)   ###  ['s', 't', 'r', 'i', 'n', 'g', 'helloworld']

　授权：授权是包装的一个特性，包装一个类型通常是对已存在的类型的一些定制，这种做法可以是新建、修改或删除原有产品的功能，其他则保持原样。授权的过程，即是所有更新的功能都是有新类的某部分

来处理。

import time
class file_handler:
    def __init__(self,filename,mode="r",encoding="utf-8"):
        # self.filename = filename
        self.file = open(filename,mode,encoding="utf-8") ###获取文件句柄
        self.mode = mode
        self.encoding = encoding
    def write(self,line):
        t = time.strftime("%Y-%m-%d %X")
        self.file.write("%s %s" %(t,line))
    def __getattr__(self, item):
        print(item)
        # self.file.read
        return getattr(self.file,item)
 
f1 = file_handler("a.text","w+")
    # print(f1.file)
    # print(f1.read)
f1.write("11111111343234\n")
time.sleep(1)
f1.write("用户root远程登录服务器\n")
time.sleep(2)
f1.write("用户root修改了目录/opt的权限为777\n")