目录
元组:
- 元素tuple,使用的();
- 元素和列表非常相似,都可以存储多个数据,都可以存储任意类型的数据;
- 区别就是元组中的数据不能修改,列表中可以修改;
- 因为元组中的数据不能修改,所以只能查询方法,如index,count,支持下标和切片;
- 元组,主要用于传参和返回值。
# 元组可以从语法的层面来限制数据的意外修改
# 元组使用小括号来定义
my_tuple = (1, 2, 3)
print(my_tuple[0])
# 注意:元组中如果只有一个元素的话,需要在元素后面加逗号
my_tuple = (20,)
my_tuple = ((10,),)
print(my_tuple)
# 元组可以嵌套元组
my_tuple = ((1, 2), (10, 20))
print(my_tuple)
my_tuple = (1, 2, 3, 4)
for t in my_tuple:
print(t)
#查询
pos = my_tuple.index(2)
print(pos)
#元组支持切片操作
my_tuple = (1,2,3,4)
print(my_tuple[1:])
使用元组交换两个变量值
- 在定义元组的时候,小括号可以省略不写;
- 组包(pack),将多个数据值组成元组的过程a = 1,2 # a = (1,2);
- 拆包(解包unpack),将容器中多个数据分别给到多个变量,需要保证容器中元素个数和变量个数保持一致。
a = 10
b = 20
#数据交换过程
c = b,a #组包
print(c) #(20, 10)
a,b = c #拆包
print(a, b) #20 10
#直接交换
a,b = b,a
print(a, b)
x,y,z = 'abc'
print(y) #b
元组小结:
- 元组一旦创建不可修改;
- 元组中只有一个元素时,需要在尾部额外添加一个逗号;
- 元组比列表更节省空间,因为列表可以添加元素,会导致列表一次性增加多余内存,元组不可以修改元素,因此占用内存固定;
- 元组是序列式容器,支持索引、切片操作.
字典:
字典的查找效率比较高,但是比较占内存,字典以空间换时间.字典是非序列式容器,不支持索引、切片操作,字典的查询性能优于列表.
- 字典dict,使用{}表示;
- 字典是由键(key)值(value)对组成的,key:value;
- 一个键值对是一组数据,多个键值对之间使用逗号隔开;
- 在一个字典中,字段的键是不能重复的;
- 字典中的键主要使用字符串类型,可以是数字。
#1.类实例化的方式
my_dict1 = dict()
print(type(my_dict1),my_dict1) #<class 'dict'> {}
#2.直接使用{}定义
#2.1 定义空字典
my_dict2 = {}
print(my_dict2)
#2.2 定义非空字典,姓名,年龄,身高,性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)
字典语法:
字典是另一种可存储任意类型对象,字典的每个键值key=>value对用冒号(:)分隔,每个键值对之间用逗号(,)分割,整个字典包括在大括号{}中.
键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一.
格式:
my_dict = {key1:value1,key2:value2}
# 字典定义
def test01():
my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
print(my_dict['name'])
print(my_dict[102]) # key 关键字,value 值
my_dict['gender'] = '女'
print(my_dict)
test01()
# 字典不支持索引,切片
def test02():
my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
print(my_dict[1])
print(my_dict[1:])
# 获得字典的值
def test03():
my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
# 使用中括号这种访问字典中元素的方式,如果键不存在则报错.程序终止
# print(my_dict['age1'])
# 使用get方法,如果key不存在默认值返回None,也可以指定默认返回值,
print(my_dict.get('age1', '默认返回值'))
# 添加和修改元素
def test04():
my_dict = {'name': '团子', 'age': 20, 'gender': '男', 102: 100}
# 如果key不存在则是新增元素
my_dict['score'] = 90 # 添加新元素
print(my_dict)
# 如果key存在的话就是修改元素
my_dict['name'] = 'AAA'
print(my_dict)
字典增加:
字典['键'] = 值
1.键存在,修改;
2.键不存在,添加。
#2.2 定义非空字典,姓名,年龄,身高,性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)
#3.将年龄改为20
my_dict3['age'] = 20
print(my_dict3)
#4.添加体重
my_dict3['weight'] = 65
print(my_dict3)
字典删除操作:
字典的删除是根据字典的键,删除键值对
字典.pop('键')
#2.2 定义非空字典,姓名,年龄,身高,性别
my_dict3 = {"name":"小明","age":18,"height":180,"sex":"男"}
print(my_dict3)
#3.将年龄改为20
my_dict3['age'] = 20
print(my_dict3)
#4.添加体重
my_dict3['weight'] = 65
print(my_dict3)
#5.删除
my_dict3.pop('weight')
print(my_dict3) #{'name': '小明', 'age': 20, 'height': 180, 'sex': '男'}
# 字典删除操作
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
del my_dict['aaa']
print(my_dict)
# 清空字典
my_dict.clear()
print(my_dict)
# del不仅能删除字典中的某个键值对,还能删除列表中的元素
# 1.删除某个变量
a = 10
del a
# print('a = ',a)
# 2.删除列表中的元素
my_list = [1,2,3]
del my_list[0]
print(my_list)
字典的查询:
根据字典的键,获取对应的值
方法一:字典['键'] #键不存在,会报错;
方法二:字典.get(键) #键不存在,返回Nonem
my_dict = {'name':'小明','age':20}
#获取name值
print(my_dict['name'])
print(my_dict.get('name'))
#获取sex
#print(my_dict['sex']) #会报错,因为sex键不存在 KeyError: 'sex'
print(my_dict.get('sex')) #None
字典的遍历:
字典存在键(key),值(value),遍历分为三种情况
1.遍历字典的键
#方式一:
for 变量 in 字典:
print(变量)
#方式二:for 变量 in 字典.keys(): #字典.keys()可以获取字典所有的键
print(变量)
2.遍历字典的值(使用较多)
for 变量 in 字典.values(): #字典.values()可以获取字典中所有的值print(变量)
3.遍历字典的键和值
#变量1就是键,变量2就是值
for 变量1,变量2 in 字典.items(): #字典.items()获取的是字典的键值对
print(变量1,变量2)
my_dict = {"name":"小明","age":18,"height":180,"sex":"男"}
for a in my_dict:
print(a)
for b in my_dict.keys():
print(b)
for c in my_dict.values():
print(c)
for d in my_dict.items():
print(d)
# 字典的遍历
#由于字典是非序列式列表,因此不能直接遍历,需要转换成列表再遍历
# keys方法可以获得所有的键列表
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
key_list = my_dict.keys()
print(list(key_list))
# keys方法获得所有的值列表
value_list = my_dict.values()
print(list(value_list))
# keys方法可以获得所有的键值对列表,每一个键值对都是一个元素
key_values_list = my_dict.items()
print(list(key_values_list))
for key_value in key_values_list:
# print('key:',key_value[0],'value:',key_value[1])
print(key_value)
使用while遍历字典:
# 使用while循环遍历字典
my_dict = {'aaa': 10,'bbb': 20,'ccc': 30}
my_list = list(my_dict.items())
i = 0
while i < len(my_dict):
print('key: ',my_list[i][0],'value:',my_list[i][1])
i += 1
文件访问模式:
访问模式 | 说明 |
r | 以只读方式打开文件,文件的指针将会放在文件的开头,这是默认模式. |
w | 打开一个文件只用于写入,如果该文件已存在则将其覆盖,如果该文件不存在,创建新文件. |
a | 打开一个文件用于追加.如果该文件已存在,文件指针将会放在文件的结尾.也就是说,新的内容将会被写入到已有内容之后.如果该文件不存在,创建新文件进行写入. |
rb | 以二进制格式打开一个文件用于只读.文件指针将会放在文件的开头,这是默认模式. |
wb | 以二进制格式打开一个文件只用于写入,如果该文件已存在则将其覆盖,如果该文件不存在,创建新文件. |
ab | 以二进制格式打开一个文件用于追加,如果该文件已存在,文件指针将会放在文件的结尾,也就是说,新的内容将会被写入到已有内容之后,如果该文件不存在,创建新文件进行写入. |
程序:hello world\n
Windows:hello world\r\n
Mac:hello world\r\
Linux:hello world\n
打开文件用的文本模式,会进行换行符的转换;打开文件用的是二进制模式的话,不会进行换行符转换.文件本质上都是以二进制的方式存储在磁盘上的.
打开文件(open):
open(file, mode='r', encoding=None) --file:表示要操作的文件的名字,可以使用相对路径和绝对路径 --绝对路径,从根目录开始书写的路径 C:/ D:/ --相对路径,从当前目录开始书写的路径 ./ ../ --mode:打开文件的方式 -r,只读打开,read,如果文件不存在,会报错 -w,只写打开,write,如果文件存在,会覆盖原文件 -a,追加打开,append,在文件的末尾写入新的内容 --encoding:编码格式,指二进制数据和汉字转换的规则 -utf-8(常用):将一个汉字转换为3个字节的二进制 -gbk:将一个汉字转换为2个字节的二进制 返回值:文件对象,后续对文件的操作,都需要这个文件对象
# 文件打开模式
def test01():
"""读方式打开文件"""
f = open('a.txt', 'r')
content = f.read()
print(content)
f.close()
def test02():
# w模式默认是会覆盖文件中的数据的
# w模式如果发现文件不存在,则会新建文件
f = open('a.txt', 'w')
f.write('hello world!')
f.close()
# 追加
def test03():
f = open('a.txt', 'a')
f.write('\nhello python')
f.close()
# test01()
# test02()
test03()
关闭文件close():
文件对象.close() #关闭文件,如果是写文件,会自动保存,即将内存中的数据同步到硬盘中
读文件read():
文件对象.read()
返回值:返回读取到的文件内容,类型是字符串
# 使用open函数打开一个文件
fa = open('a.txt', 'w')
my_content = 'hello world!第一次写入文件!'
fa.write(my_content)
# 关闭文件
fa.close()
# 2.读取文件数据
fb = open('b.txt', 'r', encoding='utf-8')
# read函数默认读取文件中所有数据
my_content = fb.read()
fb.close()
print(my_content)
# 写文件:write writelines
def test01():
"""1.write函数用法"""
f = open('a.txt', 'w')
# write函数一次写一行
f.write('hello world!')
# wrirelines一次可以写多行,参数是一个列表,列表每一个元素都是一行数据
lines = ['aaa\n', 'bbb\n', 'ccc\n']
f.writelines(lines)
f.close()
def test02():
"""2.读操作"""
f = open('a.txt', 'r')
# read没有指定参数,则读取文件中的所有数据
# read指定参数,则读取参数中指定个数的数据
content = f.read()
f.close()
print(content)
def test03():
"""一次读取一行"""
f = open('a.txt', 'r')
content = f.readline()
print(content)
f.close()
def test04():
"""一次读取所有行"""
f = open('a.txt', 'r')
# content = f.readlines()
# print(content)
lines = f.readlines()
print(lines)
for line in lines:
if line[-1] == '\n':
print(line[:-1])
else:
print(line)
f.close()
# test01()
# test02()
# test03()
test04()
写文件write()
文件对象.write()
#参数:写入文件的内容,类型字符串
#返回值:写入文件中的字符数.字符串的长度一般不关注
#1.打开文件
f = open('a.txt','w',encoding='utf-8')
#2.写文件
f.write('好好学习/天天向上')
#3.关闭文件
f.close()
文件打开的另一种写法(推荐):
with open(file,mode,encoding) as 变量: #变量就是文件对象
pass
#使用这些写法打开文件,会自动进行关闭,不用手动书写关闭的代码
#出了with的缩进之后,文件就会自动关闭
with open('a.txt',encoding='utf-8') as f:
buf = f.read()
print(buf)
文件拷贝:
# 1.获得要拷贝的文件名
old_file_name = input('请输入您要拷贝的文件名:')
# 2.读取要拷贝的文件内容
new_file_name = old_file_name + '.bk'
# 3.打开新的文件
f_old = open(old_file_name,'rb')
f_new = open(new_file_name,'wb')
# 4. 将老文件内容写到新文件里面
old_file_content = f_old.read()
f_new.write(old_file_content)
# 5.关闭新老文件
f_old.close()
f_new.close()
文件和目录操作:
# 文件和目录操作
import os
def test01():
"""文件重命名"""
os.rename('a.txt', 'cmt.txt')
def test02():
"""文件删除"""
# 路径问题:如果只写文件名,默认只在当前目录下找文件,如果找不到就报错!
os.remove(r'C:\USERS\30467\DESKTOP\A.TXT')
def test03():
"""创建和删除目录"""
# os.mkdir(r'C:\USERS\30467\DESKTOP\cj')
os.rmdir(r'C:\USERS\30467\DESKTOP\cj')
def test04():
"""获得指定目录下的文件列表"""
content = os.listdir()
print(content)
def test05():
"""获得和设置工作目录"""
cwd = os.getcwd() # cwd current working directory
print(cwd)
# 将默认的工作目录设置到我的桌面了
os.chdir(r'C:\USERS\30467\DESKTOP')
os.mkdir('aaa')
# test01()
# test02()
# test03()
# test04()
test05()