python-人工智能基础
华为泰克人工智能实训教程html
文章目录
- Python 基础语法
- 01. 编码
- 02. 标识符
- 03. python保留字
- 04. 注释
- 05. 行与缩进
- 06. 多行语句
- 07. 空行
- 08. 等待用户输入
- 09. 同一行显示多条语句(不建议使用此类语法)
- 10. 多个语句构成代码组
- 11. Print 输出
- 12. import 与 from...import
- Python基本数据类型
- 01. 标准数据类型
- 02. Number（数字）
- 03. String（字符串）
- 04. List（列表）
- 05. Tuple（元组）
- 06. Set（集合）
- 07. Dictionary（字典）
- 08. Python数据类型转换
- Python运算符
- 什么是运算符？
- Python算术运算符
- Python比较运算符
- Python赋值运算符
- Python位运算符
- Python逻辑运算符
- Python成员运算符
- Python身份运算符
- Python运算符优先级
- Python 条件控制
- Python3 循环语句
- Python 函数
Python 基础语法
01. 编码
默认状况下，Python 3 源码文件以 UTF-8 编码，全部字符串都是 unicode 字符串。 固然你也能够为源码文件指定不一样的编码：
# -*- coding: gbk -*-
上述定义容许在源文件中使用 Windows中的简体中文字符编码，对应适合语言为非unicode的简体中文。python
02. 标识符
- 第一个字符必须是字母表中字母或下划线 _ 。
- 标识符的其余的部分由字母、数字和下划线组成。
- 标识符对大小写敏感。
在 Python 3 中，非 ASCII 标识符也是容许的了。c++
03. python保留字
保留字也称关键字，在程序中不能把它们用做标识符。Python 的标准库提供 keyword 模块，能够输出当前版本的全部关键字：web
>>>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']
04. 注释
Python中单行注释以 # 开头，实例以下：算法
实例shell
#!/usr/bin/python3 # 上一行表示在命令行直接执行Python文件时所调用的Python解释器 print ("Hello, Python!")# 打印输出字符串
执行以上代码，输出结果为：express
Hello, Python!
多行注释能够用多个#号，还有'''和"""：服务器
实例数据结构
#!/usr/bin/python3 # 第一个注释 # 第二个注释 ''' 第三注释 第四注释 ''' """ 第五注释 第六注释 """ print ("Hello, Python!")
执行以上代码，输出结果为：闭包
Hello, Python!
05. 行与缩进
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
06. 多行语句
Python 一般是一行写完一条语句，但若是语句很长，咱们可使用反斜杠\来实现多行语句，例如：
total = item_one + \ item_two + \ item_three
在[]，{}，或()中的多行语句，不须要使用反斜杠\，例如：
total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']
07. 空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不一样，空行并非Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。可是空行的做用在于分隔两段不一样功能或含义的代码，便于往后代码的维护或重构。
**记住：**空行也是程序代码的一部分。
08. 等待用户输入
执行下面的程序在按回车键后就会等待用户输入：
实例
#!/usr/bin/python3 input("\n\n按下 enter 键后退出。")
以上代码中 ，"\n\n"在结果输出前会输出两个新的空行（输出中的空行）。
一旦用户按下Enter键时，程序将退出。
09. 同一行显示多条语句(不建议使用此类语法)
Python能够在同一行中使用多条语句，语句之间使用分号(;)分割，如下是一个简单的实例：
实例
#!/usr/bin/python3 import sys; x = 'TechLab'; sys.stdout.write(x + '\n')
执行以上代码，输出结果为：
TechLab
10. 多个语句构成代码组
缩进相同的一组语句构成一个代码块，咱们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行以后的一行或多行代码构成代码组。
咱们将首行及后面的代码组称为一个子句(clause)。
以下实例：
if expression : suite elif expression : suite else : suite
11. Print 输出
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
12. import 与 from…import
在 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 中的变量不须要声明。每一个变量在使用前都必须赋值，变量赋值之后该变量才会被建立。
在 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。
01. 标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
-
**不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；
-
**可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。
02. Number（数字）
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
区别就是:
- type()不会认为子类是一种父类类型。
- isinstance()会认为子类是一种父类类型。
注意：
- 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
- 到 Python3 中，把 True 和 False 定义成关键字了，但它们的值仍是 1 和 0，它们能够和数字相加。
当你指定一个值时，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
注意：
- 一、Python能够同时为多个变量赋值，如a, b = 1, 2。
- 二、一个变量能够经过赋值指向不一样类型的对象。
- 三、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
- 四、在混合计算时，Python会把整型转换成为浮点数。
数值类型实例
| 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都是浮点型
03. String（字符串）
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可让反斜杠不发生转义。 - 二、字符串能够用
+运算符链接在一块儿，用*运算符重复。 - 三、Python中的字符串有两种索引方式，从左往右以
0开始，从右往左以-1开始。 - 四、Python中的字符串不能改变。
04. List（列表）
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()等等，这在后面会讲到。
注意：
- 一、List写在方括号之间，元素用逗号隔开。
- 二、和字符串同样，list能够被索引和切片。
- 三、List可使用+操做符进行拼接。
- 四、List中的元素是能够改变的。
05. Tuple（元组）
元组（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 "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment
虽然tuple的元素不可改变，但它能够包含可变的对象，好比list列表。
构造包含 0 个或 1 个元素的元组比较特殊，因此有一些额外的语法规则：
tup1 = () # 空元组 tup2 = (20,) # 一个元素，须要在元素后添加逗号
string、list和tuple都属于sequence（序列）。
注意：
- 与字符串同样，元组的元素不能修改。
- 元组也能够被索引和切片，方法同样。
- 注意构造包含0或1个元素的元组的特殊语法规则。
- 元组也可使用+操做符进行拼接。
06. Set（集合）
集合（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'}
07. Dictionary（字典）
字典（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()等。
注意：
- 一、字典是一种映射类型，它的元素是键值对。
- 二、字典的关键字必须为不可变类型，且不能重复。
- 三、建立空字典使用
{}。
08. Python数据类型转换
有时候，咱们须要对数据内置的类型进行转换，数据类型的转换，你只须要将数据类型做为函数名便可。
如下几个内置的函数能够执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
| 函数 | 描述 |
|---|---|
| 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运算符
什么是运算符？
本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操做数，"+" 称为运算符。
Python语言支持如下类型的运算符:
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 运算符优先级
接下来让咱们一个个来学习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
Python比较运算符
如下假设变量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
Python赋值运算符
如下假设变量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位运算符
按位运算符是把数字看做二进制来进行计算的。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逻辑运算符
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成员运算符
除了以上的一些运算符以外，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 中
Python身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| 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 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
Python运算符优先级
如下表格列出了从最高到最低优先级的全部运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘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 条件控制
Python条件语句是经过一条或多条语句的执行结果（True或者False）来决定执行的代码块。
能够经过下图来简单了解条件语句的执行过程:
if 语句
Python中if语句的通常形式以下所示：
if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3
- 若是 “condition_1” 为 True 将执行 “statement_block_1” 块语句
- 若是 “condition_1” 为False，将判断 “condition_2”
- 若是"condition_2" 为 True 将执行 “statement_block_2” 块语句
- 若是 “condition_2” 为False，将执行"statement_block_3"块语句
Python 中用 elif 代替了 else if，因此if语句的关键字为：if – elif – else。
注意：
- 一、每一个条件后面要使用冒号 :，表示接下来是知足条件后要执行的语句块。
- 二、使用缩进来划分语句块，相同缩进数的语句在一块儿组成一个语句块。
- 三、在Python中没有switch – case语句。
实例
如下是一个简单的 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 语句中，能够把 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
Python3 循环语句
Python中的循环语句有 for 和 while。
Python循环语句的控制结构图以下所示：
while 循环
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 语句
在 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! ……
for 语句
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()函数
若是须要遍历数字序列，可使用内置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和continue语句及循环中的else子句
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
pass 语句
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 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提升应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，好比print()。但你也能够本身建立函数，这被叫作用户自定义函数。
定义一个函数
你能够定义一个由本身想要功能的函数，如下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间能够用于定义参数。
- 函数的第一行语句能够选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，而且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return至关于返回 None。
语法
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 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是能够修改的对象。
- **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，至关于新生成了a。
- **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，自己la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
- **不可变类型：**相似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象自己。好比在 fun（a）内部修改 a 的值，只是修改另外一个复制的对象，不会影响 a 自己。
- **可变类型：**相似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
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 <module>
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 <module>
f(1, 2, 3) # 报错
TypeError: f() takes 2 positional arguments but 3 were given
"""
f(1, 2, c=3) # 正常
"""
6
"""
匿名函数
python 使用 lambda 来建立匿名函数。
所谓匿名，意即再也不使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式，函数体比 def 简单不少。
- lambda 的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda 函数拥有本身的命名空间，且不能访问本身参数列表以外或全局命名空间里的参数。
- 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增长运行效率。
语法
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 [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的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 （Local） 局部做用域
- E （Enclosing） 闭包函数外的函数中
- G （Global） 全局做用域
- B （Built-in） 内建做用域（内建函数和类的做用域）
以 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 "<stdin>", line 1, in <module> 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关键字
当内部做用域想修改外部做用域的变量时，就要用到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 <module>
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