python面向对象

面向对象概述

python是一门面向对象语言，面向对象的三大特性，封装、继承、多态，python支持多继承，这里与java语言等还是有区别的

创建类关键字 class ，类中包含属性和方法，通过类创建对象

python的类和对象

创建类的关键字为class 

创建对象为 对象名=类名() 

调用属性和方法 对象名.xxx

class Person:
    name = None
    gender=None
    age=None

    def eat(self):
        print(f"{self.name}这个人在吃饭")

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

zhangsan = Person("zhangsan","男",18)

zhangsan.eat()

"""
输出结果：
zhangsan这个人在吃饭
"""

 类中成员方法创建第一个参数为self，指代本类对象,调用的时候python自动传入

    def eat(self):
        print(f"{self.name}这个人在吃饭")

__init__(self,...) 此类方法为构造方法,类初始化的时候自动调用，与java类似

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

创建对象 

zhangsan = Person("zhangsan","男",18)

调用方法

zhangsan.eat()

私有成员变量和方法的定义，前边加两个下划线，即__xxx,对象不可以调用私有变量和方法

class Person:
    # 私房钱
    __money = 10000

    #通过公有方法访问私有成员
    def getMoney(self):
        return self.__money;
    #私有方法
    def __heigt(self):
        print("175cm")

zhangsan = Person()

zhangsan.getMoney()

python的类方法

用@classmecthod装饰符来表示，类方法只能访问类变量，不能访问实例变量

class Person:

    name = "lisi"
    def __init__(self,name,age):
        self.name=name
        self.age=age

    # 类方法,只能访问 name = lisi的成员变量，通过构造方法传进来的会报错
    @classmethod
    def getName(self):
        print(f"姓名是:{self.name}")

zhangsan = Person("zhagnsan",13)

zhangsan.getName()

"""
输出结果：姓名是:lisi
"""

python的静态方法

通过@staticmethod装饰器来表示，该方法可以把@staticmethod下面的函数和所属的类截断，这个函数就不属于这个类，也没有类的属性，只不过要通过类名的方式调用

class Person:

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

    # 静态方法，类名调用
    @staticmethod
    def testStatic():
        print("我是静态方法")


Person.testStatic()
zhangsan = Person("zhangsan",18)
zhangsan.testStatic()

"""
 输出结果
 我是静态方法
 我是静态方法
"""

 python的属性方法

用@property装饰符表示，把一个方法变成一个静态属性，然后直接把它作为属性调用

class Person:

    @property
    def propertiesMethod(self):
        print("我是属性方法")


a = Person()
# 如果a.propertiesMethod()会报错
a.propertiesMethod

"""
输出结果
我是属性方法
"""

python的魔术方法 

方法名	说明
__init__	类似构造器，在类生成对象后就会被执行
__del__	在对象消亡时执行
__call__	在类的对象被执行时被调用
__str__	在对象被str()包裹的时候会被执行
__int__	在对象被int()包裹的时候会被执行
__add__	在两个对象相加的时候，调用第一个对象的__add__方法，可以将第二个对象传递进来
__dict__	这个方法是以字典的形式列出类或对象中所有成员
__iter__	类对如果想变成一个可迭代的对象，那么对象中必须要有__iter__方法，并且这个方法返回一个迭代器

更多魔术方法的使用请参考：传送门

python的继承 

python中的继承通过在类名后边写（xxx），python支持多继承

注意：父类和子类都重新定义了构造函数init()时，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造器，必须在子类中显示调用

class Student:
    def myName(self):
        print("我叫zhangsan")

class Person(Student):


    def myAge(self):
        print("我18岁")

a = Person()
a.myName()
a.myAge()


"""
输出结果
我叫zhangsan
我18岁
"""

python的子类调用父类

python调用父类的成员变量和方法有两种方式

1、使用父类名.[成员变量|成员方法()]

2、super().[成员变量|成员方法()]

class Fu():
    name ="zhangsan"

    def test(self):
        print(f"名称为{self.name}")

class Zi(Fu):
    def excuteFu(self):
        print(Fu.name)
        super().test()

Zi().excuteFu()

"""
输出结果
zhangsan
名称为zhangsan
"""

python的多态

多态性是面向对象重要的特征之一。“多态”是指对象可以表现出多种形态。经典例子例如：猫 狗 都属于动物，它们都有叫 动等行为，但是叫的方式与动的方式各不相同

def start(obj):
    obj.speak()

class Animail():
    def speak(self):
        print("动物在叫")

class Dog(Animail):
    def speak(self):
        print("狗在叫")

class Cat(Animail):
    def speak(self):
        print("猫在叫")


Dog().speak()
Cat().speak()
start(Dog())
start(Cat())

"""
输出结果
狗在叫
猫在叫
狗在叫
猫在叫
"""

python的接口

python中没有interface关键字，python中的接口也就是抽象类

定义方式：

        1、类声明加上metaclass=abc.ABCMeta

        2、定义抽象方法，加注解@abc.abstractmethod，内容为pass，表示为空

注意事项：

        1、抽象类不能实例化对象

        2、继承实现抽象类的类必须实现所有抽象方法

        3、抽象类可以定义实际方法

import abc

class AbsTest(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def test(self):
        pass
    def test1(self):
        print("444")

class AbsTestImpl(AbsTest):
    def show(self):
        print("555")

    def test(self):
        print("666")

AbsTestImpl().test()
AbsTestImpl().test1()

"""
输出结果
666
444
"""

python的异常处理

异常是Python对象，当Python无法正常处理程序时就会抛出一个异常。一旦Python脚本发生异常，程序需要捕获并处理它，否则程序会终止执行，与其他面向对象语言的异常处理类似，比如java

Python中所有异常类的根类是BaseException类，它们都是BaseException的直接或间接子类。大部分常规异常类的基类是Exception的子类

python的异常处理语法 

处理异常的语法与其他语言类似 

try:

        可能出现异常的代码

expect Exception as 别名:

        异常处理方法

else:

        没有出现异常

finally:

        一定会执行的代码

try:
    # 打开不存在的文件
    open("test.txt","r",encoding="UTF-8")
except Exception as e:
    print("出现异常")
else:
    print("123")
finally:
    print("一定会执行")

"""
输出结果
出现异常
一定会执行
"""