Python简明教程
Python可能是极少数能够同时兼顾简单与功能强大的编程语言。
Python的特色
简单易于学习、自由且奔放、高级语言、跨平台性、解释性、面向对象、可扩展性、可嵌入性、丰富的庫。
Python着实是一门令人心生激动且强大的语言，它得当的结合了性能和功能，使得编写Python程序变得简单而有趣。
如何运行我们编写的Python程序呢？
使用解释器提示符
在你的操作系统中打开终端程序，然后通过输入 python 并按下 [enter] 键来打开 Python 提示符。当你启动 Python 后，你会看见在你能开始输入内容的地方出现了 >>> 。这个被称作 Python解释器提示符。
在 Python 解释器提示符，输入：
print("Hello World")
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello World")
Hello World
>>>
选择一款编辑器
当我们希望运行某些程序时，总不能每次都在解释器提示符中输入我们的程序。要想创建我们的 Python 源代码文件，我们需要在一款能够为你提供输入并储存代码的编辑器软件。一款优秀的面向程序员的编辑器能够帮助你的编写源代码文件工作变得轻松。对编辑器的一项最基本要求为语法高亮，这一功能能够通过标以不同颜色来帮助你区分Python 程序中的不同部分，从而能够让你更好看清你的程序，并使它的运行模式更加形象化。PyCharm 教育版是一款能够对你编写 Python 程序的工作有所帮助的免费编辑软件。
注释
注释是任何存在于 # 号右侧的文字，其主要用作写给程序读者看的笔记。
举个例子：
print('hello world') #注意到 print 是一个函数
或者：
# 注意到 print 是一个函数
print('hello world')
你应该在你的程序中尽可能多地使用有用的注释：
解释假设
说明重要的决定
解释重要的细节
说明你想要解决的问题
说明你想要在程序中克服的问题，等等。
代码会告诉你怎么做，注释会告诉你为何如此。
数字
数字主要分为两种类型，整数与浮点数。有关整数的例子即 2 ，它只是一个整数。有关浮点数的例子是 3.23 或52.3E-4 。其中， E 表示 10 的幂。在这里， 52.3E-4 表示 52.3 * 10^-4 。
字符串
一串字符串是字符的序列。基本上，字符串就是一串词汇。你将会在几乎所有你撰写的 Python 程序中使用字符串，所以对下面的部分你要多上点心。
单引号
你可以使用单引号来指定字符串，例如 '将我这样框进来' 或 'Quote me on this' 。
所有引号内的空间，诸如空格与制表符，都将按原样保留。
双引号
被双引号包括的字符串和被单引号扩起的字符串其工作机制完全相同。例如 "你的名字是？" 或 "What's your name?" 。
三引号
你可以通过使用三个引号""" 或 ''' 来指定多行字符串。你可以在三引号之间自由地使用单引号与双引号。来看看这个例子：
'''这是一段多行字符串。这是它的第一行。
This is the second line.
"What's your name?," I asked.
He said "Bond, James Bond."
'''
转义序列
如果你希望生成一串包含单引号（ ' ）的字符串，你应该如何指定这串字符串？例如，你想要的字符串是 "What's your name?" 。你不能指定 'What's your name?' ，因为这会使 Python 对于何处是字符串的开始、何处又是结束而感到困惑。所以，你必须指定这个单引号不代表这串字符串的结尾。这可以通过 转义序列来实现。你通过\ 来指定单引号：要注意它可是反斜杠。现在，你可以将字符串指定为：
'What\'s your name?' 。
另一种指定这一特别的字符串的方式是这样的：
"What's your name?"
如这个例子般使用双引号。类似地， 你必须在使用双引号括起的字符串中对字符串内的双引号使用转义序列。同样，你必须使用转义序列 \\ 来指定反斜杠本身。
如果你想指定一串双行字符串该怎么办？一种方式即使用如前所述的三引号字符串，或者你可以使用一个表示新一行的转义序列\n 来表示新一行的开始。下面是一个例子：
'This is the first line\nThis is the second line'
另一个你应该知道的大有用处的转义序列是制表符： \t 。在一个字符串中，一个放置在末尾的反斜杠表示字符串将在下一行继续，但不会添加新的一行。来看看例子：
"This is the first sentence. \
This is the second sentence."
相当于
"This is the first sentence. This is the second sentence."
标识符命名
标识符是为某些东西提供的给定名称。在你命名标识符时，你需要遵守以下规则：
第一个字符必须是字母表中的字母（大写字符或小写字符或 Unicode 字符）或下划线。
标识符的其它部分可以由字符（大写字符或小写字符或 Unicode 字符）、下划线、数字组成。
标识符名称区分大小写。例如， myname 和 myName 并不等同。
针对面向对象编程语言用户的提示：
Python 是强（Strongly）面向对象的，因为所有的一切都是对象， 包括数字、字符串与函数。
针对静态编程语言程序员的提示：
变量只需要被赋予某一个值，不需要声明或定义数据类型。
逻辑行与物理行
所谓物理行是你在编写程序时你所看到的内容。所谓逻辑行是 Python 所看到的单个语句。Python 会假定每一 物理行会对应一个 逻辑行。有关逻辑行的一个例子是诸如 print('hello world') 这样一句语句，如果其本身是一行，那么它也对应着一行物理行。Python 之中暗含这样一种期望：Python 鼓励每一行使用一句独立语句从而使得代码更加可读。如果你希望在一行物理行中指定多行逻辑行，那么你必须通过使用分号( ; )来明确表明逻辑行或语句的结束。下面是一个例子：
i = 5
print(i)
实际上等同于
i = 5;
print(i);
同样可以看作
i = 5; print(i);
也与这一写法相同
i = 5; print(i)
强烈建议对于每一行物理行最多只写入一行逻辑行。这个观点就是说你不应该使用分号。实际上，我从未在 Python 程序中使用、甚至是见过一个分号。在一类情况下这一方法会颇为有用：如果你有一行非常长的代码，你可以通过使用反斜杠将其拆分成多个物理行。这被称作显式行连接：
s = 'This is a string. \
This continues the string.'
print(s)
输出：
This is a string. This continues the string.
类似地，
i = \
5
等同于
i = 5
在某些情况下，会存在一个隐含的假设，允许你不使用反斜杠。这一情况即逻辑行以括号开始，它可以是方括号或花括号，但不能是结束括号。这被称作隐式行连接。
缩进
空白区在 Python 中十分重要。实际上，空白区在各行的开头非常重要。这被称作缩进。在逻辑行的开头留下空白区（使用空格或制表符）用以确定各逻辑行的缩进级别，而后者又可用于确定语句的分组。这意味着放置在一起的语句必须拥有相同的缩进。每一组这样的语句被称为块（block）。
有一件事你需要记住：错误的缩进可能会导致错误。下面是一个例子：
i = 5
# 下面将发生错误，注意行首有一个空格
print('Value is', i)
print('I repeat, the value is', i)
当你运行这一程序时，你将得到如下错误：
File "whitespace.py", line 3
print('Value is', i)
^
IndentationError: unexpected indent
# 缩进错误：意外缩进
Python 指出的错误信息告诉我们程序的语法是无效的，程序没有被正确地写入。这一错误信息让你得知不能任意开始一个新的语句块（除非你一直在使用默认的主代码块）。
如何缩进：使用四个空格来缩进。确保你在缩进中使用数量一致的空格，否则你的程序将不会运行。
Python 将始终对块使用缩进，并且绝不会使用大括号。
运算符
+ （加）
两个对象相加。
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
13 / 3 输出 4.333333333333333 。
// （整除）
x 除以 y 并对结果向下取整至最接近的整数。
13 // 3 输出 4 。-13 // 3 输出 -5 。
% （取模）
返回除法运算后的余数。
13 % 3 输出 1 。 -25.5 % 2.25 输出 1.5 。
<< （左移）
将数字的位向左移动指定的位数。（每个数字在内存中以二进制数表示，即 0 和1）
2 << 2 输出 8 。 2 用二进制数表示为 10 。向左移 2 位会得到 1000 这一结果，表示十进制中的 8 。
>> （右移）
将数字的位向右移动指定的位数。
11 >> 1 输出 5 。11 在二进制中表示为 1011 ，右移一位后输出 101 这一结果，表示十进制中的5 。
& （按位与）
对数字进行按位与操作。
5 & 3 输出 1 。
| （按位或）
对数字进行按位或操作。
5 | 3 输出 7 。
^ （按位异或）
对数字进行按位异或操作。
5 ^ 3 输出 6 。
~ （按位取反）
x 的按位取反结果为 -(x+1)。
~5 输出 -6 。
< （小于）
返回 x 是否小于 y。
所有的比较运算符返回的结果均为 True 或 False 。
请注意这些名称之中的大写字母。5 < 3 输出 False ， 3 < 6 输出 True 。1234符与表达式43比较可以任意组成组成链接： 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>=3 返回 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 是 Ture ，则返回 False 。如果 x 是 False ，则返回 True 。
x = Ture; not x 返回 False 。
and （布尔“与”）
如果 x 是 False ，则 x and y 返回 False ，否则返回 y 的计算值。
当 x 是 False 时， x = False; y = True; x and y 将返回 False 。Python 将不会计算 y，它已经了解 and 表达式的左侧是 False ，这意味着整个表达式都将是 False 而不会是别的值。这种情况被称作短路计算。
or （布尔“或”）
如果 x 是 True ，则返回 True ，否则它将返回 y 的计算值。
x = Ture; y = False; x or y 将返回 Ture 。在这里短路计算同样适用。
表达式
length = 5
breadth = 2
area = length * breadth
print('Area is', area)
print('Perimeter is', 2 * (length + breadth))
输出：
Area is 10
Perimeter is 14
if 语句
if 语句用以检查条件：如果条件为真（True），我们将运行一块语句（称作 if-block 或 if块），否则我们将运行另一块语句（称作 else-block 或 else 块）。其中 else 从句是可选的。
number = 23
guess = int(input('Enter an integer : '))
if guess == number:
# 新块从这里开始
print('Congratulations, you guessed it.')
print('(but you do not win any prizes!)')
# 新块在这里结束
elif guess < number:
# 另一代码块
print('No, it is a little higher than that')
# 你可以在此做任何你希望在该代码块内进行的事情
else:
print('No, it is a little lower than that')
# 你必须通过猜测一个大于（>）设置数的数字来到达这里。
print('Done')
# 这最后一句语句将在if 语句执行完毕后执行。
输出：
$ python if.pyEnter an integer : 50
No, it is a little lower than that
Done
$ python if.py
Enter an integer : 22
No, it is a little higher than that
Done
$ python if.py
Enter an integer : 23
Congratulations, you guessed it.(but you do not win any prizes!)
Done
while 语句
while 语句能够让你在条件为真的前提下重复执行某块语句。 while 语句是循环语句的一种。 while 语句同样可以拥有 else 子句作为可选选项。
number = 23
running = True
while running:
guess = int(input('Enter an integer : '))
if guess == number:
print('Congratulations, you guessed it.')
# 这将导致 while 循环中止
running = False
elif guess < number:
print('No, it is a little higher than that.')
else:
print('No, it is a little lower than that.')
else:
print('The while loop is over.')
# 在这里你可以做你想做的任何事
print('Done')
输出：
$ python while.py
Enter an integer : 50
No, it is a little lower than that
Enter an integer : 22
No, it is a little higher than that.
Enter an integer : 23
Congratulations, you guessed it.
The while loop is over.Done
for 循环
for...in 语句是另一种循环语句，其特点是会在一系列对象上进行迭代，意它会遍历序列中的每一个项目。
for i in range(1, 5):
print(i)
else:
print('The for loop is over')
输出：
$ python for.py
1
2
3
4
The for loop is over
break 语句
break 语句用以中断（Break）循环语句，也就是中止循环语句的执行，即使循环条件没有变更为 False ，或队列中的项目尚未完全迭代依旧如此。有一点需要尤其注意，如果你的中断了一个 for 或 while 循环，任何相应循环中的else 块都将不会被执行。
while True:
s = input('Enter something : ')
if s == 'quit':
break
print('Length of the string is', len(s))
print('Done')
输出：
$ python break.py
Enter something : Programming is fun
Length of the string is 18
Enter something : When the work is done
Length of the string is 21
Enter something : if you wanna make your work also fun:
Length of the string is 37
Enter something : use Python!
Length of the string is 11
Enter something : quit
Done
continue 语句
continue 语句用以告诉 Python 跳过当前循环块中的剩余语句，并继续该循环的下一次迭代。
while True:
s = input('Enter something : ')
if s == 'quit':
break
if len(s) < 3:
print('Too small')
continue
print('Input is of sufficient length')
# 自此处起继续进行其它任何处理
输出：
$ python continue.py
Enter something : a
Too small
Enter something : 12
Too small
Enter something : abc
Input is of sufficient length
Enter something : quit
函数
函数是指可重复使用的程序片段。它们允许你为某个代码块赋予名字，允许你通过这一特殊的名字在你的程序任何地方来运行代码块，并可重复任何次数。这就是所谓的调用函数。函数可以通过关键字 def 来定义。这一关键字后跟一个函数的标识符名称，再跟一对圆括号，其中可以包括一些变量的名称，再以冒号结尾，结束这一行。随后而来的语句块是函数的一部分。
def say_hello():
# 该块属于这一函数
print('hello world')
# 函数结束
say_hello() # 调用函数
say_hello() # 再次调用函数
输出：
$ python function1.py
hello world
hello world
函数参数
函数可以获取参数，这个参数的值由你所提供，借此，函数便可以利用这些值来做一些事情。这些参数与变量类似，这些变量的值在我们调用函数时已被定义，且在函数运行时均已赋值完成。函数中的参数通过将其放置在用以定义函数的一对圆括号中指定，并通过逗号予以分隔。当我们调用函数时，我们以同样的形式提供需要的值。要注意在此使用的术语——在定义函数时给定的名称称作“形参”（Parameters），在调用函数时你所提供给函数的值称作“实参”。
def print_max(a, b):
if a > b:
print(a, 'is maximum')
elif a == b:
print(a, 'is equal to', b)
else:
print(b, 'is maximum')
# 直接传递字面值
print_max(3, 4)
x = 5
y = 7
# 以参数的形式传递变量
print_max(x, y)
输出：
$ python function_param.py
4 is maximum
7 is maximum
局部变量
当你在一个函数的定义中声明变量时，它们不会以任何方式与身处函数之外但具有相同名称的变量产生关系，也就是说，这些变量名只存在于函数这一局部。这被称为变量的作用域。所有变量的作用域是它们被定义的块，从定义它们的名字的定义点开始。
x = 50
def func(x):
print('x is', x)
x = 2
print('Changed local x to', x)
func(x)
print('x is still', x)
输出：
$ python function_local.py
x is 50
Changed local x to 2
x is still 50
global 语句
如果你想给一个在程序顶层的变量赋值（也就是说它不存在于任何作用域中，无论是函数还是类），那么你必须告诉 Python 这一变量并非局部的，而是全局（Global）的。因为在不使用 global 语句的情况下，不可能为一个定义于函数之外的变量赋值。
你可以使用定义于函数之外的变量的值（假设函数中没有具有相同名字的变量）。然而，这种方式不会受到鼓励而且应该避免，因为它对于程序的读者来说是含糊不清的，无法弄清楚变量的定义究竟在哪。而通过使用 global 语句便可清楚看出这一变量是在最外边的代码块中定义的。
x = 50
def func():
global x
print('x is', x)
x = 2
print('Changed global x to', x)
func()
print('Value of x is', x)
输出：
$ python function_global.py
x is 50
Changed global x to 2
Value of x is 2
默认参数值
对于一些函数来说，你可能为希望使一些参数可选并使用默认的值，以避免用户不想为他们提供值的情况。默认参数值可以有效帮助解决这一情况。你可以通过在函数定义时附加一个赋值运算符（ = ）来为参数指定默认参数值。要注意到，默认参数值应该是常数。
def say(message, times=1):
print(message * times)
say('Hello')
say('World', 5)
输出：
$ python function_default.py
Hello
WorldWorldWorldWorldWorld
关键字参数
如果你有一些具有许多参数的函数，而你又希望只对其中的一些进行指定，那么你可以通过命名它们来给这些参数赋值——这就是关键字参数，我们使用命名（关键字）而非位置来指定函数中的参数。
这样做有两大有点：1、我们不再需要考虑参数的顺序，函数的使用将更加容易。2、我们可以只对那些我们希望赋予的参数以赋值，只要其它的参数都具有默认参数值。
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)
输出：
$ python function_keyword.py
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
func 函数有一个没有默认参数值的参数，后跟两个各自带有默认参数值的参数。在第一次调用函数时， func(3, 7) ，参数 a 获得了值 3 ，参数 b 获得了值 7 ，而 c获得了默认参数值 10 。在第二次调用函数时， func(25, c=24) ，由于其所处的位置，变量 a 首先获得了值 25。然后，由于关键字参数指定，变量 c 获得了值 24 。变量 b 获得默认参数值5 。在第三次调用函数时， func(c=50, a=100) ，我们全部使用关键字参数来指定值。在这里要注意到，尽管 a 在 c 之前定义，但我们还是我们在变量 a 之前指定了变量 c 。
可变参数
有时你可能想定义的函数里面能够有任意数量的变量，也就是参数数量是可变的，这可以通过使用星号来实现。
def total(a=5, *numbers, **phonebook):
print('a', a)
#遍历元组中的所有项目
for single_item in numbers:
print('single_item', single_item)
#遍历字典中的所有项目
for first_part, second_part in phonebook.items():
print(first_part,second_part)
print(total(10,1,2,3,Jack=1123,John=2231,Inge=1560))
输出：
$ python function_varargs.py
a 10
single_item 1
single_item 2
single_item 3
Inge 1560
John 2231
Jack 1123
None
当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数都将被收集并汇集成一个称为“param”的元组（Tuple）。类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。
return 语句
return 语句用于从函数中返回，也就是中断函数。我们也可以选择在中断函数时从函数中返回一个值。
def maximum(x, y):
if x > y:
return x
elif x == y:
return 'The numbers are equal'
else:
return y
print(maximum(2, 3))
输出：
$ python function_return.py
3
