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()函数实现了父类引用指向子类实例,完成了一个函数的多种实现

你可能感兴趣的:(python,python,开发语言)