聪明办法学 Python 2nd Edition¶

Chapter 3 变量与函数 Variables and Functions¶

聪明办法学 Python 教学团队

learn.python.the.smart.way@gmail.com

变量 Variables¶

A variable is a named value that references or stores a piece of data.

变量是一个名字，它所指代的是一段数据
使用 = 来对这段数据的区域进行赋值

In [7]:

x = 5

In [8]:

print(x)

In [9]:

print(x*2)

新的值会覆盖掉旧的值
新值的数据类型不必与旧值相同

In [10]:

y = 10
print(y - 2)

In [11]:

y = True
print(y)

True

变量命名规则：

必须以字母或下划线（_）开头
命名可由字母、数字和下划线组成
大小写敏感
尽量避免使用保留字命名

In [12]:

numberOfRabbits = 40
courseIs15112 = True

In [13]:

99problems = 0 # 会崩溃！因为变量名以数字开头

  Cell In [13], line 1
    99problems = 0 # 会崩溃！因为变量名以数字开头
      ^
SyntaxError: invalid syntax

保留字¶

In [14]:

import keyword
keyword.kwlist

Out[14]:

['False',
 'None',
 'True',
 '__peg_parser__',
 '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']

更新变量¶

In [15]:

x = 5
x += 2 # 等价于 x = x + 2
print(x) # 7

In [16]:

# 换成其他运算符也是同理
y = 350
y //= 10
print(y) # 35

多变量赋值¶

In [17]:

a = b = c = 2
print(f"a={a}, b={b}, c={c}")

a=2, b=2, c=2

In [18]:

a, b, c = 1, 2, 6
print(f"a={a}, b={b}, c={c}")

a=1, b=2, c=6

函数 Functions¶

A function is a procedure (a sequence of statements) stored under a name that can be used repeatedly by calling the name.

函数是一个名字，代表一串代码序列（流程、过程）
函数由两个部分组成：header 和 body
- header 用于定义函数接口（函数名称与参数）
- body 包含函数所需要执行的操作

header 用于定义函数的名称和参数

当函数被调用时，参数将会作为变量被提供给函数的 body 部分
可以提供多个参数（用逗号 , 分隔），也可以不提供参数（0 个）
header 以冒号（:）结尾，代表后面会跟着 body 部分

函数的 header 的写法：

In [19]:

def functionName(parameters):
    pass # 函数的 body 部分，这里使用 pass 代替

body¶

body 包含函数执行的语句（statement）

语句需要缩进（由 Code Style Guide 决定）
当语句不再缩进，函数部分结束
一般会使用 return 语句，来让函数返回其结果，但不是必须的

类似于用一个 = 来对多个变量赋值，函数的返回结果也可以不止一个（用逗号 , 分隔）

下面我们用一个例子来解释函数的细节

In [21]:

def double(x):
    print("我在一个名叫 “double” 函数里！")
    return 2 * x

我们使用函数名来调用函数
函数名后紧跟一对括号
括号中是我们设定的参数的值，一个不多，一个不少（这很重要）
函数会返回设定的 return 语句的值

调用示例函数 double() 会返回一个值（2 * x）

In [23]:

print(double(2)) # 会输出 4

我在一个名叫 “double” 函数里！
4

In [25]:

print(double(5)) # 会输出 10

我在一个名叫 “double” 函数里！
10

In [26]:

print(double(1) + 3) # 会输出 5

我在一个名叫 “double” 函数里！
5

函数可以有任意多个参数，也可以一个都没有

In [27]:

# 三个参数
def f(x, y, z):
    return x + y + z

print(f(1, 3, 2)) # 返回 6

In [28]:

# 无参数
def g():
    return 42

print(g()) # 返回 42

可是如果参数数目没有匹配的话……Oops!

In [29]:

print(g(2)) # 崩溃！

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [29], line 1
----> 1 print(g(2))

TypeError: g() takes 0 positional arguments but 1 was given

In [30]:

print(f(1, 2)) # 也会崩溃

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [30], line 1
----> 1 print(f(1, 2))

TypeError: f() missing 1 required positional argument: 'z'

多返回值¶

In [31]:

def Multi_Return_Values():
    return 9, 2, 8

In [32]:

a, b, c = Multi_Return_Values()
print(f"a={a}, b={b}, c={c}")

a=9, b=2, c=8

语句与表达式 Statements and Expressions¶

An expression is a data value or an operation that evaluates to a value.

对于表达式

它本身是值
它的计算结果是值

Statements, by contrast, do not evaluate to a value, and we can't print them. Usually they perform some action, though.

对于语句

它不是值
它不能打印
但它能执行一些操作

表达式的一些例子

In [33]:

Out[33]:

In [34]:

"Hello World"

Out[34]:

'Hello World'

In [35]:

7 + 2

Out[35]:

In [36]:

True or False

Out[36]:

True

In [37]:

(2 < 3) and (9 > 0)

Out[37]:

True

Python 只能 print 值和表达式，如果你能用 print() 输出它，那它就是表达式

In [38]:

print((2 < 3) and (9 > 0))

True

语句的一些例子

In [39]:

def f(x):
    return 5*x

In [40]:

x = 5 + 4

In [42]:

if 10 > 5:
    y = 5 + 3

内置函数 Builtin Functions¶

就是 Python 自己带的函数啦🤗

类型转换¶

In [43]:

print(bool(0))   # 转换为布尔类型（True or False）

False

In [44]:

print(float(42)) # 转换为浮点数

42.0

In [45]:

print(int(2.8))  # 转换为一个整数（舍弃小数点）

一些基本数学函数¶

但是它们不在 math 库中

In [46]:

print(abs(-5))   # 绝对值

In [47]:

print(max(2,3))  # 返回最大值

In [48]:

print(min(2,3))  # 返回最小值

In [49]:

print(pow(2,10))  # 次方运算，等价于 2**10

In [50]:

print(round(2.354, 2)) # 取最近的一个整数（并不完全是四舍五入，二进制精度丢失）

2.35

变量作用域 Variable Scope¶

每个变量都有属于自己的作用范围
超出作用范围后，变量不可见

我们设定一个函数 f(x)，它的内部有 x 和 y 两个变量

记得一定要重启 Jupyter Kernel！

In [5]:

def f(x):
    print("x:", x)
    y = 5
    print("y:", y)
    return x + y

In [2]:

print(f(4))

x: 4
y: 5
9

In [3]:

print(x) # crash!

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [3], line 1
----> 1 print(x)

NameError: name 'x' is not defined

In [4]:

print(y) # crash！

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In [4], line 1
----> 1 print(y)

NameError: name 'y' is not defined

函数内的变量具有局部作用域，它只存在于函数内部，与其他函数中的同名变量无关

In [10]:

def f(x):
    print("In f, x =", x)
    x += 5
    return x

def g(x):
    y = f(x*2)
    print("In g, x =", x)
    z = f(x*3)
    print("In g, x =", x)
    return y + z

print(g(2))

In f, x = 4
In g, x = 2
In f, x = 6
In g, x = 2
20

In [1]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=def%20f%28x%29%3A%0A%20%20%20%20print%28%22In%20f,%20x%20%3D%22,%20x%29%0A%20%20%20%20x%20%2B%3D%205%0A%20%20%20%20return%20x%0A%0Adef%20g%28x%29%3A%0A%20%20%20%20y%20%3D%20f%28x*2%29%0A%20%20%20%20print%28%22In%20g,%20x%20%3D%22,%20x%29%0A%20%20%20%20z%20%3D%20f%28x*3%29%0A%20%20%20%20print%28%22In%20g,%20x%20%3D%22,%20x%29%0A%20%20%20%20return%20y%20%2B%20z%0A%0Aprint%28g%282%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[1]:

In [12]:

def f(x):
    print("In f, x =", x)
    x += 7
    return round(x / 3)

def g(x):
    x *= 10
    return 2 * f(x)

def h(x):
    x += 3
    return f(x+4) + g(x)

print(h(f(1)))

In f, x = 1
In f, x = 10
In f, x = 60
50

In [13]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=def%20f%28x%29%3A%0A%20%20%20%20print%28%22In%20f,%20x%20%3D%22,%20x%29%0A%20%20%20%20x%20%2B%3D%207%0A%20%20%20%20return%20round%28x%20/%203%29%0A%0Adef%20g%28x%29%3A%0A%20%20%20%20x%20*%3D%2010%0A%20%20%20%20return%202%20*%20f%28x%29%0A%0Adef%20h%28x%29%3A%0A%20%20%20%20x%20%2B%3D%203%0A%20%20%20%20return%20f%28x%2B4%29%20%2B%20g%28x%29%0A%0Aprint%28h%28f%281%29%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[13]:

在函数外部定义变量时，变量具有全局作用域，在任何地方都可以使用

我们应该尽量避免使用全局变量，但是在非常少的一些场合你会需要用到它

In [14]:

g = 100

def f(x):
    return x + g

print(f(5)) # 105
print(f(6)) # 106
print(g)    # 100

105
106
100

In [15]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=g%20%3D%20100%0A%0Adef%20f%28x%29%3A%0A%20%20%20%20return%20x%20%2B%20g%0A%0Aprint%28f%285%29%29%20%23%20105%0Aprint%28f%286%29%29%20%23%20106%0Aprint%28g%29%20%20%20%20%23%20100&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[15]:

In [23]:

g = 100

def f(x):
    # 如果我们想要修改 g 的值，我们必须声明它是全局变量
    # 否则 Python 会假设它是局部变量
    global g
    g += 1
    return x + g

print(f(5)) # 106
print(f(6)) # 108
print(g)    # 102

106
108
102

In [1]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=g%20%3D%20100%0A%0Adef%20f%28x%29%3A%0A%20%20%20%20global%20g%0A%20%20%20%20g%20%2B%3D%201%0A%20%20%20%20return%20x%20%2B%20g%0A%0Aprint%28f%285%29%29%20%23%20106%0Aprint%28f%286%29%29%20%23%20108%0Aprint%28g%29%20%20%20%20%23%20102&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[1]:

返回语句 Return Statements¶

In [24]:

def isPositive(x):
    return (x > 0)

In [25]:

print(isPositive(5))  # True

True

In [26]:

print(isPositive(-5)) # False

False

In [27]:

print(isPositive(0))  # False

False

一旦返回，函数立即结束！

In [28]:

def isPositive(x):
    print("Hello!")   # 会运行
    return (x > 0)
    print("Goodbye!") # 不会运行

print(isPositive(5))  # 输出 “Hello!” 然后返回 True

Hello!
True

In [2]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=def%20isPositive%28x%29%3A%0A%20%20%20%20print%28%22Hello!%22%29%0A%20%20%20%20return%20%28x%20%3E%200%29%0A%20%20%20%20print%28%22Goodbye!%22%29%0A%0Aprint%28isPositive%285%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[2]:

没有返回语句的时候，函数会返回 None

In [30]:

def f(x):
    x + 42

print(f(5)) # None

None

In [31]:

def f(x):
    result = x + 42

print(f(5)) # None

None

Print versus Return¶

print() 和 return 是初学者比较容易出现的错误

In [37]:

def cubed(x):
    print(x**3)  # 这里的操作不太合适

In [36]:

cubed(2)  # 但是似乎看起来也正常运行了

In [39]:

print(cubed(3))  # 应该也能有效（但是返回 None，太怪了）

27
None

In [41]:

print(2*cubed(4)) # Error!

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [41], line 1
----> 1 print(2*cubed(4))

TypeError: unsupported operand type(s) for *: 'int' and 'NoneType'

正确写法：

In [42]:

def cubed(x):
    return (x**3) # 这样做更好

In [44]:

cubed(2)  #似乎输出被忽略了，为什么？

Out[44]:

In [45]:

print(cubed(3))  # 有效了！

In [46]:

print(2*cubed(4))  # 也是有效的！

函数组合 Function Composition¶

对于嵌套的函数而言，应该最先运行最内层的函数

In [48]:

def f(w):
    return 10*w

def g(x, y):
    return f(3*x) + y  #在我们返回它之前，我们必须先执行 f(3*x)

def h(z):
    return f(g(z, f(z+1)))  # 最内部的 f(z+1) 必须先执行

print(h(1)) # 你一定得“亲眼看看”

In [3]:

from IPython.display import IFrame
IFrame('https://pythontutor.com/render.html#code=def%20f%28w%29%3A%0A%20%20%20%20return%2010*w%0A%0Adef%20g%28x,%20y%29%3A%0A%20%20%20%20return%20f%283*x%29%20%2B%20y%0A%0Adef%20h%28z%29%3A%0A%20%20%20%20return%20f%28g%28z,%20f%28z%2B1%29%29%29%0A%0Aprint%28h%281%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false', width=1300, height=600)

Out[3]:

Helper Functions¶

编写函数是用来解决问题的

我们还可以编写函数来存储那些经常被用到的一系列操作

这种函数就叫做 Helper Function