Python基础刻意练习——Day13&14:类与对象

深碍√TFBOYSˉ_ 2023-06-11 13:28 17阅读 0赞

[Day1:变量、运算符与数据类型][Day1]  
[Day2:条件与循环][Day2]  
[Day3&4:列表与元组][Day3_4]  
[Day5:字符串与序列][Day5]  
[Day6&7:函数与Lambda表达式][Day6_7_Lambda]  
[Day8:字典与集合][Day8]  
[Day9&10:文件与文件系统][Day9_10]  
[Day11:异常处理][Day11]  
[Day12:else 与 with 语句][Day12_else _ with]  
Day13&14:类与对象——>本文  
[Day15&16:魔法方法][Day15_16]  
[Day17:模块][Day17]  
面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

# 一.基本定义 #

*  类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
 *  方法：类中定义的函数。
 *  类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
 *  数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
 *  方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
 *  局部变量：定义在方法中的变量，只作用于当前实例的类。
 *  实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
 *  继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
 *  实例化：创建一个类的实例，类的具体对象。
 *  对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

# 二.类和实例 #

## 1.类的定义 ##

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。  
类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类**继承**下来的，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

*  通过class关键字定义类：

class Student(object):
        pass

## 2.类的实例 ##

定义好了Student类，就可以根据Student类创建出Student的实例

*  创建实例是通过类名+()实现的：

Stu1=Student()
    print(type(Stu1))
    #<class '__main__.Student'>

## 3.类的属性 ##

类对象支持两种操作：属性引用和实例化。可以用这两种方法修改其属性

## 1.属性引用 ##

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

class Student():
        Name='?'
    Stu1=Student()
    Stu1.Name='Lisa'
    print(Stu1.Name)
    #Lisa

## 2.实例化 ##

类对象创建后，类命名空间中所有的命名都是有效属性名。  
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性变量强制填写进去。

*  类有一个名为 **init**() 的特殊方法（构造方法），该方法在类实例化时会自动调用，可以把类的属性直接写入这个函数
 *  **init**()中的第一个参数永远是self，表示创建的实例本身，因此，在\_\_init\_\_方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身，相当于C++中的this

class Student(object):
        def __init__(self,Name,Sex,Score=60):	#仍可以设定默认参数
            self.name=Name			
            self.sex=Sex
            self.score=Score
    
    Stu1=Student('Lisa','F')
    print(Stu1.name,Stu1.sex,Stu1.score)
    #Lisa F 60

*  另外，要想实现类中函数或变量的私有，只需要在前面加上"\_\_"(双下划线)如下例：

class Student(object):
        def __init__(self,Name,Sex,Score=60):
            self.name=Name
            self.sex=Sex
            self.__score=Score
    	def printscore(self):
            print(self.__score)
    Stu1=Student('Lisa','F',99)
    
    print(Stu1.__score)
    #'Student' object has no attribute '__score'
    
    print(Stu1.score)
    #'Student' object has no attribute 'score'
    
    Stu1.printscore()	#只能通过内部定义方法读取
    #99

*  如果又要允许外部代码修改score可以再给Student类增加set\_score方法(方法名字可以改),这样可以对参数做检查，避免传入无效的参数：

def set_score(self,Score):
            if Score>100 or Score<0:
                print('输入成绩有误')
            else:
                self.__score=Score

双下划线开头的实例变量是不是一定不能从外部访问呢？  
其实也不是。  
不能直接访问\_\_name是因为Python解释器对外把\_\_name变量改成了\_Student\_\_name，所以，仍然可能可以通过\_Student\_\_name来访问\_\_name变量  
但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把\_\_name改成不同的变量名。比如我的用这个名字就不能访问

# 三、类的继承 #

## 1.继承与多态 ##

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）

我们先编写了一个名为Animal的class，里面有个eat()方法：

class Animal(self):
        def eat(self):
            print('Animal is eating...')

如果再编写Dog对Animal类进行继承,便可直接继承Animal类中的方法：

class Dog(Animal):
        pass
    Dog.eat()
    #Animal is eating...

但是，当子类和父类都存在同名的方法(属性同理)时，子类的方法会覆盖父类的方法，在代码运行的时候，总是会调用子类的方法。  
这样，我们就获得了继承的另一个好处：多态。

class Animal():
        def eat(self):
            print('Animal is eating...')
    
    class Dog(Animal):
        def eat(self):
            print('Dog is eating...')
    
    class Cat(Animal):
        def eat(self):
            print('Cat is eating...')
    
    D=Dog()
    C=Cat()
    D.eat()
    #Dog is eating...
    C.eat()
    #Cat is eating...

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。  
判断一个变量是否是某个类型可以用isinstance()判断：

D=Dog()
    print(isinstance(D, Dog),isinstance(D,Animal))
    #True True

我们会发现D作为Dog类的实例化对象，既是Dog类型的，也是Animal类型的。  
所以，在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来就不行：

A=Animal()
    print(isinstance(A, Dog))
    #False

## 2.super函数 ##

另外，在使用继承和多态的同时还要避免一类情况：  
那就是，在需要使用父类的方法时，将这个方法所需的参数覆盖掉了。  
其中最典型的一种就是子类重写了\_\_init\_\_（）方法覆盖掉了父类的\_\_init\_\_（）方法，导致其中属性都没能被继承，如下例：

class Animal():
        def __init__(self):
            self.food='meat'
        def eat(self):
            print('Animal is eating',self.food)
    
    class Dog(Animal):
        pass
    
    class Cat(Animal):
        def __init__(self):
            self.name='kiki'
    
    D=Dog()
    D.eat()
    #Animal is eating meat 没问题
    C=Cat()
    C.eat()
    #发生异常: AttributeError
    #'Cat' object has no attribute 'food' 找不到相关属性

不过这一情况有两种解决办法：

*  一是调用未绑定的父类方法

class Cat(Animal):
        def __init__(self):
            Animal.__init__(self)
            self.name='kiki'
    C=Cat()
    C.eat()
    #Animal is eating meat

*  二是使用super()函数,可以直接找到基类方法  
    （注意这个\_\_init\_\_（）括号内没有self）

class Cat(Animal):
        def __init__(self):
            super().__init__()
            self.name='kiki'
    C=Cat()
    C.eat()
    #Animal is eating meat

## 3.多继承 ##

Python同样有限的支持多继承形式。多继承的类定义形式如下例:

class Child(Mom,Dad,Grandpa,Grandma):
    	pass

# 四.组合 #

想将将两个类放入一个类中使用，但又不想用继承，就可以把他们组合起来，如下例：

class Dog(Animal):
        def __init__(self,Num):
            self.num=Num
    
    class Cat(Animal):
        def __init__(self,Num):
            self.num=Num
    
    class Park():
        def __init__(self,d,c):
            self.dog=Dog(d)
            self.cat=Cat(c)
        def print_num(self):
            print('There are %d dogs and %d cats in the park.'%(self.dog.num,self.cat.num))
    
    P=Park(5,9)
    P.print_num()
    #There are 5 dogs and 9 cats in the park.

# 五.绑定 #

python方法严格要求需要有实例才能被调用，这种限制就是所谓的绑定概念，通过下例来理解:

class A():
        def __init__(self,Num):
            self.num=Num
        def printnum(self):
            print(self.num)
    
    myA=A(5)				#用A实例化myA
    myA.printnum()
    #5 实例化成功，值为5存入myA
    
    del A					#删除类A
    myA2=A()
    #发生异常: NameError 无法实例化 
    #name 'A' is not defined
    
    myA.printnum()			#尝试调用方法再次输出myA中的值
    #5 没有异常

这说明类实例化后，相关方法和属性已经变为静态变量绑定在myA上，删除类也没有影响  
用一个通俗的例子来理解（[弹幕][Link 1]上看到的）：  
我们拿图纸A去建了一个房子myA，建好了以后把图纸撕了，但是房子并不会倒塌，门和窗当然也不会被破坏。

# 六、获取对象信息 #

除了isinstance()，还有一些函数可以获取对象的信息

*  type() 判断对象类型  
    之前用过，不举例了
 *  dir() 获得一个对象的所有属性和方法(包括魔法方法)

class A():
        def __init__(self,Num):
            self.num=Num
        def printnum(self):
            print(self.num)
    
    myA=A(5)
    print(dir(myA))
    #['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'num', 'printnum']

*  hasattr(obj, ‘x’) 检测对象是否有属性’x’  
    注意属性名为字符串形式

print(hasattr(myA,'num'))
    #True

*  setattr(obj, ‘y’, 19) 设置一个属性’y’
 *  getattr(obj, ‘y’) 获取属性’y’  
    可以传入一个default参数，如果属性不存在，就返回默认值：

myA=A(5)
    print(getattr(myA,'abc','no_def'))
    #no_def

[Day1]: https://blog.csdn.net/nanashi_F/article/details/102576036
[Day2]: https://blog.csdn.net/nanashi_F/article/details/102576205
[Day3_4]: https://blog.csdn.net/nanashi_F/article/details/102576336
[Day5]: https://blog.csdn.net/nanashi_F/article/details/102576606
[Day6_7_Lambda]: https://blog.csdn.net/nanashi_F/article/details/102728193
[Day8]: https://blog.csdn.net/nanashi_F/article/details/102738525
[Day9_10]: https://blog.csdn.net/nanashi_F/article/details/102746726
[Day11]: https://blog.csdn.net/nanashi_F/article/details/102788316
[Day12_else _ with]: https://blog.csdn.net/nanashi_F/article/details/102763810
[Day15_16]: https://blog.csdn.net/nanashi_F/article/details/102870209
[Day17]: https://blog.csdn.net/nanashi_F/article/details/102873502
[Link 1]: https://www.bilibili.com/video/av4050443?p=40