Python面向对象（全套）

前言

编程思想分为面向对象和面向语言

什么是面向过程？

面向过程即以事物发生过程为主要目标进行编程（什么正在发生）

什么是面向对象？

面向对象即把一件事物为对象进行编程，每个对象都有属性和方法。

例如：人可以作为对象，属性有姓名、年龄、身高...方法有走、跑、跳...

车可以作为对象，属性有轮胎、车灯，方向盘...方法有载人、放音乐...

Python也支持面向对象的三大特征：封装、继承、多态

类和对象

类：是对一些具有相同特征和行为的事物的分类，它是抽象的

对象：它是类的实例化，是具体的

类与对象的关系即模板与产品：模板只能有一个，但对象可以有很多个

我们通常用大驼峰命名法去命名一个类名

类的详解

Python中定义类有两种：旧式类和新式类

在早期Python中，类不会默认继承object，而没有继承object的类为旧式类。而在python3之后，类会默认继承object类，继承了object的类为新式类

旧式类：

class A:
    pass

新式类：

class B(object):
    pass

现在一般都使用新式类

属性

在Python中类中的属性分为两种：公有属性和私有属性

公有属性：可以在类内类外使用，没有限制

私有属性：只能在类内使用，但可以使用方法间接访问

私有属性定义时需在前面加上两个下划线（__）

class A(object):
    
    #公有属性
    a = "public"
 
    #私有属性
    __b = "private" 
 
    print("属性为"+a)
    print("属性为"+__b)
test = A()

属性为public
属性为private

方法

在Python中类中的方法分为两种：公有方法和私有方法

公有方法：可以在类内类外使用，没有限制

私有方法：只能在类内使用

私有属性定义时需在前面加上两个下划线（__）

class A(object):
    def public(self):
        print("公有方法")
    def __private(self):
        print("私有方法")
test = A()
test.public()
test._A__private()

公有方法
私有方法

Python中访问私有方法可以通过：实例化类._类__私有化方法

类中内置方法（魔法函数）

在Python的类中以__XX__命名的方法都是类中的内置方法即魔法函数

如何查看类中的内置函数：

print(dir(object))

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

类中常用的内置方法：

1、__init__对象初始化时，会被自动调用

可以使用__init__方法来控制对象初始化的过程

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

2、__new__创建对象时，会被自动调用

3、__del__对象被从内存中销毁前，会被自动调用

4、__str__返回对象的描述信息，print函数输出使用

class Animal(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
 
    def __str__(self):
        return "name = "+ self.name +""
 
a = Animal("dog","2years","man")
print(a)

name = dog

在使用__str__方法后用print函数去输出实例化对象时会输出__str__函数中给定的描述信息（属性为私有化也可被输出）

面向对象的三大特征

封装 继承 多态

封装

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

在Python中定义类时，我们都需要将属性私有化，如何提供公开的方法去供外部访问和修改

class Animal(object):
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex
 
a = Animal("dog","2years","man")

此例子中的属性都为私有属性，那我们如何去访问？

第一种封装方式：

在类中提供get方法和set方法供外部访问

class Animal(object):
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex
 
    #提供公开的get方法
    def get_name(self):
        return self.__name
 
    #提供公开的set方法
    def set_name(self,name):
        self.__name = name
 
a = Animal("dog","2years","man")
print(a.get_name())
a.set_name("cat")
print(a.get_name())

dog

cat

第二种封装方式：

使用porperty（）函数，使用此函数的时候需要有get方法和set方法

class Animal(object):
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex
 
    #提供公开的get方法
    def get_name(self):
        return self.__name
 
    #提供公开的set方法
    def set_name(self,name):
        self.__name = name
 
    name = property(get_name,set_name)
a = Animal("dog","2years","man")
print(a.name)
a.name = "cat"
print(a.name)

dog
cat

注意：在类外修改属性时a.后需要跟接受property的变量

第三种封装方式：

通过装饰器@property在get方法上进行装饰

class Animal(object):
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex
 
    @property
    def name(self):
        return self.__name
 
    @name.setter
    def name(self,name):
        self.__name = name
 
 
a = Animal("dog","2years","man")
print(a.name)
a.name = "cat"
print(a.name)

dog
cat

继承

类与类之间还有种关系，即继承

继承可以提高代码的利用率、复用率

object为所有类的父类，Python支持多继承class Son(father1,father2......)，在多继承中需要注意继承顺序，在继承时它会按照继承顺序来继承，即优先级

class father(object):
    def __init__(self):
        self.money =100
        self.home = "房子"
    def tell(self):
        print("ok")
 
#儿子继承了父亲
class son(father):
    pass
 
if __name__ == '__main__':
    a = son()
    a.tell()
    print(a.money)
    print(a.home)

ok
100
房子

注意：子类可以继承父类的所有公有属性和公有方法

在子类继承父类后，父类中的方法不能满足子类的使用时，我们可以在子类中进行方法重写

方法重写时，子类与父类的方法名称、参数必须相同

在Python中有方法的重写，但是没有方法重载，但是可以实现方法的重载（装饰器）

方法重写示例：

class father(object):
    def tell(self):
        print("我喜欢平平淡淡")
 
#儿子继承了父亲
class son(father):
    def tell(self):
        print("我喜欢赚钱")
 
if __name__ == '__main__':
    a = son()
    a.tell()

我喜欢赚钱

super（）关键字：它相当于一个指针，默认指向指针

class father(object):
    def tell(self):
        print("我喜欢平平淡淡")
 
#儿子继承了父亲
class son(father):
    def tell(self):
        print("我喜欢赚钱")
 
    def test(self):
        self.tell()
        super().tell()
 
if __name__ == '__main__':
    a = son()
    a.test()

我喜欢赚钱
我喜欢平平淡淡

多态

多态基于继承的基础之上，一个对象的多种实现，即父类引用指向子类实例的现象

Python是弱数据语言，所以多态在python中显得不太重要，它在定义变量的时候不用声明数据类型，因此支持多态

class father(object):
    def tell(self):
        print("我是父亲")
 
#儿子继承了父亲
class son(father):
    def tell(self):
        print("我是儿子")
 
#女儿继承了父亲
class daughter(father):
    def tell(self):
        print("我是女儿")
 
def test(father):
    father.tell()
 
 
if __name__ == '__main__':
    a = father()
    b = son()
    c = daughter()
    test(a)
    test(b)
    test(c)

我是父亲
我是儿子
我是女儿

在例子中通过tell（）函数实现了父类引用指向子类实例，完成了一个函数的多种实现