python入门学习笔记3-面向对象

函数

1. 函数的格式及基本使用

1. 函数的格式：

• 函数以def关键词开头，后接函数名和圆括号()。
• 函数执行的代码以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

def functionname (parameters):

       “函数_文档字符串”

        function_suite

        return [expression]

2. 函数的调用：

def printme(str):
    print(str)
    
printme("我要调用用户自定义函数!")  # 我要调用用户自定义函数

3. 函数文档

def MyFirstFunction(name):
    "函数定义过程中name是形参"
    # 因为Ta只是一个形式，表示占据一个参数位置
    print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))


MyFirstFunction('老马的程序人生')  
# 传递进来的老马的程序人生叫做实参，因为Ta是具体的参数值！

print(MyFirstFunction.__doc__)  
# 函数定义过程中name是形参

help(MyFirstFunction)
# Help on function MyFirstFunction in module __main__:
# MyFirstFunction(name)
#    函数定义过程中name是形参

2. 函数参数及返回值

Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态如下：

• 位置参数 (positional argument)
• 默认参数 (default argument)
• 可变参数 (variable argument)
• 关键字参数 (keyword argument)
• 命名关键字参数 (name keyword argument)
• 参数组合

1. 位置参数

def functionname(arg1):

       “函数_文档字符串”

       function_suite

       return [expression]

• arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。

Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def printinfo(name, age):
    print('Name:{0},Age:{1}'.format(name, age))


printinfo(age=8, name='小马')  # Name:小马,Age:8

有一种特殊的参数名叫命名关键字参数，他要求传入参数时必须指定参数名称：

def functionname(arg1, arg2=v, *args, *, nkw, **kw):

       “函数_文档字符串”

       function_suite

       return [expression]

• *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
• 如果要限制关键字参数的名字，就可以用「命名关键字参数」
• 使用命名关键字参数时，要特别注意不能缺少参数名。

2. 默认参数

def functionname(arg1, arg2=v):

       “函数_文档字符串”

       function_suite

       return [expression]

• arg2 = v - 默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
• 默认参数一定要放在位置参数 后面，不然程序会报错。

def printinfo(name, age=8):
    print('Name:{0},Age:{1}'.format(name, age))

printinfo('小马')  # Name:小马,Age:8
printinfo('小马', 10)  # Name:小马,Age:10

3. 可变参数

顾名思义，可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args):

• *args - 可变参数，可以是从零个到任意个，自动组装成元组。
• 加了星号（*）的变量名会存放所有未命名的变量参数。

def printinfo(arg1, *args):
    print(arg1)
    for var in args:
        print(var)


printinfo(10)  # 10
printinfo(70, 60, 50)
# 70
# 60
# 50

关键字参数：另一种可变参数，不同的是将传入的参数组装成字典

def functionname(arg1, arg2=v, *args, **kw):

• **kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

def printinfo(arg1, *args, **kwargs):
    print(arg1)
    print(args)
    print(kwargs)

printinfo(70, 60, 50)
# 70
# (60, 50)
# {}
printinfo(70, 60, 50, a=1, b=2)
# 70
# (60, 50)
# {'a': 1, 'b': 2}

4. 参数组合

在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

• 位置参数、默认参数、可变参数和关键字参数。
• 位置参数、默认参数、命名关键字参数和关键字参数。

要注意定义可变参数和关键字参数的语法：

• *args 是可变参数，args 接收的是一个 tuple
• **kw 是关键字参数，kw 接收的是一个 dict

命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名关键字参数不要忘了写分隔符 *，否则定义的是位置参数。

警告：虽然可以组合多达 5 种参数，但不要同时使用太多的组合，否则函数很难懂。

5. 函数的返回值
   可以在返回值中进行运算：

def add(a, b):
    return a + b


print(add(1, 2))  # 3
print(add([1, 2, 3], [4, 5, 6]))  # [1, 2, 3, 4, 5, 6]

3. 作用域

1. 变量的作用域

• Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
• 定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
• 定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
  全局变量的创建方法有三种：
  • 在函数外创建。
  • 在函数内创建但需添加global修饰符。
  • 在有参构造内创建但需使用self.前缀并进行初始化。
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

num = 1


def fun1():
    global num  # 需要使用 global 关键字声明
    print(num)  # 1
    num = 123
    print(num)  # 123


fun1()
print(num)  # 123

2. 内嵌函数和闭包
   内嵌函数是定义在函数内部的函数。不过这种设计很少被使用，后续会被面向对象的架构所取代。
   闭包是一种特殊的内嵌函数。如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。闭包的返回值通常是函数。

def make_counter(init):
    counter = [init]

    def inc(): counter[0] += 1

    def dec(): counter[0] -= 1

    def get(): return counter[0]

    def reset(): counter[0] = init

    return inc, dec, get, reset

inc, dec, get, reset = make_counter(0)
inc()
inc()
inc()
print(get())  # 3
dec()
print(get())  # 2
reset()
print(get())  # 0

4. 特殊函数

递归函数
自己调用自己，逐层调用，调用到最底层后再逐层返回。

# 利用循环
i = 0
j = 1
lst = list([i, j])
for k in range(2, 11):
    k = i + j
    lst.append(k)
    i = j
    j = k
print(lst)  
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

# 利用递归
def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)


lst = list()
for k in range(11):
    lst.append(recur_fibo(k))
print(lst)  
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

匿名函数

1. 匿名函数的格式

Python 使用 lambda 关键词来创建匿名函数，而非def关键词，它没有函数名，其语法结构如下：

lambda argument_list: expression

• lambda - 定义匿名函数的关键词。
• argument_list - 函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
• :- 冒号，在函数参数和表达式中间要加个冒号。
• expression - 只是一个表达式，输入函数参数，输出一些值。

注意：

• expression 中没有 return 语句，因为 lambda 不需要它来返回，表达式本身结果就是返回值。
• 匿名函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

lbd_sqr = lambda x: x ** 2
print(lbd_sqr)
# <function <lambda> at 0x000000BABB6AC1E0>

sumary = lambda arg1, arg2: arg1 + arg2
print(sumary(10, 20))  # 30

func = lambda *args: sum(args)
print(func(1, 2, 3, 4, 5))  # 15

2. 匿名函数的应用

其实匿名函数的作用唯一作用就是简化了代码，与函数式编程的高阶函数 (high-order function)可以实现更好的效果：

• 参数是函数 (filter, map)：自动对传入的list进行遍历。

• 返回值是函数 (closure)

• filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

• map(function, *iterables) 根据提供的函数对指定序列做映射。

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  
# [1, 4, 9, 16, 25]

我们也可以自己定义高阶函数。

def apply_to_list(fun, some_list):
    return fun(some_list)

lst = [1, 2, 3, 4, 5]
print(apply_to_list(sum, lst))
# 15

print(apply_to_list(len, lst))
# 5

print(apply_to_list(lambda x: sum(x) / len(x), lst))
# 3.0

类与对象

1. 概念

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

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

1. 属性
   之前讨论的作用域是指一个变量在一个类内部的作用范围。而公有（public）和私有（private）是指一个变量或函数是否可以被外部调用。能够被外部调用的全局变量被称为类的属性。
   一般在类内创建的全局变量都是属性，类内的函数都为公有。如果想要私有化只需要在变量名或函数名前加上两个下划线“__”。

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


counter = JustCounter()
print(counter.publicCount)  # 2
# Python的私有为伪私有
print(counter._JustCounter__secretCount)  # 2 
print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'

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

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

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

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

2. 组合
   在有参构造中创建对象作为属性：

class Turtle:
    def __init__(self, x):
        self.num = x


class Fish:
    def __init__(self, x):
        self.num = x


class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))


p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

3. self和有参构造

Python 的 self 相当于 C++ 的 this 指针。
在有参构造中，通过self可以声明创建并初始化全局变量。

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")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

3. 绑定

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

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

class CC:
    def setXY(self, x, y):
        self.x = x
        self.y = y

    def printXY(self):
        print(self.x, self.y)

dd = CC()
print(dd.__dict__)
# {}

print(vars(dd))
# {}

dd.setXY(4, 5)
print(dd.__dict__)
# {'x': 4, 'y': 5}

print(vars(CC))
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

print(CC.__dict__)
# {'__module__': '__main__', 'setXY': <function CC.setXY at 0x000000632CA9B048>, 'printXY': <function CC.printXY at 0x000000632CA83048>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

2. 面向对象的三大特性

python也具有面向对象语言的三种特性，即封装，继承，多态。

1. 封装：信息隐蔽，具体表现为只有通过getter和setter才可以改变类的属性。
2. 继承：子类自动共享父类之间数据和方法的机制

• 继承python内置类

class MyList(list):
    pass

lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort()
print(lst)

# [1, 2, 5, 7, 8, 9]

• 自定义类并实现继承

# 类定义
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) # 此处也可以使用super().__init__()
        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 年级，因为子类的构造方法把父类的构造方法覆盖了。

• 多继承：Python 虽然支持多继承的形式，但我们一般不使用多继承，因为容易引起混乱。

class DerivedClassName(Base1, Base2, Base3):

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法。

• 类对象
  类对象由该来自动创建的一个供所有实例对象共用的对象，调用类对象需要添加Test.前缀。
  

# 创建类对象：相当于公用对象
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

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

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

3. **多态**：不同对象对同一方法响应不同的行动。以及对同一对象内对同名但参数不同的方法响应不同的行动。

```python
class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')


class People(Animal):
    def run(self):
        print('人正在走')


class Pig(Animal):
    def run(self):
        print('pig is walking')


class Dog(Animal):
    def run(self):
        print('dog is running')


def func(animal):
    animal.run()


func(Pig()) # 将pig类作为Animal类传入了func函数中
# pig is walking

python对象的内置方法

由于所有类都继承了object，所以天生拥有许多内置方法。

1. 常用方法

1. 算术运算符

• __add__(self, other)定义加法的行为：+
• __sub__(self, other)定义减法的行为：-
• __mul__(self, other)定义乘法的行为：*
• __truediv__(self, other)定义真除法的行为：/
• __floordiv__(self, other)定义整数除法的行为：//
• __mod__(self, other) 定义取模算法的行为：%
• __divmod__(self, other)定义当被 divmod() 调用时的行为
• divmod(a, b)把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

2. 反算术运算符
   反运算魔方方法，与算术运算符保持一一对应，不同之处就是反运算的魔法方法多了一个“r”。当文件左操作不支持相应的操作时被调用。

• __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)定义按位或操作的行为：|

比如：a + b

这里加数是a，被加数是b，因此是a主动，反运算就是如果a对象的__add__()方法没有实现或者不支持相应的操作，那么 Python 就会调用b的__radd__()方法。

class Nint(int):
    def __radd__(self, other):
        return int.__sub__(other, self) # 注意 self 在后面
a = Nint(5)
b = Nint(3)
print(a + b)  # 8
print(1 + b)  # -2：1没有add方法，所以执行的是b的__radd__方法，也就3-5

3. 增量赋值运算符

• __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)定义赋值按位或操作的行为：|=

4. 一元运算符

• __neg__(self)定义正号的行为：+x
• __pos__(self)定义负号的行为：-x
• __abs__(self)定义当被abs()调用时的行为
• __invert__(self)定义按位求反的行为：~x

5. 输出字符串

• __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. 初始化

魔法方法也是object的内置方法，在对象创建时会被自动调用。我们可以通过重写内置方法使对象在被创建时自动完成某些功能：

• __init__(self[, ...]) 构造器，当一个实例被创建的时候调用的初始化方法
• __new__(cls[, ...]) 在一个对象实例化的时候所调用的第一个方法，在调用__init__初始化前，先调用__new__。
  • __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__。
  • __new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是，执行了__new__，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入。

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__") # 3
        print(cls) # 4
        return object.__new__(cls) # 返回的是当前cls的实例，此次传入的cls是B，返回的也就是B的实例


class B(A):
    def __init__(self, value): # self返回的是
        print("into B __init__") # 5
        self.value = value
        print(self.value) # 6

    def __new__(cls, *args, **kwargs): # cls自动设定为B
        print("into B __new__") # 1
        print(cls) # 2
        return super().__new__(cls, *args, **kwargs) # 父类A的__new__返回的是B的实例


b = B(10)

# 结果：（测试程序执行流程的方法就是在关键的步骤设一个print）
# 1. into B __new__
# 2. <class '__main__.B'>
# 3. into A __new__
# 4. <class '__main__.B'>：因为传入的是cls对象，而cls对象是b
# 5. into B __init__
# 6. 10

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

class A(object):
    def __init__(self, value):
        print("into A __init__")
        self.value = value

    def __new__(cls, *args, **kwargs):
        print("into A __new__")
        print(cls)
        return object.__new__(cls)


class B(A):
    value = 1
    def __init__(self, value1):
        print("into B __init__")
        # python的属性默认public，public声明的公共是针对外部的，内部默认为公共的，但是内部调用属性必须要加self
        # 加self是为了区分全局变量和方法内的局部变量。java中调用内部属性和方法也必须要加this
        self.value = value1
        print(self.value)

    def __new__(cls, *args, **kwargs):
        print("into B __new__")
        print(cls)
        return super().__new__(A, *args, **kwargs)  # 改动了cls变为A


b = B(10)
print(b.value)
# into B __new__
# <class '__main__.B'>
# into A __new__
# <class '__main__.A'>

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

class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return str.__new__(cls, string) # 调用str的new方法，创建了一个str对象


a = CapStr("i love lsgogroup")
print(a)  # I LOVE LSGOGROUP

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

Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 1；当程序中有两个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 2，依此类推，如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，因此 Python 就会回收该对象。

大部分时候，Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况，比如对象 a 持有一个实例变量引用对象 b，而对象 b 又持有一个实例变量引用对象 a，此时两个对象的引用计数都是 1，而实际上程序已经不再有变量引用它们，系统应该回收它们，此时 Python 的垃圾回收器就可能没那么快，要等专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环。

3. 判断继承关系

• issubclass(class, classinfo) 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
  • 一个类被认为是其自身的子类。
  • classinfo可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回True。
• isinstance(object, classinfo) 方法用于判断一个对象是否是一个已知的类型，类似type()。
  • type()不会认为子类是一种父类类型，不考虑继承关系。
  • isinstance()会认为子类是一种父类类型，考虑继承关系。
  • 如果第一个参数不是对象，则永远返回False。
  • 如果第二个参数不是类或者由类对象组成的元组，会抛出一个TypeError异常。

4. 属性访问

• hasattr(object, name)用于判断对象是否包含对应的属性。
• getattr(object, name[, default])用于返回一个对象属性值。
• setattr(object, name, value)对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
• delattr(object, name)用于删除属性。
• class property([fget[, fset[, fdel[, doc]]]])用于在新式类中返回属性值。
  • fget – 获取属性值的函数
  • fset – 设置属性值的函数
  • fdel – 删除属性值函数
  • doc – 属性描述信息
• __getattr__(self, name): 定义当用户试图获取一个不存在的属性时的行为。
• __getattribute__(self, name)：定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存在，接着去调用__getattr__）。
• __setattr__(self, name, value)：定义当一个属性被设置时的行为。
• __delattr__(self, name)：定义当一个属性被删除时的行为。

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

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

5. 定制序列

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

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

容器类型的协议

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

【例子】编写一个可变的自定义列表，要求记录列表中每个元素被访问的次数。

class CountList:
    def __init__(self, *args):
        self.values = [x for x in args]
        self.count = {}.fromkeys(range(len(self.values)), 0)

    def __len__(self):
        return len(self.values)

    def __getitem__(self, item):
        self.count[item] += 1
        return self.values[item]

    def __setitem__(self, key, value):
        self.values[key] = value

    def __delitem__(self, key):
        del self.values[key] # key=1, value = 3
        for i in range(0, len(self.values)): # len = 4, range(0, 4)
            if i >= key: # 1, 2, 3
                self.count[i] = self.count[i - 1] + 1
        self.count.pop(len(self.values))


c1 = CountList(1, 3, 5, 7, 9)
c2 = CountList(2, 4, 6, 8, 10)
print(c1[1])  # 3
print(c2[2])  # 6
c2[2] = 12
print(c1[1] + c2[2])  # 15
print(c1.count)
# {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
print(c2.count)
# {0: 0, 1: 0, 2: 2, 3: 0, 4: 0}
del c1[1]
print(c1.count)
# {0: 0, 1: 0, 2: 0, 3: 0}

6. 迭代器

1. 概念

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

2. 基本方法

迭代器有两个基本的方法：iter() 和 next()。

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

links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}

it = iter(links)
while True:
    try:
        each = next(it)
    except StopIteration:
        print("error")
        break
    print(each)

# B
# A
# T

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

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

class Fibs:
    def __init__(self, n):
        self.a = 0
        self.b = 1
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > self.n:
            raise StopIteration
        return self.a


fibs = Fibs(100)
for each in fibs:
    print(each, end=' ')

# 1 1 2 3 5 8 13 21 34 55 89

3. 生成器

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

def myGen():
    print('生成器执行！')
    yield 1 # 所谓迭代器表示的是可迭代对象中的一个元素
    yield 2
    yield 3
    
myG = myGen()
for each in myG:
    print(each)

'''
生成器执行！
1
2
3
'''

用生成器实现斐波那契数列：

def libs(n):
    a = 0
    b = 1
    while True:
        a, b = b, a + b
        if a > n:
            return
        yield a


for each in libs(100):
    print(each, end=' ')

# 1 1 2 3 5 8 13 21 34 55 89

资料参考自阿里天池python训练营