目录
列表使用：[] ，元组使用：() ，字符串使用：“” ，集合使用：{}
Python数据容器
列表list使用：[] ，元组tuple使用：() ，字符串str使用：“” ，集合set使用：{}，字典dict使用{}
list(列表)
定义变量：变量名称=[元素1,元素2,元素3...]
定义空列表：变量名称=[] or 变量名称=list()
列表索引：从左到右：0 → len(list)-1 从右到左：-1 → -len(list)
注：列表内元素可以为不同数据类型，可以重复，支持嵌套，数据有序存储，可以修改
列表方法：
list的遍历：
①while循环遍历(while循环可以遍历有索引的容器)：
index=0 while index<len(list): value1=list[index] 处理逻辑 index+=1 |
②for循环遍历：
for i in list: value1=i 逻辑处理 |
俩个循环的细节：
while可以自定义循环条件，自行控制
for循环不可以自定循环条件，只能一个个取数据
while可以做到无限循环，for循环不行
tuple(元祖)
定义元祖变量：变量名称=(元素1，元素2，元素3...)
定义空元祖： 变量名称=() or 变量名称=tuple()
元组索引：从左到右：0 → len(list)-1 从右到左：-1 → -len(list)
注：元组内元素可以为不同数据类型，可以重复，支持嵌套，数据有序存储，不可以修改(但可以修改元组内的列表内的元素)，元组只有一个元素，则这个元素后面要添加逗号
元祖相关操作：
元组的遍历：同样可以和列表list一样，进行俩种循环方式遍历
str(字符串)
字符串和元组都是无法修改的容器，修改的话只会生成一个新的字符串，索引和列表一样
字符串操作：
遍历：同list和tuple一样，都可以用俩种循环方式遍历
数据容器(序列)的切片
序列是指：内容连续、有序，可使用下标索引的一类数据容器。 列表、元组、字符串，均可以可以视为序列
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长] 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列： 起始下标表示从何处开始，可以留空，留空视作从头开始 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾 步长表示，依次取元素的间隔 步长1表示，一个个取元素 步长2表示，每次跳过1个元素取 步长N表示，每次跳过N-1个元素取 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记） |
注：切片不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）,结束下标不含进切片
例：list=[1,2,3,4,5,6] list1=list[4:1:-1] print(list1) 结果：[5,4,3] |
set(集合)
定义集合变量：变量名称={元素1,元素2,元素3...}
定义空集合：变量名称=set()
列表使用：[] ，元组使用：() ，字符串使用：“” ，集合使用：{}
注：去重且无序
集合操作：
遍历方式：for循环，while循环不可遍历无序的容器
dict(字典、映射)
定义字典变量：变量名称={key:value1，key:value2，key:value3...}
定义空字典：变量名称=dict()
注：使用{}存储，key不可重复，key不可以为字典，可以镶嵌，类似java中的map
字典常用操作：
数据容器对比：
Python函数
def function_name(传参)： 函数体 return xxx （可返回也可不返回--默认为NONE） |
多个返回值：
按照返回值顺序，写对应顺序的多个变量接受即可，变量之间逗号隔开，支持不同类型数据return
def func1(): return 1,2 x,y=func1() |
函数多种传参：
位置参数：传递的参数和定义的参数的顺序及个数必须一致
关键字参数：函数调用时通过“键=值”形式传递参数。
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
函数调用时，如果为缺省参数传值则修改默认参数值, 否则使用这个默认值
不定长参数：
①位置传递：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递
def func1(*args):
print(args)
func1('zhangsan','lisi') |
②关键字传递：参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典.
def func1(**kwargs): print(args) func1(name1='zhangsan',name2='lisi') |
匿名函数：
函数作为参数传递：计算逻辑的传递，而非数据的传递
def func1(func): print(func(1,2)) def func2(x,y): return x+y func1(func2) #结果：3 |
lambda匿名函数：
定义： lambda 传入参数：函数体（一行代码）
注：lambda匿名函数只能写一行，无法写多行代码，只可临时使用一次
函数定义中：
- def关键字，可以定义带有名称的函数
- lambda关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用。 无名称的匿名函数，只可临时使用一次。
def func1(func): print(func(1,2)) func1(lambda x,y:x+y) #结果：3 |
Python文件操作：
文件操作流程：打开文件 → 读写文件 → 关闭文件
文件读取：
使用open函数，可以打开一个已经存在的文件，或者创建一个新文件： open(name, mode, encoding)
例：
f = open('python.txt', 'r', encoding=”UTF-8)
# encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
mode的三种基本模式：r (只读形式) , w(打开文件覆盖写，不存在则创建文件) ，a(打开文件追加写，不存在则创建文件)
文件的读操作方法：
文件写入：
文件的写方法是 文件对象.write() ，此时内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
当 文件对象.flush() 的时候，内容才真正写入文件，这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）
异常、模块与包
异常：
try: xxx #抛出异常的代码 except Exception as e: #捕获异常，也可以用元组的方式书写多个异常如： except (NameError,ZeroDivisionError) xxx #捕获异常后的动作：打印异常？ else: xxx #如果没有异常要执行的代码 finally: xxx #最后要做的事情 |
异常具有传递性
python模块：
是一个 Python 文件，以 .py 结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码。简白：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）
模块导入方式： [from 模块名] import [模块 | 类 | 变量 | 函数 | * ] [as 别名]
自定义模块：
在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用。
注：①.在当前工具模块中使用 if __name__ == '__main__': 表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入，所以可以用来进行模块中的函数测试等
②.当导入多个模块的时候，且模块内有同名功能. 当调用这个同名功能的时候，调用到的是后面导入的模块的功能
③.如果一个模块文件中有`__all__`变量，当使用`from xxx import *`导入时，只能导入这个列表中的元素： __all__=['func1','func2']
python包：
自定义包：从物理上看，包就是一个文件夹，在该文件夹下包含了一个 __init__.py 文件，该文件夹可用于包含多个模块文块；从逻辑上看，包的本质依然是模块
作用：当我们的模块文件越来越多时,包可以帮助我们管理这些模块, 包的作用就是包含多个模块，但包的本质依然是模块，通过__init__.py来管理模块
操作流程：
1、新建包-package，然后模块放到package内
2、在package中的__init__.py文件中添加模块： __all__=[''模块1,'模块2']
3、在想使用的模块中导入包即可使用
Python面向对象
类和对象：
类是程序的设计图纸，对象是基于图纸产生的实体
类的定义：
class 类名称: #class是关键字，表示类 类型的属性 #定义在类中的变量(成员变量) 类的方法 #定义在类中的函数(成员方法) 对象=类名称() #创建类对象的语法 |
成员方法的定义语法：
def 方法名(self,形参1，形参2，...)：
方法体
#self关键字必填，表示类对象本身的意思，在方法内部想要访问类的成员变量必须使用self
#self关键字在传参的时候可以省略，当使用类对象调用方法的时候，self会自动被python传入
例：
def say_hi(self,):
print(f"hello,我是{self.name}") |
构造方法：
python类可以使用 __init__() 方法，称为构造方法
构造方法的俩个作用：①该方法会在创建对象时候自动执行 ②创建对象时候，将传入参数自动传递给 __init__() 方法使用
#可以替代 成员属性赋值 def __init__(self,v1,v2,...): self.value1=v1 self.value2=v2 ... |
内置方法：
封装：
私有成员变量：变量名以 __ 开头（2个下划线）
私有成员方法：方法名以 __ 开头（2个下划线）
私有的成员只能被本类的成员和方法使用，不能被类对象使用（获取值，设置值）
继承：
单继承、多继承：从父类继承成员变量和方法
class 类名(父类1,父类2,....父类N): 类内容体 |
注意：继承的优先级为从左到右
类的方法如果不写可以用pass关键字占位，记为该类为抽象类，需要继承的子类去实现该方法
class 父类: def func1(self): pass class 子类(父类)： def func1(self): 必须重写方法体 |
调用父类成员：父类名.成员变量/方法 or super().成员变量/方法
类型注解：
类似java中的泛型，一般无法看出变量类型才会使用注解。注解是提示性的，不是决定性的
注解方式：
① 变量：类型 ② #type：类型
所有的注解的使用都是 [ ]
变量类型注解：
为变量、类对象设置注解：
为容器设置注解：
函数（方法）的类型注解：
形参注解：
返回值类型注解：
Union联合类型注解：
导包： from typing import Union
使用Union[类型，.... ，类型]
这里的my_list：list[Union[int,str]] 应该是这样
多态：
抽象类（接口）：
使用含义：抽象的父类进行设计（设计标准），具体的子类实现（实现标准）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
