Python面向对象

根据不怕猫的耗子A的文章把Python的类回顾了一下。

# 类
# object-oriented programming
# 把对象作为程序的基本单元，一个对象包含数据和操作数据的函数

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

"""面向对象术语简介
1、类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

2、方法：类中定义的函数

3、类变量(属性)：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体(方法)之外。类变量通常不作为实例变量使用，类变量也称作属性

4、数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据

5、方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写

6、实例变量：定义在__init__方法中的变量，只作用于当前实例的类

7、继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待,以普通的类为基础建立专门的类对象

8、实例化：创建一个类的实例，类的具体对象。一个类可以实例化出无数个对象

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

10、多态：对不同类的对象使用同样的操作

11、封装：对外部世界隐藏对象的工作细节
"""

# 注：对象的特征称为“属性”，一个对象的行为称为“方法”，方法的调用需要绑定到特定的对象上（通过self.或实例对象名）

# class MyClass:
"""一个简单的实例"""
    # a_str = 'fudan university'  # 定义一个类属性

    # def f(self):  # 定义一个类方法，第一个参数必须是self， 除第一个参数外，类的方法和普通的函数差不多，且调用方法时都不用传递self，其他正常传入
    #     return '自由而无用'


# x = MyClass()
# 访问类的属性与方法：
# print("MyClass 类的属性 a_str 为：", x.a_str)  # 调用类的属性： 实例对象名.类属性名
# print("MyClass 类的属性 a_str 为：", MyClass.a_str)  # 调用类的属性： 类名.类属性名
# print("MyClass 类的方法 f 输出为：", x.f())  # 类外调用， 类方法中没有定义参数
# MyClass 类的属性 a_str 为： fudan university
# MyClass 类的属性 a_str 为： fudan university
# MyClass 类的方法 f 输出为： 自由而无用

'1. self:'
# self 代表的是当前的实例对象本身,在调用类方法时明确调用的是哪个实例对象


# class Ball:
#
#     def setname(self, name, age):
#         self.name = name
#         print(age)
#
#     def kick(self):
#         return "My name is %s" % self.name
#
#
# a = Ball()
# b = Ball()
# c = Ball()
#
# a.setname("A", 1)  # 调用时就不用传入self参数
# b.setname("B", 2)
# c.setname("C", 3)


# print(a.kick())
# print(b.kick())
# print(c.kick())

'----------------------------------------------------------'

'2. 类变量和实例变量：'
# 创建一个对象也叫作类的实例化
# 调用对象里的方法，就需要判断是在类中调用还是类外调用

# 类变量：是该类所有实例共享的属性和方法(也可以叫"类属性")。
# 类变量是直接定义在类中的，比如前例中a_str就是一个类属性，类中的所有方法、实例都可以使用它。

# 实例变量：是每个实例都独有的数据，实例变量通常是定义在 _init_ 方法中

'SUM:'  # 某个属性对于每个实例都是独有的，就需要将其定义为实例变量；某个属性是每个实例同共有的就可以定义为类属性


# class Student():
#     address = "China"  # 定义类变量
#
#     def __init__(self, name, age):  # 定义实例变量
#         self.name = name
#         self.age = age
#
#     def Info(self, score):  # 作用域在方法内
#         return "Student comes from %s, name is %s, age is %s, score is %s" % (Student.address, self.name, self.age, score)
#         类中访问实例变量：self.实例变量名
#         类中访问类变量：类名.类变量名
#         类中访问方法中的普通变量：直接变量名(且该变量只能在这个方法中使用，不能再其他方法或类外调用)


# student_1 = Student("Bob", 20)
# print(student_1.address, student_1.name, student_1.age)
# print(student_1.Info(98))

# 1、在Student类中，类属性address为所有实例所共享；实例属性name和age每个student的实例独有(每个实例有不同的name和age)
# ⑴类属性：实例对象student和student_1拥有一样的address属性
# ⑵实例属性：实例对象student和student_1拥有不一样的name和age属性(每个实例独有的属性)
# 2、调用类属性：
# ⑴类中访问类变量：类名. 类属性名
# ⑵类外访问类变量：类名.类属性名或实例名.类属性名
# 3、调用实例属性：
# ⑴类中访问实例变量：self.实例变量名
# ⑵类外访问实例变量：实例名.实例属性名
# 4、调用类方法：
# ⑴类中访问类方法：self.方法名(参数)或类名.方法名(self,参数)，这个例子中未涉及到
# ⑵类外访问类方法：实例名.方法名(参数)
# 5、类变量直接定义在类中，实例变量需要定义在__init__方法中
# ⑴定义类变量：类变量直接写就好了，定义一个变量然后赋值，相当于定义一个普通的变量
# ⑵定义实例变量：需要使用self来将变量绑定到实例上。self.name = name，表示将外部传来的参数name的值赋值给Student当前实例对象自己的实例变量name
# ⑶因为实例属性是每个实例独有的，而self表示实例对象本身，因此就需要将变量用self绑定到每个实例
# 6、类中存在__init__方法时，在实例化类时需要传入参数(实例变量的实参)，在调用类的方法时也需要传入方法的实参(方法中存在形参时)

'----------------------------------------------------------'

'3. 类对象和实例对象：'

# 类对象仅支持两个操作
#     实例化：使用instance_name = class_name()的方式实例化，实例化操作创建该类的实例
#     属性引用：使用class_name.attr_name的方式引用类属性。(类名.属性名)

# 实例对象
#     实例对象是类对象实例化的产物，实例对象仅支持一个操作：属性引用
#     属性引用：与类对象属性引用的方式类似，使用instance_name.attr_name的方式。(实例对象名.属性名)

'类属性绑定'
# 发生在：
# （1）类定义时
# （2）运行时任意阶段
# class Dog:
#
#     kind = 'canine'
#
# Dog.country = 'China'
#
# print(Dog.kind, ' - ', Dog.country)  # 输出: canine - China
# del Dog.kind
# print(Dog.kind, ' - ', Dog.country)  # 由于上一行删除的kind属性，因此输出为AttributeError: type object 'Dog' has no attribute 'kind'

'实例属性绑定'
# 发生在：
# （1）类定义时
# （2）运行时任意阶段


# class Dog:
#
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#
# dog = Dog('Lily', 3)
# dog.fur_color = 'red'  # 为实例对象dog增加一个fur_color属性
#
# print('%s is %s years old, it has %s fur' % (dog.name, dog.age, dog.fur_color))

# 1、语句self.name = name，self.age = age以及后面的语句dog.fur_color = 'red'为实例dog增加三个属性name, age, fur_color。
# 2、Python类实例有两个特殊之处：
# ⑴__init__在实例化时执行
# ⑵Python实例对象调用方法时，会将实例对象作为第一个参数传递因此，__init__方法中的self就是实例对象本身，这里是dog

'----------------------------------------------------------'

'4. 属性引用：'

'类属性引用'
# 类属性的引用，肯定是需要类对象的，属性分为两种：数据属性、函数属性。只是通常很少有引用类函数属性的需求


# class Dog:
#     kind = 'canine'
#
#     def tell_kind(self):
#         print(Dog.kind)
#
#     def info(self):
#         return self.tell_kind()  # 类中调用类方法
#
#
# dog = Dog()
# dog.tell_kind()  # Output: canine
# dog.info()  # Output: canine

'实例属性引用'
# ⑴总是先到实例对象中查找属性，再到类属性中查找属性
# ⑵属性绑定语句总是为实例对象创建新属性，属性存在时，更新属性指向的对象


# class Dog:
#     kind = 'canine'
#     country = 'China'
#
#     def __init__(self, name, age, country):
#         self.name = name
#         self.age = age
#         self.country = country
#
#
# dog = Dog('Lily', 3, 'Britain')
# print(dog.name, dog.age, dog.kind, dog.country)  # output:Lily 3 canine Britain
# print(dog.__dict__)
#
# dog.kind = 'feline'
# print(dog.name, dog.age, dog.kind, dog.country)  # output:Lily 3 feline Britain
# print(dog.__dict__)
# print(Dog.kind)  # canine

# 类对象Dog与实例对象dog均有属性country，按照规则，dog.country会引用到实例对象的属性；但实例对象dog没有属性kind，按照规则会引用类对象的属性。
# 使用属性绑定语句dog.kind = 'feline'，按照规则，为实例对象dog增加了属性kind，后面使用dog.kind引用到实例对象的属性。这里不要以为会改变类属性Dog.kind的指向，实则是为实例对象新增属性，可以使用查看__dict__的方式证明这一点。

'可变类属性引用'

'----------------------------------------------------------'

'5. 类、类对象、实例对象'


# class C:
#     count = 0
#
#
# a = C()
# b = C()
# c = C()
# print(a.count, b.count, c.count)  # output:0,0,0
#
# a.count += 10  # 实例对象调用类属性
# print(a.count, b.count, c.count)  # output:10,0,0
#
# C.count += 100  # 类对象调用类属性
# print(a.count, b.count, c.count)  # output:10 100 100

# print(count)  #name 'count' is not defined，不能直接访问类属性，具体访问方法参考前面的属性访问

# 找属性的顺序为：现在当前实例中找，有就用当前实例中的，如果没有就找类中的
# 类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象

'----------------------------------------------------------'

'6. Python中的self参数'


# class Student(object):
#     def __init__(self, name_name):
#         name_name相当于是占位的形参，只是方便外部向类中传递参数(给实例变量传递值)，没有什么实际意义
        # self.name = name_name
#
#
# student = Student('Bob')
# print(student.name)

# 有了__init__方法，在创建实例的时候(类实例化)，就不能传入空的参数了，必须传入与__init__方法匹配的参数
# self就是指类实例本身，self.name就是当前student实例对象的name属性，是该student实例对象独有的


# class CC:
#
#     def setXY(self, x, y):
#         self.x = x
#         self.y = y
#
#     def printXY(self):
#         print(self.x, self.y)
#
#
# dd = CC()
# dd.setXY(4, 5)
# dd.printXY()

再次感谢 不怕猫的耗子A 的文章。
原文链接：https://blog.youkuaiyun.com/qq_39314932/article/details/80716295