Python编程基础与进阶指南-优快云博客

文章目录

Python概览表
1. Python基础
2. 流程控制结构
3. 数据序列
4. 函数
5. 面向对象
6. 异常，模块，文件
7. Python 进阶知识
- 7.1 迭代器（Iterator）
- 7.2 生成器（Yield）

Python概览表

序号	章节	描述
1	Python基础	1.认识Python 2.注释，变量，变量类型，输入输出，运算符
2	流程控制结构	1.判断语句 2.循环
3	数据序列	1.字符串（str） 2.列表（list） 3.元组（tuple） 4.字典（dict） 5.集合（set）
4	函数	1.函数基础 2.变量进阶 3.函数进阶 4.匿名函数
5	面向对象	1.面向对象编程 2.类和对象 3.面向对象基础语法 4.封装，继承，多态 5.类属性和类方法
6	异常，模块，文件	1.异常 2.模块和包 3.文件操作
7	Python进阶知识	1.迭代器（Iterator） 2.生成器（Yield）

1. Python基础

1.1 认识Python

Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。

1.2 注释

单行注释

# 这是一个单行注释
# 一般是要空一格开始写。

多行注释

"""双引号多行注释"""
'''单引号多行注释'''
"""一般用于函数中描述"""

1.3 变量

1.3.1 变量名的规范

变量名只能包含字母，数字和下划线。不能以数字开头。
变量名不能包含空格，但能使用下划线分隔单词。
不能将Python关键字和函数名用作变量名。
变量名应简短且具有描述性。
慎用小写字母 l 和大写字母 O ，因为它们可能被人看错成数字。

1.3.2 变量的类型

数字类型

类型	变量名	描述
整型	int	1
浮点型	float	1.0
布尔类型	bool	True / False

非数字类型

类型	变量名	描述
字符串	str	‘李四’
列表	list	[1,2,3]
元组	tuple	(1,2,3)
字典	dict	{1 : ‘李四’, 2 : ‘张三’}

1.3.3 变量类型转换

类型	方法	描述
整形	int( )	1.将`float`类型转为整数型 2.将`整数类型的字符串`转为整数型
浮点型	float( )	1.将`int`类型转为浮点型 2.将`数字类型的字符串`转为浮点型
字符串	str( )	将其他类型转换为字符串

1.4 输入（input( )）

# 获取用户使用键盘录入的内容
变量 = input('请输入内容：')

1.5 输出（print( )）

# 将程序中的数据或者结果打印到控制台(屏幕)
print("hello world")

1.5.1 格式化输出

在字符串中指定的位置，输出变量中存储的值。
1.在需要使用变量的地方，使用特殊符号占位。
2.使用变量填充占位的数据。

% 格式化输出占位符号
- %d 占位, 填充整型数据 digit
- %f 占位. 填充浮点型数据 float
- %f 占位. 填充字符串数据 str

# 定义变量 姓名  年龄  身高
name = '李四'  
age = 20   
height = 1.75

# 使用格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print('我的名字是 %s, 年龄是 %d, 身高是 %f m' % (name,age,height))
# 小数默认显示 6 位, 如果想要指定显示小数点后几位,  %.nf , n 需要换成具体的整数数字,即保留小数的位置

F-string( f字符串的格式化方法)

f-string 格式化的方法,想要使用 ,Python 的版本 >= 3.6
1. 需要在字符串的前边加上 f"" 或者 F""
2. 占位符号统一变为 {} 
3. 需要填充的变量 写在 {} 中

# 定义变量 姓名  年龄  身高
name = '李四'  
age = 20   
height = 1.75
# 使用 F 格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print("我的名字是 {name}, 年龄是 {age}, 身高是 {height} m")

1.6 快捷键(小操作)

撤销 : Ctrl Z 
删除一行: Ctrl x
复制粘贴一行: Ctrl d

1.7 运算符

1.7.1 算术运算符

运算符	描述	实例
+	加	x + y = 3
-	减	x - y = 1
*	乘	x * y = 10
/	除	x + y = 0.5
//	求商	x // y = 2
%	求余	x % y = 1
**	幂运算，指数运算	x ** 3 = 8

1.7.2 比较运算符

运算符	描述	实例
>	大于	x > 3
<	小于	x < 3
>=	大于等于	x >= 3
<=	小于等于	x <= 3
==	等于	x == 3
!=	不等于	x != 3

1.7.3 逻辑运算符

运算符	描述	实例
and	逻辑与	一假为假
or	逻辑或	一真为真
not	逻辑非	取反

1.7.4 成员运算符

运算符	描述	实例
in	如果在序列中找到值/变量，则为真	5 in list
not in	如果在序列中找到值/变量，则为真	5 not in list

1.7.5 身份运算符

运算符	描述	实例
is	判断俩个变量是否引用同一个地址值，且数值相同	a is b
not is	判断俩个变量是否引用同一个地址值，且数值不相同相同	a not is b

2. 流程控制结构

2.1 判断语句

2.1.1 if 结构

if 判断条件:
    书写条件成立(真),执行的代码
    书写条件成立(真),执行的代码
print("i like python")

# 顶格书写,没有缩进的代码,和 if 无关, 不管条件是否成立,都会执行

2.1.2 if elif else 结构

if 判断条件1:
    判断条件1成立,执行的代码
elif 判断条件2:  # 只有判断条件1不成立,才会判断 判断条件2
    判断条件2成立执行的代码
else:
    以上条件都不成立,执行的代码

2.1.3 if else 结构

if 判断条件:
    书写条件成立(真),执行的代码
    书写条件成立(真),执行的代码
else:
    书写条件不成立(假), 执行的代码
    书写条件不成立(假), 执行的代码

2.1.4 三元表达式

# 语法
结果 if 条件 else 结果
# 例如
c = a if a > b else b

2.2 循环

2.2.1 for 循环

for 变量名 in 容器:
    重复执行的代码

# 1. for 和 in 都是关键字。
# 2. 容器中有多少个数据，循环会执行多少次(0 个数据,执行 0 次, ...)。
# 3. 每次循环，会将容器中数据取出一个保存到 in 关键字前边的变量中。

2.2.2 数据的构建（range）

# 语法: range(start_index,end_index,len)
# start_index: 开始下标; end_index: 结束下标（不包含）;len: 步长。
for value in range(,5,2)
	print(value)
    
list_numbers = list(range(1,5,2))
print(list_numbers)

2.2.2 while 循环

index = 0
while index < 5:
    print(index)
    index += 1
# 相当于 Java 中的 for 循环

2.2.2 循环终结（continue - break - pass）

break: 终止循环, 即代码执行遇到 break, 循环不再执行,立即结束。
continue: 跳过本次循环. 即代码执行遇到 continue,本次循环剩下的代码不再执行, 继续下一次循环。
pass: 执行传递时没有任何反应，结果为无操作（NOP）。

3. 数据序列

3.1 字符串（str）

3.1.1 定义

使用引号(单引号, 双引号, 三引号)引起来的内容就是字符串

3.1.2 下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是下标

# 语法: 
str[index]  # 获取指定位置的字符

3.1.3 字符串切片

# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
str[start:end:step] # start:开始位置（从0起步）end:结束位置 step:步长
str[0:2:2]

3.1.4 成员方法

成员方法	描述	实例
find( string, start_index = 0 )	在字符串中查找“指定字符”。	str.find( ‘lisi’ )
replace( old_str, new_str, count = 全部 )	替换字符串中的“指定字符”。	str.replace( ‘g’, 'G )
split( string, count = 全部 )	按照“指定字符”拆分字符串	str.split( ‘,’ )
join( string )	将字符串和指定字符串链接	‘-’.join(str)
title()	将字符串的首字母大写	str.title()
upper()	将字符串进行全部大写	str.upper()
lower()	将字符串进行全部小写	str.lower()
strip()	将字符串的空白删除	str.strip()
rstrip()	将字符串的右空白删除	str.rstrip()
lstrip()	将字符串的左空白删除	str.lstrip()

3.2 列表（list）

3.2.1 定义

列表的特点：可重复性，有下标性，可扩展性。

3.2.2 列表切片

# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
list[start:end] # start:开始位置（从0起步）end:结束位置
str[0:5]

3.2.3 成员方法

成员方法	描述	实例
append()	在列表末尾添加一个数据	list.append(‘数据’)
insert(index, 元素)	在列表index下标上添加“指定元素”	list.insert(0, ‘元素’)
del list[index]	根据列表下标索引来删除元素	del list[0]
pop(index = -1)	1.把列表末尾的数据抛出 2.根据列表下标索引来抛出元素	1.list.pop() 2.list.pop(0)
remove()	根据“指定元素”删除列表中的值	list.remove(‘元素’)
clear()	清空列表内容	list.clear()
index(‘元素’, start_index,end_index)	查找“指定元素”第一次出现的下标值	list.index(‘元素’)
count(‘元素’)	查找“指定元素”出现的个数	list.count(‘元素’)
copy()	浅克隆一个列表，地址值一样	list.copy()
reverse()	反转列表	list.reverse()
sort(reverse=True)	列表排序	list.sort()
sorted()	列表临时排序，不改变原列表	list.sorted()

3.2.4 列表解析 *

# 语法
运算表达式 循环体 循环后的表达式
# 一
[x**2 for i in range(10)]
# 二
[x**2 for i in range(10) if x % 3 == 0]
# 三
[x**2 for i in range(1,10) for j in range(1,10)]

3.2.5 嵌套列表浅拷贝和深拷贝

拷贝会改变元素地址值
浅拷贝：只拷贝原列表的最外层列表，而内层列表依然指向原列表创建时的内存地址。

成员方法	描述	实例
copy()	浅克隆一个嵌套列表，子对象元素地址值一样。	list.copy()

深拷贝：将外层列表和内层列表同时拷贝。

成员方法	描述	实例
deepcopy()	深克隆一个嵌套列表，元素地址值都不相同。（需要导入copy包）	copy.deepcopy()

3.3 元组（tuple）

3.3.1 定义

元组的特点：可重复性，有下标性，数据不可变，不可扩展性。
应用: 在函数的传参或者返回值中使用, 保证数据不会被修改

3.3.2 成员方法

成员方法	描述	实例
index(‘元素’, start_index,end_index)	查找“指定元素”第一次出现的下标值	tuple.index(‘元素’)
count(‘元素’)	查找“指定元素”出现的个数	tuple.count(‘元素’)

3.3.3 枚举（enumerate）

# enumerate( ) 把列表中的每个值转换为元组（0，‘元素’）
lis = ['mon', 'tur', 'sun']
# 遍历
for i in enumerate(lst):
    print(i)

3.4 字典（dict）

3.4.1 定义

Python字典是一个无序的项集合。其他复合数据类型只有值作为元素，而字典有一个键:值对（key：value）。

3.4.2 成员方法

成员方法	描述	实例
del dict[key]	根据字典“键值”来删除元素	del dict[‘key’]
pop[key]	根据字典“键值”来抛出元素	dict.pop[‘key’]
clear()	清空字典的键值对	dict.clear()
get(key)	根据“键值“获取字典中对应的值	dict.get[‘key’]

3.4.3 字典的遍历（3种）

# 1. 遍历字典的键
for k in my_dict.keys():
    print(k)

# 2. 遍历字典的值
for v in my_dict.values():
    print(v)

# 3. 遍历键值
for k, v in my_dict.items():
    print(k, v)

3.4.4 内置函数（zip）

# zip( ) 函数用于把俩个列表组合起来转换为字典
lis1 = ['name','age','day']
lis2 = ['lisi', 12 , 30]
# 第一种方法
for i in zip(lis1,lis2):
    print(f"{i}")
# 第二种方法
lis = list(zip(lis1,lis2))
print(lis)

3.5 集合（set）

3.5.1 定义

集合是项目的无序集合。每个元素都是唯一的（没有重复项），只能增加或删除元素（不能更改元素）。

3.5.2 成员方法

成员方法	描述	实例
add(元素)	在集合末尾添加一个数据	set.add(元素)
remove(元素)	根据“指定元素”删除集合中的值	set.remove(‘元素’)
交集 &	集合相交	set1 & set2
并集 \|	集合并集	set1 \| set2
差集 -	集合相差	set1 - set2

4. 函数

4.1 函数的定义

函数是一组执行特定任务的相关语句。

def function_name(parameters):
	"""docstring"""
	print(parameters)
    return parameters

4.2 函数的参数

4.2.1 默认参数

def greet(name, msg="早上好!"):
    """
    此函数向提供消息的人打招呼。
    如果没有提供消息，
    则默认为“早上好!”
    """
    print("你好", name + ', ' + msg)

4.2.2 关键字参数

def greet(name, msg):
    print("你好", name + ', ' + msg)
    
greet(name='lisi',msg='你好啊!')
greet(msg='你好啊!',name='lisi')
greet('lisi',msg='你好啊!')

4.2.3 任意参数（2种）

不定长元组参数

# 不定长元组参数
def greet(*args):l;kl  
    """此函数被打招呼的对象为
        元组列表中的所有人."""
    for arg in args:
        print("Hello", arg)
# 名称是一个带有参数的元组
greet("Monica", "Luke", "Steve", "John")
greet(*("Monica", "Luke", "Steve", "John"))

不定长字典参数

# 不定长字典参数
def greet(**kwargs):
    """此函数被打招呼的对象为
        元组列表中的所有人."""
    for key in kwargs.keys():
        print(kwargs[key])
# 名称是一个带有参数的字典
greet(a=1, b=2, c=3)
greet(a=1, b=2, c=3)

4.3 闭包函数

4.3.1 定义

闭包函数是指一个函数内部定义的函数，并且内部函数可以访问外部函数的局部变量或者参数。在Python中，函数是一等对象，因此我们可以将函数作为返回值返回，这样就创建了一个闭包函数。

4.3.2 语法

# 闭包函数
def outer_func(*args):
    print(f"this is args: {args}")
    def inner_func(**kwargs):
        print(f"this is kwargs: {kwargs}")
        print(f"this is outer_func de args:{args}")
    return inner_func
a = outer_func(*(1,2,3,4,5,6,7,8))
print("this is inner:",a(**{"name": "lisan", "age" : 18}))
# 结果
this is args: (1, 2, 3, 4, 5, 6, 7, 8)
this is kwargs: {'name': 'lisan', 'age': 18}
this is outer_func de args:(1, 2, 3, 4, 5, 6, 7, 8)
this is inner: None

4.4 装饰器

4.4.1 定义

装饰器是利用了函数的这些特性（函数是一等对象、闭包和语法糖），实现在不修改被装饰函数源代码的情况下，向函数添加额外功能的一种方式。
装饰器本质上是一个函数，它接受一个函数作为输入，并返回一个新的函数，这个新函数通常会包装原始函数并添加额外的功能。

4.4.2 语法

# 装饰器(给函数附加功能)
def decorator(func):
    def cost_time(*args):
        start_time = time.time()
        func(args[0], args[1])
        end_time = time.time()
        print(f"cost time is : {end_time - start_time}")
    return cost_time

@decorator
def user_add(username, password):
    print(f"username: {username} and password: {password}")
    time.sleep(1)

user_add("lisi", 123456)
# 结果
username: lisi and password: 123456
cost time is : 19.870102167129517

4.5 内置函数

4.5.1 map函数（迭代执行）

# 格式
map(func,*args)
# 举例
map(lamdba x : x + 3,range(1,10))

4.5.2 filter函数（过滤）

# 格式
filter(func,*args)
# 举例
filter(lamdba x : x > 0,range(-3,3))

4.6 匿名函数（lambda）

4.6.1 定义

匿名函数: 就是使用 lambda 关键字定义的函数

匿名函数只能书写一行代码。
匿名函数的返回值不需要 return, 一行代码(表达式) 的结果就是返回值。

使用场景: 作为函数的参数, 这个函数比较简单,值使用一次,没有必要使用 def 定义。

4.6.2 语法

lambda 参数: 一行代码   # 这一行代码,称为是表达式

# 匿名函数一般不需要我们主动的调用, 一般作为函数的参数使用的
# 我们在学习阶段为了查看匿名函数定义的是否正确,可以调用
# 1, 在定义的时候 ,将匿名函数的引用保存到一个变量中
变量 = lambda 参数: 一行代码
fun = lambda x : print(x,'Hello')
# 调用lambda函数
fun(9)

5. 面向对象

5.1 面向过程与对象的区别

面向过程
- 关注的是具体步骤的实现, 所有的功能都自己书写
- 亲力亲为
- 定义一个个函数, 最终按照顺序调用函数
面向对象
- 关注的是结果, 谁(对象) 能帮我做这件事
- 偷懒
- 找一个对象(), 让对象去做

5.2 类

5.2.1 定义

抽象的概念, 对多个特征和行为相同或者相似事物的统称
泛指的(指代多个,而不是具体的一个)

5.2.2 组成

类名 (给这多个事物起一个名字, 在代码中满足大驼峰命名法(每个单词的首字母大写))
属性 (事物的特征, 即有什么, 一般文字中的名词)
方法 (事物的行为, 即做什么事, 一般是动词)

5.2.3 特性

封装

封装是指将属性和操作方法打包在一起，形成一个称为类的实体。
类通过公共接口提供对其内部实现细节的访问。
通过封装，我们可以隐藏具体实现的细节，只暴露必要的接口给外部使用。使用关键字class定义一个类来实现封装。

class Animal:
    """动物类"""
    def __init__(self, name, age, fly):
        self.name = name
        self.age = age
        self.__fly = fly

    def eat(self, food):
        print(f"{self.name} is eating {food}")

    def __era(self):
        print(f"{self.name} 是私有方法!")

继承

继承是指使用一个已经存在的类作为基础，从而创建一个新类。
新类可以继承原有类的属性和方法，并可以添加自己特定的属性和方法。
继承提供了重用代码的方式，子类可以重写父类的方法或者添加新的方法。使用关键字class后面跟上父类名称，实现继承。

class Fish(Animal):
    """鱼类"""
    def __init__(self, name, age, color):
        super().__init__(name, age, fly="None")
        self.color = color

    def show(self):
        print(f"{self.name} is showing")

多态

多态是指在不同的对象上执行相同的操作时，可以根据对象的类型执行不同的操作。
多态允许使用一致的方式处理不同类型的对象

5.2.4 语法

class 类名:
    """定义添加属性的方法"""
    def __init__(self, name, age):  # 这个方法是创建对象之后调用
        self.name = name  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性
        
    """在缩进中书写的内容,都是类中的代码"""
    def 方法名(self):   # 就是一个方法
        pass

5.3 魔法方法(内置函数)

5.3.1 init 方法

1. 什么情况下自动调用
    > 创建对象之后会自动调用
2. 有什么用, 用在哪
    > 1. 给对象添加属性的, (初始化方法, 构造方法)   2. 某些代码, 在每次创建对象之后, 都要执行,就可以将这行代码写在 __init__ 方法
3. 书写的注意事项
    > 1. 不要写错了   2. 如果 init 方法中,存在出了 self 之外的参数, 在创建对象的时候必须传参

class Cat:
    # 定义添加属性的方法
    def __init__(self, name, age):  # 这个方法是创建对象之后调用
        self.name = name  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性

5.3.2 _str_ 方法

1. 什么情况下自动调用
    > 使用 print(对象) 打印对象的时候 会自动调用
2. 有什么用, 用在哪
    > 在这个方法中一般书写对象的 属性信息的, 即打印对象的时候想要查看什么信息,在这个方法中进行定义的
    > 如果类中没有定义 __str__ 方法,  print(对象) ,默认输出对象的引用地址
3. 书写的注意事项
    > 这个方法必须返回 一个字符串

class Cat:
    # 定义添加属性的方法
    def __init__(self, n, age):  # 这个方法是创建对象之后调用
        self.name = n  # 给对象添加 name 属性
        self.age = age   # 给对象添加 age 属性

    def __str__(self):
        # 方法必须返回一个字符串, 只要是字符串就行,
        return f'小猫的名字是: {self.name}, 年龄是: {self.age}'

5.3.3 _del_ 方法

__init__ 方法, 创建对象之后,会自动调用  (构造方法)
__del__ 方法, 对象被删除销毁时, 自动调用的(遗言, 处理后事)  (析构方法)

1. 调用场景, 程序代码运行结束, 所有对象都被销毁
2. 调用场景, 直接使用 del 删除对象(如果对象有多个名字(多个对象引用一个对象),需要吧所有的对象都删除才行 )

class Demo:
    def __init__(self, name):
        print('我是 __init__, 我被调用了 ')
        self.name = name

    def __del__(self):
        print(f'{self.name} 没了, 给他处理后事...')

5.3.4 dict方法

__dict__ 方法，查看实例化对象的所有属性

class Demo:
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
        
d1 = Demo('lisan', 12, 1)
print(d1.__dict__) # 展示d1的所有属性

5.4 装饰器

5.4.1 类方法@classmethod

class Demo:
    @classmethod
    dfe met(cls) # cls -> 类本身
    	print(cls)
        
Demo.met()
# 结果
<class '__main__.Work'>

5.4.2 静态方法@staticmethod

class Demo:
    @staticmethod
    def method():
        return 1
    
print('Data is :', Demo.metod())

5.5 cls 和 self 的区别（知识点）

cls和self的区别?
答：cls是类本身的引用，例如：<class '__main__.Work'>。
self是类实例化对象的引用，例如：<__main__.Work object at 0x0000013B1BFCF3D0>
Student # Student -> 是cls的引用
s1 = Student() # s1 -> 是Student的实例化对象，s1-> self

6. 异常，模块，文件

6.1 异常

6.1.1 语法

try:
    可能发生异常的代码
except 异常类型1:
    发生异常类型1执行的代码  
except Exception as 变量:  
    发生其他类型的异常,执行的代码
    # Exception是常见异常类的父类。Exception,可以捕获常见的所有异常, as 变量, 这个变量是一个异常类的对象, print(变量) 可以打印异常信息 
else:
    没有发生异常会执行的代码
finally: 
    不管有没有发生异常,都会执行的代码xxxxxxxxxx

6.2 模块

方式一

import 模块名
# 使用模块中的内容
模块名.工具名

方式二

from 模块名 import 工具名
# 使用
工具名  # 如果是函数和类需要加括号

方式三 [了解] 基本不用

from 模块名 import *  
# 将模块中所有的内容都导入

6.3 文件

6.3.1 文件操作

方法一

# 1.打开文件
file_name = 'a.txt'
file = open(file_name, 'w', encoding='utf-8')
"""
参数 mode:  默认参数(r参数), 表示的是打开文件的方式 
        > r: read 只读打开
        > w: write  只写打开
        > a> append 追加打开, 在文件的末尾写入内容
"""
# 2.读文件
file.read()
file.readline()
# 3.写文件
file.write('好好学习\n')
# 4.关闭文件
file.close()

方法二

with open() 打开文件的好处: 不用自己去书写关闭文件的代码, 会自动进行关闭

file_name = 'a.txt'
with open(file_name, 'r' , encoding='utf-8') as file:
    while True:
        buf = file.readline()
        if buf:  # if len(buf) != 0
            print(buf)
        else:
            break

6.3.2 json 文件的处理

json文件的读取

# 1, 导入 json
import json

# 2, 读打开文件
file_name = 'info.json'
with open(file_name, encoding='utf-8') as f:
    # 3. 读取文件
    result = json.load(f)

json文件的写入

# 1, 导入 json
import json

# 2, 读打开文件
file_name = 'info.json'
data = {
    "name": "Tom",
    "age": 20,
    "city": "New York"
}
with open(file_name, 'w' ,encoding='utf-8') as f:
    # 3. 读取文件
    result = json.dump(my_list, f, ensure_ascii=False, indent=4)
    
# ensure_ascii: 默认值为True，如果该选项为True，则所有非 ASCII 字符将转换成 Unicode 转义序列.
# indent: 如果指定了该参数，则使用指定的缩进间隔，使得输出更加易读.

7. Python 进阶知识

7.1 迭代器（Iterator）

迭代器是可以迭代的对象。
从技术上讲，Python 迭代器对象必须实现两个特殊方法，iter()和__next__()统称为迭代器协议。

lis = [1, 2, 3, 4]
lis_iter = iter(lis)
lis_iter.__next__() # 此操作会使得迭代索引➕1
for i in lis_iter:
    print(i)

7.2 生成器（Yield）

Python生成器是创建迭代器的简单方法。我们上面提到的所有开销都由Python的生成器自动处理。
生成器是一个函数，它返回一个对象（迭代器），我们可以对其进行迭代（一次一个值）。

def demo_yield(n):
    print('start')
    while n > 0:
        print('yiekd before')
        yield n				# 程序执行开始挂起，返回n值
        n -= 1
        print('after yield')
        
y = demo_yield(3)
print(y.__next__())	# 第一次调用
print(y.__next__())	# 第二次调用
print(y.__next__())	# 第三次调用
print(y.__next__())	# 超出调用