python 学习7 类、对象与魔法方法

面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭，很多初学者会因无法理解面向对象而放弃学习编程。
面向对象编程（Object-oriented Programming，简称 OOP），是一种封装代码的方法。
代码封装，其实就是隐藏实现功能的具体代码，仅留给用户使用的接口，就好像使用计算机，用户只需要使用键盘、鼠标就可以实现一些功能，而根本不需要知道其内部是如何工作的。

一、基本概念

类：可以理解是一个模板，通过它可以创建出无数个具体实例。
对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。
属性：类中的所有变量称为属性。
方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数。类方法无法单独使用，只能和类的对象一起使用。
创建一个新对象的过程叫做实例化（instantiation），这个新对象叫做这个类的一个实例（instance）。

1.定义类

使用关键字 class 定义 Python 类，关键字后面紧跟类的名称、分号和类的实现。

class 类名：
    多个（≥0）类属性...
    多个（≥0）类方法...

2.init()类构造方法（魔法方法）

在创建类时，可以手动添加一个 init() 方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）。

构造方法用于创建对象时使用，每当创建一个类的实例对象时，Python 解释器都会自动调用它。Python 类中，手动添加构造方法的语法格式如下：

def __init__(self,...):
    代码块

开头和结尾各有 2 个下划线，中间不能有空格。
init() 方法可以包含多个参数，但必须包含一个名为 self 的参数，且必须作为第一个参数。
类的构造方法最少也要有一个 self 参数。

self 参数的具体作用：
把类比作造房子的图纸，那么类实例化后的对象是真正可以住的房子。
根据一张图纸（类），我们可以设计出成千上万的房子（类对象），每个房子长相都是类似的（都有相同的类变量和类方法），但它们都有各自的主人，通过 self 参数对它们进行区分，它就相当于每个房子的门钥匙，可以保证每个房子的主人仅能进入自己的房子（每个类对象只能调用自己的类变量和类方法）。
Python 类方法中的 self 参数相当于 C++ 中的 this 指针。

同一个类可以产生多个对象，当某个对象调用类方法时，该对象会把自身的引用作为第一个参数自动传给该方法，换句话说，Python 会自动绑定类方法的第一个参数指向调用该方法的对象。如此，Python解释器就能知道到底要操作哪个对象的方法了。

class TheFirstDemo:
    '''这是一个学习Python定义的第一个类'''
    #构造方法
    def __init__(self):
        print("调用构造方法")
    # 下面定义了一个类属性
    add = 'http://c.biancheng.net'
    # 下面定义了一个say方法
    def say(self, content):
        print(content)

即便不手动为类添加任何构造方法，Python 也会自动为类添加一个仅包含 self 参数的构造方法。
仅包含 self 参数的 init() 构造方法，又称为类的默认构造方法。

3.对象

创建类对象的过程，又称为类的实例化。
定义的类只有进行实例化，也就是使用该类创建对象之后，才能得到利用。
实例化后的类对象可以执行以下操作：
访问或修改类对象具有的实例变量，甚至可以添加新的实例变量或者删除已有的实例变量；
调用类对象的方法，包括调用现有的方法，以及给类对象动态添加方法。

# 类对象
class A(object):
    pass

实例对象：就是通过实例化类创建的对象，称为实例对象，实例对象可以有多个。

# 实例化对象 a、b、c都属于实例对象。
a = A()
b = A()
c = A()

4.属性

类属性：类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性，说白了就是类属性所有的通过该类实例化的对象都能共享。

class A():
    a = 0  # 类属性

    def __init__(self, xx):
        # 使用类属性可以通过 （类名.类属性）调用。
        A.a = xx

实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的，说白了实例属性只能在自己的对象里面使用，其他的对象不能直接使用，因为self是谁调用，它的值就属于该对象。

class 类名():
    __init__(self)：
        self.name = xx #实例属性

类属性和实例属性区别
类属性：类外面，可以通过实例对象.类属性和类名.类属性进行调用。类里面，通过self.类属性和类名.类属性进行调用。
实例属性 ：类外面，可以通过实例对象.实例属性调用。类里面，通过self.实例属性调用。
实例属性就相当于局部变量。出了这个类或者这个类的实例对象，就没有作用了。
类属性就相当于类里面的全局变量，可以和这个类的所有实例对象共享。
类对象访问变量或方法
使用已创建好的类对象访问类中实例变量的语法格式如下：

类对象名.变量名

使用类对象调用类中方法的语法格式如下：

对象名.方法名(参数)

注意，对象名和变量名以及方法名之间用点 “.” 连接。

# 创建类对象
class Test(object):
    class_attr = 100  # 类属性

    def __init__(self):
        self.sl_attr = 100  # 实例属性

    def func(self):
        print('类对象.类属性的值:', Test.class_attr)  # 调用类属性
        print('self.类属性的值', self.class_attr)  # 相当于把类属性 变成实例属性
        print('self.实例属性的值', self.sl_attr)  # 调用实例属性


a = Test()
a.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

b = Test()
b.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

a.class_attr = 200
a.sl_attr = 200
a.func()
# 类对象.类属性的值: 100
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 100
# self.类属性的值 100
# self.实例属性的值 100

Test.class_attr = 300
a.func()
# 类对象.类属性的值: 300
# self.类属性的值 200
# self.实例属性的值 200

b.func()
# 类对象.类属性的值: 300
# self.类属性的值 300
# self.实例属性的值 100

注意：属性与方法名相同，属性会覆盖方法。

class A:
    def x(self):
        print('x_man')
aa = A()
aa.x()  # x_man
aa.x = 1
print(aa.x)  # 1
aa.x()
# TypeError: 'int' object is not callable

给类对象动态添加/删除变量

aa.c= 159.9
print(aa.c)
运行结果为：
159.9

直接增加一个新的实例变量并为其赋值，可为对象添加一个变量。

使用 del 语句实现动态删除变量

del aa.c
print(aa.c)
运行程序会发现，结果显示 AttributeError 错误：
AttributeError: 'A' object has no attribute 'c'

class Coordinate:
    x = 10
    y = -5
    z = 0


point1 = Coordinate()

print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5
print('z = ', point1.z)  # z =  0
delattr(Coordinate, 'z')
print('--删除 z 属性后--')  # --删除 z 属性后--
print('x = ', point1.x)  # x =  10
print('y = ', point1.y)  # y =  -5
# 触发错误
print('z = ', point1.z)
# AttributeError: 'Coordinate' object has no attribute 'z'

5.魔法方法（内置类属性）

描述符（魔法方法）就是一个类，只不过它定义了另一个类中属性的访问方式。换句话说，一个类可以将属性管理全权委托给描述符类。
https://fishc.com.cn/forum.php?mod=viewthread&tid=48793&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403


http://c.biancheng.net/python/special_member/

6.方法

和类属性一样，类方法也可以进行更细致的划分，具体可分为类方法、实例方法和静态方法。
采用 @classmethod 修饰的方法为类方法；采用 @staticmethod 修饰的方法为静态方法；不用任何修改的方法为实例方法。
Python 中允许使用类名直接调用实例方法，但必须手动为该方法的第一个 self 参数传递参数，这种调用方法的方式被称为“非绑定方法”。
用类的实例对象访问类成员的方式称为绑定方法，而用类名调用类成员的方式称为非绑定方法。

7.封装

大多数面向对象编程语言（诸如 C++、Java 等）都具备 3 个典型特征，即封装、继承和多态，Python也不例外。
封装（Encapsulation），即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。
类为什么要进行封装？
封装机制保证了类内部数据结构的完整性，因为使用类的用户无法直接看到类中的数据结构，只能使用类允许公开的数据，很好地避免了外部对内部数据的影响，提高了程序的可维护性。

Python 类中的变量和函数，不是公有的（类似 public 属性），就是私有的（类似 private）：
public：公有属性的类变量和类函数，在类的外部、类内部以及子类中，都可以正常访问；
private：私有属性的类变量和类函数，只能在本类内部使用，类的外部以及子类都无法使用。如果类中的变量和函数，其名称以双下划线“__”开头，则该变量（函数）为私有变量（私有函数），其属性等同于 private。以单下划线“_”开头的类属性或者类方法（例如 _name、_display(self)），通常被视为私有属性和私有方法。

【例子】类的私有属性实例

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)


counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2

print(counter._JustCounter__secretCount)  # 2 Python的私有为伪私有
print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'
【例子】类的私有方法实例

class Site:
    def __init__(self, name, url):
        self.name = name  # public
        self.__url = url  # private

    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)

    def __foo(self):  # 私有方法
        print('这是私有方法')

    def foo(self):  # 公共方法
        print('这是公共方法')
        self.__foo()


x = Site('老马的程序人生', 'https://blog.csdn.net/LSGO_MYP')
x.who()
# name  :  老马的程序人生
# url :  https://blog.csdn.net/LSGO_MYP

x.foo()
# 这是公共方法
# 这是私有方法

x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'

8.继承

继承机制经常用于创建和现有类功能类似的新类，又或是新类只需要在现有类基础上添加一些成员（属性和方法），但又不想直接将现有类代码复制给新类。也就是说，通过使用继承这种机制，可以轻松实现类的重复使用。

实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。
子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。语法格式如下：

class 类名(父类1, 父类2, ...)：
    #类定义部分

如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。
Python 的继承是多继承机制（和 C++ 一样），即一个子类可以同时拥有多个直接父类。根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。

“派生”和继承是一个意思，只是观察角度不同而已。继承是相对子类来说的，即子类继承自父类；而派生是相对于父类来说的，即父类派生出子类。

【例子】如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。

# 类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
# 小马的程序人生 说: 我 10 岁了，我在读 3 年级

注意：如果上面的程序去掉：people.init(self, n, a, w)，则输出： 说: 我 0 岁了，我在读 3 年级，因为子类的构造方法把父类的构造方法覆盖了。

【例子】

import random

class Fish:
    def __init__(self):
        self.x = random.randint(0, 10)
        self.y = random.randint(0, 10)

    def move(self):
        self.x -= 1
        print("我的位置", self.x, self.y)


class GoldFish(Fish):  # 金鱼
    pass


class Carp(Fish):  # 鲤鱼
    pass


class Salmon(Fish):  # 三文鱼
    pass


class Shark(Fish):  # 鲨鱼
    def __init__(self):
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True

g = GoldFish()
g.move()  # 我的位置 9 4
s = Shark()
s.eat() # 吃货的梦想就是天天有得吃！
s.move()  
# AttributeError: 'Shark' object has no attribute 'x'

9.重用

子类继承了父类，那么子类就拥有了父类所有的类属性和类方法。通常情况下，子类会扩展一些新的类属性和类方法。

当子类从父类继承得来的类方法中，但有个别的类方法，并不能直接照搬父类的，如果不对这部分类方法进行修改，子类对象无法使用。针对这种情况，就需要在子类中重复父类的方法。

举个例子，鸟通常是有翅膀的，也会飞，因此我们可以像如下这样定义个和鸟相关的类：
class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
但是，对于鸵鸟来说，它虽然也属于鸟类，也有翅膀，但是它只会奔跑，并不会飞。针对这种情况，可以这样定义鸵鸟类：
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")
class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
#调用 Ostrich 类中重写的 fly() 类方法
ostrich.fly()
运行结果为：
鸵鸟不会飞

二、练习题：

1、以下类定义中哪些是类属性，哪些是实例属性？

class C:
num = 0
def init(self):
self.x = 4
self.y = 5
C.count = 6
2、怎么定义私有⽅法？

3、尝试执行以下代码，并解释错误原因：

class C:
def myFun():
print(‘Hello!’)
c = C()
c.myFun()
4、按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价。

要求:

平日票价100元
周末票价为平日的120%
儿童票半价
class Ticket():
# your code here

5、上面提到了许多魔法方法，如__new__,init, str,rstr,getitem,__setitem__等等，请总结它们各自的使用方法。

6、利用python做一个简单的定时器类

要求:

定制一个计时器的类。
start和stop方法代表启动计时和停止计时。
假设计时器对象t1，print(t1)和直接调用t1均显示结果。
当计时器未启动或已经停止计时时，调用stop方法会给予温馨的提示。
两个计时器对象可以进行相加：t1+t2。
只能使用提供的有限资源完成。