【Python】列表 元组 字典 文件
目录
列表
创建列表
切片操作
遍历列表
新增元素
查找元素
删除元素
连接列表
元组
创建元组
列表和元组的区别
字典
创建字典
遍历字典
查找key
新增键值对
修改value
删除键值对
文件
打开文件
关闭文件
写文件
读文件
上下文管理器
列表
列表：[element, element, ...] 列表里面 可以存放不同类型的变量
创建列表
[] / [element, element, ...] 直接进行创建
list() 声明某个变量是列表
# 创建列表
x =[]
a = [1, 2, 3, 4]
b = list()
print(type(a))
print(type(b))切片操作
切片操作：不涉及数据拷贝，只是从原列表中取数据，所以切片操作很高效
list[start : end : step_size] 切片是一个左闭右开的区间[start：end)
start：从列表的哪一个下标开始切，如果不写，默认是从0下标开始
end：在列表的哪个下标结束，如果不写，默认是最后一个下标len(list)
step_size：每次切走几步，不写则是默认走一步
a = [1, 2, 3, 4]
print(a[1:3]) #下标[1, 3)
print(a[::-1])
print(a[-1::-1])
print(a[:-1:1])遍历列表
# 遍历
a = [1, 2, 3, 4]
for i in a:i += 10print(i) #修改i是不会改变原列表的值
print(a)i = 0
while i < len(a):print(a[i]) # 下标遍历 修改值 原列表发生改变i += 1新增元素
append 向列表末尾新增元素append(element)
insert 向列表任意位置插入元素insert(index, element)
如果使用insert进行新增，index下标超出了列表下标范围，不会抛出异常，会在列表末尾新增元素
a = [1, 2, 3, 4]
for i in range(5, 10):a.append(i) # 向列表的末尾新增元素
print(f"append新增后：{a}")a.insert(5, 10)
a.insert(10, 20)
print(f"insert新增后：{a}")查找元素
in 判断元素是否存在与列表中 not in不存在
index 判断当前元素在列表中的位置，并返回下标
index(element) 如果元素没有在列表当中，则会直接抛出异常
a = [1, 2, 3, 4]
print(f"4是否在a列表中：{4 in a}")
print(f"20不在a列表中：{20 not in a}")print(f"20所在下标：{a.index(20)}") # 元素没有在列表 则会抛出异常删除元素
pop 删除列表中最末尾的值
pop(index) 能删除任意位置的值
remove 按照指定值进行删除 remove(element)，列表中没有指定元素，则会抛出异常
a = [1, 2, 3, 4]
a.pop()
print(f"a列表使用pop()删除末尾值后：{a}")
a.pop(2)
print(f"使用pop(index) 删除指定下标元素：{a}")
a.remove(10)
print(f"remove(element) 指定元素删除值：{a}") # 列表中没有指定元素 则会抛出异常连接列表
+ 使用加号 将两个列表进行拼接， += 涉及数据拷贝和数据释放
extend 将后一个列表，拼接到前一个列表里面 extend(list)
a = [1, 2, 3, 4]
b = list()
for i in range(20, 100, 10):b.append(i)c = a + b
print(f"使用+ 新列表的拼接值：{c}")a.extend(b)
print(f"使用extend(list) 将list直接拼到原列表：{a}")a += b
print(f"涉及数据拷贝与释放 不像extend直接拼接：{a}")元组
元组：(element, elemnet, ...) 元组里面，可以存放不同类型的变量，和列表一样
创建元组
() / (element, element, ...) 直接进行创建
tuple() 声明某个变量是元组
# 创建元组
x = (1, 2, 3, 4)
y = tuple()
print(type(x))
print(type(y))# 遍历
for i in x:print(i)for i in range(0, len(x)):print(x[i])# 查找
print(5 in a)
print(x.index(4))列表和元组的区别
相同点：元组的遍历、切片、拼接都是和列表相同
不同点：列表使用的是[]，元组使用的是()，列表用list声明，元组用tuple声明
列表支持：增、删、改、查
元组只支持读操作，不支持修改操作，所以元组是不可变对象，可以哈希
字典
字典中，可以包含很多键值对，但是键不能够重复
字典的各种操作，都是针对key来进行操作的
字典是哈希表，进行增、删、改、查操作，效率都非常高，但是遍历效率稍微低些
合法的key类型
使用hash函数，能够计算出一个变量的哈希值，则就是一个合法的key
可变的类型是不能计算出hash值，例如列表、字典就不能作为key
不可变的才能计算出hash值，例如常数、字符串、元组就能作为key
创建字典
{ } / {key:value, key:value, ...} 创建字典，键值对使用逗号进行分割，使用冒号将键和值进行分割
dict() 声明某个变量是字典
# 创建字典
a = {}
b = {"id": 1,"name":"张三","gender":"男",
}
c = dict()print(type(a))
print(type(b))
print(type(c))遍历字典
keys() 获取到所有的keys
values() 获取到所有的values
items() 获取到所有键值对，首先是一个列表结构，里面的每一个元素又是一个元组，元组里面包含了键和值
在python中，遍历顺序和插入顺序是一致的；但是c++和Java中，哈希表里的键值对，存储顺序都是无序的
# 遍历字典
b = {"id": 1,"name":"张三","gender":"男",
}print(f"keys() 方法，拿到了所有key：{b.keys()}")
print(f"values() 方法，拿到了所有value：{b.values()}")
print(b.items())for key in b:print(key, b[key]) # 循环遍历 拿到的是字典里的key 再通过key拿到value查找key
in 使用in，判断key，是否存在与字典中，not in不存在
[key] 根据key，获取到value，则会返回value值；当key不存在时，则会抛出异常
# 查找key
b = {"id": 1,"name":"张三","gender":"男",
}
print(f"判断name这个key，是否在字典b中：{'name' in b}")
print(f"判断gender这个key，是否在字典b中：{'gender' not in b}")
value1 = b["id"]
value2 = b["name"]
value3 = b["gender"]
print(value1, value2, value3)新增键值对
[ ] 向字典中新增键值对，dict_variable[key] = value
字典变量[key] = value
# 新增键值对
a = {}
a["id"] = 2
a["name"] = "李四"
a["gender"] = "男"
print(a.items())修改value
[ ] 根据key修改value，也是使用[ ]，dict_variable[key] = value
key不存在，向字典中写入，就是新增
key存在，向字典中写入，就是根据key修改value值
# 修改value
b = {"id": 1,"name":"张三","gender":"男",
}
b["name"] = "王五"
b["gender"] = "女" # 字典中key存在，则是修改原value值
b["address"] = "python" # 字典中key不存在，则是新增键值对
print(b.items())删除键值对
pop() 根据key，删除value值，pop(key)
# 删除键值对
b = {"id": 1,"name":"张三","gender":"男",
}
print(f"没有删除前：{b.items()}")
b.pop("id")
b.pop("gender")
print(f"pop删除后：{b.items()}")
文件
内存：变量就是存放在内存中（内存空间小、访问速度快、成本高、数据易丢失）
硬盘：文件就是存放在硬盘中（硬盘空间大、访问速度慢、成本低、数据持久化存储）
打开文件
open() 打开一个文件，会返回一个文件对象
open("c:/W_code/python/文件" , r) 第一个参数是：文件在硬盘上的路径；第二个参数是：打开方式
r：read 读方式打开
w：write 写方式打开，会清空掉文件原有内容，重新写入内容
a：append 写方式打开，将新内容写到原有内容后面，不会清空原内容
打开文件是在硬盘上，会返回一个文件对象是在内存上，通过操作这个内存上的变量，修改硬盘上的内容，这种远程操控遥控器，称为“句柄”handler
# 打开文件
file = open("C:/W_Code/python/file.txt", "r")
print(file)
file.close()关闭文件
close() 关闭文件
文件在使用完后，一定要关闭；打开文件就是在申请一定的系统资源，不及时释放文件，可能造成文件资源泄露
写文件
write() 实现写文件操作
写文件，如果不是使用w或r，这样的写方式打开，则会抛出异常
w：write方式打开，会清空文件原有内容，重新写入内
a：append方式打开，新内容写到原内容后面，不会清空原有内容
# 写文件
file = open("C:/W_Code/python/file.txt", "w", encoding="utf-8")
file.write("w 打开方式，清空原内容，写入新内容\n")
file.close()file = open("C:/W_Code/python/file.txt", "a", encoding="utf-8")
file.write("a 新内容写到原内容后面，不会清空原有内容")
file.close()读文件
read() 读文件内容，可以指定读几个字符；也可以按行进行读取，使用for循环
readlines() 读取文件所有内容，按照行组织到列表当中
# 读几个字符
file = open("C:/W_Code/python/file.txt", "r", encoding="utf-8")
result = file.read(4) # 表示读到的是4个字符，一个汉字就是一个字符
print(result)
file.close()# 按行读取
file = open("C:/W_Code/python/file.txt", "r", encoding="utf-8")
for line in file:print(f"line:{line}", end="")# 一行内容的末尾是有一个\n的，print打印也会加一个\n，则打印出的内容会多一行空行# 可以通过修改print参数来解决空行问题，end = ''的默认参数是\n，此时可以改为空字符串
file.close()# readlines()
file = open("C:/W_Code/python/file.txt", "r", encoding="utf-8")
print()
lines = file.readlines()
print(lines)
file.close()上下文管理器
当with对应的代码块执行结束，就会自动将文件close
目的：就是要及时释放资源，避免资源泄露
# 上下文管理器
with open("C:/W_Code/python/file.txt", "r", encoding="utf-8") as file:print("只要with里面的代码执行完，就会将file自动close")