列表 list
定义
由一系列变量组成的可变序列容器。
列表内存
"""
列表内存图
１５：４０ 练习:exercise04.py
exercise05.py exercise06.py"""
list01 = ["张无忌","赵敏"]
list02 = list01
# 修改的是列表第一个元素
list01[0] = "无忌"
print(list02[0])
list01 = ["张无忌","赵敏"]
list02 = list01
# 修改的是list01变量
list01 = ["无忌"]
print(list02[0])#张无忌
list01 = [800,1000]
# 通过切片获取元素，会创建新列表.
list02 = list01[:]
list01[0] = 900
print(list02[0])#?800
list01 = [500]
print(list02[0])#?800
# 列表套列表
list01 = [800,[1000,500]]
list02 = list01
list01[1][0] = 900
print(list02[1][0])#?900
list01 = [800,[1000,500]]
# 浅拷贝
# list02 = list01[:]
list02 = list01.copy()
list01[1][0] = 900
print(list02[1][0])#?900
import copy
list01 = [800,[1000,500]]
# 深拷贝
list02 =copy.deepcopy(list01)
list01[1][0] = 900
print(list02[1][0])#?
基础操作
- 创建列表：
- 列表名 = []
- 列表名 = list(可迭代对象)
# 1. 创建列表
# 空
list01 = []
list01 = list()
# 默认值
- 获取元素
# 2. 获取元素
# 索引
print(list02[2]) # 齐
# 切片
print(list02[-4:]) # ['齐', '天', '大', '圣']
- 添加元素：
- 列表名.append(元素)
- 列表.insert(索引，元素)
# 3. 添加元素
# 追加(在末尾添加)
list02.append("八戒")
# 插入(在指定位置添加)
list02.insert(1, True) # 在索引为１(第二个)的位置添加True
- 删除元素：
- 列表名.remove(元素)
- del 列表名[索引或切片]
# 4. 删除元素
# 根据元素删除
list02.remove("是")
# 根据位置删除
del list02[0]
print(list02)
- 定义元素：
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。
# 切片
del list02[1:3]
print(list02)
# [True, '大', '圣', '八戒']
# [True, 'a', 'b', '八戒']
list02[1:3] = ["a", "b"]
# [True,'八戒']
# list02[1:3] = []
print(list02)
- 遍历列表：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
# 遍历列表
# 获取列表中所有元素
for item in list02:
print(item)
# 倒序获取所有元素
# 不建议
# list02[::-1] 通过切片拿元素，会重新创建新列表.
# for item in list02[::-1]:
# print(item)
# 3 2 1 0
for i in range(len(list02) - 1, -1, -1):
print(list02[i])
# -1 -2 -3 -4
for i in range(-1, -len(list02) - 1, -1):
print(list02[i])
深拷贝和浅拷贝
浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。
列表VS字符串
-
列表和字符串都是序列,元素之间有先后顺序关系。
-
字符串是不可变的序列,列表是可变的序列。
-
字符串中每个元素只能存储字符,而列表可以存储任意类型。
-
列表和字符串都是可迭代对象。
-
函数：
将多个字符串拼接为一个。
result = “连接符”.join(列表)
将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
列表推导式
- 定义：
使用简易方法，将可迭代对象转换为列表。
- 语法：
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
- 说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
列表推导式嵌套
- 语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
- 传统写法：
result = []
for r in [“a”, “b”, “c”]:
for c in ["A", "B", "C"]:
result.append(r + c)
- 推导式写法：
result = [r + c for r in list01 for c in list02]
"""
列表推导式
练习:exercise01.py
"""
# 将list01中所有元素,增加１以后存入list02中.
list01 = [5, 56, 6, 7, 7, 8, 19]
# list02 = []
# for item in list01:
# list02.append(item + 1)
list02 = [item + 1 for item in list01]
print(list02)
# 将list01中大于１０元素,增加１以后存入list02中.
# list02 = []
# for item in list01:
# if item >10:
# list02.append(item + 1)
list02 = [item + 1 for item in list01 if item > 10]
list01 = ["a", "b", "c"]
list02 = ["A", "B", "C"]
list03 = []
for r in list01:
for c in list02:
list03.append(r + c)
print(list03)
list04 = [r + c for r in list01 for c in list02]
print(list04)
# 练习:列表的全排列
# [“香蕉”,"苹果","哈密瓜"]
# [“可乐”,"牛奶"]
list01 = ["香蕉","苹果","哈密瓜"]
list02 = ["可乐","牛奶"]
list03 = []
for r in list01:
for c in list02:
list03.append(r+c)
list04 = [r+c for r in list01 for c in list02]
print(list03)
print(list03)
元组 tuple
定义
-
由一系列变量组成的不可变序列容器。
-
不可变是指一但创建，不可以再添加/删除/修改元素。
基础操作
- 创建空元组：
元组名 = ()
元组名 = tuple()
- 创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
- 获取元素：
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表
- 遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
元组名[索引名]就是元素
作用
-
元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
-
元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
-
应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)
字典 dict
定义
-
由一系列键值对组成的可变散列容器。
-
散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
-
键必须惟一且不可变(字符串/数字/元组)，值没有限制。
基础操作
- 创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象)
- 添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改值。
- 获取元素：
变量 = 字典名[键] # 没有键则错误
- 遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
- 删除元素：
del 字典名[键]
# 1. 创建
# 空
dict01 = {}
dict01 = dict()
# 默认值
dict01 = {"wj":100,"zm":80,"zr":90}
dict01 = dict([("a","b"),("c","d")])
print(dict01)
# 2. 查找元素(根据ｋｅｙ查找ｖａｌｕｅ)
print(dict01["a"])
# 如果ｋｅｙ不存在，查找时会错误.
if "qtx" in dict01:# 如果存在key
print(dict01["qtx"])
# 3. 修改元素(之前存在ｋｅｙ)
dict01["a"] = "BB"
# 4. 添加(之前不存在ｋｅｙ)
dict01["e"] = "f"
# 5. 删除
del dict01["a"]
print(dict01)
# 6. 遍历（获取字典中所有元素）
# 遍历字典，获取key
for key in dict01:
print(key)
print(dict01[key])
# 遍历字典，获取value
for value in dict01.values():
print(value)
# 遍历字典，获取键值对key value(元组).
# for item in dict01.items():
# print(item[0])
# print(item[1])
for k,v in dict01.items():
print(k)
print(v)
字典推导式
- 定义：
使用简易方法，将可迭代对象转换为字典。
- 语法:
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}
字典 VS 列表
-
都是可变容器。
-
获取元素方式不同,列表用索引,字典用键。
-
字典的插入,删除,修改的速度快于列表。
-
列表的存储是有序的,字典的存储是无序的。
# 1 2 3 4 ... 10 -> 平方
dict01 = {}
for item in range(1, 11):
dict01[item] = item ** 2
print(dict01)
# 推导式:
dict02 = {item: item ** 2
for item in range(1, 11)}
print(dict02)
# 只记录大于５的数字
dict01 = {}
for item in range(1, 11):
if item >5:
dict01[item] = item ** 2
print(dict01)
dict02 = {item: item ** 2
for item in range(1, 11) if item >5}
print(dict02)
集合 set
定义
-
由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
-
相当于只有键没有值的字典(键则是集合的数据)。
![[字典内嵌列表内存图.jpg]]
基础操作
- 创建空集合：
集合名 = set()
集合名 = set(可迭代对象)
- 创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
- 添加元素：
集合名.add(元素)
- 删除元素：
集合名.discard(元素)
运算
- 交集&：返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
- 并集：返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
-
补集-：返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^：返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
-
子集<：判断一个集合的所有元素是否完全在另一个集合中
-
超集>：判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True
- 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
# 1. 创建集合
set01 = set()
# set --> str
set01 = set("abcac")
list01 = list(set01)
str01 = "".join(list01)
print(str01) # "bca"
# 创建具有默认值的集合
set02 = {"a", "b", "a"}
# 2. 添加元素
set02.add("qtx")
# 3. 删除元素
set02.remove("a")
# 4. 获取所有元素
for item in set02:
print(item)
# 5. 数学运算
set01 = {1, 2, 3}
set02 = {2, 3, 4}
# 交集
print(set01 & set02) # {2,3}
# 并集
print(set01 | set02) # {1, 2, 3, 4}
# 补集
print(set01 ^ set02) # {1, 4}
print(set01 - set02) # {1}
print(set02 - set01) # {4}
# 子集
set03 = {1, 2}
print(set03 < set01)
# 超集
print(set01 > set03)
集合推导式
- 定义：
使用简易方法，将可迭代对象转换为集合。
- 语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
函数 function
pycharm相关设置
- “代码自动完成”时间延时设置
File -> Settings -> Editor -> General -> Code Completion -> Autopopup in (ms):0
- 快捷键：
Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档
Ctrl + Alt + M 提取方法
定义
-
用于封装一个特定的功能，表示一个功能或者行为。
-
函数是可以重复执行的语句块, 可以重复调用。
作用
提高代码的可重用性和可维护性（代码层次结构更清晰）。
定义函数
- 语法：
def 函数名(形式参数):
函数体
- 说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：方法定义者要求调用者提供的信息。
函数体：完成该功能的语句。
- 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
# 参数：调用者传递给定义者的信息
# 返回值：定义者传递给调用者的结果
def fun01(a):
print("fun01执行喽")
# 作用：1. 返回结果 2.退出方法
return 20
print("fun01又执行喽")
# F8 逐过程 （调试时跳过方法）
# F7 逐语句 （调试时进入方法）
re = fun01(10)
print(re)
# 无返回值函数
def fun02(a):
print("fun01执行喽")
# return None
re = fun02(100)
print(re)
调用函数
-
语法：函数名(实际参数)
-
说明：根据形参传递内容。
def add(number01, number02):
# 逻辑处理
return number01 + number02
# 调用者提供数据
number01 = int(input("请输入第一个数字："))
number02 = int(input("请输入第二个数字："))
result = add(number01, number02)
# 调用者负责显示结果
print("结果是:" + str(result))
返回值
- 定义：
方法定义者告诉调用者的结果。
- 语法：
return 数据
- 说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。
可变／不可变类型在传参时的区别
- 不可变类型参数有:
数值型(整数，浮点数,复数)
布尔值bool
None 空值
字符串str
元组tuple
固定集合frozenset
- 可变类型参数有:
列表 list
字典 dict
集合 set
- 传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。
函数内存图
函数参数
实参传递方式argument
位置传参
定义：实参与形参的位置依次对应。
序列传参
定义：实参用*将序列拆解后与形参的位置依次对应。
关键字传参
定义：实参根据形参的名字进行对应。
ef fun01(a, b, c, d):
print(a)
print(b)
print(c)
print(d)
# 17:00
# 位置实参：实参与形参根据位置进行依次对应.
# fun01(1, 2, 3, 4)
# 关键字实参:实参与形参根据名称进行对应
# fun01(b=1, d=2, c=3, a=4)
# 序列实参:星号将序列拆分后按位置与形参进行对应
# 如果参数很多，可以存储在序列(字符串/列表/元组)中,
# 再通过*拆分,直接传入函数.
# list01 = ["a","b","c","d"]
# fun01(*list01)
# 字典实参:双星号将字典拆分后按名称与形参进行对应
# 如果参数很多，可以存储在字典中,
# 再通过**拆分,传入函数.
dict01 = {"a": 1, "c": 3, "d": 4, "b": 2}
fun01(**dict01)
字典关键字传参
-
定义：实参用**将字典拆解后与形参的名字进行对应。
-
作用：配合形参的缺省参数，可以使调用者随意传参。
形参定义方式parameter
缺省参数
- 语法：
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
函数体
- 说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个，甚至全部都有缺省参数。
位置形参
语法：
def 函数名(形参名1, 形参名2, …):
函数体
星号元组形参
- 语法：
def 函数名(*元组形参名):
函数体
- 作用：
收集多余的位置传参。
- 说明：
一般命名为’args’
形参列表中最多只能有一个
命名关键字形参
- 语法：
def 函数名(*, 命名关键字形参1, 命名关键字形参2, …):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, …):
函数体
- 作用：
强制实参使用关键字传参
双星号字典形参
- 语法：
def 函数名(**字典形参名):
函数体
- 作用：
收集多余的关键字传参
- 说明:
一般命名为’kwargs’
形参列表中最多只能有一个
参数自左至右的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
# 1. 缺省(默认)形参:如果实参不提供，可以使用默认值.
def fun01(a=None, b=0, c=0, d=0):
print(a)
print(b)
print(c)
print(d)
# 关键字实参 + 缺省形参:调用者可以随意传递参数.
# fun01(b=2, c=3)
# 2. 位置形参
def fun02(a, b, c, d):
print(a)
print(b)
print(c)
print(d)
# 3.星号元组形参: * 将所有实参合并为一个元组
# 作用：让实参个数无限
def fun03(*args):
print(args)
# fun03()# ()
# fun03(1)# (1,)
# fun03(1,"2")# (1, '2')
# 4.命名关键字形参:在星号元组形参以后的位置形参
# 目的：要求实参必须使用关键字实参.
def fun04(a, *args, b):
print(a)
print(args)
print(b)
fun04(1, b=2)
fun04(1, 2, 3, 4, b=2)
def fun05(*, a, b):
print(a)
print(b)
fun05(a=1, b=2)
# 5. 双星号字典形参：**目的是将实参合并为字典.
# 实参可以传递数量无限的关键字实参.
def fun06(**kwargs):
print(kwargs)
fun06(a=1, b=2)
# 作业:调用fun07。
def fun07(a, b, *args, c, d, **kwargs):
pass
作用域LEGB
-
作用域：变量起作用的范围。
-
Local局部作用域：函数内部。
-
Enclosing 外部嵌套作用域 ：函数嵌套。
-
Global全局作用域：模块(.py文件)内部。
-
Builtin内置模块作用域：builtins.py文件。
变量名的查找规则
-
由内到外：L -> E -> G -> B
-
在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。
局部变量
-
定义在函数内部的变量(形参也是局部变量)
-
只能在函数内部使用
-
调用函数时才被创建，函数结束后自动销毁
全局变量
-
定义在函数外部,模块内部的变量。
-
在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
global 语句
- 作用：