Task 3 --字典、元组、布尔类型、读写文件&课后练习及补充

一、字典、元组、布尔类型、读写文件

1.1字典

1.1.1字典的认识及基本操作

字典（也叫 dict）是一种和列表类似的数据存储方式。但是不同于列表只能用数字获取数据，字典可以用任何东西来获取。你可以把字典当成是一个存储和组织数据的数据库。
下面对列表和字典进行比较：
列表操作

things=['a','b','c','d']
print(things[1])

b

things[1]='z'
print(things[1])

z

things

['a', 'z', 'c', 'd']

以上可以看到，可以用数字来索引列表，找到列表里有什么，同时还能进行切片、改变元素等操作。
相比之下，字典能让你用几乎所有的东西，而不只是数字。是的，字典能够把一个东西和另一个东西关联起来，不管它们是什么类型。我们来看看：使用花括号语法创建字典时，花括号中应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。下面对字典的操作进行展示。

stuff={'name':'Zed','age':39,'height':6*12+2}
print(stuff['name'])
print(stuff['age'])
print(stuff['height'])
stuff['city']='SF'
print(stuff['city'])

Zed
39
74
SF

通过上面的举例，可以看到用了字符串（而不是数字）来从 stuff 字典中取出了我们想要的东西。 我们也可以用字符串来给字典添加新的东西。而且，也可以不用字符串，也可以这样做：

stuff[1]='wow'
stuff[2]='Neato'
print(stuff[1])
print(stuff[2])

wow
Neato

stuff

{'name': 'Zed', 'age': 39, 'height': 74, 'city': 'SF', 1: 'wow', 2: 'Neato'}

在打印字典的时候既可以用数字也可以用字符串来作为键。
同样的，和列表操作一样，可以使用del来删除其中的东西：

del stuff['city']
del stuff[1]
del stuff[2]
stuff

{'name': 'Zed', 'age': 39, 'height': 74}

练习
将州名和他们的缩写以及州的缩写和城市映射起来，“映射”或者说“关联”（associate）是字典的核心理念。

#creat a mapping of state to abbreviation
states={
    'Oregon': 'OR',
    'Florida': 'FL',
    'California': 'CA',
    'New York': 'NY',
    'Michigan': 'MI'
}
#creat a basic set of states and some cities in them
cities={
    'CA':'San Francisco',
    'MI':'Detroit',
    'FL':'Jacksonville'
}
#add some more cities
cities['NY']='New York'
cities['OR']='Portland'
#print out some cities
print('-'*10)
print('NY State has:',cities['NY'])
print('OR State has:',cities['OR'])
#print some cities
print('-'*10)
print("Machigan's abbreviation is:",states['Michigan'])
print("Florida's abbreviation is:",states['Florida'])
#do it by using the state then cities dict
print('-'*10)
print("Michigan has:",cities[states['Michigan']])
print("Florida has:",cities[states['Florida']])
#print every state abbreviation
print('-'*10)
for state,abbrev in list(states.items()):
    print(f"{state} is abbreviated {abbrev}")
#print every city in state
print('-'*10)
for abbrev,city in list(cities.items()):
    print(f"{city}is abbreviated {abbrev}")
#now do both at the same time 
print('-'*10)
for state,abbrev in list(states.items()):
    print(f"{state}state is abbreviated {abbrev}")
    print(f"and has city {cities[abbrev]}")
print('-'*10)
#safely get a abbreviation by state that might not be there
state=states.get('Texas')

if not state:
    print('Sorry,no Texas')

#get a city with a default value
#default -- 如果指定键的值不存在时，返回该默认值或设置的默认值。
city=cities.get('TX','Does Not Exist')
print(f"The city for the state 'TX' is:{city}")

----------
NY State has: New York
OR State has: Portland
----------
Machigan's abbreviation is: MI
Florida's abbreviation is: FL
----------
Michigan has: Detroit
Florida has: Jacksonville
----------
Oregon is abbreviated OR
Florida is abbreviated FL
California is abbreviated CA
New York is abbreviated NY
Michigan is abbreviated MI
----------
San Franciscois abbreviated CA
Detroitis abbreviated MI
Jacksonvilleis abbreviated FL
New Yorkis abbreviated NY
Portlandis abbreviated OR
----------
Oregonstate is abbreviated OR
and has city Portland
Floridastate is abbreviated FL
and has city Jacksonville
Californiastate is abbreviated CA
and has city San Francisco
New Yorkstate is abbreviated NY
and has city New York
Michiganstate is abbreviated MI
and has city Detroit
----------
Sorry,no Texas
The city for the state 'TX' is:Does Not Exist

附加练习
写一个中国省份与省份缩写对应的字典代码

province={
    'Beijing':'BJ',
    'Tianjin':'TJ',
    'Hebei':'HB',
    'Shanxi':'SX',
    'Shandong':'SD',
    'Liaoning':'LN',
    'Jilin':'JL',
    'Heilongjiang':'HLJ'
}
province

{'Beijing': 'BJ',
 'Tianjin': 'TJ',
 'Hebei': 'HB',
 'Shanxi': 'SX',
 'Shandong': 'SD',
 'Liaoning': 'LN',
 'Jilin': 'JL',
 'Heilongjiang': 'HLJ'}

1.1.2字典的其他操作总结

（1）get（）
就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误； 但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。例如：

#根据上面创建的province字典进行演示
print(province.get('Hebei'))
print(province.get('Hunan'))

HB
None

（2）update()
update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。例如：

province.update({'Hubei':'HB', 'Hainan': 'HN'})  
print(province)

{'Beijing': 'BJ', 'Tianjin': 'TJ', 'Hebei': 'HB', 'Shanxi': 'SX', 'Shandong': 'SD', 'Liaoning': 'LN', 'Jilin': 'JL', 'Heilongjiang': 'HLJ', 'Hubei': 'HB', 'Hainan': 'HN'}

（3）pop（）
pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对，例如

print(province.pop('Hainan'))

HN

print(province)

{'Beijing': 'BJ', 'Tianjin': 'TJ', 'Hebei': 'HB', 'Shanxi': 'SX', 'Shandong': 'SD', 'Liaoning': 'LN', 'Jilin': 'JL', 'Heilongjiang': 'HLJ', 'Hubei': 'HB'}

1.2元组

1.2.1元组的认识与基本操作

元组是另一个数据类型，类似于list。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple=('runoob',786,2.33,'john',70.2)
tinytuple=(123,'john')
print(tuple)#输出完整元组
print(tuple[0])#输出元组的第一个元素
print(tuple[1:3])#输出元组的第二到第四个（不包含）的元素
print(tuple[2:])#输出元组从第三个到第最后一个元素
print(tinytuple*2)#输出元组两次
print(tuple+tinytuple)#输出组合的元组

('runoob', 786, 2.33, 'john', 70.2)
runoob
(786, 2.33)
(2.33, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.33, 'john', 70.2, 123, 'john')

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

tuple=('runoob',786,2.33,'john',70.2)
list=['runoob',786,2.33,'john',70.2]
tuple[2]=1000#元组中是非法应用
list[2]=1000#列表中是合法应用

出现报错

1.1.2元组的其他操作总结

主要是根据查找到的资料练习教程中未出现的操作

tuple_new=('BJ','TJ','HB','SD','SX')#创建一个新的元组，下面的例子也基于此

（1）元组反转，通过分片操作即可，分片操作中当步长为-1就可以实现列表反转

tuple_new[::-1]

('SX', 'SD', 'HB', 'TJ', 'BJ')

（2）元素是否存在于元组中的判断，与列表操作一样

'SJZ'in tuple_new

False

'SJZ'not in tuple_new

True

（3）删除元组，使用del

tuple1 = (1,2,3,4)
del tuple1
tuple1

1.2.3总结

（1）元组的许多操作方法和列表是一样的，由于元组不可以随意的插入和删除，所以我们需要使用分片的方法来实现这两个功能。
（2）当创建的元组只包含一个元素时，里面的逗号是必不可少的，有逗号才可以证明我们创建的是元组。
（3）元组与列表和字符串一样都可以看做是一个可迭代对象，并且三者可以相互转化。

1.3布尔类型

在python表述的语法是

• and • or • not
• != （不等于）
• == （等于）
• >= （大于等于）
• <= （小于等于）
• True
• False
练习在 Python 中运用逻辑表

print(True and True,#True
      False and True,#False
      1 == 1,2 == 2,#False
      "test"=="test",#True
      1 == 1 or 2!= 1,#True
      True and 1== 1,#True
      False and 0!= 0,#False
      True or 1 == 1,#True
      'test'=='testing',#False
      1!=0 and 2==1,#False
      'test'!='testing',#True
      'test'==1,#False
      not(True and False),#True
      not(1 == 1 and 0!=1),#False
      not(10 == 1 or 1000 == 1000),
      not(1!=10 or 3 == 4),#False
      not('testing' == 'testing' and 'Zed'=='cool guy'),#True
      1==1 and (not('testing' == 1 or 1 == 0)),#True
      'chunky'=='bacon'and (not(3==4 or 3==3 )),#False
      3==3 and (not('testing'== 'testing'or 'Python' == 'Fun'))#False
     )

True False True True True True True False True False False True False True False False False True True False False

判断正确

1.4读写文件

1.4.1读写文件基本操作

•close - 关闭文件，就像编辑器中的 “文件->另存为”一样。
•read - 读取文件内容。你可以把读取结果赋给一个变量。
• readline - 只读取文本文件的一行内容。 •truncate - 清空文件。清空的时候要当心。 •write(‘stuff’) - 给文件写入一些“东西”。
•seek(0) - 把读/写的位置移到文件最开头。
练习，用这些命令做一个小小的编辑器

from sys import argv
filename ='test1.txt'
print(f"We're going to erase {filename}.")     
print(f"If you don't want that ,hit CTRL-C(^C).")
print(f"If you do want that ,hit RETURN.")
input("?")
print("Opening the file...")
target == Open(filename,'w')
print("Truncating the file.Goodbye!")
target.truncate
print("Now I'm going to ask you for three lines.")
line1=input("line 1:2020")
line2=input("line 2:2021")
line3=input("line 3:2022")
print("I'm going to write these to the file ")
target.write(line1)
target.write("\n")
target.write(line2)
target.write("\n")
target.write(line3)
target.write("\n")
print("And finally,we close it.")
target.close()

C:\Users\Administrator\python3.9\python.exe D:/PycharmProjects/untitled1/test.py
We're going to erasetest1.txt.
If you don't want that, hit CTRL-C (^C).
If you do want that, hit RETURN.
?
Opening the file...
Truncating the file. Goodbye!
Now I'm going to ask you for three lines.
line 1: i
line 2: love
line 3: you
I'm going to write these to the file.
And finally, we close it.





Process finished with exit code 0

1.4.2 其中用到的函数及参数

open（）函数
•语法
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True)

•运行
打开file并返回对应的文件对象。若文件不能打开，则触发OSError。

•参数

常用的是file，mode和encoding

•file
file 是一个路径类对象，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。
•mode
指定了文件的打开模式，也就是设定文件的打开权限。
打开模式及模式描述

打开模式	模式描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

下图很好地总结了几种常见的模式

•encoding
用于指定文件的编码方式，默认采用utf-8，一般使用utf8或gbk。
编码方式主要是指文件中的字符编码。
win系统默认是gbk编码的，所以桌面生成的TXT之类的都是gbk编码的。
附加练习
（1）如果你理解不了这个练习，回过头去按照给每行加注释的方法再过一遍，注释能帮助你理解每一行的意思，至少让你知道你不理解的地方在哪里，然后动手去查找答案。

# 将sys模块导入
from sys import argv

# 将变量赋值
filename ='test1.txt'
# 打印字符串：我们将擦除给定文件名内的内容
print(f"We're going to erase {filename}.")
# 打印字符串：如果你不想要这样，点击CTRL-C （^C）
print("If you don't want that, hit CTRL-C (^C).")
# 打印字符串：如果你想要这样，点击RETURN
print("If you do want that, hit RETURN.")

# 打印“？”并获得输入内容
input("?")

# 打印字符串：正在打开文件……
print("Opening the file...")
# 以只写方式打开文件并返回相应的文件对象，并将其赋值给左边的target变量
target = open(filename, "w")

# 打印字符串：删截文件。再见！
print("Truncating the file. Goodbye!")
# 清空target文件
target.truncate()

# 打印字符串：现在我要问你三句话
print("Now I'm going to ask you for three lines.")

# 打印“line 1：”，获得输入内容并将其赋值给line1
line1 = input("line 1: ")
# 打印“line 2：”，获得输入内容并将其赋值给line2
line2 = input("line 2: ")
# 打印“line 3：”，获得输入内容并将其赋值给line3
line3 = input("line 3: ")

# 打印字符串：我要将这些写入文件
print("I'm going to write these to the file.")

# 将line1写入target
target.write(line1)
# 将\n换行符写入target
target.write("\n")
# 将line2写入target
target.write(line2)
# 将\n换行符写入target
target.write("\n")
# 将line3写入target
target.write(line3)
# 将\n换行符写入target
target.write("\n")

# 打印字符串：最终，我们关闭文件
print("And finally, we close it.")
# 关闭target文件
target.close()

（2）写一个类似于上个练习的脚本，使用 read 和 argv 来读取你刚刚创建的文件。

from sys import argv
filename ='test.txt'
txt = open(filename)
print(txt.read())
txt.close()

C:\Users\Administrator\python3.9\python.exe D:/PycharmProjects/untitled1/test.py
2020        
2021
2022

（3）这个练习中有太多的重复，试着用一个 target.write() 命令来打印 line1、line2、line3，你可以使用字符串、格式字符串和转义字符。

target.write(f"{line1} \n {line2} \n {line3} \n")

（4）弄明白为什么我们要用一个 ‘w’ 作为一个额外的参数来打开。提示：通过明确说明你想要写入一个文件，来安全地打开它。

确保操作完成后文件内的内容仅为本次操作写入的内容。
（5）如果你用 w 模式打开文件，那你还需要 target.truncate() 吗？ 读一读 Python 的 open 函数文件，来搞明白这个问题。

不需要，‘w‘ ：打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。就算不使用truncate（），文件的原有内容也会被清空，而不会追加。

1.4.3读写文件方法与经验总结
详见教程：https://linklearner.com/datawhale-homepage/index.html#/learn/detail/6

二、课后练习及补充

2.1 数据类型相关练习

2.1.1 数据类型转换

# str -> int
X = int('ABCD', 16)
print(X)
type(X)

43981

int

# int -> float
a = 520
b = float(a)
b

520.0

# float -> str
a = 5.99
b = str(a)
b

'5.99'

#接下来，请尝试将字符串'520'转化为小数，可以使用float()
a = '520'
b =float(a)
b

520.0

#运行下面单元格，了解字符串的切片操作

a_string = 'Hello' + ' ' + "Women Who Code!"
print(a_string)
print("str[0]  :" + a_string[0])
print("str[2:5]:" + a_string[2:5]) # Python speak: slicing
print("str[2:] :" + a_string[2:])

Hello Women Who Code!
str[0]  :H
str[2:5]:llo
str[2:] :llo Women Who Code!

2.2 列表操作

lis = [ "WWCode", 786 , 2.23, 'singapore', 70.2 ]
print(lis[0:3])#切片
type(lis)#类型

['WWCode', 786, 2.23]
list

#列表切片操作
lis[0][2:]

‘Code’

#列表中元素更改
lis[2] = 3.3
lis

['WWCode', 786, 3.3, 'singapore', 70.2]

#将最后一个元素改为50
lis[-1]=50
lis

['WWCode', 786, 3.3, 'singapore', 50]

# list comprehension操作，可以运行下面单元格感受一下
symbols = '$¢£¥€¤'
codes = [ord(symbol) for symbol in symbols]
codes

[36, 162, 163, 165, 8364, 164]

补充：ord()函数是Python中的一个库函数，
用于从给定字符值中获取数字值，它接受一个字符并返回一个整数，即用于将字符转换为整数，即用于获取ASCII给定字符的值

2.3 元组操作

t1 = ( "WWCode", 100000 , 0.5 ) # org name, members, proportion of engineers
t2 = 'Singapore', 1160.5
t_singleton = ('We',) # singleton
t_empty = ()
print(type(t1)); print(type(t2))
print(t_singleton);
type(t_empty)

<class 'tuple'>
<class 'tuple'>
('We',)
tuple

#元组内元素不可修改
t1[2] = 20

出现报错

2.4 字典操作

dict1 = {'name':'Women Who Code Singapore', 
        'org':'WWCode', 
        'city':'Singapore',
        'members':1260}
print(dict1['org'])
type(dict1)

WWCode
dict

#字典元素可以更改

# 增加元素
dict1['rank'] = 10
dict1

{'name': 'Women Who Code Singapore',
 'org': 'WWCode',
 'city': 'Singapore',
 'members': 1260,
 'rank': 10}

# 获取元素
dict1['city']
dict1

{'name': 'Women Who Code Singapore',
 'org': 'WWCode',
 'city': 'Singapore',
 'members': 1260,
 'rank': 10}

# 获取不知是否存在的元素
dict1.get('org','不存在')

'WWCode'

dict1.get('ors','不存在')

‘不存在’

2.5 Sets 集合

•跟数学的概念很相似，类似于字典的键，但没有对应的值
•用花括弧
•不支持下标应用和切片

wwcode_asia_networks = {'Bangalore','Beijing','Chennai','Delhi','Gujarat','Hong Kong','Kuala Lumpur','Manila','Pune','Rajasthan','Shanghai','Singapore','Taipei','Tel-Aviv','Tokyo'}
type(wwcode_asia_networks)

set

print(wwcode_asia_networks)

{'Hong Kong', 'Rajasthan', 'Shanghai', 'Singapore', 'Tokyo', 'Chennai', 'Bangalore', 'Tel-Aviv', 'Beijing', 'Kuala Lumpur', 'Manila', 'Pune', 'Taipei', 'Delhi', 'Gujarat'}

wwcode_asia_networks[0:]#不支持切片

出现报错

2.6 运算和布尔运算

x = 1 + 2 # Addition
y = 3 - 4 # Subtraction
z = 5 * 6 # Multiplication
a = z / y # Division
b = z % x # Modulus
c = y ** x # Exponent
d = c // x # Floor Division
print("x:" + str(x) + " y:" + str(y) + " z:" + str(z) + 
      " a:" + str(a) + " b:" + str(b) + " c:" + str(c) + " d:" + str(d))

x:3 y:-1 z:30 a:-30.0 b:0 c:-1 d:-1

常见运算符见教程：https://linklearner.com/datawhale-homepage/index.html#/learn/detail/6

2.6.1 布尔运算和比较运算

print(a == b) # equals
print(a != b) # not equals
print(a > b)  # greater than
print(a < b)  # lesser than
print(a >= b) # greater than or equal
print(a <= b) # lesser than or equal

False
True
False
True
False
True

2.6.2 逻辑运算符

a_string = "Women Who Code"
print("Women" in a_string)
print("Men" not in a_string)
print(len("Women Who Code") is len(a_string))
print(len("Hello World!") is not len(a_string))

True
True
True
True

练习：判断闰年的方法

years=2018
if (years % 4 == 0 and years % 100 != 0) or (years % 400 == 0):
    print(years, "是闰年")
else:
    print(years, "不是闰年")

2018 不是闰年

2.6.3 is 和 is not 运算符 与==以及！=的区别

is 用于判断两个变量引用对象是否为同一个= = 用于判断引用变量的值是否相等。
is not 用于判断两个标识符是否引自不同对象，！=用于判断引用变量的值是否不相等

x = 5
y = 5
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
True
140736927246240
140736927246240

x = "abcabcabcabcabcabcabcabcabcabc"
y = "abcabcabcabcabcabcabcabcabcabc"
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
True
1708879959904
1708879959904

# 数组比较
x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
False
1708878927488
1708879005824

# 元组比较
x = (1, 2, 3)
y = (1, 2, 3)
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
False
1708878741696
1708879356544

# 字典比较
x = {"id": 1, "name": "Tom", "age": 18}
y = {"id": 1, "name": "Tom", "age": 18}
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
False
1708880004864
1708880004992

# 集合比较
x = set([1, 2, 3])
y = set([1, 2, 3])
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
False
1708878835040
1708878833696

# 赋值后比较
x = [1, 2, 3]
y = x
print(x == y)
print(x is y)
print(id(x))
print(id(y))

True
True
1708879004352
1708879004352

#空值比较
none_type = None
none_type is None

True

补充：#id(object)函数是返回对象object在其生命周期内位于内存中的地址，id函数的参数类型是一个对象。

2.7 附录 一些可能用到的知识

2.7.1 保留字

import keyword
keyword.kwlist#一些关键字是系统自带的保留字，即不能用作为标识符

['False',
 'None',
 'True',
 'and',
 'as',
 'assert',
 'async',
 'await',
 'break',
 'class',
 'continue',
 'def',
 'del',
 'elif',
 'else',
 'except',
 'finally',
 'for',
 'from',
 'global',
 'if',
 'import',
 'in',
 'is',
 'lambda',
 'nonlocal',
 'not',
 'or',
 'pass',
 'raise',
 'return',
 'try',
 'while',
 'with',
 'yield']

2.7.2 内置函数

这些函数不能作为变量名，可以作为函数直接调用，如：print() input()

dir(__builtins__)

三、Task 3总结

Task 3主要对字典、元组、布尔类型、读写文件相关知识根据教程进行梳理，主要在读写文件那里遇到了一些问题，通过领航员的解答，解决了问题（♪(･ω･)ﾉ），同时通过查找资料，对相关操作进行了补充。同时完成了1~3章课后练习及补充。个人的小小建议，Task3可以给四天的学习时间，对于小白来说，学习第三章再加上做练习工作量有点大 ~