Python学习心得面向对象的三大特征

一、封装

我们清楚的知道有些内容我们可以去开源，但是有内容我们需要去限制用户对其的操作，以至于维持整个系统的正常操作。下面要讲的内容就是关于权限控制的知识。

1.封装的定义：隐藏内部细节，对外是提供一些操作方式。

2.权限控制：通过对属性和方法添加单下划线、双下划线以及首尾双下滑线来实现。

（1）单下滑线开头：以单下划线开头的属性或方法是受到保护的成员，这部分成员被视为只供内部使用，允许类本身和子类进行访问，但实际上他可以被外部代码访问。

 注：表示可以被强硬访问。

（2）双下划线开头：表示私有成员，这类成员只允许定义该属性或方法的类本身进行访问。

（3）首尾下划线：一般表示特殊的方法。

3.权限控制的运用：

class Student():
    #首尾双下划线
    def __init__(self,name,age,gender):
        self._name=name
        self.__age=age
        self.gender=gender

    def _fun1(self):
        print('子类及本身可以访问')

    def __fun2(self):#私有的
        print('只有定义的类可以访问')

    def show(self):
        self._fun1()
        self.__fun2()
        print((self._name))
        print(self.__age)


#创建一个学生对象
a=Student('wjl',19,'男')

#私有的实例属性和实例方法也能访问
print(a._Student__age)
a._Student__fun2()

4.说明：前面我们提到了不能对私有的属性和方法进行访问（访问的意思就是进行调用），其实私有的属性和方法也可以进行访问（进行调用）。

 私有的实例属性和实例方法的访问：

#私有的实例属性和实例方法也能访问
print(a._Student__age)
a._Student__fun2()

5.但是这种方法是不提倡的，我们会使用下面的这种方法。

class student():
    def __init__(self,name,gender):
        self.name=name
        self.__gender=gender

    @property
    def gender(self):
        return self.__gender

stu=student('w','男')
print(stu.name,stu.gender)

 6.我们能通够对私有的属性进行访问，同时我们还可以将私有属性设置为可写属性。

class student():
    def __init__(self,name,gender):
        self.name=name
        self.__gender=gender

#将我们的gender这个属性设置为可写属性
    @gender.setter
    def gender(self,value):
        if value!='nan'and value!='女':
           print('有误的,已将性别设置为默认值。')
           self.__gender='男'
        else:
            self.__gender=value

stu.gernder='其他'
print(stu.name,stu.gender)

二、继承

1.继承的定义：在Python中一个子类可以继承N多个父类，一个父类也可以拥有N个子类，如果一个类也没有继承任何类，那么这个类默认继承的是object类。

2.继承的语法结构：

class 类名(父类1,父类2,...,父类N):
     pass

3.继承的应用：

class person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(f'大家好，我叫：{self.name}，今年：{self.age}')

#student继承person类
class student(person):
    #编写初始化的方法:用于设置对象的属性
    def __init__(self,name,age,stuno):
        super().__init__(name,age)
        self.stuno=stuno

#doctor继承person类
class doctor(person):
    #编写初始化方法
    def __init__(self,name,age,depertment):
        super().__init__(name,age)
        self.depertment=depertment

#创建一个学生类的对象
stu=student('wjl',19,1002)
stu.show()
doctor=doctor('zyy',24,'外科')
doctor.show()

注：子类能继承父类的公开的和受保护的内容。

4.python当中的多继承：

class fathera():
    def __init__(self,name):
        self.name=name

    def showa(self):
        print('fathera的方法')

class fatherb():
    def __init__(self,age):
        self.age=age

    def showb(self):
        print('fatherb的方法')

#多继承
class son(fathera,fatherb):
    def __init__(self,name,age,gender):
        #需要调用两个父类的初始化方法
        fathera.__init__(self,name)
        fatherb.__init__(self,age)
        self.gender=gender

son=son('wjl',19,'男')
son.showa()
son.showb()

注：通过上面我们可以得知，一个类的属性不只有一种，其功能（也就是所说的方法）也不只有一种。

5.方法重写

（1）方法重写的介绍：

a.子类继承了父类就拥有了父类中公有成员和受保护的成员；

b.父类的方法并不能完全适合子类的需求，这个时候子类就可以重写父类的方法；

c.子类在重写父类的方法时，要求方法的名称必须与父类方法的名称相同。在子类重写后的方法中，可以通过 super().xxx() 调用父类中的方法；

(2)方法重写的运用：

class person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(f'大家好，我叫：{self.name}，今年：{self.age}')

#student继承person类
class student(person):
    #编写初始化的方法:用于设置对象的属性
    def __init__(self,name,age,stuno):
        super().__init__(name,age)
        self.stuno=stuno

    def show(self):
        super().show()
        print(f'我来自XXX大学，我的学号是：{self.stuno}')

#doctor继承person类
class doctor(person):
    #编写初始化方法
    def __init__(self,name,age,depertment):
        super().__init__(name,age)
        self.depertment=depertment

    def show(self):
        #super().show()
        print(f'大家好，我叫：{self.name},我今年{self.age},我的工作室是：{self.depertment}')

#创建一个学生类的对象
stu=student('wjl',19,1002)
stu.show()#调用的子类的，子类中有show()方法就用子类的
doctor=doctor('zyy',24,'外科')
doctor.show()

注：现已经在重写方法时，子类自己有方法，那么就用子类自己的方法，否则的话就调用父类的。

 三、多态

1.多态的描述：

（1）“指的就是‘多种形态’，即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用对象的方法。

（2）在程序运行过程中根据变量所引用对象的数据类型，动态决定调用哪个对象中的方法。

注：动态决定调用哪个对象中的方法，可以提高程序的可拓扩展性。

（3）Python语言中的多态，根本不关心对象的数据类型，也不关心类之间是否存在继承关系，只关心对象的行为（方法）。只要不同的类中有同名的方法，即可实现多态。”

 注：只关心同名的方法。

2.多态的运用：

class person():
    def eat(self):
        print('1')

class cat():
    def eat(self):
        print('2')

class dog():
    def eat(self):
        print('3')

#这三个类中都有一个同名方法，eat
#编写函数
def fun(obj):#obj是函数的形式参数，在定义处并不知道这个参数的数据类型
    obj.eat()#通过变量obj()

#创建三个类的对象
per=person()
cat=cat()
dog=dog()

#调用fun函数
fun(per)
fun(cat)
fun(dog)