学习 Python 之 面向对象

学习 Python 之 面向对象

• • python面向对象
  • • 1. 类的定义
    • 2. 类的实例化
    • 3. 调用类中的方法
    • 4. 使用类中的变量
    • 5. 类与对象
    • 6. 类的构造函数
    • 7. 类变量与实例变量
    • • `__dict__`
      • 变量的查找顺序
    • 8. 类中函数的第一个参数
    • 9. 类变量
    • 9. 类函数(类方法)
    • • (1). 定义
      • (2). 使用
    • 10. 静态方法
    • • (1). 定义
      • (2). 使用
    • 11. 访问修饰符
    • • (1). 私有变量
      • (2). 类外访问私有变量
    • 12. 继承
    • • (1). 变量和函数继承性
      • (2). 构造函数
      • (3). super()

python面向对象

类与对象, 类的最基本作用是封装

1. 类的定义

使用class关键字定义一个类

类中可以定义变量, 定义函数

学生类

class Student:
    name = ''
    age = 0
    
    def fun(self):
        pass

2. 类的实例化

class Student:
    name = ''
    age = 0
    
    def fun(self):
        pass
    
student = Student()

3. 调用类中的方法

类中方法的一个参数代表类本身, 它用来访问类中变量

class Student:
    name = ''
    age = 0
    
    def fun(self):
        print(self.name, self.age)
    
student = Student()
student.fun()

4. 使用类中的变量

使用.运算符

class Student:
    name = ''
    age = 0
    
    def fun(self):
        print(self.name, self.age)
    
student = Student()
print(student.name, student.age)

5. 类与对象

类是现实世界或思维世界中的实体在计算机中的反映, 它将数据以及这些数据上的操作封装在一起

类中的函数和变量称为数据成员

类的特征由成员变量表示, 类的行为由成员函数表示

6. 类的构造函数

构造函数用来初始化类中的变量, 构造函数的名字必须是__init__

def __init__(self):
        pass

当对象实例化时, 会自动调用构造函数, 不需要显式的调用

class Student:
    name = ''
    age = 0

    def fun(self):
        print(self.name, self.age)

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

student = Student('a', 10)
student.fun()

a 10

注意:

1. 构造函数只能返回None
2. 构造函数可以显式调用, 但是返回值是None
3. 定义了构造方法后, 如果构造方法需要传入参数, 创建对象时必须传入参数

7. 类变量与实例变量

类变量: 与类相关的变量

实例变量: 与对象相关的变量, 即对象可以访问的变量

学生类中, name和age是类变量
self.age, self.name是实例变量

class Student:
    name = ''
    age = 0

    def fun(self):
        print(self.name, self.age)

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

下面定义了两个个实例变量

student1 = Student('a', 10)
student2 = Student('b', 10)

注意打印结果

class Student:
    name = '默认名字'
    age = 0

    def fun(self):
        print(self.name, self.age)

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



student = Student('a', 10)
print(student.name)
print(Student.name)

a

默认名字

第一个输出的是对象的实例变量的值

第二个输出的是类的变量的值

__dict__

使用__dict__类变量查看对象的实例变量

class Student:
    name = '默认名字'
    age = 0

    def __init__(this, name, age):
        pass



student = Student('a', 10)
print(student.__dict__)

{}

这种情况下, student对象无实例变量, 下面这种情况是有实例变量的

class Student:
    name = '默认名字'
    age = 0

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


student = Student('a', 10)
print(student.__dict__)

{‘name’: ‘a’, ‘age’: 10}

使用__dict__类变量查看类变量

print(Student.__dict__)

{__module__: '__main__', 'name': '默认名字', 'age': 0, '__init__': , '__dict__': , '__weakref__': , '__doc__': None}

变量的查找顺序

当我们访问一个对象中的实例变量时, 首先会查找实例变量字典, 如果没有找到会查找类变量字典, 如果没有找到回到它的父类寻找

8. 类中函数的第一个参数

类中方法的一个参数代表类本身, 它用来访问类中变量, 必须要创建, 它代表当前这个对象

当调用类中的方法时, 不用传值

实例方法: 对象可以调用的方法, 第一个参数必须指定, 代表当前这个对象

9. 类变量

使用方式 类.变量名或 self.__class__.变量名

class Student:
    name = '默认名字'
    age = 0

    def __init__(this, name, age):
        this.name = name
        this.age = age
        Student.name = 5
        print('类中访问', this.__class__.name)
student = Student('a', 10)
print('类外访问', Student.name)

类中访问 5

类外访问 5

9. 类函数(类方法) (1). 定义

定义类方法, 使用@classmethod装饰器

类方法的第一个参数代表类本身

class Student:
    studentCount = 0

    @classmethod
    def fun(cls):
        cls.studentCount += 1
        print(cls.studentCount)

(2). 使用

Student.fun()

类方法关联类变量

实例方法关联实例变量

10. 静态方法 (1). 定义

定义类方法, 使用@staticmethod装饰器

class Student:
    studentCount = 0

    @staticmethod
    def fun(x):
        print(x)

静态方法第一个参数不代表类本身, 而是一个参数

(2). 使用

类和对象都可以调用静态方法

class Student:
    studentCount = 0

    @staticmethod
    def fun(x):
        print(x)

student = Student()
student.fun(2)
Student.fun(3)

静态方法可以使用类变量

11. 访问修饰符 (1). 私有变量

默认情况下, 定义的变量和函数可以在类外直接访问

使用__开头的且结尾不是以__结尾的变量或函数, 系统会认为是私有的, 不可以在类外直接访问

class Student:
    __studentCount = 2

    def __fun(self):
        print(self.__studentCount)

student = Student()
print(student.__studentCount)
student.__fun()

这样访问是错误的, 会报错

注意下面这种情况

class Student:
    __studentCount_ = 2

    def __fun(self):
        print(self.__studentCount_)

student = Student()
student.__studentCount_ = 5
print(student.__studentCount_)

结果

5

为什么这种情况可以直接访问呢?

因为student.__studentCount_ = 5语句动态为student对象添加了一个__studentCount_变量, 所以可以访问

查看一下, 改一下代码

class Student:
    __studentCount_ = 2

    def __fun(self):
        print(self.__studentCount_)

student = Student()
student.__studentCount = 5
print(student.__studentCount)
print(student.__dict__)

5

{‘__studentCount’: 5}

(2). 类外访问私有变量

最好不要这么做, 不然定义私有变量就无意义了

访问方法_类名 + 私用变量名

class Student:
    __v = '私有变量'

    def fun(self):
        print(self.__v)

student = Student()
print(student._Student__v)

结果

私有变量

12. 继承

python支持多继承, 即一个子类可以继承多个父类

语法:

class 类名(继承的类名):
    pass

class People:
    pass

class Student(People):
    pass

(1). 变量和函数继承性

子类继承父类的全部变量和函数

class People:

    __name = None

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

    def getName(self):
        return self.__name

class Student(People):
    pass

student = Student('张三')
print(student.getName())

(2). 构造函数

子类调用父类构造函数, 使用super()

class People:

    __name = None

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

    def getName(self):
        return self.__name

class Student(People):
    def __init__(self, school, name):
        self.__school = school
        super(Student, self).__init__(name)
        super().__init__(name)

    def getSchool(self):
        return self.__school

student = Student('张三', '光明小学')
print(student.getName(), student.getSchool())

结果

光明小学 张三

子类调用父类构造函数, 使用父类名.__init__(self, 参数)

class People:

    __name = None

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

    def getName(self):
        return self.__name

class Student(People):
    def __init__(self, school, name):
        self.__school = school
        People.__init__(self, name)

    def getSchool(self):
        return self.__school

(3). super()

super()表示父类引用

当父类和子类有同名函数时, 默认情况调用的是子类函数, 如果要调用父类的函数, 可以使用super()