编码,深浅拷贝和文件操作

三.再谈编码

小数据池, 常量池,

id() 查看变量的内存地址

is和==

is  判断内存地址是否一致
==  判断内容是否一致

小数据池的作用：

为了快速的创建字符串对象, 可以减少内存的浪费
用缓存的前提：数据可以被共享。不可变.

2. 再谈编码

ascii:       数字，字母， 特殊字符。
字节：       8bit
gbk:          国标码。16bit， 2byte
unicode:    万国码。32bit， 4byte
utf-8：       可变长度的unicode
英文：         1byte 8bit
欧洲文字：   2byte，16bit
中文：         3byte， 24bit

python中的内存里使用的是unicode

python2中用的是ascii

python3用的是unicode

字符串如果传输：

encode(编码) 结果是bytes类型
接受到bytes之后。 需要解码
decode(编码). 结果是字符串

s = "你好啊" # python3中使用的是unicode, python2里面使用的ascii
print(s)
# unicode 不适合存储. utf-8适合存储和传输
# unicode适合进行计算
s = "和a哈" # unicode: 缺点
print(len(s))
#需要都字符串进行编码。 编码成适合传输的utf-8或者GBK #encode()来编码
s = "胡辣汤"
# 编码之后是字节。 方便传输
bs = s.encode("utf-8")  # b'\xe8\x83\xa1\xe8\xbe\xa3\xe6\xb1\xa4'
print(bs)

s = "alex"
bs = s.encode("utf-8") # 英文在编码的时候还是英文本身
print(bs) # 一个中文是3个字节
s = "棍斤拷"
bs = s.encode("gbk") # 一个gbk中文占2个字节
print(bs) # b'\xc2\xed\xbb\xaf\xcc\xda'
bs1 = s.encode("utf-8")
print(bs1) # b'\xe9\xa9\xac\xe5\x8c\x96\xe8\x85\xbe'
#解码
bs = b'\xe9\xa9\xac\xe5\x8c\x96\xe8\x85\xbe'
s = bs.decode("utf-8")
print(s)
#编码： 存储和传输。 encode()
#解码: 接受数据的时候。decode()

b'xxxxx' 这种格式的数据是bytes类型的数据
bytes是python中的最小数据单元
数据传输中。包括文字。图片。视频都是bytes

重点

# GBK
bs = b'\xc2\xed\xbb\xaf\xcc\xda'
# 1. 解码成unicode(str)
s = bs.decode("gbk")
# 2. 编码成utf-8
bss = s.encode("utf-8")
print(bss) # b'\xe9\xa9\xac\xe5\x8c\x96\xe8\x85\xbe'

作业

1，老男孩好声⾳选秀⼤赛评委在打分的时候呢, 可以进⾏输入. 假设, 老男孩有10个评委. 让10个评委进⾏打分, 要求, 分数必须⼤于5分, ⼩于10分.

lst = []
for i in range(10):
    num = int(input("%s号评委请打分" % (i + 1)))
    if 5 < num and num < 10:
        print("有效的分数")
    else:
        print("无效的分数")
        num = 0
    lst.append(num)
print(lst)

方案二

lst = []
index = 1
while index <= 10:
    num = int(input("%s号评委请打分" % (index)))
    if 5 < num and num < 10:
        lst.append(num)
    else:
        print("您输入的有问题.")
        continue
    index = index + 1
print(lst)

2. 电影投票. 程序先给出⼀个⽬前正在上映的电影列表. 由⽤户给每⼀个电影打分. 最终，将该⽤户打分信息公布出来 lst = ['⾦瓶梅', '解救吾先⽣', '美国往事', '⻄⻄⾥的美丽传说'] 结果: {'⾦瓶梅': 99, '解救吴先⽣': 80, '美国往事': 6, '⻄⻄⾥的美丽传说': 23}

lst = ['⾦瓶梅', '解救吾先⽣', '美国往事', '⻄⻄⾥的美丽传说']
dic = {}
for el in lst:
    num = int(input("请给%s电影打分" % el))
    dic[el] = num
print(dic)

1念数字. 给出一个字典. 在字典中标识出每个数字的发音. 包括相关符号. 然后由用户输入一个数字. 让程序读出相对应的发音(不需要语音输出. 单纯的打印即可)

dic = {'-': 'fu',
       '0': 'ling',
       '1': 'yi',
       '2': 'er',
       '3': 'san',
       '4': 'si',
       '5': 'wu',
       '6': 'liu',
       '7': 'qi',
       '8': 'ba',
       '9': 'jiu',
       '.': 'dian'
       }

s = input("请随意的输入一个数字:") # "-5.987"
for c in s:   # 循环字符串。 拿到每一个字符
       print(dic[c])

2 车牌区域划分, 现给出以下车牌. 根据车牌的信息, 分析出各省的车牌持有量. (升级题)

cars = ["鲁A32444", "鲁B12333","鲁A32444", "鲁B12333","鲁A32444", "鲁B12333", "京B8989M", "黑C49678", "黑C46555", "沪B25041"]
locations = {'沪': "上海", "黑": "黑龙江", "鲁": "山东", "鄂": "湖北", "湘": "湖南", "京": "北京"}
# 结果
result = {}
for car in cars: # 车牌子 "鲁A32444"
       c = car[0] # 鲁
       local = locations[c] # 山东
       # 第五天。 字典。 新增和查询 去代码里找
       # result[local] = result.setdefault(local, 0) + 1
       if result.get(local): # 原来出现过
              result[local] = result[local] + 1
       else: # 第一次出现
              result[local] = 1
print(result)

3 干掉主播. 现有如下主播收益信息, 按照要求, 完成相应操作:

dic={'卢本伟':122000,'冯提模':189999,'金老板':99999,'吴老板':25000000,'alex':12600}
shuru=[]
sum = 0
for v in dic.values():
       sum += v
avg = sum/len(dic)
print(avg)

# dictionary changed size during iteration
# 字典在循环的时候不允许修改大小。不能增加和删除
# 错误实例
for k, v in dic.items():
if v < avg: =====>>>>>错误案例
dic.pop(k)
print(dic)

# 找到主播收入小于平均收入的人（key）

lst = []
for k, v in dic.items():
       if v < avg:
              lst.append(k) # 记录要删除的人
 # 循环的是列表
for el in lst:
       dic.pop(el) # 从字典中删除
print(dic)
# 3,干掉卢本伟
dic.pop("卢本伟")
print(dic)

四.Set集合及深浅拷贝

1. 基础数据部分的补充

1. join: 把列表中的数据进行拼接。拼接成字符串

lst = ["alex", "wusir", "ritian", "taibai"]
#方法一
s = "_".join(lst) # 吧列表拼接起来.  split()相反
print(s)
#方法二
s = ""
for el in lst:
    s += el + "_"
print(s.strip("_"))

字符串转化成列表: split()
列表转化成字符串：join()
x->y类型 y(x)
表示False的数据类型： False, 0, "", [], tuple(), dict(), set(), None.
2. 关于删除:

1）列表和字典在循环的时候都不能删除。

lst = ["王大锤", "王有才", "张小白", "刘大哥"]
#清空这个列表
lst.clear()
for el in lst:
    lst.remove(el) # 删除是不彻底的。 原因是每次删除都会导致元素的移动。 每次都会更新一次索引

#把要删除的内容记录在一个新列表中
new_lst =  []
for el in lst:
    new_lst.append(el)

2把要删除的内容保存在新列表中。循环新列表。删除老列表（字典）

# 循环这个新列表. 删除原来的列表
for el in new_lst: # 不会导致循环的列表的元素移动问题
lst.remove(el) # 注意，删除的是老列表

例一:

lst = ["王大锤", "王有才", "张小白", "刘大哥"]
# 删除掉姓王的
new_lst = [] # 装要删除的内容
for el in lst:
    if el.startswith("王"): # 判断字符串是否以xxx开头
        new_lst.append(el)
# 执行删除
for el in new_lst:
    lst.remove(el)
print(lst)

dic = {"jay":'周杰伦', "jj":"林俊杰 ", "jack": "莱昂纳多迪卡普里奥"}
#要删除的内容在列表中保存
lst = [] # 所有的key
for k in dic:
    lst.append(k)
for el in lst:
    dic.pop(el)
print(dic)

3. fromkeys

dict.fromkeys(iter， value)
把可迭代对象进行迭代。 和后面的value组合成键值对 返回新字典
坑1： 返回新字典。不会改变原来的字典
dic = {}
dic.fromkeys(xxx, xxx)
print(dic) # {}
坑2:
d = fromkeys(xxx.[])
字典中的所有的value都是同一个列表

4 set集合

  特点：无序不重复。 内部元素必须可哈希     #方法 add() 添加

3. 深浅拷贝(画图理解)

1. =  赋值操作没有创建新的对象。 此时 两个变量指向的是同一个内存地址
2. copy() [:] 浅拷贝。 拷贝第一层内容
3. 深拷贝

import copy
copy.deepcopy() 深度拷贝。 把对象内部的所有内容都拷贝一份
作用： 快速创建对象
浅拷贝的问题
优点： 省内存.
缺点： 容易出现同一个对象被多个变量所引用

lst1 = ["孙悟空", "贝吉塔", "卡卡罗特",["七龙珠","战斗陀螺"]]
lst2 = lst1.copy() # 浅拷贝
# lst1.append("短笛")
lst1[3].append("巴啦啦小魔仙")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))

深拷贝

有点： 完全拷贝出一份两个对象之间除了数据相同。 没有任何关系
缺点： 占内存

import copy # 引入拷贝模块
lst1 = ["孙悟空", "贝吉塔", "卡卡罗特",["七龙珠","战斗陀螺"]]
lst2 = copy.deepcopy(lst1) # 会把这个对象相关的内部信息全部复制一份
lst1[3].append("巴啦啦小魔仙")
print(lst1)
print(lst2)
print(id(lst1), id(lst2))
共同有点： 快速创建对象  -> 原型模式(设计模式)

作业

1 判断一个数是否是水仙花数, 水仙花数是一个三位数, 三位数的每一位的三次方的和还等于这个数. 那这个数就是一个水仙花数, 例如: 153 = 1**3 + 5**3 + 3**3

s = input("请输入一个数:")
if int(s) > 999 or int(s) < 100:
    print("错了")
else:
    diyi = s[0]
    dier = s[1]
    disan = s[2]
    sum = int(diyi)**3 + int(dier)**3 + int(disan)**3
    if int(s) ==  sum:
        print("水仙花数")
    else:
        print("不是水仙花数")

2给出一个纯数字列表，请对列表进行排序

思路:

完成a和b的数据交换. 例如, a = 10, b = 24 交换之后, a = 24, b = 10
循环列表. 判断a[i]和a[i+1]之间的大小关系, 如果a[i]比a[i+1]大. 则进行互换. 循环结束的时候. 当前列表中最大的数据就会被移动到最右端.
想一想, 如果再次执行一次上面的操作. 最终第二大的数据就移动到了右端. 以此类推. 如果反复的进行执行相应的操作. 那这个列表就变成了一个有序列表.

lst = [1, 9, 5, 3,8, 288, 197, 666, 12, 5, 2, 6, 7]
for j in range(len(lst)): # 控制内层循环执行的次数, 执行排序的次数
    for i in range(len(lst)-1): # 比较和互换, 时间复杂度比较高。 你们回去想办法降低时间复杂度
        if lst[i] > lst[i+1]:
            lst[i], lst[i+1] = lst[i+1], lst[i]
print(lst)

# 核心思想： 互换
# 快排，归并，堆排序， 希尔排序........
# a = 10
# b = 20
# a, b = b, a

3 完成彩票36选7的功能. 从36个数中随机的产生7个数. 最终获取到7个不重复的数据作为最终的开奖结果.

随机数:

from random import randint
 
randint(0, 20) # 0 - 20 的随机数
 
from random import randint
for i in range(100): # 验证
    s = set()
    while len(s) < 7: # 当集合中的元素少于7个就去生成随机数
        s.add(randint(1, 36)) # 0 - 20 的随机数， [0,20]
    print(s)

**for 迭代一个可迭代对象. 如果计数。不够灵活
**while 死循环. 无法确定循环次数

4. 税务部门征收所得税. 规定如下:

1). 收入在2000以下的. 免征.

2). 收入在2000-4000的, 超过2000部分要征收3%的税.

3). 收入在4000-6000的, 超过4000部分要征收5%的税.

4). 收入在6000-10000的, 超过6000部分要征收8%的税.

4). 收入在10000以上的, 超过部分征收20%的税.

注, 如果一个人的收入是8000, 那么他要交2000到4000的税加上4000到6000的税加上6000到8000的税.

收入 = 8000-(4000-2000)*3%-(6000-4000)*4%-(8000-6000)*8%

让用户输入它的工资, 计算最终用户拿到手是多少钱.

salary = int(input("请输入你的工资:"))
if salary <= 2000: # 基准点
    print("你不用交税")
    print("你的收入是%s" % salary)
elif salary <= 4000:
    print("你要交的税款:%s" % ((salary - 2000) * 0.03))
    print("你的收入是:%s " % (salary - (salary - 2000) * 0.03))
elif salary <= 6000:
    print("你要交的税款:%s" % ((4000-2000)*0.03 + (salary-4000)*0.05))
    print("你的收入是:%s " % (salary - ((4000-2000)*0.03 + (salary-4000)*0.05)))
elif salary <= 10000:
    print("你要交的税款:%s" % ((4000-2000)*0.03 + (6000-4000)*0.05 + (salary-6000)*0.08))
    print("你的收入是:%s " % (salary - ((4000-2000)*0.03 + (6000-4000)*0.05 + (salary-6000)*0.08)))
else:
    print("你要交的税款:%s" % ((4000 - 2000) * 0.03 + (6000 - 4000) * 0.05 + (10000 - 6000) * 0.08 + (salary - 10000) * 0.2))
    print("你的收入是:%s " % (salary - ((4000 - 2000) * 0.03 + (6000 - 4000) * 0.05 + (10000 - 6000) * 0.08 + (salary - 10000) * 0.2)))

　　　　　　　　　　三.文件操作

1. 文件操作 open() 文件句柄

open()打开一个文件，获取的是文件句柄

read()
readline()
readlines()
write()

open表示打开一个文件
f 变量, 操控胡辣汤.txt文件的句柄

f = open("胡辣汤", mode="r", encoding="utf-8")
#读取文件中的内容
read(n) 读取n个字符
content = f.read(3)
content = f.read() # 一次性全都读取出来
line = f.readline() # 读取一行数据
print(line.strip()) # strip()去掉空白。空格， \t \n
line = f.readline() # 读取一行数据
print(line.strip())
lst = f.readlines() # 一次性全都读取出来, 返回的是列表
print(lst)

路径的问题
两种：

  1. 绝对路径(当文件路径是固定的时候)
     从磁盘根目录找文件。  windows下用的就是c，d，e，f， linux： \user\bin\xxxx
  2. 相对路径（用的多)
      相对路径相对于当前程序所在的文件夹
      ../ 表示上一层文件夹

#\n \t 转义字符。 有固定的含义的。 推荐用r
f = open(r"E:\哈哈\t\n\护士模特少妇.txt", mode="r", encoding="utf-8")
print(f.read())
f = open("胡辣汤", mode="r", encoding="utf-8")
正常情况下不能用
f.read()
f.readlines()
#一次读取一行
while 1:
    line = f.readline()
    print(line)

必须要掌握
文件句柄是一个可迭代对象

f = open("胡辣汤", mode="r", encoding="utf-8")
for line in f: # 读取文件中的内容。 一行一行的读取。 每次读取的内容交给前面的变量
    print(line.strip())

2. 文件操作的相关模式Mode

r: 只读
w: 只写
a: 追加
r+:
w+:
a+:
非文本文件
rb
wb
ab
r+b
w+b
a+b

# f = open("taibai", mode="w", encoding="utf-8") # w可以帮我们创建文件
# f.write("\n")
# # f.write("太白\n")
# # f.write("很白\n")
# # f.write("特别白\n")
# f.close()
# f = open("taihei", mode="a", encoding="utf-8")
# # f.write("太黑\n")
# # f.write("很黑\n")
# # f.write("特别黑\n")
# print(f.read())
# f.close()
# 文本文件的复制
f1 = open(r"c:\日记本.txt", mode="r", encoding="utf-8")
f2 = open(r"d:\日记本.txt", mode="w", encoding="utf-8")
 
for line in f1: # 从f1中读取数据
    f2.write(line) # 写入到f2中
f1.close()
f2.close()

例一

# b - bytes 读取和写入的是字节 , 用来操作非文本文件(图片，音频，视频）
# rb, wb, ab
# 需要你掌握的
# 把胡一菲从c盘复制到d盘, 单纯的从bytes角度来复制的。适用于所有文件

f1 = open(r"c:\胡一菲.jpg", mode="rb")
f2 = open(r"d:\胡二非.jpg", mode="wb")

for line in f1: # 分批量的读取内容
    f2.write(line) # open(）出来的结果可以使用read或者write. 根据mode来看
f1.close()
f2.close()

r+ 读写, w+ 写读, a+ 追加写读, r+b, w+b, a+b.+: 扩展
正常的

f = open("person", mode="r+", encoding="utf-8")
content = f.read()
f.write("黄蓉")
print(content)
错误的示范
f = open("person", mode="r+", encoding="utf-8")
f.write("杨千桦") # 默认如果直接写入的话。 在开头写入。 覆盖开头的内容
content = f.read()
print(content)

坑：不论你读取多少内容。再次写入的时候都是在末尾

f = open("person", mode="r+", encoding="utf-8")
info = f.read(3)
f.write("胡辣汤")
print(info)

f = open("person", mode="w+", encoding="utf-8") # 先清空。 然后再操作
f.write("你好。 我叫肿瘤君")
content = f.read() # 写入东西之后。 光标在末尾。 读取不到内容的
print(content)
f.close()

a+, 不论光标在何处写入的时候都是在末尾

f = open("person", mode="a+", encoding="utf-8")
f.write("我叫李嘉诚") # 默认写在末尾
content = f.read()
print(content)
f.close()

3. 相关操作

　　1）. seek()移动光标(重点)

seek(0) 开头
seek(0,2) 移动到末尾

　　2） tell() 获取光标所在的位置

　　3） truncate() 截断文件

f = open("person", mode="r", encoding="utf-8")
info = f.read(3) # 读取三个字符
seek()#移动光标

#李杰是一个大烧饼

f.seek(3) # 以字节为单位
info = f.read(3) # 读取三个字符

seek(参数1，参数2)

参数1表示的是偏移量,移动多少个单位
参数2表示从什么位置进行偏移
0: 开头
1: 当前位置
2: 末尾
把光标移动到文件的开头: seek(0)
把光标移动到末尾： seek(0, 2)

print(f.read(2)) # 读取两个字符。
f.seek(0)   # 回到开头
print(f.read(2))    # 读取两个字符
print(info)
 
tell() 程序返回当前光标的位置
info = f.read(3)
print(info)
print(f.tell()) # 获取光标位置

truncate() 截断文件. 慎用
尽量不要瞎测试, w, w+

f = open(r"C:\Program Files (x86)\Tencent\QQ\Bin\QQScLauncher.exe", mode="r+", encoding="utf-8")
f.seek(5) # 光标移动到5
f.truncate() # 默认从开头截取到光标位置
# f.truncate(3) # 从头截取到3
f.close()

4. 文件修改

with open(xxx) as 句柄, \

open(xxxxx)as xxx

不用手动关闭文件句柄

文件修改的步骤

1. 从源文件中读取数据。

2. 写入到副本文件中

3. 删除源文件

4. 把副本重命名成源文件

import os

os.remove()

os.rename()

文件内容

alen是全世界最sb的人

sb到没老婆

sb到没朋友

sb到不给涨工资

啊多么的sb

import os # 导入os模块
import time # 时间模块
# 优点：不用关闭句柄, 自动关闭连接
with open("唐诗", mode="r", encoding="utf-8") as f1,\
    open("唐诗_副本", mode="w", encoding="utf-8") as f2:
    for line in f1:
        line = line.replace("善良", "sb")
        f2.write(line)
time.sleep(5)
os.remove("唐诗") # 删除源文件
time.sleep(5)
os.rename("唐诗_副本", "唐诗") # 把副本改名成源文件

操作及应用

文件内容:

编号,名称,价格,数量,仓库,phone

1,榴莲,500,60000,1号仓库,10010

2,苹果,700,70000,2号仓库,10086

1,榴莲,500,60000,1号仓库,155

2,苹果,700,70000,2号仓库,166

f = open("水果.data", mode="r", encoding="utf-8")
titles = f.readline().strip() # 读取第一行 id,name,price,num
t_list = titles.split(",") # 【id,name,price,num】
lst = []
for line in f: # "1，苹果,500,60000"  {id：1，name:liulian, num:xx, price:xxx}
    dic = {}
    ll = line.strip().split(",")
    for i in range(len(t_list)):
        dic[t_list[i]] = ll[i]
    lst.append(dic)
f.close()
print(lst)

作业

1，有如下文件，a1.txt，里面的内容为：

老男孩是最好的培训机构，

全心全意为学生服务，

只为学生未来，不为牟利。

我说的都是真的。哈哈

分别完成以下的功能：

a,将原文件全部读出来并打印。

读取并打印

f=open("al.txt",mode="r",encoding="utf-8")
countent=f.read()
f.close()
print(countent)

b,在原文件后面追加一行内容：信不信由你，反正我信了。

追加一行

f2=open(r"al.txt",mode="a",encoding="utf-8")
content=f2.write( "\n信不信由你，反正我信了")
print(content)

c,将原文件全部读出来，并在后面添加一行内容：信不信由你，反正我信了。

追加并打印

f=open("al.txt",mode="r+",encoding="utf-8")

cot=f.read()
content=f.write( "\n信不信由你，反正我信了")
print(cot)
f.close()

d,将原文件全部清空，换成下面的内容：

每天坚持一点，

每天努力一点，

每天多思考一点，

慢慢你会发现，

你的进步越来越大。

e,将原文件内容全部读取出来，并在‘我说的都是真的。哈哈’这一行的前面加一行，‘你们就信吧~’然后将更改之后的新内容，写入到一个新文件：a1.txt。

with open("a.txt", mode="r", encoding="utf-8") as f1, \
    open("b.txt", mode="w", encoding="utf-8") as f2:
    for line in f1:
        if line.strip() == "我说的都是真的。哈哈":
            line="你们就信吧~\n" + line
        f2.write(line)

    content = f1.read()
    content = content.replace("我说的都是真的。哈哈", "你们就信吧~\n我说的都是真的。哈哈")
    f2.write(content)

2，有如下文件，t1.txt,里面的内容为：

葫芦娃，葫芦娃，

一根藤上七个瓜

风吹雨打，都不怕，

啦啦啦啦。

我可以算命，而且算的特别准:

上面的内容你肯定是心里默唱出来的，对不对？哈哈

分别完成下面的功能：

a,以r+的模式打开原文件，判断原文件是否可读，是否可写。

b,以r的模式打开原文件，利用for循环遍历文件句柄。

c,以r的模式打开原文件，以readlines()方法读取出来，并循环遍历 readlines(),并分析b,与c 有什么区别？深入理解文件句柄与 readlines()结果的区别。

d,以r模式读取‘葫芦娃，’前四个字符。

e,以r模式读取第一行内容，并去除此行前后的空格，制表符，换行符。

f,以r模式打开文件，从‘风吹雨打.....’开始读取，一直读到最后。

g,以a+模式打开文件，先追加一行：‘老男孩教育’然后在从最开始将原内容全部读取出来。

h,截取原文件，截取内容：‘葫芦娃’

3，文件a.txt内容：每一行内容分别为商品名字，价钱，个数。

apple 10 3

tesla 100000 1

mac 3000 2

lenovo 30000 3

chicken 10 3

通过代码，将其构建成这种数据类型：[{'name':'apple','price':10,'amount':3},{'name':'tesla','price':1000000,'amount':1}......] 并计算出总价钱。

f = open("money.txt", mode="r", encoding="utf-8")
# name:apple price:10   amount:3 year:2012
result = []
for line in f:
    dic = {}
    lst = line.split() # 根据空白切
    # 向字典中添加数据
    for el in lst: # price:10
        dic[el.split(":")[0]] =  el.split(":")[1]
    # 数据已经添加完了
    # 放在列表中
    result.append(dic)
print(result)

4，有如下文件：

alex是老男孩python发起人，创建人。

alex其实是人妖。

谁说alex是sb？

你们真逗，alex再牛逼，也掩饰不住资深屌丝的气质。

将文件中所有的alex都替换成大写的SB（文件的改的操作）。

5，文件a1.txt内容(升级题)

name:apple price:10 amount:3 year:2012
name:tesla price:100000 amount:1 year:2013

.......
通过代码，将其构建成这种数据类型：
[{'name':'apple','price':10,'amount':3},
{'name':'tesla','price':1000000,'amount':1}......]
并计算出总价钱。

# [{'name': 'apple', 'price': '10', 'amount': '3', 'year': '2012'},
# {'name': 'tesla', 'price': '100000', 'amount': '1', 'year': '2013'}]
f = open("money.txt", mode="r", encoding="utf-8")
# name:apple price:10 amount:3 year:2012

result = []
for line in f:
    dic = {}
    lst = line.split() # 根据空白切
    # 向字典中添加数据
    for el in lst: # price:10
        dic[el.split(":")[0]] =  el.split(":")[1]
    # 数据已经添加完了
    # 放在列表中
    result.append(dic)
sum = 0
for el in result:
    sum += int(el['price']) * int(el['amount'])
print(sum)

6，文件a1.txt内容(升级题)

序号     部门      人数      平均年龄      备注
1       python    30         26         单身狗
2       Linux     26         30         没对象
3       运营部     20         24         女生多

.......

通过代码，将其构建成这种数据类型：
[{'序号':'1','部门':Python,'人数':30,'平均年龄':26,'备注':'单身狗'},
......]
# 1. 打开文件读取内容

f = open("doller.txt", mode="r", encoding="utf-8")

# 2. 读取头信息

title_line = f.readline().strip()

# 3. 切割成列表

title_list = title_line.split() # 所有的key都在这里

# 4. 读取数据

result = []
for line in f:
    dic = {}
    # 5.切割数据
    lst  = line.strip().split() # 都是value
    # 6.把表头信息和文件数据信息进行映射
    for i in range(len(title_list)):
        dic[title_list[i]] = lst[i]
    # 7.装到列表中
    result.append(dic)

print(result)