Python快速入门
1. Python 介绍
1.1 Python 简介
Python 是一种易于学习又功能强大的编程语言。它提供了高效的高级数据结构，还有简单有效的面向对象编程。Python 优雅的语法和动态类型，以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。
Python 解释器及丰富的标准库以源码或机器码的形式提供，可以到 Python 官网 https://www.python.org/ 免费获取适用于各个主要系统平台的版本，并可自由地分发。这个网站还包含许多免费第三方 Python 模块、程序和工具以及附加文档的发布页面或链接。
1.2 为什么要用Python?
如果你经常在电脑上工作，总会有些任务会想让它自动化。比如，对一大堆文本文件进行查找替换，对很多照片文件按照比较复杂的规则重命名并放入不同的文件夹。也可能你想写一个小型的数据库应用，一个特定的界面应用，或者一个简单的游戏。
如果你是专业的软件开发人员，你可能需要编写一些C/C++/Java库，但总觉得通常的开发的流程（编写、编译、测试、再次编译等）太慢了。可能给这样的库写一组测试，就是很麻烦的工作了。或许你写了个软件，可以支持插件扩展语言，但你不想为了自己这一个应用，专门设计和实现一种新语言了。
那么，Python正好能满足你的需要。
对于这些任务，你也可以写Unix脚本或者Windows批处理完成，但是shell脚本最擅长移动文件和替换文本，并不适合GUI界面或者游戏开发。你可以写一个C/C++/Java程序，但是可能第一版本的草稿都要很长的开发时间。Python的使用则更加简单，可以在Windows，Mac OS X，以及Unix操作系统上使用，而且可以帮你更快地完成工作。
Python很容易使用，但它是一种真正的编程语言，提供了很多数据结构，也支持大型程序，远超shell脚本或批处理文件的功能。Python还提供比C语言更多的错误检查，而且作为一种“超高级语言”，它有高级的内置数据类型，比如灵活的数组和字典。正因为这些更加通用的数据类型，Python能够应付更多的问题，超过Awk甚至Perl，而且很多东西在Python中至少和那些语言同样简单。
Python允许你划分程序模块，在其他的Python程序中重用。它内置了很多的标准模块，你可以在此基础上开发程序——也可以作为例子，开始学习Python编程。例如，文件输入输出，系统调用，套接字，甚至图形界面接口工作包比如Tk。
Python是一种解释型语言，在程序开发阶段可以为你节省大量时间，因为不需要编译和链接。解释器可以交互式使用，这样就可以方便地尝试语言特性，写一些一次性的程序，或者在自底向上的程序开发中测试功能。它也是一个顺手的桌面计算器。
Python程序的书写是紧凑而易读的。Python代码通常比同样功能的C，C++，Java代码要短很多，原因列举如下：
- 高级数据类型允许在一个表达式中表示复杂的操作；
- 代码块的划分是按照缩进而不是成对的花括号；
- 不需要预先定义变量或参数。
顺便提一下，这种语言的名字（Python意为“蟒蛇”）来自于BBC节目“Monty Python的飞行马戏团”，而与爬行动物没有关系。在文档中用Monty Python来开玩笑不只是可以的，还是推荐的！
1.3 Python 教程
RUNOOB教程: http://www.runoob.com/python3/python3-tutorial.html
中文教程: https://docs.python.org/zh-cn/3/
英文教程: https://docs.python.org/3/
2. Python变量和数据类型
2.1 Python变量
2.1.1 局部变量和全局变量
Python 变量分为局部变量和全局变量。一般来说，函数内部的变量都是局部变量，其它都是全局变量。全局变量有时候需要特别声明 ，例如：
def func():
...
if True == Enable_Debug:
print("....")
....
def main():
global Enable_Debug
Enable_Debug = False
...
函数main() 中声明了一个全局变量 Enable_Debug，并赋值为False, 在另外一个函数Func就可以使用它。
全局变量尽可能避免使用，并且使用全局变量越少越好。
2.1.2 变量的命名
Python的变量命名要遵守一些规则：
- 变量名只能包含字母、数字和下划线。变量名可以以字母或下划线开头，但不能以数字开头。例如，变量可以为length_1，但不能将其命名为1_length
- 变量名不能包含空格，但可以使用下划线来分隔其中的单词。
- 不要将Python关键字和函数名作用变量名。
- 变量名应既简洁又具有描述性。例如：name比n好，name_length比length_of_persons_name好。
一句话，Python解释器不报错的使用都是可以的，但尽量遵循好的命名规则，养成好的习惯，让程序容易阅读时非常重要的。
2.2 Python的变量类型
变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数，字符串，列表，元组或字典。
2.3 Python的变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
2.4 Python的数据类型
Python有如下的数据类型：
- 数 (Numbers)。包含int（有符号整型），float（浮点型）和complex（复数）。
- 字符串(String)。Python大部分时候不区分字符和字符串，并且’c’和’hello’都可以使用单引号的。
- 列表(List)。列表是由一系列按特定顺序排列的同种数据类型的元素组成，元素可以是字符，数，或字符串等。
- 元组(tuple)。 Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
- 字典(Ｄictionary)。这个是稍微高级的数据结构，字典是一系列键-值 (key-value)对。每一个键都与一个值相关联。字典用放在大括号{}中一系列键-值对表示，如：dict1 = {‘no1’: ‘诗仙’, ‘no2’: ‘杜甫’, ‘no3’: ‘李商隐’}
2.4.1 数 (Numbers)
Python支持三种不同的数字类型：
int（有符号整型）
float（浮点型）
complex（复数）
除了 int 和 float，Python也支持其他类型的数字，例如 Decimal 或者 Fraction。Python 也内置对 复数 的支持，使用后缀 j 或者 J 就可以表示虚数部分（例如 3+5j）。
一些数值类型的实例如下:
| 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 |
2.4.2 字符串(String)
字符串或串(String)是由数字、字母、下划线组成的一串字符。
字符串有多种形式，可以使用单引号（’……’），双引号（"……"）都可以获得同样的结果。
s = “a1a2···an”, 或者
s = ‘a1a2···an’ (n>=0)
字符串可以用 + 进行连接（粘到一起），也可以用 * 进行重复。
>>> # 3 times ‘un’, followed by ‘ium’
>>> 3 * ‘un’ + ‘ium’
‘unununium’
字符串是可以被 索引 （下标访问）的，第一个字符索引是 0。单个字符并没有特殊的类型，只是一个长度为一的字符串。
>>> word = ‘Python’
>>> word[0] # character in position 0
‘P’
>>> word[5] # character in position 5
‘n’
索引也可以用负数，这种会从右边开始数。
>>> word[-1] # last character
‘n’
>>> word[-2] # second-last character
‘o’
>>> word[-6]
‘P’
除了索引，字符串还支持 切片。索引可以得到单个字符，而 切片 可以获取子字符串:
>>> word[0:2] # characters from position 0 (included) to 2 (excluded)
‘Py’
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
‘tho’
注意切片的开始总是被包括在结果中，而结束不被包括。这使得 s[:i] + s[i:] 总是等于 s
>>> word[:2] + word[2:]
‘Python’
>>> word[:4] + word[4:]
‘Python’
切片的索引有默认值；省略开始索引时默认为0，省略结束索引时默认为到字符串的结束:
>>> word[:2] # character from the beginning to position 2 (excluded)
‘Py’
>>> word[4:] # characters from position 4 (included) to the end
‘on’
>>> word[-2:] # characters from the second-last (included) to the end
‘on’
您也可以这么理解切片：将索引视作指向字符 之间 ，第一个字符的左侧标为0，最后一个字符的右侧标为 n ，其中 n 是字符串长度。例如:
±–±--±–±--±–±--+
| P | y | t | h | o | n |
±–±--±–±--±–±--+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
第一行数标注了字符串非负的索引的位置，第二行标注了对应的负的索引。那么从 i 到 j 的切片就包括了标有 i 和 j 的位置之间的所有字符。
对于使用非负索引的切片，如果索引不越界，那么得到的切片长度就是起止索引之差。例如， word[1:3] 的长度为2.
内建函数 len() 返回一个字符串的长度:
>>> s = ‘supercalifragilisticexpialidocious’
>>> len(s)
34
2.4.3 列表(List)
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 Python 最通用的复合数据类型。
一个 列表 可以包含不同类型的元素，但通常使用时各个元素类型相同:
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
和字符串及各种内建的 sequence 类型一样，列表也支持索引和切片:
>>> squares[0] # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list
[9, 16, 25]
所有的切片操作都返回一个新列表，这个新列表包含所需要的元素。就是说，如下的切片会返回列表的一个新的(浅)拷贝:
>>> squares[:]
[1, 4, 9, 16, 25]
列表同样支持拼接操作:
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
与 immutable 的字符串不同, 列表是一个 mutable 类型，就是说，它自己的内容可以改变:
>>> cubes = [1, 8, 27, 65, 125] # something’s wrong here
>>> 4 ** 3 # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64 # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]
你也可以在列表结尾，通过 append() 方法 添加新元素 (我们会在后面解释更多关于方法的内容):
>>> cubes.append(216) # add the cube of 6
>>> cubes.append(7 ** 3) # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
给切片赋值也是可以的，这样甚至可以改变列表大小，或者把列表整个清空:
>>> letters = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
>>> letters
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
>>> # replace some values
>>> letters[2:5] = [‘C’, ‘D’, ‘E’]
>>> letters
[‘a’, ‘b’, ‘C’, ‘D’, ‘E’, ‘f’, ‘g’]
>>> # now remove them
>>> letters[2:5] = []
>>> letters
[‘a’, ‘b’, ‘f’, ‘g’]
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]
内置函数 len() 也可以作用到列表上:
>>> letters = [‘a’, ‘b’, ‘c’, ‘d’]
>>> len(letters)
4
也可以嵌套列表 (创建包含其他列表的列表), 比如说:
>>> a = [‘a’, ‘b’, ‘c’]
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[[‘a’, ‘b’, ‘c’], [1, 2, 3]]
>>> x[0]
[‘a’, ‘b’, ‘c’]
>>> x[0][1]
‘b’
下图较直观和全面描述了列表的索引和切片：
2.4.4 元组(tuple)
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
>>> tuple = ( ‘runoob’, 786 , 2.23, ‘john’, 70.2 )
>>> print(tuple)
(‘runoob’, 786, 2.23, ‘john’, 70.2)
2.4.5 字典(Ｄictionary)
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
>>> tinydict = {‘name’: ‘john’,‘code’:6734, ‘dept’: ‘sales’}
>>> print(tinydict.keys())
dict_keys([‘name’, ‘code’, ‘dept’])
>>> print(tinydict.values())
dict_values([‘john’, 6734, ‘sales’])
>>>
>>> dict = {}
>>> dict[‘one’] = “This is one”
>>> dict[2] = “This is two”
３. Python控制语句
3.1 条件语句
Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
３.1.1 if 语法：
if 条件:
code1
else:
code2
'''
例子：
num1 = 10
num2 = 10
if num1==num2:
print("相同")
print("你好")
else:
print("不相同")
print("hello world")
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句
加分支, 在if 和 else中间添加elif
例子 1：
num1 = 10
num2 = 10
if num1>num2:
print("num1大")
elif num1==num2:
print("一样大")
else:
print("num2大")
例子2：
# 练习：输入一个分数，判断等级
# 90-100 等级A
# 80-89 等级B
# 70-79 等级C
# 60-69 等级D
# 0-59 等级E
# 条件语句只会执行一条分支
score = int(input("请输入分数:"))
if score>=90 and score<=100:
print("等级A")
elif score>=80 and score<90:
print("等级B")
elif score>=70 and score<80:
print("等级C")
elif score>=60 and score<70:
print("等级D")
elif score>=0 and score<60:
print("等级E")
else:
print("分数有误")
３.1.2 条件语句的嵌套
if 条件1：
if 条件2：
code1：
else：
code3
else：
code2
例子：
# 可以在任意分支里面嵌套
if score>=0 and score<=100:
if score>=90:
print("等级A")
elif score>=80:
print("等级B")
elif score>=70:
print("等级C")
elif score>=60:
print("等级D")
else:
print("等级E")
else:
if score<0:
print("分数为负数")
else:
print("分数超了")
3.2 循环语句
3.2.1 for 循环
语法：
for iterating_var in sequence:
statements(s)
例子1：
for x in range(1,6):
print("hello world")
在例子１里，变量x的取值是从１到５，因此循环只运行５次。
例子2 :
for letter in 'Python':
print('当前字母 :', letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print('当前水果 :', fruit)
在例子２里，字符串每个字符或者字符串列表的每个元素被枚举，逐一被执行，因此循环执行的次数是len(‘Python’)或者len(fruits)。
例子3 :
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print('当前水果 :', fruits[index])
在例子3里，我们使用了内置函数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。range(len(fruits)) 相当于一个列表 [0, 1, 2, … len()-1 ]
3.2.2 while 循环
while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
while 判断条件：
执行语句……
GIF 演示 Python while 语句执行过程:
例子1：
while a<6:
a += 1
print(a)
在例子１里，Python不支持a++或++a这样的语句，a += 1 或 a -= 2等是支持的。
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：
例子2：
def fun():
x = 0
while x<10:
x += 1
if x==5:
# continue
# break
return
print(x)
print("===========")
fun()
例子3：
# 输入一个整数，得出位数
# 1234 4位数
number = int(input("请输入一个整数："))
count = 0
while True:
number //= 10
count += 1
if number==0:
break
print("%d位数"%count)
或者：
# 输入一个整数，得出位数
# 1234 4位数
number = int(input("请输入一个整数："))
count = 0
while number != 0:
number //= 10
count += 1
print("%d位数"%count)
3.2.３ 循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
Python for 循环嵌套语法：
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
Python while 循环嵌套语法
while expression:
while expression:
statement(s)
statement(s)
也可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。
例子１：输出三角形
# *
# **
# ***
# ****
# *****
for x in range(5):
for y in range(x+1):
print('*',end='')
print()
例子2：打印九九乘法表
＃1x1= 1
#1x2= 2 2x2= 4
#1x3= 3 2x3= 6 3x3= 9
#1x4= 4 2x4= 8 3x4=12 4x4=16
#1x5= 5 2x5=10 3x5=15 4x5=20 5x5=25
#1x6= 6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
#1x7= 7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
#1x8= 8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
#1x9= 9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
for x in range(1,10):
for y in range(1,x+1):
print('%dx%d=%2d'% (y, x, x*y), end=' ')
print()
4. 开始写Python代码
4.1 一个Python例子
下面例子来自我的Project Euler Problem 1 (C++和Python代码实现和解析):
def getSumOfMultiplesOf3or5(n):
SumOfMultiples = 0
for x in range (1, n):
if 0 == x % 3 or 0 == x % 5:
SumOfMultiples += x
return SumOfMultiples
def main():
assert (23 == getSumOfMultiplesOf3or5(10))
print("The sum of all the multiples of 3 or 5 below 1000 is",
getSumOfMultiplesOf3or5(1000))
if __name__ == '__main__':
main()
这个例子有两个函数: 第一个函数getSumOfMultiplesOf3or5(), 第二个函数是main()。
函数 getSumOfMultiplesOf3or5(n)用来计算小于n的3或5的倍数的所有数之和。total和x是局部变量，不需要事先声明。
我们定义函数main()，跟C/C++的main()类似的。assert 用来判断后面的表达式是否为True，否则程序结束运行。print()函数用看来输出信息(到窗口)。
Python没有使用成对的打括号{ }来区分代码块，而是采用缩进和空格来区分。另外，就是函数定义或控制语句后要有":"，否则会报错的。
尽管Python不强求要定义main() ，我们还是从养成一个好的习惯的角度出发，定义了main()，当然还有重用原代码方面的原因。
Python有很多自己的特点和方法，我们慢慢来学习。
4.2 选择Python的开发工具
Python开发环境很多，我自己安装了三个：Python IDLE, Visual Studio Code和Visual Studio 2017。
4.2.1 Python官方包
Python工具包包含Python 集成环境 IDLE(包括图形编辑器和Python Shell)和Python 命令行解释器，以及Python 手册和文档。
4.2.2 Visual Studio Code
微软的Visual Studio Code支持非常多的语言，Python就是其中之一。Visual Studio Code (简称 VS Code / VSC) 是一款免费开源的现代化轻量级代码编辑器，支持语法高亮、智能代码补全、自定义热键、括号匹配、代码片段、代码对比 Diff、GIT 等特性，并针对网页开发和云端应用开发做了优化。软件跨平台支持 Win、Mac 以及 Linux，运行流畅，可谓是微软的良心之作……
我自己是很喜欢Visual Studio Code的，特别是需要编辑或查找多个文件的时候。
4.2.3 Visual Studio Community 2017
这是我自己非常喜欢和经常使用的一款集成开发工具，支持Python和C++，支持GIT，功能强大，使用方便。
Python的开发工具非常多，选择一到两个工具就可以了。