【零基础学python】python高级语法（三）
博客回顾：
【零基础学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, "1241546134576241@qq.com")
#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)