承德网站设计公司搜索网站的浏览器

博客回顾：

【零基础学python】python基础语法（一）-CSDN博客

【零基础学python】python基础语法（二）-CSDN博客

前面两篇2博文介绍了最基本的python语法，但是如果只有那些就不能体现出来这个语言的强大之处，当然还有一些高级语法，掌握之后我们用起来会更加的得心应手。

---

目录

1，列表&元组

【1】可变类型与不可变类型

【2】两种数据类型的数据存储方式

【3】可变类型的变量传递

【4】列表的深浅拷贝

列表推导式

元组

---

 

 

1，列表&元组

• 列表的概念

<列表的概念>

是一种有序可变、可重复的数据结构用于存储一组元素。在Python中，列表(Lisy(包含任意类表是Python中最常用的数据类型之例如整数、浮点数、生的元系，字符串等

l = ["yuan", 18, False] 
gf_name_list =["高圆圆", "范冰冰", "李嘉欣", "陈红"]

• 列表的特点

1，列表中的元素按照顺序进行存储和管理

2，元素可以是任意类型且可以不一致

3，元素的长度理论上没有限制

4，列表允许包含重复的元素

5，列表是可变数据类型

• 列表的序列操作

1，索引

2，切片索引操作

3，判断成员是否存在

4，相加

5，循环列表

gf_name_list =["高圆圆", "范冰冰", "李嘉欣", "陈红"] #<索引> 列表对象[索引] 
#(1)查看元素 
print(gf_name_list[1]) 
print(gf_name_list[-1]) 
#(2)修改元素 
gf_name_list[3] = "袁封" 
print(gf_name_list) #<切片索引操作> 列表对象[开始索引:结束索引] 
#(1)查看元素 print(gf_name_list[1:2]) 
print(gf_name_list[1:]) #缺省状态 
print(gf_name_list[:3]) #缺省状态 
print(gf_name_list[:])  #缺省状态 
print(gf_name_list[-2:-1]) 
#(2)修改元素 
gf_name_list[1:3] = 100,299 
gf_name_list[1:3] = [100,299] 
print(gf_name_list) # 步长:为正--从左到右切--从小到大 为负--从右到左切--从大到小 
print(gf_name_list[1:2]) 
print(gf_name_list[3:1:-1]) 
print(gf_name_list[::-1]) #<判断成员是否存在> 
# in关键字检查元素是否为序列的成员 
l = [10,11,12,13,14] print(20 in l) 
# False print(12 in 1) # True #<拼接相加> 
l1 = [1,2,3] 
l2 = [4,5,6] 
print(l1 + l2) # [1，2，3，4，5，6] #<循环列表> 
for name in["张三", "李四", "王五"] print(name) 
#循环列表的链式操作 
for name in ["wef3rg", "srtgn", "qethw"]: print(name.upper().startswith("S")) 
#range函数: 
range(start,end,step) 
for i in range(10) print(i) 
#基于for循环从100打印到1 
for i in range(100,0,-1) print(i) 
#计算列表的元素个数 
print(len(l))

• 列表的内置方法

前六个比较常用，需要重点练习

gf_name_list =["高圆圆", "范冰冰", "李嘉欣", "陈红"] 
# 1,增 append insert extend 
#append 向列表的最后位置添加元素 
gf_name_list.append("类信息") 
print(gf_name_list) 
#insert 向列表的任意位置添加元素 ----由于操作相对而言比较复杂所以尽量少用 gf_name_list.insert(0,"元放") 
print(gf_name_list) 
#extend 扩展元素 ---相当于直接改变原值 
gf_name = ["widgci", "guyvwcjhwvc"] 
gf_name_list.extend(gf_name) 
print(gf_name_list) 
# 2,删 pop remove clear 
#pop 按索引删除 ---如果没有传入索引则删除最后一个 
del_nme = gf_name_list.pop(3) 
print(gf_name_list) 
print(del_nme) 
#remove 按照内容删除 
gf_name_list.remove("元放") 
print(gf_name_list) 
#clear 清空内容 
gf_name_list.clear() 
print(gf_name_list) 
#返回一个空列表 
# 3,其他的内置方法操作 
l = [12,123,2,13,13,224] 
#sort 对列表中的元素进行排序 从小到大 ---无返回值 
l.sort() 
print(l) 
#reverse 对原有的列表中的元素的排列顺序进行大小翻转 
l.reverse() 
print(l) 
#index 查询某元素的索引 
print(l.index(12)) 
#count 计算某元素出现的个数 
print(l.count(13))

• 列表的深浅拷贝

【1】可变类型与不可变类型

python中数据类型可以分为可变类型(Mutable)和不可变类型(lmmutable)。这指的是对象在创建后是否可以更改其值或状态

不可变类型是指创建后不能更改其值或状态的对象。如果对不可变类型的对象进行修改，将会创建一个新的对象，原始对象的值保持不变。在修改后，对象的身份标识(即内存地址)会发生变化。

以下是Python中常见的不可变类型:

整数(Integer)和浮点数(Float)

布尔值(Boolean)

字符串(String)

元组(Tuple)

可变类型是指可以在原地修改的对象，即可以改变其值或状态。当对可变类型的对象进行修改时，不会创建新的对象，而是直接修改原始对象。在修改后，对象的身份标识(即内存地址)保持不变。

以下是Python中常见的可变类型:

列表(List)

字典(Dictionary)

集合(Set)

注意点：对于可变类型，可以通过方法调用或索引赋值进行修改，而不会改变对象的身份标识。而对于不可变类型，任何修改操作都会创建一个新的对象。了解对象的可变性对于理解Python中的数据处理和传递方式非常重要。可变对象通常用于存储和操作动态数据，而可变类型常用与常量值或者保持不变的数据

【2】两种数据类型的数据存储方式

#1,不可变数据类型的存储方式 
x = "yuan" 
print(id(x)) 
x = "Yuan" 
print(id(x)) 
#2,可变数据类型的存储方式 
l = [1,2,3] 
print(id(l)) 
l[2] = 20 
print(id(l)) 
l = [4,5,6] 
print(id(l)) 
#当列表中的成员完全改变的时候其内存地址也会完全改变

【3】可变类型的变量传递

变量实际上是对对象的引用，变量传递的核心是两个变量引用同一个地址空间

#1,不可变数据类型的变量传递 
x = 1 
y = x 
print(id(x)) 
print(id(y)) 
x = 2 
print(id(x)) 
print(id(y)) 
#2,可变数据类型的变量传递 
m = [1,2,3] 
n = m 
m[0] = 100 
print(id(n)) 
print(id(m)) 
print(m,n) 
n[2] = 200 
print(m,n) 
#3,可变数据类型的整体变量传递 
s = [1,2,3] 
r = [s,4,6,7] 
s[0] = 200 
print(s,r) 
r[0][2] = 500 
print(s,r) 
print(id(s)) 
print(id(r[0])) 
r[0] = 1000 
#原先r列表指向的成员可以修改成非列表 
print(r)

【4】列表的深浅拷贝

在Python中，列表的拷贝可以分为深拷贝和浅拷贝两种方式。浅拷贝(shallow Copy)是创建一个新的列表对象，该对象与原始列表共享相同的元素对象。当你对其中一个列表进行修改时，另一个列表也会受到影响。

浅拷贝会只拷贝列表内部成员的地址，其本身地址会开辟一个新的

#列表的深浅拷贝 ---在其成员都是不可变数据类型的前提下，两个列表互不影响， 
#案例一 
l1 = [1,2,3,4,5] 
l2 = l1[:] 
l3 = l1.copy() 
l4 = list(l1) 
l1[2] = 200 
print(l1) 
print(l2) 
print(l3) 
print(l4) 
#案例二 当其内部有可变数据类型的时候就会出现两个列同时受影响的情况 
l1 = [1,2,3,4,5,[4,5]] 
l2 = l1[:] 
l1[5][0] = 200 
print(l2) 
#列表的深拷贝 ---两者无论有什么样的数据都是有两个完全不同的地址，对两者中的其中一个修改其值另一个都不会受到影响 
################################################3
import copy 
l1 = [1,2,3,4,5,[4,5]] 
l2 = copy.deepcopy(l1)

• 列表推导式

列表推导式(List comprehensions)是一种简洁的语法，用于创建新的列表，并可以在创建过程中对元素进行转换、筛选或组合操作。

列表推导式的一般形式为:

new_list =[expression for item in iterable if condition]

expression 是要应用于每个元素的表达式或操作。

item 是来自可迭代对象(如列表、元组或字符串)的每个元素。

iterable 是可迭代对象，提供要遍历的元素。

condition 是一个可选的条件，用于筛选出满足条件的元素。

#1,创建一个包含1~5平方的列表 
squares = [x**2 for x in range(1,6)] 
print(squares) 
#2,筛选出长度大于5的字符串 
words = ["woure", "fwdufj", "efuyfcqv", "wefqufycc1"] 
filtered = [word for word in words if len(word) >= 5] 
print(filtered) 
#3,将两个列表中的元素进行组合 
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
letters = ["qdytdq", "fdqf", "qfuqd", "gdyqvfyd", "gfqyudvd", "efyufqy"] 
letters2 = ['q','e','w','q','u','w'] 
combined = [(num, letter) for num in nums for letter in letters] 
print(combined)

• 元组

1，元组(Tuple)是Python中的一种数据类型，它是一个有序的、木可变的序列。

2，元组使用圆括号()来表示，其中的元素可以是任意类型，并且可以包合重复的元素。与列表(List)不同，元组是不可变的，这意味着一旦创建，它的元素就不能被修改、删除或添加。

3，元组适合用于存储一组不可变的数据。例如，你可以使用元组来表示一个坐标点的x和y坐标值，或者表示日期的年、月、日等。

元组也被称为只读列表

info = ("yuan", 23, "[e-mail]") 
#1,获取长度 print(len(info)) 
#2，索引与切片 
info1 = info[:] 
info2 = info[1:2] 
print(info1) 
print(info2) 
#3,成员判断 
print(23 in info) 
#4,拼接 
print((1,2) + (3,4)) 
#5,循环 
for i in info: print(i) 
#6,内置方法
print(info.index(23))
print(info.count(1)) #补充 ---当有一个元素的元组时，需要用逗号来重点区分 
t = (1,2) 
print(t)