菜鸟教程Python-重难点归纳

之前我是粗略学习过python的，然后也在断断续续的用，最近由于科研需要，要看很多算法等代码，发现自己有时候看的比较吃力，故而重新学习一下，温故而知新。这里仅记录我之前不知道的或者我认为比较重要的内容，并不是像通常笔记那样非常全面，所有知识点一锅炖。

我在 菜鸟教程 进行学习：https://www.runoob.com/python3/python3-tutorial.html

进入正文：

琐碎的星辰

• 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数，向下取整。如果分子分母为float，则//会返回一个float的整数，例如7.0//2的返回结果是3.0。
• 反斜杠\可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。
• 元组Tuple和列表的区别在于元组写在()里面，且不同于列表，其内部的元素不能修改。其截取操作与列表和字符串类似。当元素是可变对象时。对象内部属性是可以修改的！元组的不可变限制只是在一个纬度上：元素的类型。实现理解，元组的元素所保存的内容（数值或内存地址）是不允许修改的，但地址映射的对象自身是可以修改的。
• x**2表示 x²，**表示幂运算。
• 字符串前面加b表示byte类型，x = b"hello"。
• ord(x)将一个字符串转换为它的整数。
• 集合是一个无序的不重复元素序列，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
• 字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
• 字符串方法 zfill(), 它会在数字的左边填充 0。
• 类的私有方法和属性都要使用两个下划线开头声明，只能在类的内部使用，不能在类的外部调用。例如私有属性：__secretCount = 0，私有方法：def __foo(self): 。
• Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

远方的星河

多线程

使用_thread模块：

#!/usr/bin/python3

import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# 创建两个线程
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: 无法启动线程")

while 1:
   pass

输出：

Thread-1: Wed Jan  5 17:38:08 2022
Thread-2: Wed Jan  5 17:38:10 2022
Thread-1: Wed Jan  5 17:38:10 2022
Thread-1: Wed Jan  5 17:38:12 2022
Thread-2: Wed Jan  5 17:38:14 2022
Thread-1: Wed Jan  5 17:38:14 2022
Thread-1: Wed Jan  5 17:38:16 2022
Thread-2: Wed Jan  5 17:38:18 2022
Thread-2: Wed Jan  5 17:38:22 2022
Thread-2: Wed Jan  5 17:38:26 2022

使用threading模块：

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.delay, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

输出：

开始线程：Thread-1
开始线程：Thread-2
Thread-1: Wed Jan  5 17:34:54 2022
Thread-2: Wed Jan  5 17:34:55 2022
Thread-1: Wed Jan  5 17:34:55 2022
Thread-1: Wed Jan  5 17:34:56 2022
Thread-2: Wed Jan  5 17:34:57 2022
Thread-1: Wed Jan  5 17:34:57 2022
Thread-1: Wed Jan  5 17:34:58 2022
退出线程：Thread-1
Thread-2: Wed Jan  5 17:34:59 2022
Thread-2: Wed Jan  5 17:35:01 2022
Thread-2: Wed Jan  5 17:35:03 2022
退出线程：Thread-2
退出主线程

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。因此更推荐使用threading模块。

性能度量timeit

有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

glob模块

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

global关键字

当内部作用域想修改外部作用域的变量时，就要用到 global 关键字了。

#!/usr/bin/python3
 
a = 10
def test():
    a = a + 1
    print(a)
test()

上面代码执行会报错，报错信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。

Traceback (most recent call last):
  File "test.py", line 7, in <module>
    test()
  File "test.py", line 5, in test
    a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

使用global修改a为全局变量：

#!/usr/bin/python3
 
a = 10
def test():
    global a
    a = a + 1
    print(a)
test()

输出：

11

异常处理机制

try catch else finally：

示例：

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

使用raise抛出一个指定的异常。语法格式：

raise [Exception [, args [, traceback]]]

示例：

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

# 执行上述代码会报下面的错误：
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

读写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

• filename：包含了要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读r。

下面三张图标作为模式的参考依据：

相关函数：

#!/usr/bin/python3

# 打开一个文件
f = open("/tmp/foo.txt", "r")

# read()函数可选的数字参数size，如果size被忽略或者为负数，那么该文件的所有内容都将被读取并且返回。
str = f.read()  

# readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
str1 = f.readline()

# readlines() 将返回该文件中包含的所有行。如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
str2 = f.readlines()

# write(string) 将 string 写入到文件中, 然后返回写入的字符数。
num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 如果要写入一些不是字符串的东西, 那么将需要先进行转换。
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)

# tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.tell()

print(str)

# 关闭打开的文件
f.close()

zip()函数

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

匿名函数lambda

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。

语法格式：

lambda arguments: expression

lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作。例如：

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

输出：

[1, 4, 9, 16, 25]

函数的不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

输出：

输出: 
70
(60, 50)

还有一种就是参数带两个星号 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

输出：

输出: 
1
{'a': 2, 'b': 3}

迭代器与生成器

• 迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

输出：

1 2 3 4

• 生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

yield是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

调用一个生成器函数，返回的是一个迭代器对象。

下面是一个简单的示例，展示了生成器函数的使用：

def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

以上实例中，countdown函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。

通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，可以逐步获取生成器函数产生的值。在这个例子中，首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。

生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。此外，生成器还可以与其他迭代工具（如for循环）无缝配合使用，提供简洁和高效的迭代方式。

执行以上程序，输出结果如下：

5
4
3
2
1

推导式

• 列表推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

示例：

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

• 字典推导式

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

示例：

listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

• 集合推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

示例：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

• 元组推导式
  元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

示例：

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

内置函数enumerate()

使用该函数进行遍历，该函数跟range()函数有一点区别：

>>> sequence = [12, 34, 34, 23, 45, 76, 89]
>>> for i, j in enumerate(sequence):
...     print(i, j)
... 
0 12
1 34
2 34
3 23
4 45
5 76
6 89

match…case

Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了。

match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。

语法格式如下：

match expression:
    case pattern1:
        # 处理pattern1的逻辑
    case pattern2 if condition:
        # 处理pattern2并且满足condition的逻辑
    case _:
        # 处理其他情况的逻辑

示例：

def match_example(item):
    match item:
        case (x, y) if x == y:
            print(f"匹配到相等的元组: {item}")
        case (x, y):
            print(f"匹配到元组: {item}")
        case _:
            print("匹配到其他情况")

match_example((1, 1))  # 输出: 匹配到相等的元组: (1, 1)
match_example((1, 2))  # 输出: 匹配到元组: (1, 2)
match_example("other") # 输出: 匹配到其他情况

输出：

匹配到值为1
匹配到值为2
匹配到其他值

case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。

字典内置函数&方法

函数：

方法：

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
之前习惯用百分号 (%):

>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

三引号

三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下：

#!/usr/bin/python3
 
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

输出如下：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。

随机数函数

数学函数

身份运算符 is / is not

身份运算符用于比较两个对象的存储单元

id()这个函数用于获取对象内存地址。

#!/usr/bin/python3
 
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

输出结果：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

看到这里其实是有点费解的，为啥 a is b是True ？
其实是这样，在交互式环境中，存在一个小整数池的概念，编译器会有一个小整数池的概念，会把（-5，256）间的数预先创建好，而当a和b超过这个范围的时候，两个变量就会指向不同的对象了，因此地址也会不一样。a b 在 -5~256（64位系统）时， a is b是True ；其他情况， a is b是False。

python 中，变量是以内容为基准而不是像 C 语言中以变量名为基准，所以只要数字内容是5，不管起什么名字，这个变量的 ID 是相同的，同时也就说明了 python 中一个变量可以以多个名称访问。
这样的设计逻辑决定了 python 中数字类型的值是不可变的，因此也就没有 C 语言中的自增运算符++了，因为如果a 和 b 都是 5，当改变了 a 时，b 也会跟着变，这当然不是所希望的。
因此，正确的自增操作应该 a = a + 1或者 a += 1，当此 a 自增后，通过 id() 观察可知，id 值变化了，即 a 已经是新值的名称。

is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。

成员运算符 in / not in

#!/usr/bin/python3

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")

输出结果：

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中

海象运算符

在 Python 3.8 及更高版本中，引入了一种新的语法特性，称为"海象运算符"（Walrus Operator），它使用 := 符号。这个运算符的主要目的是在表达式中同时进行赋值和返回赋值的值。

# 传统写法
n = 10
if n > 5:
    print(n)

# 使用海象运算符
if (n := 10) > 5:
    print(n)

字典

字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

如果想要输出字典的键值对，可以直接用items()函数，如下所示：

dict1 = {'abc':1,"cde":2,"d":4,"c":567,"d":"key1"}
for k,v in dict1.items():
    print(k,":",v)

列表List及其截取(切片)

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），内部元素支持修改。列表截取的语法格式如下：

变量[头下标:尾下标]  # 左闭右开

索引值以 0为开始值，-1为从末尾的开始位置。

加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

上面代码输出结果为：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

截取可以添加第三个参数为截取步长，意思是每隔步长个元素取一次元素。

列表List函数&方法

函数：

方法：

逻辑运算符

a = True
b = False

# 逻辑运算符
print(a and b)  # False
print(a or b)   # True
print(not a)    # False

解释：

• python 中的 and 从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值；
• or也是从左到有计算表达式，返回第一个为真的值；
• 其中数字 0 是假，其他都是真；
• 字符 "" 是假，其他都是真；

String的截取

变量[头下标:尾下标]  # 左闭右开

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号+是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

#!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str) 
print (str + "TEST") # 连接字符串

上面代码执行结果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

string常用函数

至此，花费两天半预习了Python的基本内容，本文结束。