内容摘自：
http://www.runoob.com/python
https://www.cnblogs.com/jiyimeng/p/python11091.html
Python简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
1. Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
2. Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
3. Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
4. Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
Python发展历史
Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。
Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。
像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。
现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。
Python 特点
- 易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
- 易于阅读：Python代码定义的更清晰。
- 易于维护：Python的成功在于它的源代码是相当容易维护的。
- 一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
- 互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
- 可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
- 可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
- 数据库：Python提供所有主要的商业数据库的接口。
- GUI编程：Python支持GUI可以创建和移植到许多系统调用。
- .可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
Python环境搭建
官方地址：https://www.python.org
下载地址：https://www.python.org/downloads
下载步骤：
1.下载相关的程序：根据与Mac OS X 和Windows区分；
2.运行下载的程序；
Python集成开发环境: PyCharm
PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/
Python环境配置注意事项
- Python添加到系统的环境变量中(一般在安装过程中勾选相关的选项即可，否则需要自己手动添加);
开发第一个简单的Python程序
Python基础语法
编码
默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。
当然可以为源码文件指定不同的编码：
# -- coding: cp-1252 --
上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。
标识符
第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。
在 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
# 第一个注释
print ("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") # 缩进不一致，会导致运行错误
多行语句
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 = 'hello '; sys.stdout.write(x + '\n'+x)
执行以上代码，输出结果为：
hello
hello
多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
if expression :
suite
elif expression :
suite
else :
suite
Print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
#!/usr/bin/python3
x="a"
y="b"
# 换行输出
print( x )
print( y )
print(1+2)
print(1-2)
print(False)
print("abc")
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()
以上实例执行结果为：
a
b
3
-1
False
abc
---------
a b
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 ('\n python 路径为',sys.path)
导入 sys 模块的 argv,path 成员
from sys import argv,path # 导入特定的成员
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path
命令行参数
很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
[ etc. ]
数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
int (整数)
如 1, 只有一种整数类型 int，表示为长整型，Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型，实际上由于机器内存的有限，我们使用的整数是不可能无限大的。
n=-4
print("n的值： :",n);
print("绝对值方法：n.__abs__() :",n.__abs__());
print("相加运算符：n.__add__(4) :",n.__add__(4));
print("按位与运算:n.__and__(-4) :",n.__and__(-4));
print("判断是否相等：n.__eq__(-4) :",n.__eq__(-4));
print("转成浮点数：n.__float__() :",n.__float__());
print("做除法，取整数:n.__floordiv__(3) :",n.__floordiv__(3));
print("做除法，取余数:n.__mod__(3) :",n.__mod__(3));
print("判断是否大于等于：n.__ge__(-4) :",n.__ge__(-4));
print("判断是否大于：n.__gt__(-4) :",n.__gt__(-4));
print("判断是否小于等于:n.__le__(-3) :",n.__le__(-3));
print("判断是否小于：n.__lt__(-4) :",n.__lt__(-4));
print("取反运算：n.__neg__() :",n.__neg__());
print("返回X的Y次方的值：n.__pow__(2) :",n.__pow__(2));
print("返回二进制的最小长度：bin(n) :",bin(n));
输出结果
n的值： : -4
绝对值方法：n.__abs__() : 4
相加运算符：n.__add__(4) : 0
按位与运算:n.__and__(-4) : -4
判断是否相等：n.__eq__(-4) : True
转成浮点数：n.__float__() : -4.0
做除法，取整数:n.__floordiv__(3) : -2
做除法，取余数:n.__mod__(3) : 2
判断是否大于等于：n.__ge__(-4) : True
判断是否大于：n.__gt__(-4) : False
判断是否小于等于:n.__le__(-3) : True
判断是否小于：n.__lt__(-4) : False
取反运算：n.__neg__() : 4
返回X的Y次方的值：n.__pow__(2) : 16
返回二进制的最小长度：bin(n) : -0b100
bool (布尔)
在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：
print(True);
print(False);
print(1>2);
print(1<2);
print(True+10);
print(False+10);
print(True==1);
print(True==2);
print(False==1);
print(True==0);
print("========================================================")
print("True and True: ",True and True);
print("True and False: ",True and False);
print("False and False: ",False and False);
print("5 > 3 and 3 > 1: ",5 > 3 and 3 > 1);
print("========================================================")
print("True or True: ",True or True);
print("True or False: ",True or False);
print("False or False: ",False or False);
print("5 > 3 or 3 > 1: ",5 > 3 or 3 > 1);
print("========================================================")
print("not True: ",not True);
print("not False: ",not False);
print("not 1 > 2: ",not 1 > 2);
print("========================================================")
输出结果
True
False
False
True
11
10
True
False
False
False
========================================================
True and True: True
True and False: False
False and False: False
5 > 3 and 3 > 1: True
========================================================
True or True: True
True or False: True
False or False: False
5 > 3 or 3 > 1: True
========================================================
not True: False
not False: True
not 1 > 2: True
========================================================
float (浮点数)
浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250），如 1.23、3E-2
complex (复数)
复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。 如 1 + 2j、 1.1 + 2.2j
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
注意：
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法（/）总是返回一个浮点数，要获取整数使用 // 操作符。
4、在混合计算时，Python会把整型转换成为浮点数。
字符串(String)
- python中单引号和双引号使用完全相同。
- 使用三引号('''或""")可以指定一个多行字符串。
- 转义符 ''
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
- 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
- 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- Python中的字符串不能改变。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：变量[头下标:尾下标]
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
实例
#!/usr/bin/python3
str='Test'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始的后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nTest') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nTest') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
输出结果为：
Test
Tes
T
st
st
TestTest
Test你好
------------------------------
hello
Test
hello\nTest
注意
- Python 没有单独的字符类型，一个字符就是长度为1的字符串。
- Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
- 字符串可以用+运算符连接在一起，用*运算符重复。
- Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
- Python中的字符串不能改变。
列表（List）
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号([])之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
list = ['abcd3R', 123, 3.21, 'EDADW', 123212.33,complex(1,-1)]
tinylist = [123, 'bill']
print("输出完整列表",list) # 输出完整列表
print("输出列表第一个元素",list[0]) # 输出列表第一个元素
print("从第二个开始输出到第三个元素",list[1:3]) # 从第二个开始输出到第三个元素
print("输出从第三个元素开始的所有元素",list[2:]) # 输出从第三个元素开始的所有元素
print("输出两次列表",tinylist * 2) # 输出两次列表
print("连接列表",list + tinylist) # 连接列表
输出结果：
输出完整列表 ['abcd3R', 123, 3.21, 'EDADW', 123212.33, (1-1j)]
输出列表第一个元素 abcd3R
从第二个开始输出到第三个元素 [123, 3.21]
输出从第三个元素开始的所有元素 [3.21, 'EDADW', 123212.33, (1-1j)]
输出两次列表 [123, 'bill', 123, 'bill']
连接列表 ['abcd3R', 123, 3.21, 'EDADW', 123212.33, (1-1j), 123, 'bill']
与Python字符串不一样的是，列表中的元素是可以改变的：
a=[1,2,3,4,5,6,7,8]
print(a)
a[1]="a"
a[3:6]=["v","b","n","x","d"] #将3到6的位置替换成后面的数组
print(a)
print(a[3])
输出结果
···
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 'a', 3, 'v', 'b', 'n', 'x', 'd', 7, 8]
v
···
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。
tuple = ( 'abcd', 786 , 2.23, 'test', 70.2 )
tinytuple = (123, 'test')
print ("输出完整元组 ",tuple) # 输出完整元组
print ("输出元组的第一个元素 ",tuple[0]) # 输出元组的第一个元素
print ("输出从第二个元素开始到第三个元素 ",tuple[1:3]) # 输出从第二个元素开始到第三个元素
print ("输出从第三个元素开始的所有元素 ",tuple[2:]) # 输出从第三个元素开始的所有元素
print ("输出两次元组 ",tinytuple * 2) # 输出两次元组
print ("连接元组 ",tuple + tinytuple) # 连接元组
输出结果
输出完整元组 ('abcd', 786, 2.23, 'test', 70.2)
输出元组的第一个元素 abcd
输出从第二个元素开始到第三个元素 (786, 2.23)
输出从第三个元素开始的所有元素 (2.23, 'test', 70.2)
输出两次元组 (123, 'test', 123, 'test')
连接元组 ('abcd', 786, 2.23, 'test', 70.2, 123, 'test')
- 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
- 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
print(tup1)
print(tup2)
输出结果
()
(20,)
注意
- string、list和tuple都属于sequence（序列）。
- 与字符串一样，元组的元素不能修改。
- 元组也可以被索引和切片，方法一样。
- 注意构造包含0或1个元素的元组的特殊语法规则。
- 元组也可以使用+操作符进行拼接。
集合（Set）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：parame = {value01,value02,...} 或者 set(value)
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("set可以进行集合运算 :",a,b)
print("a和b的差集 :",a - b) # a和b的差集
print("a和b的并集 :",a | b) # a和b的并集
print("a和b的交集 :",a & b) # a和b的交集
print("a和b中不同时存在的元素:",a ^ b) # a和b中不同时存在的元素
输出结果：
{'Tom', 'Jim', 'Jack', 'Rose', 'Mary'}
Rose 在集合中
set可以进行集合运算 : {'r', 'c', 'd', 'a', 'b'} {'z', 'l', 'c', 'a', 'm'}
a和b的差集 : {'d', 'b', 'r'}
a和b的并集 : {'z', 'r', 'c', 'l', 'd', 'a', 'm', 'b'}
a和b的交集 : {'c', 'a'}
a和b中不同时存在的元素: {'r', 'z', 'm', 'l', 'd', 'b'}
字典（Dictionary）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
基本代码：
#创建方式
dict0 = {'Alice': 2341, 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
dict = {}
dict['one'] = "bill"
dict[2] = "china"
print(dict)
print(dict0)
print(dict1)
print(dict2)
tinydict = {'name': 'bill', 'code': 1, 'site': 'www.baidu.com'}
print("输出键为 'one' 的值 ",dict['one']) # 输出键为 'one' 的值
print("输出键为 2 的值 ",dict[2]) # 输出键为 2 的值
print("输出完整的字典 ",tinydict) # 输出完整的字典
print("输出所有键 ",tinydict.keys()) # 输出所有键
print("输出所有值 ",tinydict.values()) # 输出所有值
print("========================================================")
dict = {'Name': 'Test', 'Age': 7, 'Class': 'First'}
# 修改信息
dict['Age'] = 8; # 更新 Age
dict['School'] = "Test" # 添加信息
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
dict = {'Name': 'BIll', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])
输出结果（异常会在前面抛出来）
Traceback (most recent call last):
File "E:/PythonProject/HelloWorld/Test.py", line 37, in <module>
print("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
{'one': 'bill', 2: 'china'}
{'Alice': 2341, 'Beth': '9102', 'Cecil': '3258'}
{'abc': 456}
{'abc': 123, 98.6: 37}
输出键为 'one' 的值 bill
输出键为 2 的值 china
输出完整的字典 {'name': 'bill', 'code': 1, 'site': 'www.baidu.com'}
输出所有键 dict_keys(['name', 'code', 'site'])
输出所有值 dict_values(['bill', 1, 'www.baidu.com'])
========================================================
dict['Age']: 8
dict['School']: Test
