【Python】从入门到上头—Python类和对象(4)

文章目录

  • 面向对象特性(了解即可)
  • 一.类和实例
    • 1.创建类语法
    • 2.类的属性 和 __init__方法
    • 3.类函数和普通函数的区别
    • 4.属性封装
  • 二.访问限制
  • 三.继承和多态
    • 1.继承
    • 2.多态
    • 3.多继承
    • 4.类的专有方法(初学者了解即可)

面向对象特性(了解即可)

  • 类(Class): 具有相同的属性和方法的对象的集合。对象是类的实例。

  • 方法:类中定义的函数。

  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

  • 局部变量:定义在方法中的变量,只作用于当前实例的类。

  • 实例变量:在类的声明中,属性是用变量来表示的,这种变量就称为实例变量,实例变量就是一个用 self 修饰的变量

  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例 如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。

  • 实例化:创建一个类的实例,类的具体对象。

  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

一.类和实例

1.创建类语法

class ClassName:
    <statement-1>
    <statement-N>

在Python中,定义类是通过class关键字:

  • 以Student类为例

    class Student(object):
        pass
    
  • class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类

如何实例对象

  • 定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的:

     stu = Student()
    

2.类的属性 和 __init__方法

  • 由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法,在创建实例的时候,就把name,score等属性绑上去:

    class Student(object):
    
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    • 注意:特殊方法“__init__”前后分别有两个下划线!!!

    • __init__方法第1个参数永远是self,表示创建的实例本身,因此,在__init__方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身

      • 有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去:
    bart = Student('Bart Simpson', 59)
    print(bart.name)
    print(bart.score)
    # Bart Simpson
    # 59
    

3.类函数和普通函数的区别

  • 只有一点不同,类函数第1个参数永远是实例变量self,并且,调用时不用传递该参数。除此之外和普通函数没有什么区别,所以仍然可以用默认参数、可变参数、关键字参数和命名关键字参数

4.属性封装

上面的Student类中,每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据,比如打印一个学生的成绩:

class Student(object):

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

    def print_score(self):
        print('%s: %s' % (self.name, self.score))
 bart = Student('Bart Simpson', 59)
 bart.print_score()
 #Bart Simpson: 59

二.访问限制

如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一改:

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__name和实例变量.__score了

 bart = Student('Bart Simpson', 59)
 bart.__name
 
#报错
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'Student' object has no attribute '__name'

是如果外部代码要获取name和score怎么办?可以给Student类增加get_name和get_score这样的方法:

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score
  • 需要注意的是,在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__、__score__的变量名。

    • 双下划线开头的实例变量是不是一定不能从外部访问呢?’
      • 其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量:
     bart._Student__name
     打印结果: 'Bart Simpson'
    
  • 但强烈建议不要这么干,因为不同版本的Python解释器可能会把__name改成不同的变量名

三.继承和多态

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

  • 继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。

1.继承

语法规则

  • 子类(派生类 DerivedClassName)会继承父类(基类 BaseClassName)的属性和方法。

    class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>
    
  • 比如,我们已经编写了一个名为Animal的class,有一个run()方法可以直接打印:

    class Animal(object):
        def run(self):
            print('Animal is running...')
    
  • 当我们需要编写Dog和Cat类时,就可以直接从Animal类继承

    class Dog(Animal):
        pass
    
    class Cat(Animal):
        pass
    
  • 对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。Cat和Dog类似。

继承有什么好处?

  • 最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法,因此,Dog和Cat作为它的子类,什么事也没干,就自动拥有了run()方法:

    dog = Dog()
    dog.run()
    
    cat = Cat()
    cat.run()
    
    • 运行结果
    Animal is running...
    Animal is running...
    

子类也可以有自己的一些方法,比如Dog类:

class Dog(Animal):

    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Eating meat...')

继承的第二个好处需要我们对代码做一点改进。你看到了,无论是Dog还是Cat,它们run()的时候,显示的都是Animal is running…,符合逻辑的做法是分别显示Dog is running…和Cat is running…,因此,对Dog和Cat类改进如下:

class Dog(Animal):

    def run(self):
        print('Dog is running...')

class Cat(Animal):

    def run(self):
        print('Cat is running...')

运行结果

Dog is running...
Cat is running...

2.多态

当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态。
- 当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样:

a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
  • 判断一个变量是否是某个类型可以用isinstance()判断:
isinstance(a, list)
#True
 isinstance(b, Animal)
#True
 isinstance(c, Dog)
#True

3.多继承

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

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    <statement-N>
  • 需要注意圆括号中父类的顺序,·若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时·,

4.类的专有方法(初学者了解即可)

  • 通过内置的一系列函数,我们可以对任意一个Python对象进行剖析,拿到其内部的数据。
__init__ : 构造函数,在生成对象时调用
__del__ : 析构函数,释放对象时使用
__repr__ : 打印,转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

你可能感兴趣的:(Python,python,开发语言,pyqt,dash,scikit-learn)