python 笔记

• 字面量：写在代码中的固定值。

• type() 查看数据类型

  python 中变量无类型，数据有类型

• 类型转换：str(), int(), float()

• 标识符：字母、中文、数字、下划线

  不推荐使用中文，数字不能在开头

运算符：

// 取整除是指运算后只保留整数，如 11 // 2 = 5，舍弃了 .5

** 就是算平方，如 3 ** 2 = 9，即 3 的 2 次方

复合运算符：+=，-=，//=，**= 等等

字符串

字符串定义方式

如 print('\'test\'')

字符串拼接

+ 号实现字符串拼接，但是不能拼接数字数据。

字符串格式化

name = "yzr"
tel = 7225
print("name: %s, tel:%s" % (name, tel))

占位格式：

字符串精度控制

num = 2.5
print("num:%4.2f" % num) # 结果为:2.50,包括小数点一共4位，多位小数进行缩短会四舍五入。

字符串快速格式化

f"{}" ，f 指 format，不在意类型，不做精度控制。

name = "yzr"
tel = 7225
print(f"name:{name},tel:{tel}") # 双引号可以用单引号替换

对表达式格式化

input 输入

无论键盘输入什么，input 获取的数据永远是字符串。

names = input('你是谁？') # input 的返回值总是字符串，但后续可以进行类型转换
print("你是：%s" % names)
print(f"你是{names}")

条件判断

if 语句

if else 语句

if elif else 语句

下述写法更简洁，在用户输入之后直接判断，如果判断为真，则后续输入不再执行。

循环

while 循环

print 输出不换行

默认 print 输出之后自动换行。

for 循环

待处理数据集是有限的，python for 循环无法构建无限循环。

实际遍历的是序列类型：字符串、元组、列表等

for 循环临时作用域

range 获得一个自定义的数字序列

for 和 range 配合，for x in range(10) 这里的 x 可以不使用，那么就只表示循环 10 次

range 中的参数可以使用变量。

continue 和 break

函数

函数定义语法

None 类型应用场景

1. 函数返回值（函数无返回值时，默认返回None，也可以手动指定None）
2. if 判断中，None 等同于 False。
3. 变量暂不确定值时，可以赋值 None。

函数的说明文档

函数内部的多行注释。

局部变量、全局变量、global 关键字

num = 100

def test_a():
    num = 200
    print(num) # 仍然是 100，此为局部变量

def test_b():
    global num
    num = 300
    print(num) # 变为 300，此为全局变量
    
print(num) # num 为 300，被 test_b 修改

数据容器

列表

列表定义

列表可嵌套列表。

列表不限制数据类型，一个列表可以有多种数据类型。

列表下标索引

列表常用操作

pop 在删除前会返回被删除的元素值。

列表的特点

while 循环和 for 循环对于列表

元组

列表的元素可修改，元组的元素不可修改。可以当作只读列表。

元组定义

定义只有一个元素的元组：t1 = ("hello", ) ，元素后需要加一个逗号 t1 才是元组类型。

元组操作

注意点

• 元组的元素不可以修改，但是元组中嵌套的列表中的元素可以修改。

字符串

不可修改的容器。

下标索引

字符串常用操作

替换

有一个返回值是替换后的字符串，原字符串不变。

分割

规整

strip() 函数的参数默认值是 空格、制表符、回车符、换行符。

第二个语法去除前后的是去除子字符串，都会去除与给定的两个字符相同的字符，不论数量。

my_str = "12hello121221" # 结果是 hello
# my_str = "12hello1212231" 结果是 hello121223
my_str2 = my_str.strip("12")
print(my_str2)

字符串特点

序列切片

切片不会更改序列本身，而是产生一个新序列。

可进行链式编程，如result1 = my_str.replace("来","").split("，")[1][::-1]

例子：

集合

序列：有序且支持下表索引。

集合：不是序列，因为无序且不支持下表索引（无序会导致元素下标不确定），允许修改。

集合定义

变量名称 = {} 这种形式不是空集合，而是 <class 'dict'>

集合的常用操作

**集合1.difference(集合2)**：得到一个新集合，该集合包含 集合1有的元素而集合2没有的元素。

集合的特点

不支持下标，所以不支持 while 循环遍历。

字典

通过 Key 检索 Value，通过中括号 [] 包含Key。

字典定义

嵌套字典

字典注意事项

类似真正的字典。

字典常用操作

遍历字典

不支持下标，所以不能使用 while 循环遍历。

1. 直接使用 for 遍历。
2. 通过 keys 获取所有 Key 再进行遍历。

字典的特点

各个数据容器对比

数据容器的区别

数据容器的通用操作

1. 遍历操作

   

2. 统计操作

   

3. 容器转换

   1. list 转换字典会丢失 Value
   2. str 转换列表或元组实际变成了：”[1,2,3,4,5]”，只是在输出中不带双引号。str 转换字典不会丢失 Value，而是全部转为字符串。
   3. tuple 转换字典会丢失 Value
   4. set 转换字典会丢失 Value，set 转换 list、tuple、str 后内容保留，数据是无序的，重复的话也被去重。

   

4. sorted()

   对内容排序后放入新列表中，就变成了 list 形式，带方括号的。

   sorted(my_list, reverse=True) 会将结果降序排列，默认是升序。

   

函数拓展

函数有多个返回值

函数多种参数

位置参数

关键字参数

缺省参数（默认参数）

不定长参数

也叫可变参数。

当调用函数时不确定参数个数时，使用不定长参数。

1. 位置传递
   
2. 关键字传递
   

不定长参数总结：

函数作为参数

函数作为参数实现了逻辑（+-*/）的传递，数据作为参数只是数据的传递。

lambda 函数（匿名函数）

函数体不需要return，自动return结果。

例子：

def test_func(func,x , y):
    return func(x, y)

result = test_func(lambda x, y:x*y,3, 4)

print(result)

文件

文件编码

编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。

最常用 UTF-8 编码。

文件打开和读操作

open

mode模式：

读操作

每次调用 read() 方法会移动文件指针。

关闭文件

with open 语法将打开的文件起名为 f 对象。

操作总结

文件写入

write

‘w’ 模式，文件不存在则创建文件，文件存在则覆写文件。

使用 f.close() 也有 flush 的功能。

文件追加

异常

异常的语法

下图的中括号内部的是可选的。

Exception 是最顶级的异常，可以作为捕获所有的异常。

使用 print(别名) 时，可以打印出捕获到的异常的说明。

try:
    # print("helo")
    # print(name)
    1 / 0
# except Exception as e:
except (NameError, ZeroDivisionError) as e:
    print("抛出异常", end=":")
    print(e)
else:
    print("没有异常")
finally:
    print("有没有异常都要做")

异常具有传递性

可以在异常传递的任一途径进行捕获并处理异常。

模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码.

导入模块

中括号内的内容是可选的。

如果导入了两个同名模块或函数，只会导入最后导入的那个，此时可以用别名。

1. import 模块名

   

2. from 模块名 import 功能名

   

3. from 模块名 import *

   与第一种方法区别是调用模块内函数前面不需要加模块名。

   

4. as 定义别名

   避免多模块或内部函数名重复，或者模块或函数名过长。

   

自定义模块并导入

自定义模块也就是一个python文件，只要命名符合标识符规范就行。

如果在模块中想要进行测试，模块中就包含了测试代码，此时直接导入该模块到其它文件会执行测试代码。

当前执行的文件的 __name__ 变量的值是 __main__ ，而导入的模块的__name__ 变量的值是模块名。

# 该文件是个模块文件，内部包含测试代码。
def add(x, y):
    print(x+y)

def minus(x, y):
    print(x-y)

if __name__ == "__main__": # 执行时只有内置变量 __name__ 是 __main__ 才会执行，而作为模块导入后的 __name__ 变量不是 __main__
    add(1, 2)
    minus(4, 5)

__all__

__all__ 是一个列表，默认包含当前模块的所有函数方法，如果自己定义的话，使用 from xx import * 导入就只能导入自定义的那些函数方法。

但就算 __all__ 中没有某个函数方法，也可以通过手动导入，如 from xx import func ，也可以 import xx 直接导入整个模块。

模块包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个 __init__.py 文件，该文件夹可用于包含多个模块文件

从逻辑上看，包的本质依然是模块

导入包的方式

1. 一
2. 二

安装第三方包

命令：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名

项目

json 数据

JSON本质上是一个带有特定格式的字符串。

json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互。

python 和 json 的数据转换

小结

制作图表的模块包

pyecharts 相关网站：

pyecharts 主页（一些配置信息）

pyecharts 可生成的图表大全

sort 函数

类和对象

• 类的属性，即定义在类中的变量（成员变量）
• 类的行为，即定义在类中的函数（成员方法）

类的定义方法

成员方法的形参中必须有 self。

self：

1. 表示类对象本身的意思
2. 只有通过self，成员方法才能访问类的成员变量
3. self出现在形参列表中，但是不占用参数位置，无需理会

魔术方法

类似c++运算符重载。

方法	功能
__init__	构造方法，可用于创建类对象的时候设置初始化行为
__str__	用于实现类对象转字符串的行为
__lt__	用于2个类对象进行小于或大于比较
__le__	用于2个类对象进行小于等于或大于等于比较
__eq__	用于2个类对象进行相等比较（如果不自定义，则会对类对象内存地址比较）

__str__

__lt__

__le__

__eq__

私有成员

定义

成员变量和成员方法的命名均以__作为开头即可

私有成员的使用

类对象无法访问私有成员。

类中的其它成员可以访问私有成员。

继承

继承后的类可以有自己的成员变量和成员方法，也可以使用继承的父类的非私有成员变量和非私有成员方法。

继承语法

单继承

多继承

多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。

先继承的保留，后继承的被覆盖。

pass 关键字

pass是占位语句，用来保证函数（方法）或类定义的完整性，表示无内容，空的意思。

子类复写父类成员

在子类中重新定义实现同名成员方法或成员属性即可。

子类调用父类同名成员

如果在多继承中使用 super() 调用父类（多个父类有同名成员）同名成员，那么会根据继承顺序从左到右的优先级调用。

只可以在子类内部调用父类的同名成员，子类的实例对象调用默认是调用子类复写的。

类型注解

类型注解是非强制性的，只起到提示作用。

变量类型注解

可以在变量之后加冒号进行类型注解（var: int = 10），也可以在注释中进行类型注解（# type: int）。

类型详细注解：使用中括号，如 var: list[int] = [1, 2, 3]

• 元组类型设置类型详细注解，需要将每一个元素都标记出来。
• 字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value。

示例代码：

"""
演示变量的类型注解
"""

# 基础数据类型注解
import json
import random

# 基础变量类型注解
var_1: int = 10
var_2: str = "itheima"
var_3: bool = True
# 类对象类型注解
class Student:
    pass
stu: Student = Student()

# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"itheima": 666}

# 容器类型详细注解
my_list: list[int] = [1, 2, 3]
my_tuple: tuple[int, str, bool] = (1, "itheima", True)
my_dict: dict[str, int] = {"itheima": 666}

# 在注释中进行类型注解
var_1 = random.randint(1, 10)   # type: int
var_2 = json.loads('{"name": "zhangsan"}')  # type: dict[str, str]
def func():
    return 10
var_3 = func()  # type: int

# 类型注解的限制，类型和数据不同也不会报错
var_4: int = "itheima"
var_5: str = 123

函数参数类型注解

对函数参数类型进行注解：

对函数返回值类型进行注解：

Union 联合类型注解

用于定义联合类型注解，如 list 中既有 int 又有 str 类型，字典中的 Value 既有 int 又有 str 类型。

1. 导包。
2. 通过 Union 指定包含的类型。

from typing import Union

testList: list[Union[int, str, bool]] = [1, "str", True]

testDict: dict[str, Union[str, int]] = {"name": "A", "age": 18}

testDict: dict[Union[str, int], Union[str, int]] = {"name": "A", "age": 18, 1: "1"}

函数或返回值也可以使用Union进行注解：、

下述函数形参类型注解表示既可以接受 int 也可以接收 str 类型。

下述返回值类型注解表示既可以返回 int 也可以返回 str 类型。

多态

多态：多种状态，即完成某个行为时，使用不同的对象实例会得到不同的状态行为。

常用于定义一个接收父类的函数，但是传入子类对象进行工作：

抽象类（接口）

用于规范一个顶层标准，由继承该抽象类的子类再实现所有成员方法。

抽象类是包含抽象方法的类。抽象方法相当于 c++ 的纯虚函数，python 在成员方法中使用 pass 使得该方法变为抽象方法。

如果某个子类继承了一个抽象类，则该子类在重写抽象类中的成员方法时需要保持形参一致。不要再重写方法时随意添加或删除参数（不要违反 Liskov 替换原则）。

SQL

数据库（库->表->数据）是用来存储数据的，而SQL语言(Structured Query Language，结构化查询语言)，就是一种对数据库、数据进行操作、管理、查询的工具。

字符串的值，出现在SQL语句中，必须要用单引号包围起来。

SQL 语言分为：

SQL 语言特点：

DDL

库管理

表管理

DML

插入、更新、删除

插入

删除

更新

DQL

数据查询

数据过滤

分组聚合

排序和分页限制

python 操作 mySQL

安装第三方库 pymysql

连接

执行操作

执行查询语句

插入

插入需要 commit 确认。

Spark

Spark是一款分布式的计算框架，用于调度成百上千的服务器集群，计算TB、PB乃至EB级别的海量数据，是全球顶级的分布式计算框架，支持众多的编程语言进行开发。

pyspark

python下的第三方库 pyspark 就是 Spark。

pyspark 编程模型

构建PySpark执行环境入口对象

RDD 对象

RDD 对象想要获取可读数据，需要调用 collect() 方法。

1. python 数据容器转换为 RDD 对象

   

2. 读取文件转换为 RDD 对象

   

python 高阶技巧

闭包

在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。

定义双层嵌套函数， 内层函数可以访问外层函数的变量，将内存函数作为外层函数的返回，此内层函数就是闭包函数。

优点：

• 无需定义全局变量即可实现通过函数，持续的访问、修改某个值

  因为定义了全局变量的话，被导包时该全局变量可以被修改。

• 闭包使用的变量的所用于在函数内，难以被错误的调用修改

缺点：

• 由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放，一直占用内存

下图右侧为闭包：

定义

nonlocal

用于使闭包的内层函数可以修改外层函数的变量。

装饰器

在不改动函数功能的前提下，为函数添加新功能。在函数前执行一个功能，在函数后再执行一个功能，装饰作用。

@outer 语法糖，意味着为之后的函数增加功能，效果也就是将之后的函数传入 outer 函数。

1. 为目标函数（要添加新功能的函数）构建一个闭包。
2. 通过 @ 语法糖+闭包的外层函数，也就是装饰器。也就是给 sleep(目标函数)增加了一个 outer（闭包） 的装饰器

装饰器的一般写法（闭包写法）

装饰器的语法糖写法

语法糖

语法糖（Syntactic sugar）是计算机科学中的一个术语，指的是一种编程语言中添加的语法结构，可以使代码更易读、更简洁，但并不会带来新的功能。语法糖并不改变语言的功能，只是让代码更加易于编写和理解。

语法糖通常是对一些常用模式、约定或者惯用法的简化表示，它使得代码更具可读性、更易于记忆，同时也可以减少代码的书写量。语法糖的存在并不是必要的，但它能够提高代码的可读性和编写效率。

例如，在Python中，列表推导式就是一种语法糖。它提供了一种简洁的方式来创建列表，而不需要使用显式的循环语句。另一个例子是Python中的装饰器（Decorator），它是一种语法糖，可以简化函数的装饰和扩展功能的实现。

设计模式

设计模式是一种编程套路，可以极大的方便程序的开发。

最常见、最经典的设计模式，就是我们所学习的面向对象了。

除了面向对象外，在编程中也有很多既定的套路可以方便开发，我们称之为设计模式：

• 单例、工厂模式

• 建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式

• 等等模式

单例模式

单例模式（Singleton Pattern）是一种创建型设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。简单概括单例模式可以归纳为以下几点：

1. 唯一实例：单例模式确保一个类只有一个实例存在，无论何时何地请求该类的实例，都返回同一个实例。

2. 全局访问点：单例模式提供一个全局访问点，使得其他对象可以轻松获取该类的唯一实例。

3. 延迟实例化：单例模式通常延迟实例化，即在第一次请求实例时才创建实例。

4. 线程安全：在多线程环境下，单例模式需要考虑线程安全性，确保只有一个实例被创建。

总的来说，单例模式适用于需要全局访问某个对象实例，并且确保只有一个实例存在的情况。它可以帮助简化代码结构、节省系统资源，并提供一个统一的访问点。

代码实现

工厂模式

将对象的创建由使用原生类本身创建转换到由特定的工厂方法来创建。

工厂模式（Factory Pattern）是一种创建型设计模式，旨在提供一种统一的方式来创建对象，而无需指定具体创建哪个类。工厂模式通过定义一个创建对象的接口，但是将对象的实际创建延迟到子类中来实现，从而实现对象的解耦和灵活性。

工厂模式通常包括以下几种形式：

1. 简单工厂模式（Simple Factory Pattern）：由一个工厂类负责创建多个不同类型的对象，客户端通过传递不同的参数来指定要创建的对象类型。

2. 工厂方法模式（Factory Method Pattern）：定义一个创建对象的抽象方法，由子类来实现具体的对象创建，客户端只需要调用接口即可，无需关心具体的实现类。

3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类，使得一系列对象的创建可以独立变化而不影响客户端。

工厂模式能够降低代码的耦合度，使得代码更具灵活性和可扩展性。它将对象的创建和使用分离开来，使得系统更容易维护和扩展。

优点：

• 大批量创建对象的时候有统一的入口，易于代码维护
• 当发生修改（即构造对象的类方法发生变化），仅修改工厂类的创建方法即可
• 符合现实世界的模式，即由工厂来制作产品（对象）

正则表达式

正则表达式，又称规则表达式（Regular Expression），是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换那些符合某个模式（规则）的文本。

简单来说，正则表达式就是使用：字符串定义规则，并通过规则去验证字符串是否匹配。

原始字符串

在Python中，字符串前面的r是原始字符串（Raw String）的标识符，用于告诉解释器将字符串中的转义字符视为普通字符，而不是特殊字符。原始字符串中的反斜杠\不会被解释为转义字符，而是作为普通字符处理。

例如，正则表达式常用反斜杠\来表示特殊字符，如\d表示数字字符，\s表示空白字符等。如果不使用原始字符串，需要双重转义，即'\\d'或'\\s'，而使用原始字符串可以使代码更清晰、简洁。

示例：

# 不使用原始字符串，需要双重转义
pattern = '\\d+'
print(pattern)  # 输出：\d+

# 使用原始字符串，不需要双重转义
pattern = r'\d+'
print(pattern)  # 输出：\d+

因此，原始字符串的作用是简化字符串中特殊字符的处理，特别在处理正则表达式、文件路径等需要使用反斜杠的情况下非常有用。

re 模块的常用方法

在Python的re（Regular Expression）模块中，有三个常用的方法：match()、search()和findall()，用于在字符串中进行正则表达式匹配。以下是它们的简介和使用方法：

1. **match(pattern, string, flags=0)**：

   • 简介：从字符串的开头开始匹配正则表达式模式。
   • 使用方法：如果在字符串的开头找到了匹配的模式，则返回一个匹配对象；如果没有找到匹配，返回None。
   • 示例代码：

     import re
     
     pattern = r'hello'
     string = 'hello world'
     result = re.match(pattern, string)
     if result:
         print('Match found:', result.group())
     else:
         print('No match')

2. **search(pattern, string, flags=0)**：

   • 简介：在整个字符串中搜索匹配正则表达式模式的位置。
   • 使用方法：返回第一个匹配项的匹配对象；如果没有找到匹配，返回None。
   • 示例代码：

     import re
     
     pattern = r'world'
     string = 'hello world'
     result = re.search(pattern, string)
     if result:
         print('Match found:', result.group())
     else:
         print('No match')

3. **findall(pattern, string, flags=0)**：

   • 简介：在字符串中查找所有匹配正则表达式模式的子串，并返回一个包含所有匹配子串的列表。
   • 使用方法：返回一个包含所有匹配子串的列表；如果没有找到匹配，返回空列表。
   • 示例代码：

     import re
     
     pattern = r'\d+'
     string = 'There are 123 apples and 456 oranges'
     result = re.findall(pattern, string)
     print('Matches found:', result)

span() 和 group() 方法：

在Python的re模块中，match()、search()和findall()这三个方法返回的匹配对象都包含了span()和group()方法。这两个方法用于获取匹配对象的位置和内容。以下是它们的简介和使用方法：

1. span()方法：

   • 简介：span()方法返回一个包含匹配对象开始和结束位置的元组。
   • 使用方法：调用span()方法会返回一个元组，元组的第一个元素是匹配对象的起始位置，第二个元素是结束位置（不包括）。
   • 示例代码：

     import re
     
     pattern = r'world'
     string = 'hello world'
     result = re.search(pattern, string)
     if result:
         print('Match found:', result.group())
         print('Match position:', result.span())

2. group()方法：

   • 简介：group()方法返回匹配对象的字符串表示。
   • 使用方法：调用group()方法会返回匹配的字符串。
   • 示例代码：

     import re
     
     pattern = r'\d+'
     string = 'There are 123 apples and 456 oranges'
     result = re.search(pattern, string)
     if result:
         print('Match found:', result.group())

这两个方法可以帮助我们获取匹配对象的位置和内容，对于处理正则表达式匹配时非常有用。

元字符匹配

递归

在Python中，递归是指函数可以调用自身的编程技术。递归函数通常在解决问题时将问题分解为更小的子问题，并通过递归调用自身来解决这些子问题。递归在某些情况下可以简化问题的解决方案，但需要小心处理递归结束条件，以避免无限循环。

函数调用自己，即称之为递归调用。

递归的基本原理

1. 递归函数调用自身：在函数内部调用函数本身来解决更小规模的问题。
2. 递归结束条件：必须定义一个递归结束条件，以避免无限递归。

递归示例：计算阶乘

下面是一个简单的示例，展示如何使用递归来计算阶乘（factorial）：

def factorial(n):
    if n == 0:  # 递归结束条件
        return 1
    else:
        return n * factorial(n - 1)  # 递归调用自身

# 计算5的阶乘
result = factorial(5)
print("Factorial of 5 is:", result)

在这个示例中，factorial()函数用于计算一个数的阶乘。当输入参数为0时，函数返回1作为结束条件；否则，函数通过调用自身来计算n的阶乘。

递归的关键在于找到递归结束条件，确保递归调用不会无限循环。在编写递归函数时，需要谨慎选择递归结束条件，以及确保递归调用能够收敛到结束条件。递归在某些情况下可以提供简洁、优雅的解决方案，但需要小心处理避免潜在的问题。

python 菜鸟编程补充

推导式

reference

• 列表(list)推导式

  [表达式 for 变量 in 列表] 
  [out_exp_res for out_exp in input_list]
  
  或者 
  
  [表达式 for 变量 in 列表 if 条件]
  [out_exp_res for out_exp in input_list if condition]

  • out_exp_res：列表生成元素表达式，可以是有返回值的函数。
  • for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
  • if condition：条件语句，可以过滤列表中不符合条件的值。

  >>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
  >>> new_names = [name.upper()for name in names if len(name)>3]
  >>> print(new_names)
  ['ALICE', 'JERRY', 'WENDY', 'SMITH']

  列表生成式的if语句可以放在两个地方，分别有着不同的含义。

  1. 如果if放在for之后，那么if语句用于过滤for循环遍历到的元素。只有满足if条件的元素才会被用于生成新的列表。例如：

     [x for x in range(10) if x % 2 == 0]

     这个列表生成式会生成一个包含0到9中所有偶数的列表。

  2. 如果if放在for之前，那么它是一个三元表达式，用于根据条件决定列表中元素的值。例如：

     [x if x % 2 == 0 else -x for x in range(10)]

     这个列表生成式会生成一个列表，其中偶数保持不变，奇数取负。

  所以，if语句的位置决定了它的作用：放在for后面用于过滤元素，放在for前面用于决定元素的值。

• 字典(dict)推导式

  { key_expr: value_expr for value in collection }
  
  或
  
  { key_expr: value_expr for value in collection if condition }

  listdemo = ['Google','Runoob', 'Taobao']
  # 将列表中各字符串值为键，各字符串的长度为值，组成键值对
  >>> newdict = {key:len(key) for key in listdemo}
  >>> newdict
  {'Google': 6, 'Runoob': 6, 'Taobao': 6}

• 集合(set)推导式

  { expression for item in Sequence }
  或
  { expression for item in Sequence if conditional }

• 元组(tuple)推导式

  元组并没有推导式。当你在括号中使用类似推导式的语法时，你实际上创建的是一个生成器。这是因为在Python中，圆括号被用于多个场景，包括定义元组、定义生成器以及改变运算优先级等。

  gen = (x**2 for x in range(10))

  这个生成器可以通过next函数或者在循环中使用。

  (expression for item in Sequence )
  或
  (expression for item in Sequence if conditional )

迭代器和生成器

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

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

迭代器

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

字符串，列表或元组对象都可用于创建迭代器（可用 for 遍历迭代器，也可以用 next）：
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况

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

#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
    

#!/usr/bin/python3
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

生成器

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

def countdown(n):
    while n > 0:
        yield n
        n -= 1

# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

输入和输出

https://www.runoob.com/python3/python3-inputoutput.html

文件打开模式比较：

带 + 号是读写，不带 + 号是只读只写等。

pylint 代码检测

pip install pylint

1. 在代码报出警告的前一行添加注释指令 # pylint: disable=C0114 可避免该指令警告。
   常见于：C0114: Missing module docstring (missing-module-docstring)

2. vscode 中左下角点击设置、用户、右上角的 打开设置(json) ，加入以下配置：

   "pylint.args": [
       "--disable=missing-module-docstring",
       "--disable=missing-class-docstring",
       "--disable=missing-function-docstring"
   ]