Python核心编程总结(四面向对象与异常)

Posted 生命是有光的

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python核心编程总结(四面向对象与异常)相关的知识,希望对你有一定的参考价值。

✍、脑图时刻

1、面向对象

面向对象的三大特征:封装、继承、多态

  1. 封装:将属性和方法书写到类的里面的操作即为封装,封装可以为属性和方法添加私有权限。
  2. 继承:子类默认继承父类的所有属性和方法,与此同时子类也可以重写父类属性和方法。
  3. 多态:多态是同一类事物具有的多种形态。不同的对象调用同一个接口(方法),表现出不同的状态,称为多态。

1.1、定义类

  • 语法
class 类目():
	代码

1.1.2、创建对象

  • 语法:对象名 = 类名()
# 定义类
class Washer():
    def wash(self):
        print('能洗衣服')

# 创建对象 对象名 = 类名()
haier = Washer()

# 使用wash功能  实例方法/对象方法   对象名.方法()
haier.wash() # 能洗衣服

注意:创建对象的过程也叫实例化对象。

1.1.3、self

self 指的是调用该函数的对象。

打印对象和 self 得到的结果是一致的,都是当前对象的内存中存储地址。

# 定义类
class Washer():
    def wash(self):
        print('能洗衣服')
        print(self)
        # <__main__.Washer object at 0x00000228BDBEF860>

# 创建对象 对象名 = 类名()
haier1 = Washer()
print(haier1)
# <__main__.Washer object at 0x00000228BDBEF860>

1.2、添加和获取对象属性

属性即是特征,比如:洗衣机的宽度、高度、重量

对象属性既可以在类外面添加和获取,也能在类里面添加和获取

1.2.1、类外面添加对象属性

  • 语法
对象名.属性名 = 值
  • 体验
haier1.width = 500
haier2.height = 800

1.2.2、类外面获取对象属性

  • 语法
对象名.属性名
  • 体验
print(f'haier洗⾐衣机的宽度是haier.width')
print(f'haier洗⾐衣机的⾼高度是haier.height')
  • 完整代码如下:
# 定义类
class Washer():
    def wash(self):
        print('能洗衣服')


# 创建对象 对象名 = 类名()
haier1 = Washer()
haier1.width = 500
haier1.heigh = 300

print(f'洗衣机的宽度是haier1.width') #洗衣机的宽度是500
print(f'洗衣机的高度是haier1.heigh') #洗衣机的高度是300

1.2.3、类里面获取对象属性

  • 语法
self.属性名
  • 体验
# 定义类
class Washer():
    def print_info(self):
    # 类里面获取对象属性
        print(f'haier1洗衣机的宽度是self.width')
        print(f'haier1洗衣机的⾼高度是self.height')

# 创建对象
haier1 = Washer()

# 添加实例属性
haier1.width = 500
haier1.height = 800

haier1.print_info()
# haier1洗衣机的宽度是500
# haier1洗衣机的⾼高度是800

1.3、魔法方法

在 Python 中 ,__xx__() 的函数叫做魔法方法,指的是具有特殊功能的函数

1.3.1、__init__()

思考:洗衣机的宽度高度是与生俱来的属性,可不可以在生产过程中就赋予这些属性呢?

答:理应如此

__init__方法的作用:初始化对象

# 定义类
class Washer():
    # 定义初始化功能的函数
    def __init__(self):
        #添加实例属性
        self.width = 500
        self.height = 800
    def print_info(self):
        #类里面调用实例属性
        print(f'洗衣机的宽度是self.width,高度是self.height')

# 创建对象
haier1 = Washer()
haier1.print_info() # 洗衣机的宽度是500,高度是800

注意:

  • __init__()方法,在创建一个对象时默认被调用,不需要手动调用
  • __init__(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递过去。

1.3.2、带参数的__init__()

思考:一个类可以创建多个对象,如何对不同的对象设置不同的初始化属性呢?

答案:传参数

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def print_info(self):
        print(f'洗衣机的宽度是self.width')
        print(f'洗衣机的⾼高度是self.height')

haier1 = Washer(10, 20)
haier1.print_info() # 洗衣机的宽度是10 洗衣机的⾼高度是20

haier2 = Washer(30, 40)
haier2.print_info() # # 洗衣机的宽度是30 洗衣机的⾼高度是40

1.3.3、__str__()

当使用 print 输出对象的时候,默认打印对象的内存地址。如果类定义了__str__方法,那么就会打印从在这个方法中 return 的数据。

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __str__(self):
        return '这是海尔洗衣机的说明书'


haier1 = Washer(10, 20)
# 这是海尔洗衣机的说明书
print(haier1)

1.3.4、__del__()

当删除对象时,python解释器也会默认调用 __del__()方法。

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __del__(self):
        print(f'self对象已经被删除')


haier1 = Washer(10, 20)
# <__main__.Washer object at 0x000001BDAD57F860>对象已经被删除
del haier1

1.4、总结

面向对象重要组成部分

    • 创建类
    class 类名():
        代码
    
    • 创建对象
    对象名 = 类名()
    
  • 添加对象属性

    • 类外面添加
    对象名.属性名 =
    • 类里面
    self.属性名 =
  • 获取对象属性

    • 类外面
    对象名.属性名
    
    • 类里面
    self.属性名
    
  • 魔法方法

    • __init__() 初始化

    • __str__() 输出对象信息

    • __del__() 删除对象时调用

2、面向对象-继承

2.1、继承的基本语法

# 父类
class Father(object):
    pass

# 子类,继承父类
class Son(Father):
    pass

在Python中,所有类默认继承object类,object类是顶级类或基类;其他子类叫做派生类。

2.2、继承相关概念

  • 继承:一个类从另一个已有的类获得其成员的相关特性,就叫作继承!
  • 派生:从一个已有的类产生一个新的类,称为派生!

很显然,继承和派生其实就是从不同的方向来描述的相同的概念而已,本质上是一样的!

  • 父类:也叫作基类,就是指已有被继承的类!
  • 子类:也叫作派生类或扩展类
  • 扩展:在子类中增加一些自己特有的特性,就叫作扩展,没有扩展,继承也就没有意义了!
  • 单继承:一个类只能继承自一个其他的类,不能继承多个类,单继承也是大多数面向对象语言的特性!
  • 多继承:一个类同时继承了多个父类, (C++、Python、Java等语言都支持多继承)[注意:当一个类有多个父类的时候,默认使用第一个父类的同名属性和方法]

Python中的继承指的是多个类之间的所属关系,即子类默认继承父类的所有属性和方法,如下:

# 父类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 子类B
class B(A):
    pass


result = B()
result.info_print() # 1

在python中,所有类默认基础object类,object类是顶级类或者基类,其他子类叫做派生类

2.3、单继承

单继承:一个类只能继承自一个其他的类,不能继承多个类。这个类会有具有父类的属性和方法。

例如:猫,狗 都属于动物,它们行为相似性高。都会吃、会睡

# 动物类
class Animal(object):
    def eat(self):
        print("吃...")
    def sleep(self):
        print("睡...")
    def call(self):
        print("叫...")
        
# 狗类
class Dog(Animal):
    pass

# 猫类
class Cat(Animal):
    pass

2.4、重写方法

重写也叫覆盖,就是当子类成员与父类成员名字相同的时候,从父类继承下来的成员会重新定义

子类重写父类同名方法和属性,上面的例子中Animal 的子类 Cat和Dog 继承了父类的属性和方法,但是我们狗类Dog 有自己的叫声’汪汪叫’,猫类 Cat 有自己的叫声 ‘喵喵叫’ ,这时我们需要对父类的 call() 方法进行重构:

class Animal(object):
    def eat(self):
        print("吃...")
    def sleep(self):
        print("睡...")
    def call(self):
        print("叫...")


class Dog(Animal):
    def call(self):
        print("汪汪叫...")

class Cat(Animal):
    def call(self):
        print("喵喵叫...")

# Dog实例对象
dog = Dog()
dog.call()  # 汪汪叫...

# Cat实例对象
cat = Cat()
cat.call()  # 喵喵叫...

子类和父类具有同名属性和方法,默认使用子类的同名属性和方法

思考:此时父类中的 call 方法还在不在?

答:还在,只不过是在其子类中找不到了。类方法的调用顺序,当我们在子类中重构父类的方法后,Cat 子类的实例先会在自己的类Cat中查找该方法,当找不到该方法时才会去父类Animal中查找对应的方法。

2.5、调用父类属性和方法

super():调用父类属性和方法,完整写法为:super(当前类名,self).属性或方法()

class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("吃...")
    def sleep(self):
        print("睡...")
    def call(self):
        print("叫...")


class Dog(Animal):
    def __init__(self,name,age,sex):
        # 调用父类的 init 方法
        # super(Dog,self).__init__(name,age)
        super().__init__(name,age)
        self.sex = sex


class Cat(Animal):
    def __init__(self,name,age,sex):
        # 调用父类的 init 方法
        # super(Cat,self).__init__(name,age)
        super().__init__(name,age)
        self.sex = sex

2.6、多继承

多继承:一个类同时继承了多个父类,并且同时具有所有父类的属性和方法例如:孩子会继承父亲 和 母亲的方法

class Father(object):
    pass

class Mother(object):
    pass

class Child(Father,Mother):
    pass

3、面向对象-多态

定义:多态是一种使用对象的方式,子类重写父类方法,调用不同子类对象的相同父类方法,可以产生不同的执行结果

  1. 多态依赖继承
  2. 子类方法必须要重写父类方法

3.1、多态的实现步骤

  1. 定义父类,并提供公共方法
  2. 定义子类,并重写父类方法
  3. 传递子类对象给调用者,可以看到不同子类执行效果不同

3.2、多态实现

类具有继承关系,并且子类类型可以向上转型可看做父类类型,如果我们从 Animal 派生出 Cat 和 Dog,并且都写了一个 call() 方法,如下示例:

# 动物类
class Animal(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def call(self):
        print(self.name,'会叫')

# 狗类继承动物类
class Dog(Animal):
    def __init__(self,name,age,sex):
        # 调用父类的 init 方法
        super(Dog,self).__init__(name,age)
        self.sex = sex
    def call(self):
        print(self.name,'会汪汪叫')

# 猫类继承动物类
class Cat(Animal):
    def __init__(self,name,age,sex):
        # 调用父类的 init 方法
        super(Cat,self).__init__(name,age)
        self.sex = sex

    def call(self):
        print(self.name,'会喵喵叫')


# 定义一个do函数
def do(all):
    all.call()

# 创建实例
A = Animal('动物',4)
C = Cat('猫',2,'男')
D = Dog('狗',2,'女')

for x in (A,C,D):
    do(x)
    '''
    动物 会叫
    猫 会喵喵叫
    狗 会汪汪叫
    '''

上述这种行为称为多态,也就是说,方法调用将作用在 all 的实际类型上。

  • C 是 Cat 类型,它实际上上拥有自己的 call() 方法以及从 Animal 继承的 call 方法,但调用 C.call() 总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。
  • 传递给函数 do(all) 的参数 all 不一定是 Animal 或 Animal 的子类型。任何数据类型的实例都可以,只要它有一个 call() 的方法即可。
  • 其他类不继承于 Animal,具备 call 方法也可以使用 do 函数。
  • 这就是动态语言,动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用。

再来看一个例子:

class Dog(object):
    # 父类提供统一的方法,哪怕是空方法
    def work(self):
        print("指哪打哪")

class ArmyDog(Dog):
    # 子类重写父类同名方法
    def work(self):
        print("追击敌人")


class DrugDog(Dog):
    # 子类重写父类同名方法
    def work(self):
        print("追查毒品")

class Person(object):
    def work_with_dog(self,dog):
        dog.work()

ad = ArmyDog()
dd = DrugDog()

police = Person()
police.work_with_dog(ad)    # 追击敌人
police.work_with_dog(dd)    # 追查毒品

def work_with_dog(self,dog): 传入不同的对象,执行不同的代码,即不同的work函数。

4、面向对象-其他特性

4.1、私有属性和私有方法

在Python中,可以为实例属性和方法设置私有权限,即设置某个实例属性或实例方法不继承给子类。

设置私有属性和私有方法的方式非常简单:在属性名和方法名前面加上两个下划线 "__" 即可。

class Girl():
    def __init__(self):
        self.name = '小美'
        self.age = 18

    def __showinfo(self):
        print(f'姓名:self.name,年龄:self.age')

girl = Girl()
print(girl.name)    # 小美
print(girl.age)     # 18

#外界不能直接访问私有属性和私有方法
girl.showinfo()  # 报错

4.2、私有属性和私有方法与继承的关系

私有属性和私有方法也不能被子类继承

class Cat(object):
    def __init__(self):
        self.name = '猫大师'
        self.kungfu = '闪、展、腾、挪'
        # 私有属性
        self.__skill = '爬树'

class Tiger(Cat):
    pass

tiger = Tiger()
tiger.name = '学徒虎'
print(f'tiger.name,功夫:tiger.kungfu') # 学徒虎,功夫:闪、展、腾、挪
print(f'tiger.__skill') # 报错,私有属性不能被子类继承

4.3、获取和设置私有属性值

在Python中,一般定义函数名 get_xx 用来获取私有属性,定义 set_xx 用来修改私有属性值

class Girl():
    def __init__(self):
        self.name = '小美'
        self.age = 18
    def get_age(self):
        return self.age
    def set_age(self,age):
        self.age = age


girl = Girl()
girl.set_age(19)
print(girl.get_age()) # 19

4.4、类属性和实例属性

4.4.1、类属性

类属性就是类对象中定义的属性,它是该类的所有实例对象所共有

class Tool(object):
    # 定义类属性,用于记录创建了多少个工具对象
    count = 0

4.4.2、类方法

类方法:类方法就是针对类对象定义的方法,在类方法中可以直接访问类属性或者调用其他类方法。

基本语法:

@classmethod
def 类名称(cls):
    pass
  • 类方法需要用修饰器 @classmethod 来标识,告诉解释器这是一个类方法,类方法的第一个参数是 cls

    • 有哪一个类调用的方法,方法内的 " cls " 就是哪一个类的引用
    • 这个参数和示例方法的第一个参数是 “self” 类似
    • 提示使用其他名称也可以,不过习惯使用 " cls " 通过类名.调用类方法,调用方法时,不需要传递" cls "参数
  • 在方法内部

    • 可以通过 cls. 访问类的属性
    • 也可以通过 cls. 调用其他的类方法
class Tool(object):
    # 定义类属性,用于记录创建了多少个对象
    count = 0

    def __init__(self, name):
        selfpython 面向对象总结

Python面向对象编程_类

从《Java核心编程》纵览Java全貌

面向对象总结

Python面向对象编程基础

python之基础篇——类与面向对象