简明Python教程 5)表达式 6)控制流 7)函数
第5章 运算符与表达式
简介
表达式可以分解为运算符和操作数: 2+3 ;
运算符是完成某件事, 由符号或者特定的关键字表示; 运算符需要数据来进行计算, 数据被称为操作数;
运算符
可以使用交互式的带提示符的python解释器:
|
1
2
3
4
|
>>>
2
+
3
5
>>>
3
*
5
15
|
具体:
| 运算符 | 名称 | 说明 | 例子 |
|---|---|---|---|
| + | 加 | 两个对象相加 | 3 + 5得到8。'a' + 'b'得到'ab'。 |
| - | 减 | 得到负数或是一个数减去另一个数 | -5.2得到一个负数。50 - 24得到26。 |
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 | 2 * 3得到6。'la' * 3得到'lalala'。 |
| ** | 幂 | 返回x的y次幂 |
3 ** 4得到81（即3 * 3 * 3 * 3） |
| / | 除 | x除以y | 4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到1.3333333333333333 |
| // | 取整除 | 返回商的整数部分 | 4 // 3.0得到1.0 |
| % | 取模 | 返回除法的余数 | 8%3得到2。-25.5%2.25得到1.5 |
| << | 左移 | 把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1） | 2 << 2得到8。——2按比特表示为10 |
| >> | 右移 | 把一个数的比特向右移一定数目 | 11 >> 1得到5。——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。 |
| & | 按位与 | 数的按位与 | 5 & 3得到1。 |
| | | 按位或 | 数的按位或 | 5 | 3得到7。 |
| ^ | 按位异或 | 数的按位异或 | 5 ^ 3得到6 |
| ~ | 按位翻转 | x的按位翻转是-(x+1) | ~5得到-6。 |
| < | 小于 | 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | 5 < 3返回0（即False）而3 < 5返回1（即True）。比较可以被任意连接：3 < 5 < 7返回True。 |
| > | 大于 | 返回x是否大于y | 5 > 3返回True。如果两个操作数都是数字，它们首先被转换为一个共同的类型。否则，它总是返回False。 |
| <= | 小于等于 | 返回x是否小于等于y | x = 3; y = 6; x <= y返回True。 |
| >= | 大于等于 | 返回x是否大于等于y | x = 4; y = 3; x >= y返回True。 |
| == | 等于 | 比较对象是否相等 | x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。 |
| != | 不等于 | 比较两个对象是否不相等 | x = 2; y = 3; x != y返回True。 |
| not | 布尔“非” | 如果x为True，返回False。如果x为False，它返回True。 | x = True; not y返回False。 |
| and | 布尔“与” | 如果x为False，x and y返回False，否则它返回y的计算值。 | x = False; y = True; x and y，由于x是False，返回False。在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。这个现象称为短路计算。 |
| or | 布尔“或” | 如果x是True，它返回True，否则它返回y的计算值。 | x = True; y = False; x or y返回True。短路计算在这里也适用。 |
运算符优先级
下表给出python的运算符优先级, 上到下->从最低优先级(松散结合)到最高优先级(紧密结合);
建议使用圆括号来分组运算符和操作数, 明确指出运算的先后顺序, 使程序更加易读;
| 运算符 | 描述 |
|---|---|
| lambda | Lambda表达式 |
| or | 布尔“或” |
| and | 布尔“与” |
| not x | 布尔“非” |
| in，not in | 成员测试 |
| is，is not | 同一性测试 |
| <，<=，>，>=，!=，== | 比较 |
| | | 按位或 |
| ^ | 按位异或 |
| & | 按位与 |
| <<，>> | 移位 |
| +，- | 加法与减法 |
| *，/，% | 乘法、除法与取余 |
| +x，-x | 正负号 |
| ~x | 按位翻转 |
| ** | 指数 |
| x.attribute | 属性参考 |
| x[index] | 下标 |
| x[index:index] | 寻址段 |
| f(arguments...) | 函数调用 |
| (experession,...) | 绑定或元组显示 |
| [expression,...] | 列表显示 |
| {key:datum,...} | 字典显示 |
| 'expression,...' | 字符串转换 |
计算顺序
使用圆括号改变运算符优先级表决定的计算顺序: (2+3)*4
结合规律
运算符通常由左向右结合; 2+3+4被计算成(2+3)+4 ;
一些如赋值运算符是由右向左结合的: a=b=c被处理为a=(b=c) ;
快捷方式
e.g. a = a*3 --> a *= 3
将 var = var operation expression 写成 var operator= expression ;
表达式
使用
|
1
2
3
4
5
6
7
|
#!/usr/bin/python
# Filename: expression.py
length
=
5
breadth
=
2
area
=
length
*
breadth
print
(
'Area is'
, area)
print
(
'Perimeter is'
,
2
*
(length
+
breadth))
|
输出:
Area is 10
Perimeter is 14
>'完美打印' python会自动在输出的地方加上空格, 为了打印输出易读; 程序员无需考虑如何控制空格;
第6章 控制流
简介
控制流语句改变语句流的执行顺序: if, for, while ;
if语句
用来检测一个条件, 为真运行if-块, 否则处理else-块; else从句是可选的;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
number
=
23
i
=
0
while
i !
=
1
:
try
:
guess
=
int
(
input
(
'Enter an integer : '
))
except
:
print
(
"please input a integer instead of string"
)
break
;
if
guess
=
=
number:
print
(
'Congratulations, you guessed it.'
)
# New block starts here
print
(
"(but you do not win any prizes!)"
)
# New block ends here
i
=
1
elif
guess < number:
print
(
'No, it is a little higher than that'
)
# Another block
# You can do whatever you want in a block ...
else
:
print
(
'No, it is a little lower than that'
)
# you must have guess > number to reach here
print
(
'Done'
)
|
>input()是内建函数build-in func; 字符串会被打印在屏幕上, 然后等待用户输入; 用户按回车之后, 函数返回输入; 对input函数来说取得的是字符串, 通过int把字符串转换为整数, 存储到变量guess中; int是一个类;
>使用缩进来告诉python每个语句属于哪一块; if语句在结尾处包含一个冒号: 通过冒号告诉python下面跟着一个语句块; if-elif-else把两个相关联的if else-if else语句合并; 也可以使用嵌套的if语句达到效果, elif和else是可选的;
可以在if语句的if块中存在另一个if语句, 这称为if语句嵌套;
Note To C/C++ 在python中没有switch语句, 使用if..elif..else语句完成同样的工作; (某些场合使用字典会更快捷)
while语句
在一个条件为真的情况下, while语句允许重复执行一块代码; while语句属于循环语句, 有一个可选的else从句;
|
1
2
3
4
5
6
7
8
9
|
i
=
0
res
=
True
while
res:
i
+
=
1
print
(i)
if
i >
2
:
res
=
False
else
:
print
(
"while loop over"
)
|
> True和False是布尔类型; 可以把它们等效地理解为1和0; 被使用在检验重要条件的时候, 它们并不是真实的值1; 与while同级的else块是可选的, 直接将语句跟在while语句之后有相同效果;
Note To C/C++ 可以在while循环中使用一个else从句;
for循环
for..in是循环语句, 在一序列的对象上, 递归/逐一使用队列中的每个项目;
|
1
2
3
4
|
for
i
in
range
(
1
,
5
):
print
(i)
else
:
print
(
'The for loop is over'
)
|
>内建的range函数生成序列 [1, 2, 3, 4], 序列从第一个数开始到第二个数为止; [当i到达上限时, 序列结束]; range步长为1, 如果为range提供第三个数, 称为步长; e.g. range(1, 5, 2)输出 [1, 3]
如果想输出range: list(range(1,8))
Note 1) range序列不包含第二个数; 2) else部分是可选的, 如果包含else, 它总是在for循环结束后执行一次, 除非遇到break语句; 3) for...in循环对于任何类型的序列都适用;
Note To C/C++/Java/C# python的for循环从根本上不同与C/C++的; python的for循环与C#中的foreach循环类似; [C++现在也有foreach了...]; 对Java来说和1.5的for(int i : IntArray)类似; 对于C/C++, for(int i = 0; i < 5; i++), python对应的是for i in range(0, 5), 简单不易错;
break语句
用来终止循环语句, 即使循环条件没有False或序列还没有完全递归, 也会停止循环语句;
Note 如果从for或者while中break, 对应循环块的else块将不会执行;
|
1
2
3
4
5
6
7
|
while
True
:
s
=
input
(
'Enter something : '
)
if
s
=
=
'q'
:
break
print
(
'Length of the string is'
,
len
(s))
else
:
print
(
'Done'
)
|
>当用户输入是'q'时, 通过break终止循环到达程序结尾; break也跳过了else块;
>内建函数len()返回字符串的长度;
continue语句
告诉程序跳过当前循环块for/while中的剩余语句, 继续进行下一轮循环;
|
1
2
3
4
5
6
7
|
while
True
:
s
=
input
(
'Enter something : '
)
if
s
=
=
'quit'
:
break
if
len
(s) <
3
:
continue
print
(
'Input is of sufficient length'
)
|
>当字符串长度大于或等于3时才会打印, 小于3时被continue跳过;
第7章 函数
简介
函数是重用的程序段: 允许给一块语句一个名称, 然后可以在程序的任何地方使用这个名称运行这个语句块, 这称为调用函数; e.g. 内建函数len(), range();
函数通过def关键字定义; def后跟一个函数的标识符名称, 然后圆括号, 括号内可以包括一些变量名, 该行以冒号结尾; 接下去是函数体语句;
定义
|
1
2
3
|
def
sayHello():
print
'Hello World!'
# block belonging to the function
sayHello()
# call the function
|
>无参数; 参数是给函数的输入, 传递不同的值得到相应结果;
函数形参
函数取得的参数是在调用时定义的, 不是在函数本身内赋值的; 参数在函数定义的括号内对内指定, 逗号分隔; 函数中的参数名称称为形参, 提供给函数调用的值称为实参;
使用
|
1
2
3
4
5
6
7
8
9
|
def
printMax(a, b):
if
a > b:
print
(a,
'is maximum'
)
else
:
print
(b,
'is maximum'
)
printMax(
3
,
4
)
# directly give literal values
x
=
5
; y
=
7
printMax(x, y)
# give variables as arguments
|
>直接提供实参或者使用变量传值;
局部变量
函数定义内声明的变量, 和函数外具有相同名称的变量无关, 变量对于函数来说是局部的; 作用域是被定义的块--函数内部;
|
1
2
3
4
5
6
7
8
|
def
func(x):
print
(
'x is'
, x)
x
=
2
print
(
'Changed local x to'
, x)
x
=
50
func(x)
print
(
'x is still'
, x)
|
Note 变量值不受函数内部局部变量影响;
global语句
如果想要为一个定义在函数外的变量赋值, 就需要告诉python这个变量不是局部而是全局的;
可以使用定义在函数外的变量的值(假设函数内没有同名变量); 但是应该避免这样做, 这样会使得程序不清楚, 变量到底是在哪里定义的; 使用global语句清楚表明变量在函数外部定义;
|
1
2
3
4
5
6
7
8
|
def
func():
global
x
print
(
'x is'
, x)
x
=
2
print
(
'Changed local x to'
, x)
x
=
50
; func()
print
(
'Value of x is'
, x)
|
Note global语句声明x是全局的, 当在函数内赋值给x时, 这个变化也反映在主块中x的值;
>可以使用global关键字指定多个局部变量, e.g. global x, y, z;
默认参数值
在函数定义的形参后面加上赋值运算符= 和默认值, 给形参指定默认参数值; 使得函数内的一些参数是可选的, 用户可以不用输入而使用默认值;
Note 默认参数值是不可变的;
|
1
2
3
4
|
def
say(message, times
=
1
):
print
(message
*
times)
say(
'Hello'
)
say(
'World'
,
5
)
|
Note 只有在形参表末尾的参数可以有默认值; e.g. def func(a, b=5)正确, def func(a=5, b)错误;
关键参数
通过命名来为函数中的一部分参数赋值; 使用名字(关键字)而不是通过位置来给函数指定实参;
优点: 1) 不必担心参数的顺序, 使用函数更简单; 2) 假如有些参数有默认值, 可以只给需要的参数赋值;
|
1
2
3
4
5
|
def
func(a, b
=
5
, c
=
10
):
print
(
'a is'
, a,
'and b is'
, b,
'and c is'
, c)
func(
3
,
7
)
func(
25
, c
=
24
)
func(c
=
50
, a
=
100
)
|
>可以不按顺序灵活指定参数值;
变量参数
定义一个函数, 可以获取参数的任何值, 通过星号实现;
|
1
2
3
4
5
6
7
8
9
|
def
total(initial
=
5
,
*
numbers,
*
*
keywords):
count
=
initial
for
number
in
numbers:
count
+
=
number
for
key
in
keywords:
count
+
=
keywords[key]
return
count
print
(total(
10
,
1
,
2
,
3
, vegetables
=
50
, fruits
=
100
))
|
>声明一个星号参数 *param, 从这一点开始到结束的所有位置的参数都被收集到名为param的元组中;
>声明一个双星参数 **param, 从这一点到结束的所有关键字都被收集到名为param的字典中;
只有关键字的参数
想要指定特定的关键字参数作为只有关键字的参数, 而不是位置参数, 他们可以被声明在星号参数后;
|
1
2
3
4
5
6
7
8
9
10
|
def
total(initial
=
5
,
*
numbers, extra_number):
count
=
initial
for
number
in
numbers:
count
+
=
number
count
+
=
extra_number
print
(count)
total(
10
,
1
,
2
,
3
, extra_number
=
50
)
total(
10
,
1
,
2
,
3
)
# Raises error because we have not supplied a default argument value for 'extra_number'
|
>在星号参数后声明的参数, 只有关键字参数, 并且必须提供值;
如果不需要星号参数, 但还是想使用只有关键字的参数, 可以用星号代替参数: def test(init=5, *, extra_num);
return语句
从一个函数返回/跳出; 返回值可选;
|
1
2
3
4
5
6
7
8
|
def
maximum(x, y):
if
x
=
=
y :
return
elif
x > y:
return
x
else
:
return
y
print
(maximum(
3
,
3
))
|
>输出:None;
Note 没有返回值的return语句等价于return None ; None是python中表示没有任何东西的特殊类型; e.g. 变量的值为None, 表示没有值;
除非显式提供return语句, 否则每个函数在结尾隐式地含有 return None语句;
|
1
2
3
|
def
someFunc():
pass
print
(someFunc())
|
>输出为None; py中已经有了内建的mx函数, 尽量使用内建函数;
Note pass语句在python中表示一个空的语句块;
文档字符串DocStrings
python的特性, 文档字符串, document strings简称为docstrings;docStrings是一个帮助简化程序文档的工具; 甚至可以在程序运行时从函数恢复文档字符串;
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def
printMax(x, y):
'''Prints the maximum of two numbers.
The two values must be integers.'''
x
=
int
(x)
# convert to integers, if possible
y
=
int
(y)
if
x > y:
print
(x,
'is maximum'
)
else
:
print
(y,
'is maximum'
)
printMax(
3
,
5
)
print
(printMax.__doc__)
|
函数的第一个逻辑行的字符串是这函数的文档字符串, docStrings也适用于模块和类;
Note 文档字符串的惯例是一个多行字符串, 首行以大写字母开始, 句号结尾; 第二行空行, 第三行开始详细的描述; 建议遵循此惯例;
__doc__(双下划线)调用printMax函数的文档字符串属性(属于函数的名称); python把一切都作为对象, 包括这个函数; python中的help()使用的就是docStrings, 抓取函数的__doc__属性, 整理展示; 按q退出help, help也可以显示自定义函数的文档: help(printMax);
自动化工具也可以从__doc__提取文档, 建议给正式函数都编写文档字符串; 随python发行版附带的pydoc命令, 与help()类似地使用docStrings;
---TBC---YC