PythonBase02

列表 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])#?

基础操作

1. 创建列表：

• 列表名 = []
• 列表名 = list(可迭代对象)

# 1. 创建列表  
# 空  
list01 = []  
list01 = list()
# 默认值

2. 获取元素

# 2. 获取元素  
# 索引  
print(list02[2])  # 齐  
# 切片  
print(list02[-4:])  # ['齐', '天', '大', '圣']

3. 添加元素：

• 列表名.append(元素)
• 列表.insert(索引，元素)

# 3. 添加元素  
# 追加(在末尾添加)  
list02.append("八戒")  
# 插入(在指定位置添加)  
list02.insert(1, True)  # 在索引为１(第二个)的位置添加True

4. 删除元素：

• 列表名.remove(元素)
• del 列表名[索引或切片]

# 4. 删除元素  
# 根据元素删除  
list02.remove("是")  
# 根据位置删除  
  
del list02[0]  
print(list02)

5. 定义元素：

列表名[索引] = 元素

变量 = 列表名[索引]

变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表

列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。

# 切片  
del list02[1:3]  
print(list02)  
# [True, '大', '圣', '八戒']  
# [True, 'a', 'b', '八戒']  
list02[1:3] = ["a", "b"]  
# [True,'八戒']  
# list02[1:3] = []  
print(list02)

5. 遍历列表：
   
   正向：

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字符串

1. 列表和字符串都是序列,元素之间有先后顺序关系。

2. 字符串是不可变的序列,列表是可变的序列。

3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。

4. 列表和字符串都是可迭代对象。

5. 函数：

将多个字符串拼接为一个。

result = “连接符”.join(列表)

将一个字符串拆分为多个。

列表 = “a-b-c-d”.split(“分隔符”)

列表推导式

1. 定义：

使用简易方法，将可迭代对象转换为列表。

2. 语法：

变量 = [表达式 for 变量 in 可迭代对象]

变量 = [表达式 for 变量 in 可迭代对象 if 条件]

3. 说明:

如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

列表推导式嵌套

1. 语法：

变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]

2. 传统写法：

result = []

for r in [“a”, “b”, “c”]:

for c in ["A", "B", "C"]:

    result.append(r + c)

3. 推导式写法：

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

定义

1. 由一系列变量组成的不可变序列容器。

2. 不可变是指一但创建，不可以再添加/删除/修改元素。

基础操作

1. 创建空元组：

元组名 = ()

元组名 = tuple()

2. 创建非空元组：

元组名 = (20,)

元组名 = (1, 2, 3)

元组名 = 100,200,300

元组名 = tuple(可迭代对象)

3. 获取元素：

变量 = 元组名[索引]

变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表

4. 遍历元组：

正向：

for 变量名 in 列表名:

变量名就是元素

反向：

for 索引名 in range(len(列表名)-1,-1,-1):

元组名[索引名]就是元素

作用

1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。

2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。

3. 应用：

变量交换的本质就是创建元组：x, y = （y, x ）

格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)

字典 dict

定义

1. 由一系列键值对组成的可变散列容器。

2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。

3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

1. 创建字典：

字典名 = {键1：值1，键2：值2}

字典名 = dict (可迭代对象)

2. 添加/修改元素：

语法:

字典名[键] = 数据

说明:

键不存在，创建记录。

键存在，修改值。

3. 获取元素：

变量 = 字典名[键] # 没有键则错误

4. 遍历字典：

for 键名 in 字典名:

字典名[键名]

for 键名,值名 in 字典名.items():

语句

5. 删除元素：

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)

字典推导式

1. 定义：

使用简易方法，将可迭代对象转换为字典。

2. 语法:

{键:值 for 变量 in 可迭代对象}

{键:值 for 变量 in 可迭代对象 if 条件}

字典 VS 列表

1. 都是可变容器。

2. 获取元素方式不同,列表用索引,字典用键。

3. 字典的插入,删除,修改的速度快于列表。

4. 列表的存储是有序的,字典的存储是无序的。

# 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

定义

1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。

2. 相当于只有键没有值的字典(键则是集合的数据)。
   ![[字典内嵌列表内存图.jpg]]

基础操作

1. 创建空集合：

集合名 = set()

集合名 = set(可迭代对象)

2. 创建具有默认值集合：

集合名 = {1, 2, 3}

集合名 = set(可迭代对象)

3. 添加元素：

集合名.add(元素)

4. 删除元素：

集合名.discard(元素)

运算

1. 交集&：返回共同元素。

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 & s2 # {2, 3}

2. 并集：返回不重复元素

s1 = {1, 2, 3}

s2 = {2, 3, 4}

s3 = s1 | s2 # {1, 2, 3, 4}

3. 补集-：返回只属于其中之一的元素

   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)

4. 子集<：判断一个集合的所有元素是否完全在另一个集合中

5. 超集>：判断一个集合是否具有另一个集合的所有元素

   s1 = {1, 2, 3}

   s2 = {2, 3}

s2 < s1 # True

s1 > s2 # True

6. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。

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)

集合推导式

1. 定义：

使用简易方法，将可迭代对象转换为集合。

2. 语法:

{表达式 for 变量 in 可迭代对象}

 {表达式 for 变量 in 可迭代对象 if 条件}

函数 function

pycharm相关设置

1. “代码自动完成”时间延时设置

File -> Settings -> Editor -> General -> Code Completion -> Autopopup in (ms):0

2. 快捷键：

Ctrl + P 参数信息（在方法中调用参数）

Ctrl + Q 快速查看文档

Ctrl + Alt + M 提取方法

定义

1. 用于封装一个特定的功能，表示一个功能或者行为。

2. 函数是可以重复执行的语句块, 可以重复调用。

作用

提高代码的可重用性和可维护性（代码层次结构更清晰）。

定义函数

1. 语法：

def 函数名(形式参数):

 函数体

2. 说明：

def 关键字：全称是define，意为”定义”。

函数名：对函数体中语句的描述，规则与变量名相同。

形式参数：方法定义者要求调用者提供的信息。

函数体：完成该功能的语句。

3. 函数的第一行语句建议使用文档字符串描述函数的功能与参数。

# 参数：调用者传递给定义者的信息  
# 返回值：定义者传递给调用者的结果  
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)

调用函数

1. 语法：函数名(实际参数)

2. 说明：根据形参传递内容。

def add(number01, number02):  
    # 逻辑处理  
    return number01 + number02  
  
  
# 调用者提供数据  
number01 = int(input("请输入第一个数字："))  
number02 = int(input("请输入第二个数字："))  
result = add(number01, number02)  
# 调用者负责显示结果  
print("结果是:" + str(result))

返回值

1. 定义：

方法定义者告诉调用者的结果。

2. 语法：

return 数据

3. 说明：

return后没有语句，相当于返回 None。

函数体没有return，相当于返回None。

可变／不可变类型在传参时的区别

1. 不可变类型参数有:

数值型(整数，浮点数,复数)

布尔值bool

None 空值

字符串str

元组tuple

固定集合frozenset

2. 可变类型参数有:

列表 list

字典 dict

集合 set

3. 传参说明：

不可变类型的数据传参时，函数内部不会改变原数据的值。

可变类型的数据传参时，函数内部可以改变原数据。

函数内存图

函数参数

实参传递方式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)

字典关键字传参

1. 定义：实参用**将字典拆解后与形参的名字进行对应。

2. 作用：配合形参的缺省参数，可以使调用者随意传参。

形参定义方式parameter

缺省参数

1. 语法：

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):

  函数体

2. 说明：

缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。

缺省参数可以有0个或多个，甚至全部都有缺省参数。

位置形参

语法：

def 函数名(形参名1, 形参名2, …):

函数体

星号元组形参

1. 语法：

def 函数名(*元组形参名):

函数体

2. 作用：

收集多余的位置传参。

3. 说明：

一般命名为’args’

形参列表中最多只能有一个

命名关键字形参

1. 语法：

def 函数名(*, 命名关键字形参1, 命名关键字形参2, …):

函数体

def 函数名(*args, 命名关键字形参1, 命名关键字形参2, …):
函数体

2. 作用：

强制实参使用关键字传参

双星号字典形参

1. 语法：

def 函数名(**字典形参名):

函数体

2. 作用：

收集多余的关键字传参

3. 说明:

一般命名为’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

1. 作用域：变量起作用的范围。

2. Local局部作用域：函数内部。

3. Enclosing 外部嵌套作用域 ：函数嵌套。

4. Global全局作用域：模块(.py文件)内部。

5. Builtin内置模块作用域：builtins.py文件。

变量名的查找规则

1. 由内到外：L -> E -> G -> B

2. 在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。

局部变量

1. 定义在函数内部的变量(形参也是局部变量)

2. 只能在函数内部使用

3. 调用函数时才被创建，函数结束后自动销毁

全局变量

1. 定义在函数外部,模块内部的变量。

2. 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。

global 语句

1. 作用：

在函数内部修改全局变量。

在函数内部定义全局变量(全局声明)。

2. 语法：

global 变量1, 变量2, …

3. 说明

在函数内直接为全局变量赋值，视为创建新的局部变量。

不能先声明局部的变量，再用global声明为全局变量。

nonlocal 语句

1. 作用：

在内层函数修改外层嵌套函数内的变量

2. 语法

nonlocal 变量名1,变量名2, …

3. 说明

在被嵌套的内函数中进行使用

 全局变量  
g01 = "ok"  
  
# print(l01)  
def fun01():  
    # 局部变量：在函数内部定义的变量  
    l01 = 100  
# print(l01)  
    print(l01)  
    # 　在函数内部可以读取全局变量    # print(g01)  
  
    # 创建了一个局部变量g01，而不是修改全局变量  
    # g01 = "no"  
  
    # 定义全局变量g01  
    global g01  
    # 此时修改的是全局变量  
    g01 = "no"  
    print(g01)  
    # 定义全局变量g02  
    global g02  
    g02 = 250  
  
  
fun01()  
  
print(g01)  # ?  
  
print(g02)
```![请添加图片描述](https://i-blog.csdnimg.cn/direct/61abc6138f754250bd9f950a1923ea7c.jpeg