编程语言
首页 > 编程语言> > # 《Think Python 2e》学习精粹合集（更新至第七章）

# 《Think Python 2e》学习精粹合集（更新至第七章）

作者：互联网

文章目录

  • 本书的目标：教你像计算机科学家一样思考；
  • 计算机科学家的思考方式：使用形式语言表示思想，将零件组成系统，观察复杂系统的行为、形成假设并且对预测进行检验；

《Think Python 2e》学习精粹（一）： 程序之道

1、什么是程序

  • 程序 ：一系列说明如何执行计算（computation）的指令；

2、运行Python

3、第一个程序

>>> print('Hello, World!')
Hello, World!

4、算术运算符

  • 运算符（operators）：代表加法和乘法等运算的特殊符号；
>>> 40 + 2
42
>>> 43 - 1
42
>>> 6 * 7
42
>>> 84 / 2
42.0

>>> 2**4 + 26
42

5、值和类型

  • 值（value）：程序处理的基本数据；
  • 值的 类型（types） ： 整型数（integer），浮点数（floating point number）， 字符串（string）；
>>> type(2)
<class 'int'>
>>> type(42.0)
<class 'float'>
>>> type('Hello, World!')
<class 'str'>

>>> 1, 23, 456
(1, 23, 456)

6、形式语言和自然语言

  • 自然语言（natural language） ：人们交流所使用的语言；
  • 形式语言（formal language）：人类为了特殊用途而设计出来的；
  • 编程语言（programming language）：被设计用于表达计算的形式语言；

7、调试

  • 调试（debugging）：追踪错误的过程。

《Think Python 2e》学习精粹（二）： 变量、表达式和语句

  • 编程语言最强大的特性之一，就是具备操作变量的能力；

1、赋值语句

  • 赋值语句（assignment statement）：（新建变量，）为变量赋值；
>>> message = 'And now for something completely differentt'
>>> n = 17
>>> pi = 3.141592653589793
  • 状态图（state diagram）：展示了每个变量所处的状态；
    在这里插入图片描述

2、变量名

  • 变量名：存放值，一般选用有意义的名字—它们可以记录该变量的用途；
>>> pi = 3.14
>>> _pi = 3.14
>>> my name = 'Shaofeng'
  File "<stdin>", line 1
    my name = 'Shaofeng'
       ^
SyntaxError: invalid syntax
>>> myname = 'Shaofeng'
>>> 51job = '51job'
  File "<stdin>", line 1
    51job = '51job'
       ^
SyntaxError: invalid syntax
>>> MyName = 'Shaofeng'
  • 关键字（keywords）：解释器使用关键字识别程序的结构；
>>> class = 50
  File "<stdin>", line 1
    class = 50
          ^
SyntaxError: invalid syntax

3、表达式和语句

  • 表达式（expression）：值、变量和运算符及其组合；
>>> n
17
>>> 42
42
>>> n + 25
42
  • 语句（statement）：一个会产生影响的代码单元；
>>> n = 17
>>> print(n)
17

4、脚本模式

  • 交互模式（interactive mode） ：直接与解释器进行交互；
PS C:\Users\Administrator> python
Python 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 5
5
>>> x = 5
>>> x + 1
6
  • 脚本模式（script mode） ：将代码保存为脚本（script）文件，在命令行工具或者各种IDE中启动解释器并调用脚本文件以在解释器运行代码、得到需要的结果，Python脚本文件名的后缀是.py；
5
x = 5
y = x + 1
print(y) 

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\ex.py
6

5、运算顺序

  • 运算顺序（order of operations）：当一个表达式中有多于一个运算符时，计算的顺序；

6、字符串运算

>>> 'Hello' + 'World'
'HelloWorld'
>>> 'Hello' + 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> 'Hello' * 3
'HelloHelloHello'
>>> 'Hello' * -3
''
>>> 'Hello' * 0
''
>>> 'Hello' * 3.5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'

7、注释

  • 注释（comments）：以#符号开始、在程序中用自然语言做的标注；
v = 5       #速度，单位：米/秒

8、调试

《Think Python 2e》学习精粹（三）： 函数

  • 函数（function） ：一个有命名的、执行某个计算的语句序列（sequence of statements）；

1、函数调用

>>> type('Hello, World!')
<class 'str'>

>>> int(32.98)
32
>>> int('32')
32
>>> int('32.98')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '32.98'
>>> float(32)
32.0
>>> float('32.98')
32.98
>>> str(32.98)
'32.98'

2、数学函数

  • 模块（module）：一个含有相关函数的文件；
>>> math
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined
>>> import math
>>> math
<module 'math' (built-in)>

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(2)
1.4142135623730951

3、组合

>>> hours = 2
>>> minutes = hours * 60                 # 正确
>>> hours * 60 = minutes                 # 错误！
  File "<stdin>", line 1
SyntaxError: cannot assign to operator

4、新建函数

  • 函数定义（function definition） ：指定新函数的名称、当函数被调用时执行的语句序列；
def print_gsf():
	print('I am healthy.')
	print('And I am happy.')
	
def print_twice():
	print_gsf()
	print_gsf()
	
print_twice()

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\print_twice.py
I am healthy.
And I am happy.
I am healthy.
And I am happy.

5、定义和使用

print_twice()
def print_gsf():
	print('I am healthy.')
	print('And I am happy.')
	
def print_twice():
	print_gsf()
	print_gsf()
	

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\print_twice_1.py
Traceback (most recent call last):
  File "D:\WorkSpace\thinkpython2e\print_twice_1.py", line 1, in <module>
    print_twice()
NameError: name 'print_twice' is not defined

6、执行流程

  • 执行流程（flow of execution）： 语句执行的顺序；

7、形参和实参

  • 实参 ：调用函数时，（有时候）需要输入参数，输入的一个或者几个参数称为实参；
def print_gsf(years_old):
	print(years_old)
	
def print_twice():
	print_gsf(2020-1968)
	print_gsf("I'm so young!")
	
print_twice()

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\print_yeas_old.py
52
I'm so young!

8、变量和形参都是局部的

9、堆栈图

  • 堆栈图（stack diagram） ： 用以说明每个变量的值、每个变量所属的函数并跟踪哪个变量能在哪儿用的图形；
    在这里插入图片描述

10、有返回值函数和无返回值函数

  • 有返回值函数（fruitful functions）：会返回结果的函数；
  • 无返回值函数（void functions）：执行一个动作但是不返回任何值的函数；
>>> print(type(None))
<class 'NoneType'>

11、为什么写函数？

12、调试

《Think Python 2e》学习精粹（四）： 案例研究—接口设计

  • 本章将通过一个案例研究，介绍如何设计出相互配合的函数；

1、turtle 模块

>>> import turtle
>>> bob = turtle.Turtle()
>>> type(bob)
<class 'turtle.Turtle'>
>>> print(bob)
<turtle.Turtle object at 0x000001C946C106D0>

>>> import turtle
>>> sam = turtle.Turtle()
>>> sam.fd(100)
>>> sam.lt(90)
>>> sam.fd(100)
>>> sam.lt(90)
>>> sam.fd(100)
>>> sam.lt(90)
>>> sam.fd(100)
>>> turtle.mainloop()

在这里插入图片描述

2、简单的重复

for i in range(4):
    bob.fd(100)
    bob.lt(90)

for i in range(4):
	print('Hello, World!')
print('I am gsf.')

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\ex_char4_4.py
Hello, World!
Hello, World!
Hello, World!
Hello, World!
I am gsf.

3、练习

import math
import turtle

bob = turtle.Turtle()
tom = turtle.Turtle()
sam = turtle.Turtle()
jack = turtle.Turtle()

# 第二个小题（画可设边长的正方形），先把 Turtle 对象做了移位（下同）
def square(t, length):
	for i in range(4):
		t.fd(length)
		t.lt(90)

sam.pu()
sam.bk(350)
sam.pd()
square(sam,100)

# 第三个小题（画多边形）
def polygon(t, length, n):
	for i in range(n):
		t.fd(length)
		t.lt(360 / n)

tom.pu()
tom.fd(300)
tom.pd()
polygon(tom, 40, 10)

# 第四个小题（画圆）
def circle(t, r):
    circumference = 2 * math.pi * r
    n = int(circumference / 3) + 1
    length = circumference / n
    polygon(t, length, n)
	
circle(bob, 100)

# 第五个小题（画弧线），先把函数 polygon 进行泛化
def polygon_arc(t, length, n, angle):
	for i in range(int(n * angle / 360)):
		t.fd(length)
		t.lt(360 / n)

def arc(t, r, angle):
    circumference = 2 * math.pi * r
    n = int(circumference / 3) + 1
    length = circumference / n
    polygon_arc(t, length, n, angle)

jack.pu()
jack.rt(90)
jack.fd(300)
jack.lt(90)
jack.pd()
arc(jack,100,120)

turtle.mainloop()

在这里插入图片描述

4、封装

  • encapsulation（封装）：将一部分代码包装在函数里；

5、泛化

  • 泛化（generalization）：为函数增加一个形参被称作泛化；
def square(t):
    for i in range(4):
        t.fd(100)
        t.lt(90)

square(bob)

def square(t, length):
    for i in range(4):
        t.fd(length)
        t.lt(90)

square(bob, 100)

def polygon(t, n, length):
    angle = 360 / n    
    for i in range(n):       
        t.fd(length)        
        t.lt(angle)
        
polygon(bob, 7, 70)

polygon(bob, n=7, length=70)

6、接口设计

  • 函数的接口（interface） ：是一份关于如何使用该函数的总结—形参是什么？函数做什么？返回值是什么？
import math

def circle(t, r):
    circumference = 2 * math.pi * r
    n = int(circumference / 3) + 1
    length = circumference / n
    polygon(t, n, length)


import math

def circle(t, r, n):
    circumference = 2 * math.pi * r
    length = circumference / n
    polygon(t, n, length)

7、重构

  • 重构（refactoring） ：重新整理一个程序以改进函数接口和促进代码复用的过程；
def polygon(t, length, n):
	for i in range(n):
		t.fd(length)
		t.lt(360 / n)
		

def polygon_arc(t, length, n, angle):
	for i in range(int(n * angle / 360)):
		t.fd(length)
		t.lt(360 / n)

8、开发方案

  • 开发计划（development plan） ：是一种编写程序的过程；

9、文档字符串

  • 文档字符串（docstring） ：位于函数开始位置的一个字符串， 解释了函数的接口；
def polygon_arc(t, n, length, angle):
    """Draws n line segments with the given length and
    angle (in degrees) between them.  t is a turtle.
    """
    for i in range(n):
        t.fd(length)
        t.lt(angle)

10、调试

  • 函数调用时对实参的要求被称作先决条件（preconditions）， 因为它们应当在函数开始执行之前成立（true）；
  • 函数结束时的条件是后置条件（postconditions）：函数预期的效果（如画线段）及任何其他附带效果 （如 Turtle移动、转向或者做其它改变）；

《Think Python 2e》学习精粹（五）：条件和递归

  • 这章的中心话题是能够根据程序的状态执行不同命令的if语句；

1、地板除和求余

  • 地板除运算符(floor division operator) //（求模） ： 先做除法，然后将结果保留到整数；
  • 求余运算符(modulus operator) %（求余） ：将两个数相除，返回余数
>>> minutes = 105
>>> hours = minutes // 60
>>> hours
1
>>> remainder = minutes % 60
>>> remainder
45

2、布尔表达式

  • 布尔表达式（boolean expression） ：用关系运算符进行的运算；
  • 关系运算符（relational operators） ：共以下六种运算；
    x == y #x等于y
    x != y # x 不等于 y
    x > y # x 大于 y
    x < y # x 小于 y
    x >= y # x 大于或等于 y
    x <= y # x 小于或等于 y

3、逻辑运算符

  • 逻辑运算符（logical operators）：and 、or 和 not；
>>> 42 and True
True
>>> not 42
False
>>>

4、有条件的执行

  • 条件语句（Conditional statements）：检测条件、并相应地改变程序行为的语句；
if x > 0:
    print('x is positive')

5、二选一执行

if x % 2 == 0:
    print('x is even')
else:
    print('x is odd')

6 、链式条件

if x < y:
    print('x is less than y')
elif x > y:
    print('x is greater than y')
else:
    print('x and y are equal')

7、嵌套条件

if x == y:
    print('x and y are equal')
else:
    if x < y:
        print('x is less than y')
    else:
        print('x is greater than y')

if 0 < x:
    if x < 10:
        print('x is a positive single-digit number.')

if 0 < x and x < 10:
    print('x is a positive single-digit number.')

if 0 < x < 10:
    print('x is a positive single-digit number.')

8、递归

  • 递归（recursion）：一个函数调用它自己的过程；
def countdown(n):
    if n <= 0:
        print('Blastoff!')
    else:
        print(n)
        countdown(n-1)

9、递归函数的堆栈图

10、无限递归

  • 无限递归（infinite recursion） ：一个递归永不会到达基础情形，永远进行递归调用， 并且程序永远不会终止；
>>> def recurse():
...     recurse()
...
>>> recurse()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in recurse
  File "<stdin>", line 2, in recurse
  File "<stdin>", line 2, in recurse
  [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

11、键盘输入

>>> name = input('What...is your name?\n')
What...is your name?
Arthur, King of the Britons!
>>> name
Arthur, King of the Britons!

>>> prompt = 'What...is the airspeed velocity of an unladen swallow?\n'
>>> speed = input(prompt)
What...is the airspeed velocity of an unladen swallow?
42
>>> speed
'42'
>>> int(speed)
42

12、调试

《Think Python 2e》学习精粹（六）：有返回值的函数

  • 空函数（void） ：产生某种效果，像打印一个值或是移动乌龟，但是并不产生一个值；
  • 有返回值的函数 ：调用这样的函数会生成一个值， 通常将其赋值给某个变量或是作为表达式的一部分；

1、返回值

  • 返回值：调用一个函数会生成一个值，这个值称为函数的返回值；
def absolute_value(x):
    if x < 0:
        return -x
    if x > 0:
        return x

>>> absolute_value(0)
None

def compare(x, y):
	if x > y:
		return 1
	elif x < y:
		return -1
	elif x == y:
		return 0
		
print(compare(10,10))

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\new23.py
0

2、增量式开发

  • 增量式开发（ incremental development ) ：通过每次只增加和测试少量代码，来避免长时间的调试，这种开发方式即为增量式开发（ incremental development )；
def hypotenuse1(a,b):
	return 0
	
def hypotenuse2(a, b):
	squared = a**2 + b**2
	print("squared = ",squared)
	return 0
	
def hypotenuse3(a, b):
	squared = a**2 + b**2
	c = math.sqrt(squared)
	print("c = ",c)
	return 0 
	
def hypotenuse(a, b):
	squared = a**2 + b**2
	c = math.sqrt(squared)
	return c
	
print(hypotenuse1(3,4))

print(hypotenuse2(3,4))

import math
print(hypotenuse3(3,4))

print(hypotenuse(3,4))

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\new24.py
0
squared =  25
0
c =  5.0
0
5.0
  • 脚手架代码（scaffolding) ：上述练习中，print("squared = ",squared)这样的代码对程序的构建很有用，但不是最终产品的一部分，这样的代码即为脚手架代码（scaffolding) ；

3、组合

def area(radius):
    return math.pi * radius**2

def distance(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    dsquared = dx**2 + dy**2
    result = math.sqrt(dsquared)
    return result

def circle_area(xc, yc, xp, yp):
    return area(distance(xc, yc, xp, yp))

4、布尔函数

def is_between(x, y, z) :
	if x <= y and y <= z:
		return True
	else:
		return False
		
print(is_between(5, 6, 4))

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\new25.py
False

5、再谈递归

def factorial(n):
    if n == 0:
        return 1
    else:
    	recurse = factorial(n-1)
        result = n * recurse
        return result

在这里插入图片描述

6、信仰之跃

  • “信仰之跃”：阅读代码，当遇到一个函数调用时，不再去跟踪程序执行流程，而是假设这个函数正确运行并返回了正确的结果；

7、再举一例

def fibonacci (n):
    if n == 0:
        return 0
    elif  n == 1:
        return 1
    else:
        return fibonacci(n-1) + fibonacci(n-2)

8、检查类型

def factorial (n):
    if not isinstance(n, int):
        print('Factorial is only defined for integers.')
        return None
    elif n < 0:
        print('Factorial is not defined for negative integers.')
        return None
    elif n == 0:
        return 1
    else:
        return n * factorial(n-1)

9、调试

def factorial(n):
    space = ' ' * (4 * n)
    print(space, 'factorial', n)
    if n == 0:
        print(space, 'returning 1')
        return 1
    else:
        recurse = factorial(n-1)
        result = n * recurse
        print(space, 'returning', result)
        return result
        
factorial(4)

PS C:\Users\Administrator> python D:\WorkSpace\thinkpython2e\new26.py
                 factorial 4
             factorial 3
         factorial 2
     factorial 1
 factorial 0
 returning 1
     returning 1
         returning 2
             returning 6
                 returning 24

《Think Python 2e》学习精粹（七）： 迭代

  • 迭代：即重复运行某个代码块，有利用递归进行迭代、利用 for 循环进行迭代、利用 while 语句实现迭代等迭代方式；

1、重新赋值

>>> x = 5
>>> x
5
>>> x = 7
>>> x
7

2、更新变量

>>> x = x + 1

>>> x = x + 1
NameError: name 'x' is not defined

>>> x = 0
>>> x = x + 1

3、while 语句

4、break

while True:
    line = input('> ')
    if line == 'done':
        break
    print(line)

print('Done!')

5、平方根

while True:
    print(x)
    y = (x + a/x) / 2
    if y == x:
        break
    x = y

if abs(y-x) < epsilon:          # epsilon 为决定精确度的值, 如 0.0000001
    break

6、算法

  • 算法：牛顿法就是一个 算法 （Algorithm）示例，是解决一类问题的计算机制 （牛顿法是计算平方根）；

7、调试

标签：语句,return,函数,Python,2e,print,Think,def
来源： https://blog.csdn.net/weixin_41217917/article/details/112927214