华为泰克人工智能实训教程
默认情况下,Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码:
# -*- coding: gbk -*-
上述定义允许在源文件中使用 Windows中的简体中文字符编码,对应适合语言为非unicode的简体中文。
在 Python 3 中,非 ASCII 标识符也是允许的了。
保留字也称关键字,在程序中不能把它们用作标识符。Python 的标准库提供 keyword 模块,可以输出当前版本的所有关键字:
>>>import keyword
>>>keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', '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']
Python中单行注释以 #
开头,实例如下:
实例
#!/usr/bin/python3
# 上一行表示在命令行直接执行Python文件时所调用的Python解释器
print ("Hello, Python!")# 打印输出字符串
执行以上代码,输出结果为:
Hello, Python!
多行注释可以用多个#
号,还有'''
和"""
:
实例
#!/usr/bin/python3
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print ("Hello, Python!")
执行以上代码,输出结果为:
Hello, Python!
python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {}
。
缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。实例如下:
实例
if True:
print ("True")
else:
print ("False")
以下代码最后一行语句缩进数的空格数不一致,会导致运行错误:
if True:
print ("Answer")
print("True")
else:
print ("Answer")
print ("False")# 缩进不一致,会导致运行错误
以上程序由于缩进不一致,执行后会出现类似以下错误:
print ("False")# 缩进不一致,会导致运行错误
^
IndentationError: unindent does not match any outer indentation level
Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠\
来实现多行语句,例如:
total = item_one + \
item_two + \
item_three
在[]
,{}
,或()
中的多行语句,不需要使用反斜杠\
,例如:
total = ['item_one',
'item_two',
'item_three',
'item_four',
'item_five']
函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
**记住:**空行也是程序代码的一部分。
执行下面的程序在按回车键后就会等待用户输入:
实例
#!/usr/bin/python3
input("\n\n按下 enter 键后退出。")
以上代码中 ,"\n\n"在结果输出前会输出两个新的空行(输出中的空行)。
一旦用户按下Enter键时,程序将退出。
Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:
实例
#!/usr/bin/python3
import sys; x = 'TechLab'; sys.stdout.write(x + '\n')
执行以上代码,输出结果为:
TechLab
缩进相同的一组语句构成一个代码块,我们称之代码组。
像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
如下实例:
if expression :
suite
elif expression :
suite
else :
suite
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end="":
实例
#!/usr/bin/python3
x="a"
y="b"
# 换行输出
print( x )
print( y )
print('---------')
# 不换行输出
print( x, end="" )
print( y, end="" )
print()
以上实例执行结果为:
a
b
---------
a b
在 python 用import
或者from...import
来导入相应的模块。
将整个模块(somemodule)导入(相当于导入的是一个文件夹,是个相对路径),格式为:
import somemodule
从某个模块中导入某个函数(相当于导入的是一个文件夹中的文件,是个绝对路径),格式为:
from somemodule import somefunction
从某个模块中导入多个函数,格式为:
from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入,格式为:from somemodule import *
导入 sys 模块
import sys
print('================Python import mode==========================')
print('命令行参数为:')
for i in sys.argv:
print(i)
print('Python 路径为:',sys.path)
导入 sys 模块的 argv,path 成员
from sys import argv, path # 导入特定的成员
print('================python from import========================')
print('Python 路径为:', path) # 因为已经导入path成员,所以此处引用时不需要加sys.path
Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
等号=
用来给变量赋值。
等号=
运算符左边是一个变量名,等号=
运算符右边是存储在变量中的值。例如:
实例
#!/usr/bin/python3
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "PythonTest" # 字符串
print (counter)
print (miles)
print (name)
执行以上程序会输出如下结果:
100
1000.0
PythonTest
Python允许你同时为多个变量赋值。例如:
a = b = c = 1
以上实例,创建一个整型对象,值为 1,三个变量都指向同一个内存位置。
您也可以为多个对象指定多个变量。例如:
a, b, c = 1, 2, "PythonTest"
以上实例,两个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 “PythonTest” 分配给变量 c。
Python3 中有六个标准的数据类型:
Python3 的六个标准数据类型中:
**不可变数据(3 个):**Number(数字)、String(字符串)、Tuple(元组);
**可变数据(3 个):**List(列表)、Dictionary(字典)、Set(集合)。
Python3 支持 int、float、bool、complex(复数)。
在Python 3里,只有一种整数类型 int,表示为长整型,没有 Python2 中的 Long。
像大多数语言一样,数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
此外还可以用 isinstance 来判断:
实例
>>> a = 111
>>> isinstance(a, int)
True
isinstance 和 type 的区别在于:
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
区别就是:
注意:
当你指定一个值时,Number 对象就会被创建:
var1 = 1
var2 = 10
也可以使用del语句删除一些对象引用。
del语句的语法是:
del var1[,var2[,var3[....,varN]]]
可以通过使用del语句删除单个或多个对象。例如:
del var
del var_a, var_b
实例:
>>>5 + 4 # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法,得到一个浮点数
0.5
>>> 2 // 4 # 除法,得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
注意:
int | float | complex |
---|---|---|
10 | 0.0 | 3.14j |
100 | 15.20 | 45.j |
-786 | -21.9 | 9.322e-36j |
080 | 32.3e+18 | .876j |
-0490 | -90. | -.6545+0J |
-0x260 | -32.54e100 | 3e+26J |
0x69 | 70.2E-12 | 4.53e-7j |
Python还支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型
Python中的字符串用单引号(’)或双引号(")括起来,同时使用反斜杠(\)转义特殊字符。
字符串的截取的语法格式如下:
变量[头下标:尾下标]
索引值以 0 为开始值,-1 为从末尾的开始位置。
加号 (+) 是字符串的连接符, 星号 (*) 表示复制当前字符串,紧跟的数字为复制的次数。实例如下:
实例
#!/usr/bin/python3
str = 'PythonTest'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次
print (str + "TEST") # 连接字符串
执行以上程序会输出如下结果:
PythonTest
PythonTes
P
tho
thonTest
PythonTestPythonTest
PythonTestTEST
Python 使用反斜杠\
转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串:
>>> print('Python\nTest')
Python
Test
>>> print(r'Python\nTest')
Python\nTest
另外,反斜杠 \
可以作为续行符,表示下一行是上一行的延续。也可以使用 """..."""
或者 '''...'''
跨越多行。
注意,Python 没有单独的字符类型,一个字符就是长度为1的字符串。
实例
>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P
与 C 字符串不同的是,Python 字符串不能被改变。向一个索引位置赋值,比如word[0] = 'm’会导致错误。
注意:
r
可以让反斜杠不发生转义。+
运算符连接在一起,用*
运算符重复。0
开始,从右往左以-1
开始。List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。
列表是写在方括号[]
之间、用逗号分隔开的元素列表。
和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下:
变量[头下标:尾下标]
索引值以0
为开始值,-1
为从末尾的开始位置。
加号+
是列表连接运算符,星号*
是重复操作。如下实例:
实例
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'PythonTest', 70.2 ]
tinylist = [123, 'PythonTest']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
以上实例输出结果:
['abcd', 786, 2.23, 'PythonTest', 70.2]
abcd
[786, 2.23]
[2.23, 'PythonTest', 70.2]
[123, 'PythonTest', 123, 'PythonTest']
['abcd', 786, 2.23, 'PythonTest', 70.2, 123, 'PythonTest']
与Python字符串不一样的是,列表中的元素是可以改变的:
实例
>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 将对应的元素值设置为 []
>>> a
[9, 2, 6]
List内置了有很多方法,例如append()
、pop()
等等,这在后面会讲到。
注意:
元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。
元组中的元素类型也可以不相同:
实例
#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'PythonTest', 70.2 )
tinytuple = (123, 'PythonTest')
print (tuple) # 输出完整元组
print (tuple[0]) # 输出元组的第一个元素
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素
print (tuple[2:]) # 输出从第三个元素开始的所有元素
print (tinytuple * 2) # 输出两次元组
print (tuple + tinytuple) # 连接元组
以上实例输出结果:
('abcd', 786, 2.23, 'PythonTest', 70.2)
abcd
(786, 2.23)
(2.23, 'PythonTest', 70.2)
(123, 'PythonTest', 123, 'PythonTest')
('abcd', 786, 2.23, 'PythonTest', 70.2, 123, 'PythonTest')
元组与字符串类似,可以被索引且下标索引从0开始,-1 为从末尾开始的位置。也可以进行截取(看上面,这里不再赘述)
其实,可以把字符串看作一种特殊的元组。
实例
>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11 # 修改元组元素的操作是非法的
Traceback (most recent call last):
File "" , line 1, in <module>
TypeError: 'tuple' object does not support item assignment
虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:
tup1 = () # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号
string、list和tuple都属于sequence(序列)。
注意:
集合(set)是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
创建格式:
parameter = {value01,value02,...}
# 或者
set(value)
实例
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 输出集合,重复的元素被自动去掉
# 成员测试
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
以上实例输出结果:
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
字典(dictionary)是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典是一种映射类型,字典用"{ }"标识,它是一个无序的**键(key) : 值(value)**对集合。
键(key)必须使用不可变类型。
在同一个字典中,键(key)必须是唯一的。
实例
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - PythonTutorial"
dict[2] = "2 - Python教程"
tinydict = {'name': 'Python','code':1, 'site': 'www.python.org'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
以上实例输出结果:
1 - PythonTutorial
2 - Python教程
{'name': 'Python', 'code': 1, 'site': 'www.python.org'}
dict_keys(['name', 'code', 'site'])
dict_values(['Python', 1, 'www.python.org'])
构造函数 dict() 可以直接从键值对序列中构建字典如下:
实例
>>> dict([('TechLab', 1), ('Huawei', 2), ('Python', 3)])
{'Huawei': 2, 'Python': 3, 'TechLab': 1}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(TechLab=1, Huawei=2, Python=3)
dict(TechLab=1, Huawei=2, Python=3)
另外,字典类型也有一些内置的函数,例如clear()
、keys()
、values()
等。
注意:
{}
。有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 | 描述 |
---|---|
int(x [,base]) | 将x转换为一个整数 |
float(x) | 将x转换到一个浮点数 |
complex(real [,imag]) | 创建一个复数 |
str(x) | 将对象 x 转换为字符串 |
repr(x) | 将对象 x 转换为表达式字符串 |
eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s) | 将序列 s 转换为一个元组 |
list(s) | 将序列 s 转换为一个列表 |
set(s) | 转换为可变集合 |
本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中,4 和 5 被称为操作数,"+" 称为运算符。
Python语言支持以下类型的运算符:
接下来让我们一个个来学习Python的运算符。
以下假设变量a为10,变量b为21:
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 - 两个对象相加 | a + b 输出结果 31 |
- | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 |
* | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 210 |
/ | 除 - x 除以 y | b / a 输出结果 2.1 |
% | 取模 - 返回除法的余数 | b % a 输出结果 1 |
** | 幂 - 返回x的y次幂 | a**b 为10的21次方 |
// | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
以下实例演示了Python所有算术运算符的操作:
实例(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为:", c)
c = a - b
print ("2 - c 的值为:", c)
c = a * b
print ("3 - c 的值为:", c)
c = a / b
print ("4 - c 的值为:", c)
c = a % b
print ("5 - c 的值为:", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值为:", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值为:", c)
以上实例输出结果:
1 - c 的值为: 31
2 - c 的值为: 11
3 - c 的值为: 210
4 - c 的值为: 2.1
5 - c 的值为: 1
6 - c 的值为: 8
7 - c 的值为: 2
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
== | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
!= | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 True。 |
> | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
< | 小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。 | (a < b) 返回 True。 |
>= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
<= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 True。 |
以下实例演示了Python所有比较运算符的操作:
实例(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")
if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")
if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")
if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")
以上实例输出结果:
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
以下实例演示了Python所有赋值运算符的操作:
实例(Python 3.0+)
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为:", c)
c += a
print ("2 - c 的值为:", c)
c *= a
print ("3 - c 的值为:", c)
c /= a
print ("4 - c 的值为:", c)
c = 2
c %= a
print ("5 - c 的值为:", c)
c **= a
print ("6 - c 的值为:", c)
c //= a
print ("7 - c 的值为:", c)
以上实例输出结果:
1 - c 的值为: 31
2 - c 的值为: 52
3 - c 的值为: 1092
4 - c 的值为: 52.0
5 - c 的值为: 2
6 - c 的值为: 2097152
7 - c 的值为: 99864
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13二进制格式如下:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ,二进制解释: 0000 1100 |
| | 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 | (a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ | 按位异或运算符:当两对应的二进位相异时,结果为1 | (a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ | 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。 |
<< | 左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 | a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> | 右移动运算符:把">>“左边的运算数的各二进位全部右移若干位,”>>"右边的数指定移动的位数 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
以下实例演示了Python所有位运算符的操作:
实例(Python 3.0+)
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值为:", c)
c = a | b; # 61 = 0011 1101
print ("2 - c 的值为:", c)
c = a ^ b; # 49 = 0011 0001
print ("3 - c 的值为:", c)
c = ~a; # -61 = 1100 0011
print ("4 - c 的值为:", c)
c = a << 2; # 240 = 1111 0000
print ("5 - c 的值为:", c)
c = a >> 2; # 15 = 0000 1111
print ("6 - c 的值为:", c)
以上实例输出结果:
1 - c 的值为: 12
2 - c 的值为: 61
3 - c 的值为: 49
4 - c 的值为: -61
5 - c 的值为: 240
6 - c 的值为: 15
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and | x and y | 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or | x or y | 布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not | not x | 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
以上实例输出结果:
实例(Python 3.0+)
#!/usr/bin/python3
a = 10
b = 20
if ( a and b ):
print ("1 - 变量 a 和 b 都为 true")
else:
print ("1 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("2 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
print ("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
if ( a and b ):
print ("3 - 变量 a 和 b 都为 true")
else:
print ("3 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("4 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
print ("4 - 变量 a 和 b 都不为 true")
if not( a and b ):
print ("5 - 变量 a 和 b 都为 false,或其中一个变量为 false")
else:
print ("5 - 变量 a 和 b 都为 true")
以上实例输出结果:
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true,或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true,或其中一个变量为 true
5 - 变量 a 和 b 都为 false,或其中一个变量为 false
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
以下实例演示了Python所有成员运算符的操作:
实例(Python 3.0+)
#!/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 中")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中")
else:
print ("3 - 变量 a 不在给定的列表中 list 中")
以上实例输出结果:
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
身份运算符用于比较两个对象的存储单元
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
注: id() 函数用于获取对象内存地址。
以下实例演示了Python所有身份运算符的操作:
实例(Python 3.0+)
#!/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 没有相同的标识
is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
以下表格列出了从最高到最低优先级的所有运算符:
运算符 | 描述 |
---|---|
** | 指数 (最高优先级) |
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // | 乘,除,取模和取整除 |
+ - | 加法减法 |
>> << | 右移,左移运算符 |
& | 位 ‘AND’ |
^ | | 位运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
and or not | 逻辑运算符 |
以下实例演示了Python所有运算符优先级的操作:
实例
#!/usr/bin/python3
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为:", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为:", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为:", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为:", e)
以上实例输出结果:
(a + b) * c / d 运算结果为: 90.0
((a + b) * c) / d 运算结果为: 90.0
(a + b) * (c / d) 运算结果为: 90.0
a + (b * c) / d 运算结果为: 50.0
Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
Python中if语句的一般形式如下所示:
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else。
注意:
实例
以下是一个简单的 if 实例:
#!/usr/bin/python3
var1 = 100
if var1:
print ("1 - if 表达式条件为 true")
print (var1)
var2 = 0
if var2:
print ("2 - if 表达式条件为 true")
print (var2)
print ("Good bye!")
执行以上代码,输出结果为:
1 - if 表达式条件为 true
100
Good bye!
从结果可以看到由于变量 var2 为 0,所以对应的 if 内的语句没有执行。
以下实例演示了狗的年龄计算判断:
实例
#!/usr/bin/python3
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
print("输入错误!")
elif age == 1:
print("相当于 14 岁的人。")
elif age == 2:
print("相当于 22 岁的人。")
elif age > 2:
human = 22 + (age -2)*5
print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")
将以上脚本保存在dog.py文件中,并执行该脚本:
$ python3 dog.py
请输入你家狗狗的年龄: 1
相当于 14 岁的人。
点击 enter 键退出
以下为if中常用的操作运算符:
操作符 | 描述 |
---|---|
< |
小于 |
<= |
小于或等于 |
> |
大于 |
>= |
大于或等于 |
== |
等于,比较对象是否相等 |
!= |
不等于 |
实例
#!/usr/bin/python3
# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)
以上实例输出结果:
False
False
high_low.py文件演示了数字的比较运算:
实例
#!/usr/bin/python3
# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
guess = int(input("请输入你猜的数字:"))
if guess == number:
print("恭喜,你猜对了!")
elif guess < number:
print("猜的数字小了...")
elif guess > number:
print("猜的数字大了...")
执行以上脚本,实例输出结果如下:
$ python high_low.py
数字猜谜游戏!
请输入你猜的数字:1
猜的数字小了...
请输入你猜的数字:9
猜的数字大了...
请输入你猜的数字:7
恭喜,你猜对了!
在嵌套 if 语句中,可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。
if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句
实例
# !/usr/bin/python3
num=int(input("输入一个数字:"))
if num % 2 == 0:
if num % 3 == 0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2,但不能整除 3")
else:
if num % 3 == 0:
print ("你输入的数字可以整除 3,但不能整除 2")
else:
print ("你输入的数字不能整除 2 和 3")
将以上程序保存到 test.py 文件中,执行后输出结果为:
$ python test.py
输入一个数字:6
你输入的数字可以整除 2 和 3
Python中的循环语句有 for 和 while。
Python循环语句的控制结构图如下所示:
Python中while语句的一般形式:
while 判断条件:
语句
同样需要注意冒号和缩进。另外,在Python中没有do…while循环。
以下实例使用了 while 来计算 1 到 100 的总和:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
执行结果如下:
1 到 100 之和为: 5050
我们可以通过设置条件表达式永远不为 false 来实现无限循环,实例如下:
实例
#!/usr/bin/python3
var = 1
while var == 1 : # 表达式永远为 true
num = int(input("输入一个数字 :"))
print ("你输入的数字是: ", num)
print ("Good bye!")
执行以上脚本,输出结果如下:
输入一个数字 :5
你输入的数字是: 5
输入一个数字 :
你可以使用 CTRL+Z 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。
在 while … else 在条件语句为 false 时执行 else 的语句块:
实例
#!/usr/bin/python3
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
执行以上脚本,输出结果如下:
0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 大于或等于 5
类似if语句的语法,如果你的while循环体中只有一条语句,你可以将该语句与while写在同一行中, 如下所示:
实例
#!/usr/bin/python
flag = 1
while (flag): print ('Python Tutorial!')
print ("Good bye!")
**注意:**以上的无限循环你可以使用 CTRL+Z 来中断循环。
执行以上脚本,输出结果如下:
Python Tutorial!
Python Tutorial!
Python Tutorial!
Python Tutorial!
Python Tutorial!
Python Tutorial!
Python Tutorial!
Python Tutorial!
……
Python for循环可以遍历任何序列的项目,如一个列表或者一个字符串。
for循环的一般格式如下:
for <variable> in <sequence>:
<statements>
else:
<statements>
Python loop循环实例:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
languages = ["C", "C++", "Java", "Python"]
for x in languages:
print (x)
输出结果:
C
C++
Java
Python
以下 for 实例中使用了 break 语句,break 语句用于跳出当前循环体:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
sites = ["Baidu", "Google", "Huawei"]
for site in sites:
if site == "Huawei":
print("华为!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
执行脚本后,在循环到 "TechLab"时会跳出循环体:
循环数据 Baidu
循环数据 Google
华为!
完成循环!
如果需要遍历数字序列,可以使用内置range()函数。它会生成数列,例如:
实例
>>>for i in range(5):
print(i)
0
1
2
3
4
也可以使用range指定区间的值:
实例
>>>for i in range(5,9) :
print(i)
5
6
7
8
也可以使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做’步长’):
实例
>>>for i in range(0, 10, 3) :
print(i)
0
3
6
9
负数:
实例
>>>for i in range(-10, -100, -30) :
print(i)
-10
-40
-70
您可以结合range()和len()函数以遍历一个序列的索引,如下所示:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
a = ['Google', 'Baidu', 'Huawei', 'Alibaba', 'Tencent']
for i in range(len(a)):
print(i, a[i])
输出结果:
0 Google
1 Baidu
2 Huawei
3 Alibaba
4 Tencent
还可以使用range()函数来创建一个列表:
实例
>>>list(range(5))
[0, 1, 2, 3, 4]
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止,任何对应的循环 else 块将不执行。 实例如下:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
for letter in 'PythonTutorial': # 第一个实例
if letter == 'T':
break
print ('当前字母为 :', letter)
var = 11 # 第二个实例
while var > 0:
print ('当期变量值为 :', var)
var -= 3
if var == 5:
break
else:
print(var)
print ("Good bye!")
执行以上脚本输出结果为:
当前字母为 : P
当前字母为 : y
当前字母为 : t
当前字母为 : h
当前字母为 : o
当前字母为 : n
当期变量值为 : 11
当期变量值为 : 8
Good bye!
continue语句被用来告诉Python跳过当前循环块中的剩余语句,然后继续进行下一轮循环。
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
for letter in 'Huawei': # 第一个实例
if letter == 'a': # 字母为 a 时跳过输出
continue
print('当前字母 :', letter)
var = 10 # 第二个实例
while var > 0:
var = var - 1
if var == 5: # 变量为 5 时跳过输出
continue
print('当前变量值 :', var)
print("Good bye!")
执行以上脚本输出结果为:
当前字母 : H
当前字母 : u
当前字母 : w
当前字母 : e
当前字母 : i
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!
循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
如下实例用于查询质数的循环例子:
实例
#!/usr/bin/python
# -*- encoding:utf-8 -*-
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
执行以上脚本输出结果为:
2 是质数
3 是质数
4 等于 2 * 2
5 是质数
6 等于 2 * 3
7 是质数
8 等于 2 * 4
9 等于 3 * 3
Python pass是空语句,是为了保持程序结构的完整性。
pass 不做任何事情,一般用做占位语句,如下实例
实例
>>>while True:
... pass # 等待键盘中断 (Ctrl+C)
最小的类:
实例
>>>class MyEmptyClass:
... pass
以下实例在字母为 a 时 执行 pass 语句块:
实例
#!/usr/bin/python3
for letter in 'PythonTutorial':
if letter == 'T':
pass
print('执行 pass 块')
continue
print('当前字母 :', letter)
print("Good bye!")
执行以上脚本输出结果为:
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
执行 pass 块
当前字母 : u
当前字母 : t
当前字母 : o
当前字母 : r
当前字母 : i
当前字母 : a
当前字母 : l
Good bye!
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
你可以定义一个由自己想要功能的函数,以下是简单的规则:
Python 定义函数使用 def 关键字,一般格式如下:
def 函数名(参数列表):
函数体
默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例:
使用函数来输出"Hello World!":
def hello():
print("Hello World!")
hello()# Hello World!
更复杂点的应用,函数中带上参数变量:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 计算面积函数
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("Python Tutorial")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
以上实例输出结果:
Welcome Python Tutorial
width = 4 height = 5 area = 20
定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数:
实例:
#!/usr/bin/python3
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str)
return
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")
以上实例输出结果:
我要调用用户自定义函数!
再次调用同一函数
在 python 中,类型属于对象,变量是没有类型的:
a = [1, 2, 3]
a = "PythonTutorial"
以上代码中,[1,2,3] 是 List 类型,“PythonTutorial” 是 String 类型,而变量 a 是没有类型,它仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
python 函数的参数传递:
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成一个 int 值对象 10,并让 a 指向它。
可变对象在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。例如:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
以下是调用函数时可使用的正式参数类型:
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数,必须传入一个参数,不然会出现语法错误:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printme(str):
"打印任何传入的字符串"
print(str)
return
# 调用printme函数
printme()
以上实例输出结果:
Traceback (most recent call last):
File "Test.py", line 10, in
printme()
TypeError: printme() missing 1 required positional argument: 'str'
关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printme(str):
"打印任何传入的字符串"
print(str)
return
# 调用printme函数
printme(str="Python教程")
以上实例输出结果:
Python教程
以下实例中演示了函数参数的使用不需要使用指定顺序:
实例:
#!/usr/bin/python3
# 可写函数说明
def printinfo(name, age):
"打印任何传入的字符串"
print("名字: ", name)
print("年龄: ", age)
return
# 调用printinfo函数
printinfo(age=15, name="TechLab")
以上实例输出结果:
名字: TechLab
年龄: 15
调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printinfo(name, age=15):
"打印任何传入的字符串"
print("名字: ", name)
print("年龄: ", age)
return
# 调用printinfo函数
printinfo(age=22, name="Colins")
print("--------以下只填入name,age使用默认参数15--------")
printinfo(name="Colins")
以上实例输出结果:
名字: Colins
年龄: 22
--------以下只填入name,age使用默认参数15--------
名字: Colins
年龄: 15
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号 *
的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printinfo(arg1, *vartuple):
"打印任何传入的参数"
print("输出: ")
print(arg1)
print(vartuple)
# 调用printinfo 函数
printinfo(70, 60, 50)
以上实例输出结果:
输出:
70
(60, 50)
如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printinfo(arg1, *vartuple):
"打印任何传入的参数"
print("输出: ")
print(arg1)
for var in vartuple:
print(var)
return
# 调用printinfo 函数
printinfo(10)
printinfo(70, 60, 50)
以上实例输出结果:
输出:
10
输出:
70
60
50
还有一种就是参数带两个星号**
基本语法如下:
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
加了两个星号**
的参数会以字典的形式导入。
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 可写函数说明
def printinfo(arg1, **vardict):
"打印任何传入的参数"
print("输出: ")
print(arg1)
print(vardict)
# 调用printinfo 函数
printinfo(1, a=2, b=3)
以上实例输出结果:
输出:
1
{'a': 2, 'b': 3}
声明函数时,参数中星号*
可以单独出现,例如:
def f(a, b, *, c):
return a + b + c
如果单独出现星号 * 后的参数必须用关键字传入。
def f(a, b, *, c):
return a + b + c
f(1, 2, 3) # 报错
"""
Traceback (most recent call last):
File "Test.py", line 4, in
f(1, 2, 3) # 报错
TypeError: f() takes 2 positional arguments but 3 were given
"""
f(1, 2, c=3) # 正常
"""
6
"""
python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
如下实例:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
# 函数形式
def sum1(arg1, arg2): return arg1 + arg2
# lambda表达式形式
sum2 = lambda arg1,arg2 : arg1 + arg2
# 调用两个不同的sum函数
print("相加后的值为 : ", sum1(10, 20))
print("相加后的值为 : ", sum2(20, 20))
以上实例输出结果:
相加后的值为 : 30
相加后的值为 : 40
return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值,以下实例演示了 return 语句的用法:
实例:
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
以上实例输出结果:
函数内 : 30
函数外 : 30
Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种,分别是:
以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内建中找。
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如 if / elif / else、try / except、for / while等)是不会引入新的作用域的,也就是说这些语句内定义的变量,外部也可以访问,如下代码:
if True:
msg = 'I am from TechLab'
print(msg)# I am from TechLab
实例中 msg 变量定义在 if 语句块中,但外部还是可以访问的。
如果将 msg 定义在函数中,则它就是局部变量,外部不能访问:
def test():
msg_inner = 'I am from TechLab'
print(msg_inner)
"""
Traceback (most recent call last):
File "", line 1, in
NameError: name 'msg_inner' is not defined
"""
从报错的信息上看,说明了 msg_inner 未定义,无法使用,因为它是局部变量,只有在函数内可以使用。
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
total = 0 # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print("函数内是局部变量 : ", total)
return total
#调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)
以上实例输出结果:
函数内是局部变量 : 30
函数外是全局变量 : 0
当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。
以下实例修改全局变量 num:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
以上实例输出结果:
1
123
123
如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:
实例:
#!/usr/bin/python
# -*- encoding:utf-8 -*-
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
以上实例输出结果:
100
100
另外有一种特殊情况,假设下面这段代码被运行:
实例:
#!/usr/bin/python3
a = 10
def test():
a = a + 1
print(a)
test()
以上程序执行,报错信息如下:
Traceback (most recent call last):
File "test.py", line 7, in
test()
File "test.py", line 5, in test
a = a + 1
UnboundLocalError: local variable 'a' referenced before assignment
错误信息为局部作用域引用错误,因为 test 函数中的 a 使用的是局部,未定义,无法修改。
修改 a 为全局变量,通过函数参数传递,可以正常执行输出结果为:
实例:
#!/usr/bin/python3
a = 10
def test(a):
a = a + 1
print(a)
test(a)
执行输出结果为:
11