[Python知识库]Python训练营Python基础进阶学习笔记

一、学习知识点概要

Task3主要的内容是学习python的函数、类以及对象的相关知识，主要的内容有：

1. 函数的定义、参数、返回值以及作用域
2. 匿名函数的作用
3. 类与对象的关系，对象的魔法方法
4. 如何实现继承，内置函数有哪些，魔法方法有哪些
5. 迭代器和生成器的概念

二、学习内容

函数

函数文档

简单来说，就是该函数的描述。

def MyFirstFunction(name):
    "函数定义过程中name是形参"
    print('传递进来的{0}叫做实参，因为Ta是具体的参数值！'.format(name))


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

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

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

函数参数

1. 位置参数

   在调用函数时，参数位置要固定。

   def functionname(arg1):
       print(arg1)
   

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

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

2. 默认参数

   默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。

   默认参数一定要放在位置参数 后面，不然程序会报错。

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

3. 可变参数(*arg)

   传入的参数个数是可变的，不定长的参数，自动组装成元组。

   *arg - 可变参数，可以是从零个到任意个，。

   def printinfo(arg1, *args):
       print(arg1)
       for var in args:
           print(var)
   
   printinfo(10)  # 10
   printinfo(70, 60, 50)
   

4. 关键字参数(**kw)

   可以是从零个到任意个，自动组装成字典。

   def printinfo(arg1, *args, **kwargs):
       print(arg1)
       print(args)
       print(kwargs)
   printinfo(70, 60, 50, a=1, b=2)
   # 70
   # (60, 50)
   # {'a': 1, 'b': 2}
   

5. 命名关键字参数

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

   def printinfo(arg1, *, nkw, **kwargs):
       print(arg1)
       print(nkw)
       print(kwargs)
   
   printinfo(70, nkw=10, a=1, b=2)
   # 70
   # 10
   # {'a': 1, 'b': 2}
   
   printinfo(70, 10, a=1, b=2)
   # TypeError: printinfo() takes 1 positional argument but 2 were given
   

   没有写参数名nwk，因此 10 被当成「位置参数」，而原函数只有 1 个位置函数，现在调用了 2 个，因此程序会报错。

6. 参数组合

   上述5种参数中，4个参数可以一起使用，并且参数定义的顺序是：

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

变量作用域

• 局部变量：定义在函数内部的变量拥有局部作用域，只能在其被声明的函数内部访问

• 全局变量：定义在函数外部的变量拥有全局作用域，可以在整个程序范围内访问。

• 当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

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

• 闭包

  内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

  def funX(x):
      def funY(y):
          return x * y
  
      return funY
  
  i = funX(8)
  print(type(i))  # <class 'function'>
  print(i(5))  # 40
  

  如果要修改闭包作用域中的变量则需要 nonlocal 关键字

  def outer():
      num = 10
  
      def inner():
          nonlocal num  # nonlocal关键字声明
          num = 100
          print("inner", num)
  
      inner()
      print("outer", num)
  
  outer()
  
  # 100
  # 100
  

Lambda表达式

Python 使用 lambda 关键词来创建匿名函数，其语法结构为：lambda argument_list: expression。返回值是expression的结果。

匿名函数的应用

函数式编程

是指代码中每一块都是不可变的，都由纯函数的形式组成。函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

def f(x):
    y = []
    for item in x:
        y.append(item + 10)
    return y

x = [1, 2, 3]
f(x)
print(x)
# [1, 2, 3]

非函数式编程

def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x

x = [1, 2, 3]
f(x)
print(x)
# [11, 12, 13]

匿名函数 常常应用于函数式编程的高阶函数中，主要有两种形式：

• 参数是函数 (filter, map)
• 返回值是函数

在 filter和map函数中的应用：

• filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。

  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]
  
  m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
  print(list(m2))  
  # [3, 7, 11, 15, 19]
  

类与对象

对象 = 属性 + 方法

对象是类的实例。类包含所有实例共享的数据以及方法，用关键字 class 定义类。

• 继承：子类自动共享父类之间数据和方法的机制

  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 Animal:
      def run(self):
          raise AttributeError('子类必须实现这个方法')
          
  class People(Animal):
      def run(self):
          print('人正在走')
          
  class Pig(Animal):
      def run(self):
          print('pig is walking')
          
  def func(animal):
      animal.run()
   
  func(Pig())
  # pig is walking
  

self

self相当于this，指向对象，即该类的实例。

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,该死的，谁踢我...

python魔法方法

Python 对象天生拥有的方法，比如：__init__(self[, param1, param2...])方法，该方法在类实例化时会自动调用。

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

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


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

公有与私有

只需要在变量名或者方法名前加上"__"两个下划线，变量名或者方法名就是私有的了。对象不能直接读取私有变量或者方法，会报AttributeError错误

私有变量

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

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2
print(counter._JustCounter__secretCount)  # 2 
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_MY

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

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

继承

单继承

类的单继承，派生类的定义：

class DerivedClassName(BaseClassName):

? statement-1

BaseClassName为基类名，跟派生类定义在一个作用域内。

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

# 类定义
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 年级，因为子类的构造方法把父类的构造方法覆盖了。

调用父类初始化方法：

1. BaseClassName._init_(self)
2. super()._init_()

多继承

class DerivedClassName(Base1, Base2, Base3):
statement-1

若父类中有相同的方法名，子类在使用时未指定哪个父类的方法，那么从左到右找到有该方法的父类，并且调用。

类对象和实例对象

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

class A(object):
pass

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

类属性：类里面定义的变量称为类属性。类属性属于类对象并且多个实例对象之间共享同一个类属性。

实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的。

内置函数(BIF)

1. issubclass(class, classinfo)

   用于判断参数 class 是否是类型参数 classinfo 的子类。

   class A:
       pass
   
   class B(A):
       pass
   
   print(issubclass(B, A))  # True
   # 类可以是自身的子类
   print(issubclass(B, B))  # True
   print(issubclass(A, B))  # False
   print(issubclass(B, object))  # True
   

2. isinstance(object, classinfo)

   用于判断一个对象是否是一个已知的类型（判断object是否是classinfo的实例）。isinstance()会认为子类是一种父类类型，考虑继承关系；type()不会认为子类是一种父类类型，不考虑继承关系。

   a = 2
   print(isinstance(a, int))  # True
   print(isinstance(a, str))  # False
   print(isinstance(a, (str, int, list)))  # True
   
   class A:
       pass
   
   class B(A):
       pass
   
   print(isinstance(A(), A))  # True
   print(type(A()) == A)  # True
   print(isinstance(B(), A))  # True
   print(type(B()) == A)  # False
   

3. hasattr(object, name)

   用于判断对象是否包含对应的属性。

4. getattr(object, name[, default])

   用于返回一个对象属性值。default为如果没有这个属性值，那么就返回default值。

5. setattr(object, name, value)

   用于设置属性值。

6. delattr(object, name)

   用于删除属性。

7. class property([fget[, fset[, fdel[, doc]]]])

魔法方法

方法名是被双下划线包围的，比如__init__()，在类实例化时会自动调用。魔法方法的第一个参数应为cls（代表类） 或者self（代表实例对象）。

基本魔法方法

1. __init__(self[, ...])

   构造器，当一个实例被创建的时候调用的初始化方法

   class Rectangle:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def getPeri(self):
           return (self.x + self.y) * 2
   
       def getArea(self):
           return self.x * self.y
   
   rect = Rectangle(4, 5)
   print(rect.getPeri())  # 18
   print(rect.getArea())  # 20
   

2. __new__(cls[, ...])

   在一个对象实例化的时候所调用的第一个方法，在调用__init__初始化前，先调用__new__。__new__至少要有一个参数cls，代表要实例化的类，后面的参数直接传递给__init__。__new__对当前类进行了实例化，并将实例返回，传给__init__的self。但是只有__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__")
           print(cls)
           return object.__new__(cls)
   
   class B(A):
       def __init__(self, value):
           print("into B __init__")
           self.value = value
   
       def __new__(cls, *args, **kwargs):
           print("into B __new__")
           print(cls)
           return super().__new__(cls, *args, **kwargs) #返回的是当前类的实例
   
   b = B(10)
   
   # 结果：
   # into B __new__
   # <class '__main__.B'>
   # into A __new__
   # <class '__main__.B'>
   # into B __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):
       def __init__(self, value):
           print("into B __init__")
           self.value = value
   
       def __new__(cls, *args, **kwargs):
           print("into B __new__")
           print(cls)
           return super().__new__(A, *args, **kwargs)  #返回的是A类的实例
   
   b = B(10)
   
   # 结果：
   # into B __new__
   # <class '__main__.B'>
   # into A __new__
   # <class '__main__.A'>
   
   #若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行，将没有__init__被调用。
   

   __new__实现单例模式

   class Earth:
       pass
   
   
   a = Earth()
   print(id(a))  # 260728291456
   b = Earth()
   print(id(b))  # 260728291624
   
   class Earth:
       __instance = None  # 定义一个类属性做判断
   
       def __new__(cls):
           if cls.__instance is None:
               cls.__instance = object.__new__(cls)
               return cls.__instance
           else:
               return cls.__instance
   
   a = Earth()
   print(id(a))  # 512320401648
   b = Earth()
   print(id(b))  # 512320401648
   

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

   class CapStr(str):
       def __new__(cls, string):
           string = string.upper()
           return str.__new__(cls, string)
   
   a = CapStr("i love lsgogroup")
   print(a)  # I LOVE LSGOGROUP
   

3. __del__(self)

   当一个对象将要被系统回收之时调用的方法。

   Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 1；当程序中有两个变量引用该 Python 对象时，Python 会自动保证该对象引用计数为 2，依此类推，如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，因此 Python 就会回收该对象。但是循环引用的情况，比如对象 a 持有一个实例变量引用对象 b，而对象 b 又持有一个实例变量引用对象 a，此时两个对象的引用计数都是 1，而实际上程序已经不再有变量引用它们，系统应该回收它们就要等专门的循环垃圾回收器（Cyclic Garbage Collector）来检测并回收这种引用循环。

   class C(object):
       def __init__(self):
           print('into C __init__')
   
       def __del__(self):
           print('into C __del__')
   
   c1 = C()
   # into C __init__
   c2 = c1
   c3 = c2
   del c3
   del c2
   del c1
   # into C __del__
   

4. __str__(self)

   打印一个对象，使用%s格式化，str强转数据类型的时候，触发__str__。

5. __repr__(self)

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

   class Cat:
       """定义一个猫类"""
   
       def __init__(self, new_name, new_age):
           """在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
           self.name = new_name
           self.age = new_age
   
       def __str__(self):
           """返回一个对象的描述信息"""
           return "名字是:%s , 年龄是:%d" % (self.name, self.age)
           
       def __repr__(self):
           """返回一个对象的描述信息"""
           return "Cat:(%s,%d)" % (self.name, self.age)
   
       def eat(self):
           print("%s在吃鱼...." % self.name)
   
       def drink(self):
           print("%s在喝可乐..." % self.name)
   
       def introduce(self):
           print("名字是:%s, 年龄是:%d" % (self.name, self.age))
   
   # 创建了一个对象
   tom = Cat("汤姆", 30)
   print(tom)  # 名字是:汤姆 , 年龄是:30
   print(str(tom)) # 名字是:汤姆 , 年龄是:30
   print(repr(tom))  # Cat:(汤姆,30)
   tom.eat()  # 汤姆在吃鱼....
   tom.introduce()  # 名字是:汤姆, 年龄是:30
   

算术运算符

1. __add__(self, other)、__sub__(self, other)

   分别是定义对象的加法行为和减法行为

   class MyClass:
   
       def __init__(self, height, weight):
           self.height = height
           self.weight = weight
   
       # 两个对象的长相加，宽不变.返回一个新的类
       def __add__(self, others):
           return MyClass(self.height + others.height, self.weight + others.weight)
   
       # 两个对象的宽相减，长不变.返回一个新的类
       def __sub__(self, others):
           return MyClass(self.height - others.height, self.weight - others.weight)
   
       # 说一下自己的参数
       def intro(self):
           print("高为", self.height, " 重为", self.weight)
   
   def main():
       a = MyClass(height=10, weight=5)
       a.intro()
   
       b = MyClass(height=20, weight=10)
       b.intro()
   
       c = b - a
       c.intro()
   
       d = a + b
       d.intro()
   
   if __name__ == '__main__':
       main()
       
   # 高为 10  重为 5
   # 高为 20  重为 10
   # 高为 10  重为 5
   # 高为 30  重为 15
   

2. __mul__(self, other)定义对象乘法的行为：*

3. __truediv__(self, other)定义对象除法的行为：/

4. _floordiv__(self, other)定义对象整除的行为：//

5. __mod__(self, other) 定义对象取模算法的行为：%

6. __divmod__(self, other)定义对象当被 divmod() 调用时的行为

   divmod(a, b)把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

7. __pow__(self, other[, module])定义对象当被 power() 调用或 ** 运算时的行为

8. __lshift__(self, other)定义对象按位左移位的行为：<<

9. __rshift__(self, other)定义对象按位右移位的行为：>>

10. __and__(self, other)定义对象按位与操作的行为：&

11. __xor__(self, other)定义对象按位异或操作的行为：^

12. __or__(self, other)定义对象按位或操作的行为：|

反算术运算符

1. __radd__(self, other)定义加法的行为：+
2. __rsub__(self, other)定义减法的行为：-
3. __rmul__(self, other)定义乘法的行为：*
4. __rtruediv__(self, other)定义真除法的行为：/
5. __rfloordiv__(self, other)定义整数除法的行为：//
6. __rmod__(self, other) 定义取模算法的行为：%
7. __rdivmod__(self, other)定义当被 divmod() 调用时的行为
8. __rpow__(self, other[, module])定义当被 power() 调用或 ** 运算时的行为
9. __rlshift__(self, other)定义按位左移位的行为：<<
10. __rrshift__(self, other)定义按位右移位的行为：>>
11. __rand__(self, other)定义按位与操作的行为：&
12. __rxor__(self, other)定义按位异或操作的行为：^
13. __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. __iadd__(self, other)定义赋值加法的行为：+=
2. __isub__(self, other)定义赋值减法的行为：-=
3. __imul__(self, other)定义赋值乘法的行为：*=
4. __itruediv__(self, other)定义赋值真除法的行为：/=
5. __ifloordiv__(self, other)定义赋值整数除法的行为：//=
6. __imod__(self, other)定义赋值取模算法的行为：%=
7. __ipow__(self, other[, modulo])定义赋值幂运算的行为：**=
8. __ilshift__(self, other)定义赋值按位左移位的行为：<<=
9. __irshift__(self, other)定义赋值按位右移位的行为：>>=
10. __iand__(self, other)定义赋值按位与操作的行为：&=
11. __ixor__(self, other)定义赋值按位异或操作的行为：^=
12. __ior__(self, other)定义赋值按位或操作的行为：|=

一元运算符

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

属性访问

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

class C:
    def __getattribute__(self, item):
        print('__getattribute__')
        return super().__getattribute__(item)

    def __getattr__(self, item):
        print('__getattr__')

    def __setattr__(self, key, value):
        print('__setattr__')
        super().__setattr__(key, value)

    def __delattr__(self, item):
        print('__delattr__')
        super().__delattr__(item)

c = C()
c.x
# __getattribute__
# __getattr__

c.x = 1
# __setattr__

del c.x
# __delattr__

描述符

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

1. __get__(self, instance, owner)用于访问属性，它返回属性的值。

2. __set__(self, instance, value)将在属性分配操作中调用，不返回任何内容。

3. __del__(self, instance)控制删除操作，不返回任何内容。

class MyDecriptor:
    def __get__(self, instance, owner):
        print('__get__', self, instance, owner)

    def __set__(self, instance, value):
        print('__set__', self, instance, value)

    def __delete__(self, instance):
        print('__delete__', self, instance)

class Test:
    x = MyDecriptor()

t = Test()
t.x
# __get__ <__main__.MyDecriptor object at 0x000000CEAAEB6B00> <__main__.Test object at 0x000000CEABDC0898> <class '__main__.Test'>

t.x = 'x-man'
# __set__ <__main__.MyDecriptor object at 0x00000023687C6B00> <__main__.Test object at 0x00000023696B0940> x-man

del t.x
# __delete__ <__main__.MyDecriptor object at 0x000000EC9B160A90> <__main__.Test object at 0x000000EC9B160B38>

定制协议

协议（Protocols）类似与接口，它规定你哪些方法必须要定义。

容器类型的协议

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

1. __len__(self)返回容器中元素的个数
2. __getitem__(self, key)定义获取容器中元素的行为，相当于self[key]。
3. __setitem__(self, key, value)定义设置容器中指定元素的行为，相当于self[key] = value。
4. __delitem__(self, key)定义删除容器中指定元素的行为，相当于del self[key]。

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

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]

c1 = CountList(1, 3, 5, 7, 9)
c2 = CountList(2, 4, 6, 8, 10)
print(c1[1])  # 3
print(c2[2])  # 6
print(c1[1] + c2[1])  # 7

print(c1.count)
# {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}

print(c2.count)
# {0: 0, 1: 1, 2: 1, 3: 0, 4: 0}

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

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]
        for i in range(0, len(self.values)):
            if i >= key:
                self.count[i] = self.count[i + 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}

迭代器

是访问元素的一种方式，字符串，列表或元组对象都可用于创建迭代器。

string = 'lsgo'
for c in string:
    print(c)

'''
l
s
g
o
'''

for c in iter(string):
    print(c)
# 同上

• 迭代器有两个基本的方法：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:
        break
    print(each)

# B
# A
# T

it = iter(links)
print(next(it))  # B
print(next(it))  # A
print(next(it))  # T
print(next(it))  # StopIteration

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

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

class Fibs:
    def __init__(self, n=10):
        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

生成器

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

def myGen():
    print('生成器执行！')
    yield 1
    yield 2
    
myG = myGen()
for each in myG:
    print(each)

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

myG = myGen()
print(next(myG))  
# 生成器执行！
# 1

print(next(myG))  # 2
print(next(myG))  # StopIteration

三、学习问题与解答

1. python绑定的主要用处是什么呢？

四、学习思考与总结

本次task3，内容相比于前两章来说，比较难理解，涉及到了python对象的知识，其中的魔法方法的一些知识还是需要多应用，才能更好地理解。