Python基础知识

一、迭代器、生成器和yield语句

1、迭代器

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

>>>list=[1,2,3,4]
>>>it = iter(list)    # 创建迭代器对象
>>>print(next(it))   # 输出迭代器的下一个元素
1
>>>print(next(it))
2

2、生成器

Python使用生成器对延迟操作提供了支持。
所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

Python有两种不同的方式提供生成器：

• 生成器函数：常规函数定义，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行
• 生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

生成器表达式：

>>>squares = [x**2 for x in range(5)]
>>>squares
[0, 1, 4, 9, 16]
>>>squares = (x**2 for x in range(5))
>>>squares
<generator object at 0x00B2EC88>
>>>next(squares)
0
>>>next(squares)
1
>>> next(squares)
4
>>>list(squares)
[9, 16]

在调用生成器函数运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行

>>>def mygenerator():  
...    print('start...')  
...    yield 5  
...   
>>>mygenerator()     //在此处调用,并没有打印出start...说明存在yield的函数没有被运行，即暂停  
<generator object mygenerator at 0xb762502c>  
>>>mygenerator().next()     //调用next()即可让函数运行
start...  
5

如果一个函数中出现多个yield，则next()会停止在下一个yield前。

>>>def fun2():  
...    print('first')
...    yield 5  
...    print('second')  
...    yield 23  
...    print('end...')  
...   
>>>g1 = fun2()  
>>>g1.next()            //第一次运行,暂停在yield 5               
first  
5  
>>>g1.next()            //第二次运行,暂停在yield 23  
second  
23  
>>>g1.next()            //第三次运行,由于之后没有yield,再次next()就会抛出错误  
end...  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
StopIteration 

二、Python3 面向对象编程

面向对象编程：是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现。所以，面向对象编程其实就是对 “类” 和 “对象” 的使用
类：就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象：则是根据模板创建的实例，通过实例对象可以执行类中的函数

面向对象三大特性

1、封装
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

class Foo:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def detail(self):
        print(self.name)
        print(self.age)

obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

2、继承
面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容
例如：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为同为动物的猫和狗各创建一个类，那么就需要为猫和狗实现它们各自具有的功能，如果使用继承的思想，如下实现：

#定义一个“Animal”类，具有吃、喝、拉、撒的功能
class Animal:

    def eat(self):
        print("%s 吃 ") %self.name

    def drink(self):
        print("%s 喝 ") %self.name

    def shit(self):
        print("%s 拉 ") %self.name

    def pee(self):
        print("%s 撒 ") %self.name

#定义一个“Cat”类，继承“Animal”类所有功能，同时添加属于猫的“喵喵叫”功能
class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'

    def cry(self):
        print('喵喵叫')

#定义一个“Dog”类，继承“Animal”类所有功能，同时添加属于狗的“汪汪叫”功能
class Dog(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'

    def cry(self):
        print('汪汪叫')

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

3、多态
Python崇尚“鸭子类型”，也就是：当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。

扩展阅读

廖雪峰的官方网站：面向对象编程，生成器