python基础_列表元组字典集合字符串
0723-python数据结构
序列 --一块可以存放多个值的连续空间
序列结构：列表、元组、字典、集合、字符串
value是可重复的，key是不能重复的，列表不能作为字典的key，
| 数据结构 | 定义符号 | 是否可变 | 是否有序 | 是否可重复 |
|---|---|---|---|---|
| 列表 | [ ] | ✅ | ✅ | ✅ |
| 元组 | ( ) | ❌ | ✅ | ✅ |
| 字典 | ✅ | ❌ | ✅ | |
| 集合 | {} | ✅ | ❌ | ❌ |
| 字符串 | ' '或" " | ❌ | ✅ | ✅ |
in 包含在指定序列中 not in 不在指定序列中
list1 = [1,2,3,4,5]
print(3 in list1)
print(6 not in list1)
1、列表-有序
拷贝列表
1、浅拷贝：改一个影响另一个
l = ['A', 'B'] # 定义列表l
k = l # k直接指向l的同一内存地（浅拷贝）
print(k) # ['A', 'B']
l.append('C') # 对l添加元素
print(l) # ['A', 'B', 'C']
print(k) # ['A', 'B', 'C'] 同步变化
2、深拷贝：改一个不会影响另一个
m = ['A', 'B'] # 定义列表m
n = m[:] # n是m的副本（深拷贝）
print(n) # ['A', 'B']
m.append('C') # 对m添加元素
print(m) # ['A', 'B', 'C']
print(n) # ['A', 'B'] 不受影响
3、copy函数：改一个不会影响另一个
a = ['A', 'B']
b = a.copy() # 通过copy()方法拷贝
a.append('C')
print(b) # ['A', 'B'] 不受影响
只在列表中定义同一类型的数据，这样可以提高元素的可读性
可使用list()函数直接创建列表，括号里可以是字符串、range()对象或其他可迭代数据
list3 = list('python')
print(list3)
输出：['p', 'y', 't', 'h', 'o', 'n']
#list()函数是一个对象迭代器，可把range()函数返回的可迭代对象转换成列表
list1 = list(range(0,10,2))
print(list1)
输出：[0, 2, 4, 6, 8]
list2 = list(range(6,-5,-2))
print(list2)
输出：[6, 4, 2, 0, -2, -4]
li = [11,22,33,44,55,66,77,88,99 ]
print(li,type(li))
print(li[-6]) #索引取值，输出倒数第6个元素
print(li[4]) #索引取值，输出正数第5个
print(li[2:5:1]) #切片，从索引2到4（步长1）→ [3, 4, 9]
print(li[6::1]) #从索引6到末尾 → [7, 8, 9, 10]（省略结束值表示到末尾
print(li[-4:-9:-1]) #反向步长）→ [7, 6, 9, 4, 3]
print(li[-4:1:-1]) #不分正数负数索引，闭环，不包含索引1）→ [7, 6, 9, 4]
输出：
[11, 22, 33, 44, 55, 66, 77, 88, 99] <class 'list'>
44
55
[33, 44, 55]
[77, 88, 99]
[66, 55, 44, 33, 22]
[66, 55, 44, 33]
li.append(100) # 在末尾添加一个元素 → [..., 100]
li.insert(2, 11) # 在索引2位置插入11 → 原索引2及之后右移
li.extend([110, 120]) # 将列表 [110,120] 的每个元素追加到末尾
li[5] = 66 # 将索引5的元素改为66
del li #删除整个列表，后续不能再使用 li
li.remove(50) # 删除值为50的第一个元素（若不存在会报错 ValueError）
del li[50] # 删除索引50的元素（索引越界会报错 IndexError）
li.pop(2) # 删除并返回索引2的元素（默认删除最后一个）
li.clear() # 清空列表所有元素 → []
li.reverse() # 反转列表顺序（原地修改）
li.sort() # 升序排序（参数 reverse=True 时为降序），key=len 按长度 key=abs 按关键值 key=lambda 按键值
List = sorted(li) # 将li中的元素升序排序后赋给变量
print(List)
print(li.count(1)) # 查询统计元素1出现的次数
print(li.index(1)) # 查询返回第一个值为1的索引（若不存在报错 ValueError）
print(li + [11, 12]) # 列表拼接，返回新列表，原列表不变
print(li * 2) # 列表重复，返回重复两次的新列表
# 方式一：直接遍历元素
for i in li:
print(i)
# 方式二：通过索引遍历
for i in range(len(li)):
print(li[i])
list-练习
num_list = [11, 22, 33, 44, 55, 66, 77, 88, 99] # 定义列表
print(num_list[2:5]) # 从索引2到4
print(num_list[-1:-5:-2]) # 从倒数第1到倒数第4，步长-2
print(num_list[2:7:2]) # 从索引2到6，步长2
print(num_list[::-1]) # 反转整个列表
print(num_list[::-2]) # 反转后隔一个取
print(num_list[:6:]) # 从开头到索引5
print(num_list[:6:-1]) # 从末尾到索引6（不含）
print(num_list[2::-1]) # 从索引2到开头
print(num_list[4:1:1]) # 正向步长1，但起点>终点，无元素
print(num_list[100:200:1]) # 索引超出范围，自动截断
输出：[33, 44, 55]
[99, 77, 55]
[33, 55, 77]
[99, 88, 77, 66, 55, 44, 33, 22, 11]
[99, 77, 55, 33, 11]
[11, 22, 33, 44, 55, 66]
[99, 88]
[33, 22, 11]
[]
[]
2、元组-tuple-不可变
创建元组，在圆括号中添加元素，用逗号分隔开就好，也可直接省略圆括号
如果要定义一个空元组，用()表示
定义只有一个元素的元组时，需加逗号num=(1,)
num = (11,22,33)
num1 = (44,55,66)
print(num,type(num)) # 打印num和类型
print(num[2]) # 通过索引访问第3个元素
print(num + num1) # 元组拼接（返回新元组）
#内置函数
#tuple() - 将序列转换为元组
a = tuple([1, 2, 3]) # 列表转元组 (1, 2, 3)
b = tuple('abc') # 字符串转元组 ('a', 'b', 'c')
c = tuple((1, 2, 3)) # 元组转元组（原样返回） (1, 2, 3)
num = (11, 22, 33, 44, 55)
print(len(num)) # len() - 获取元组长度5
print(max(num)) # max() - 获取最大值 55
print(min(num)) # min() - 获取最小值11
for i in num: # i依次取每个元素，for循环直接遍历元素
print(i, end=" ") # 11 22 33 44 55
print()
for i in range(len(num)): # i从0到4，通过索引遍历
print(num[i], end=" ") # 11 22 33 44 55
print()
3、字典
# ========== 字典的创建 ==========
info1 = {} # 空字典
info2= {'name': '张三', 'age': 25, 'city': '北京'} # 直接创建
info3 = dict(name='李四', age=30, city='上海') # 关键字参数
keys = ['name', 'age', 'city']
info4 = dict.fromkeys(keys) # 默认值为None
print(info1) # {}
print(info2) # {'name': '张三', 'age': 25, 'city': '北京'}
print(info3) # {'name': '李四', 'age': 30, 'city': '上海'}
print(info4) # {'name': None, 'age': None, 'city': None}
# ========== 访问元素 ==========
info= {'name': '张三', 'age': 25, 'city': '北京'}
print(info['name']) # 通过键访问 → 张三（键不存在会报错KeyError）
print(info.get('name')) # 通过get访问 → 张三（键不存在返回None，不报错）
print(info.get('gender', '未知')) # 键不存在返回默认值 → 未知
# ========== 修改和添加 ==========
info['name'] = '王五' # 键存在 → 修改（更新）
print(info) # {'name': '王五', 'age': 25, 'city': '北京'}
info['phone'] = '13800138000' # 键不存在 → 添加
print(info) # {'name': '王五', 'age': 25, 'city': '北京', 'phone': '13800138000'}
info.update({'age': 26, 'job': '工程师'}) # 整体更新（存在修改，不存在添加）
print(info)
# {'name': '王五', 'age': 26, 'city': '北京', 'phone': '13800138000', 'job': '工程师'}
# ========== 删除元素 ==========
print(info.pop('name')) # 删除'name'并返回其值 → 王五
print(info.pop('name1', '不存在')) # 键不存在，返回默认值（不报错）→ 不存在
del info['city'] # 删除'city'键
info.clear() # 清空所有元素
# ========== 遍历字典 ==========
for i in info.items(): # i是元组（键, 值）
print(i) # ('name', '张三') ('age', 25)
for key, value in info.items(): # 解包元组
print(key, value) # name 张三 age 25 ...
for key in info.keys(): # 遍历键
print(key) # name age city job
for value in info.values(): # 遍历值
print(value) # 张三 25 北京 工程师
4、集合-set
python语言提供的内置数据结构
与列表、字典一样都属于可变类型
集合的时没有value值的字典
# ========== 集合的创建 ==========
num = {1,2,3,4,5} # 直接创建
print(num,type(num)) #{1, 2, 3, 4, 5} <class 'set'>
set1 = set([1, 2, 3, 3, 4]) # 列表转集合（自动去重）
print(set1) # {1, 2, 3, 4}
# ========== 元素添加 ==========
s = {1, 2, 3}
s.add(4) # 添加元素
s.add(2) # 添加已存在的元素（无变化）
s.update([5, 6, 7]) # 添加列表元素
s.update({8, 9}) # 添加集合元素
s.update((10, 11), [12, 13]) # 添加多个可迭代对象
# ========== 删除元素 ==========
s = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s.remove(10) # 删除10
s.remove(100) # 元素不存在会报错KeyError
s.discard(9) # 删除9
s.discard(100) # 元素不存在，不报错
removed = s.pop() # 随机删除
s.clear() # 清空集合
# ========== 集合运算（交并差） ==========
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
print("交集（A ∩ B）:", A & B) # {4, 5}
print("并集（A ∪ B）:", A | B) # {1, 2, 3, 4, 5, 6, 7, 8}
print("差集（A - B）:", A - B) # {1, 2, 3}（A有B没有）
print("差集（B - A）:", B - A) # {8, 6, 7}（B有A没有）
print("对称差集（A △ B）:", A ^ B) # {1, 2, 3, 6, 7, 8}
C = {4, 5} # 子集
print("C是否为A的子集:", C.issubset(A)) # True
print("A是否为C的超集:", A.issuperset(C)) # True
5、字符串-str
string是一种Python基本数据结构，是由字符组成的序列，不可变
# ========== 字符串的创建 ==========
str1 = 'Hello Python' # 单引号
str2 = "Hello Python" # 双引号
str3 = '''第一行
第二行
第三行''' # 多行字符串
str4 = 'I\'m a student' # 单引号转义
str5 = "他说：\"你好\"" # 双引号转义
str6 = r'C:\Users\name\Desktop' # 原始字符串，忽略转义
print(str4) # I'm a student
print(str5) # 他说："你好"
print(str6) # C:\Users\name\Desktop
# ========== 索引和切片操作 ==========
s = "Hello Python"
# 1. 索引（正数和负数）
print(s[0]) # H（第一个字符）
print(s[6]) # P（第7个字符）
print(s[-1]) # n（最后一个字符）
print(s[-6]) # P（倒数第6个字符）
# 2. 切片（[start:end:step]）
print(s[0:5]) # Hello（索引0到4）
print(s[6:]) # Python（索引6到末尾）
print(s[:5]) # Hello（开头到索引4）
print(s[::2]) # HloPto（步长2）
print(s[::-1]) # nohtyP olleH（反转）
print(s[6:12]) # Python（索引6到11）
print(s[6:12:2]) # Pto（步长2）
# ========== 字符串拼接 ==========
str1 = "Hello" + " " + "Python" # + 拼接
words = ["Hello", "Python", "World"]
str2 = " ".join(words) # 用空格拼接
str3 = "-".join(["2024", "01", "15"]) # 用-拼接
name = "张三"
age = 25
str4 = "姓名：%s，年龄：%d" % (name, age) # % 格式化
str5 = "姓名：{}，年龄：{}".format(name, age) # format 拼接
str7 = f"姓名：{name}，年龄：{age}" # f-string
print(str1) # Hello Python
print(str2) # Hello Python World
print(str3) # 2024-01-15
print(str4) # 姓名：张三，年龄：25
print(str5) # 姓名：张三，年龄：25
print(str7) # 姓名：张三，年龄：25
# ========== 字符串格式化 ==========
name = "李四"
age = 30
score = 95.567
print("姓名：%s，年龄：%d，分数：%.2f" % (name, age, score)) # 姓名：李四，年龄：30，分数：95.57
print("姓名：{}，年龄：{}，分数：{:.2f}".format(name, age, score)) # 姓名：李四，年龄：30，分数：95.57
print(f"姓名：{name}，年龄：{age}，分数：{score:.2f}") # 姓名：李四，年龄：30，分数：95.57
# ========== 字符串分隔 ==========
s = "apple,banana,orange,grape"
parts = s.split(",") # 按逗号分割
parts2 = s.split(",", 2) # 分割2次
s2 = "Hello Python World"
parts3 = s2.split() # 默认按空白分割
s4 = "Hello Python World"
parts4 = s4.partition(" ") # 按第一个匹配分割
print(parts) # ['apple', 'banana', 'orange', 'grape']
print(parts2) # ['apple', 'banana', 'orange,grape']
print(parts3) # ['Hello', 'Python', 'World']
print(parts4) # ('Hello', ' ', 'Python World')
# ========== 字符串替换 ==========
s = "Hello Python, Python is great"
new_s = s.replace("Python", "Java") # 替换所有Python为Java
new_s2 = s.replace("Python", "Java", 1) # 只替换第一个
print(new_s) # Hello Java, Java is great
print(new_s2) # Hello Java, Python is great
# ========== 其他常用操作 ==========
# 1. 去除空白
print(s.strip()) # Hello Python World（去除两端空白）
print(s.lstrip()) # Hello Python World （去除左端空白）
print(s.rstrip()) # Hello Python World（去除右端空白）
# 2. 大小写转换
print(s.upper()) # HELLO PYTHON WORLD （转大写）
print(s.lower()) # hello python world （转小写）
print(s.title()) # Hello Python World （单词首字母大写）
print(s.capitalize()) # hello python world （首字母大写）
print(s.swapcase()) # hELLO pYTHON wORLD （大小写互换）
# 3. 判断开头/结尾
print(s.startswith(" Hello")) # True
print(s.endswith("World ")) # True
# 4. 查找子串
print(s.find("Python")) # 8（返回索引，找不到返回-1）
print(s.index("Python")) # 8（返回索引，找不到报错）
print(s.rfind("o")) # 20（从右查找）
print(s.count("o")) # 3（统计出现次数）
# 5. 判断字符串内容
print("123".isdigit()) # True（是否全是数字）
print("abc".isalpha()) # True（是否全是字母）
print("abc123".isalnum()) # True（是否字母或数字）
print(" ".isspace()) # True（是否全是空白）
print("Hello".istitle()) # True（是否每个单词首字母大写）
# 6. 填充和居中
print("Hello".center(20, "-")) # -------Hello--------（居中）
print("Hello".ljust(20, "*")) # Hello***************（左对齐）
print("Hello".rjust(20, "*")) # ***************Hello（右对齐）
print("123".zfill(6)) # 000123（左补0）
# 7. 检查字符串包含
s = "Hello Python World"
print("Python" in s) # True
print("Java" not in s) # True
# 8. 获取长度
print(len(s)) # 18
# 9. 遍历字符串
for char in s: # 遍历每个字符
print(char, end=" ") # H e l l o P y t h o n W o r l d
print()
# 10. 连接字符串（join）
chars = ['H', 'e', 'l', 'l', 'o']
word = ''.join(chars) # 合并字符列表
print(word)
浙公网安备 33010602011771号