datawhale组队学习——Python基础——类与对象、魔法方法

下内容来自datawhale组队学习——Python基础，供自己学习记录，转载还请附上博客链接！

类与对象

知识点

1. 对象 = 属性 + 方法

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

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

名称	含义
封装	信息隐蔽技术
继承	子类自动共享父类之间数据和方法的机制
多态	不同对象对同一方法响应不同的行动

2. self 是什么？

个人感觉在学习资料中没有将self讲得很明白，于是上网搜索资料，下面这两篇博客讲得很好，将类的属性、类实例的属性、局部变量都讲清楚了。
python中的self
一篇文章让你彻底搞清楚Python中self的含义
其中关键的一点就是 self代表类的实例，而非类。

3. Python 的魔法方法

魔法方法和self的区别:

如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，而这一切都是自动发生的…
类有一个名为__init__(self[, param1, param2…])的魔法方法，该方法在类实例化时会自动调用。

未使用魔法方法：

class Ball:
    def setName(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)


a = Ball()
a.setName("球A")
b = Ball()
b.setName("球B")
c = Ball()
c.setName("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

使用魔法方法：

class Ball:
    def __init__(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)


a = Ball("球A")
b = Ball("球B")
c = Ball("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

4. 公有和私有

私有方法只能间接调用，公有方法可以直接调用。

在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会为私有的了。

私有方法好理解一些：

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'

私有属性（没太看明白）：

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'
#因为————secretCount是私有变量，所以直接调用就会出错，只能像上一个print那样调用

5. 继承

6. 组合

例子中并没有讲清楚组合的意思。

7. 类、类对象和实例对象

类对象：创建一个类，其实也是一个对象也在内存开辟了一块空间，称为类对象，类对象只有一个。

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

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

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

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

类属性和实例属性区别

类属性：类外面，可以通过实例对象.类属性和类名.类属性进行调用。类里面，通过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

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

8. 什么是绑定？

Python 严格要求方法需要有实例才能被调用，这种限制其实就是 Python 所谓的绑定概念。

Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

9. 一些相关的内置函数（BIF）

①issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
②一个类被认为是其自身的子类。
③classinfo可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回True。

①isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。
②type()不会认为子类是一种父类类型，不考虑继承关系。
③isinstance()会认为子类是一种父类类型，考虑继承关系。
④如果第一个参数不是对象，则永远返回False。
⑤如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。

hasattr(object, name)用于判断对象是否包含对应的属性。

getattr(object, name[, default])用于返回一个对象属性值。

class A(object):
    bar = 1


a = A()
print(getattr(a, 'bar'))  # 1
print(getattr(a, 'bar2', 3))  # 3   
#不懂上面这句是什么意思
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'

setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

delattr(object, name)用于删除属性。

class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值。
fget – 获取属性值的函数
fset – 设置属性值的函数
fdel – 删除属性值函数
doc – 属性描述信息

练习题

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

魔法方法

魔法方法总是被双下划线包围，例如__init__。

魔法方法是面向对象的 Python 的一切，如果你不知道魔法方法，说明你还没能意识到面向对象的 Python 的强大。

魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用。

魔法方法的第一个参数应为cls（类方法） 或者self（实例方法）。

cls：代表一个类的名称
self：代表一个实例对象的名称

知识点

1. 基本的魔法方法

若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行，将没有__init__被调用。

__new__方法主要是当你继承一些不可变的 class 时（比如int, str, tuple）， 提供给你一个自定义这些类的实例化过程的途径。

del(self) 析构器，当一个对象将要被系统回收之时调用的方法。

str(self):

当你打印一个对象的时候，触发__str__
当你使用%s格式化的时候，触发__str__
str强转数据类型的时候，触发__str__
repr(self)：

repr是str的备胎
有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__
repr(obj)内置函数对应的结果是__repr__的返回值
当你使用%r格式化的时候 触发__repr__

str(self) 的返回结果可读性强。也就是说，str 的意义是得到便于人们阅读的信息，就像下面的 ‘2019-10-11’ 一样。

repr(self) 的返回结果应更准确。怎么说，repr 存在的目的在于调试，便于开发者使用。

2. 算术运算符

mul(self, other)定义乘法的行为：*
truediv(self, other)定义真除法的行为：/
floordiv(self, other)定义整数除法的行为：//
mod(self, other) 定义取模算法的行为：%
divmod(self, other)定义当被 divmod() 调用时的行为
divmod(a, b)把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

pow(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
lshift(self, other)定义按位左移位的行为：<<
rshift(self, other)定义按位右移位的行为：>>
and(self, other)定义按位与操作的行为：&
xor(self, other)定义按位异或操作的行为：^
or(self, other)定义按位或操作的行为：|

3. 反算术运算符

radd(self, other)定义加法的行为：+
rsub(self, other)定义减法的行为：-
rmul(self, other)定义乘法的行为：*
rtruediv(self, other)定义真除法的行为：/
rfloordiv(self, other)定义整数除法的行为：//
rmod(self, other) 定义取模算法的行为：%
rdivmod(self, other)定义当被 divmod() 调用时的行为
rpow(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
rlshift(self, other)定义按位左移位的行为：<<
rrshift(self, other)定义按位右移位的行为：>>
rand(self, other)定义按位与操作的行为：&
rxor(self, other)定义按位异或操作的行为：^
ror(self, other)定义按位或操作的行为：|

4. 增量赋值运算符

iadd(self, other)定义赋值加法的行为：+=
isub(self, other)定义赋值减法的行为：-=
imul(self, other)定义赋值乘法的行为：*=
itruediv(self, other)定义赋值真除法的行为：/=
ifloordiv(self, other)定义赋值整数除法的行为：//=
imod(self, other)定义赋值取模算法的行为：%=
ipow(self, other[, modulo])定义赋值幂运算的行为：**=
ilshift(self, other)定义赋值按位左移位的行为：<<=
irshift(self, other)定义赋值按位右移位的行为：>>=
iand(self, other)定义赋值按位与操作的行为：&=
ixor(self, other)定义赋值按位异或操作的行为：^=
ior(self, other)定义赋值按位或操作的行为：|=

5. 一元运算符

neg(self)定义正号的行为：+x
pos(self)定义负号的行为：-x
abs(self)定义当被abs()调用时的行为
invert(self)定义按位求反的行为：~x

6. 属性访问

getattr(self, name): 定义当用户试图获取一个不存在的属性时的行为。
getattribute(self, name)：定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存在，接着去调用__getattr__）。
setattr(self, name, value)：定义当一个属性被设置时的行为。
delattr(self, name)：定义当一个属性被删除时的行为。

7. 描述符

描述符就是将某种特殊类型的类的实例指派给另一个类的属性。

get(self, instance, owner)用于访问属性，它返回属性的值。
set(self, instance, value)将在属性分配操作中调用，不返回任何内容。
del(self, instance)控制删除操作，不返回任何内容。

扩展资料：技术图文：什么是Python的描述符？

8. 定制序列

协议（Protocols）与其它编程语言中的接口很相似，它规定你哪些方法必须要定义。然而，在 Python 中的协议就显得不那么正式。事实上，在 Python 中，协议更像是一种指南。

容器类型的协议

如果说你希望定制的容器是不可变的话，你只需要定义__len__()和__getitem__()方法。
如果你希望定制的容器是可变的话，除了__len__()和__getitem__()方法，你还需要定义__setitem__()和__delitem__()两个方法。

len(self)定义当被len()调用时的行为（返回容器中元素的个数）。
getitem(self, key)定义获取容器中元素的行为，相当于self[key]。
setitem(self, key, value)定义设置容器中指定元素的行为，相当于self[key] = value。
delitem(self, key)定义删除容器中指定元素的行为，相当于del self[key]。

9. 迭代器

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
迭代器只能往前不会后退。
字符串，列表或元组对象都可用于创建迭代器：

迭代器有两个基本的方法：iter() 和 next()。
iter(object) 函数用来生成迭代器。
next(iterator[, default]) 返回迭代器的下一个项目。
iterator – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

把一个类作为一个迭代器使用需要在类中实现两个魔法方法 iter() 与 next() 。

iter(self)定义当迭代容器中的元素的行为，返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 返回下一个迭代器对象。
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

10. 生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。

练习题

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

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

要求:

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