Python2.x是历史，Python3.x是这门语言的现在和未来。Python2和3大约90%的地方都很相似的。
1、注释
单行注释：在注释的前面输入#号，如下：
# 这是一条注释
多行注释：使用三个单引号或者三个双引号来添加多行注释：
'''
这是一条注释
还可以再加一条注释
'''
2、变量
变量是我们需要存储和操作数据的名字，定义一个新变量之后，需要给它赋一个初始的值。在后续的程序中还是可以修改这个值
userAge, userName = 30, 'Peter'
#等同于以下
userAge = 30
userName = 'Peter'
2.1 变量命名
1）变量名仅可以包含字母(a-z,A-Z)，数字或者下划线(_)
2）第一个字符不能是数字
3）大小写敏感
4）不能使用Python中预留的词语
5）命名规则：
驼峰式：单词组合在一起，并且混合大小写，一般是每个单词的第一个字母都是大写，其他小写，例如userAge。一般采用的方式。
下划线(_)：利用下划线将每个单词分开，例如user_age。
2.2 赋值符号(=)
在程序中，x = y 和 y = x 有着不同的含义
x = 5
y = 10
x = y
print("x = ", x) # output：10
print("y = ", y) # output：10 x = 5
y = 10
y = x
print("x = ", x) # output：5
print("y = ", y) # output：5
2.3 基本操作符
基本操作符：+、—、*、/、//、%和**
分别表示：加、减、乘、除、整除、取余和指数
x = 5
y = 2 # 加法
x + y # # 减法
x - y # #乘法
x * y # # 除法
x / y # 2.5 # 整除（向最近的整数向下取整）
x // y # # 取余（余数）
x % y # 1(当5除以2时得到的余数) # 指数
x ** y # 25 (5的2次方)
2.4 更多操作符
表示自增、自减和自乘，如+=、-=和*=这样的操作符。x = x + 2可以写成有相同含义的x += 2。
3、Python中的数据类型
基本的类型有整数、浮点数和字符串，以及这些类型之间的转化。
高级的数据类型有列表、元组和字典。
3.1 整型
没有小数部分的数字，比如-5，0，5，7等。
userAge = 10
3.2 浮点型
带有小数点部分的数字，比如1.234等。
userHeight = 1.82
3.3 字符串
表示文本，可以使用单引号或者双引号来声明。可以使用连接符号(+)来连接多个字符号，比如'Peter' + 'Lee'等于字符串'PeterLee'。
userName = 'Peter'
3.3.1 内嵌的字符串函数（大小写敏感）
1、upper()，将字符串中每个字符都变成大写。比如，'Peter'.upper()得到'PETER'。
2、lower()：将字符串变为小写。
3、count(sub, [start, [end]])，返回子字符串sub在字符串中出现的次数。[start, [end]]表示的是开始和结束是可选择的参数。
>>> 'This is a string'.count('s') # 计算's'在字符串中出现的次数
3
>>> 'This is a string'.count('s', 4) # 计算从索引4到字符串的结尾
2
4、endswith(suffix, [start, [end]])，如果字符串以指定的后缀suffix结尾，就返回True。
>>> 'Postman'.endswith('man') # 检查整个字符串
True
>>> 'Postman'.endswith('man',2, 6) # 检查索引2到6-1的位置
False
>>> 'Postman'.endswith(('man','ma'), 2, 6) # 使用一个后缀的元组（从索引2到6-1的位置检索）
True
5、startswith(prefix[, start[, end]])：如果字符串以前缀prefix开始，则返回True，否则False。
>>> 'Postman'.startswith('Post')
True
>>> 'Postman'.startswith('Post', 3)
False
6、find/index(sub, [start, [end]])，返回字符串中子字符串sub首次出现的索引位置。
find()在无法找到sub是返回-1；index()在无法找到sub时返回ValueError。
>>> 'This is a string'.find('s')
3
>>> 'This is a string'.index('s')
3
>>> 'This is a string'.find('p')
-1
>>> 'This is a string'.index('p')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
7、isalnum()：判断字符串是否都是字母和数字。
8、isalpha()：判断字符串是否都是字母。
9、isdigit()：判断字符串是否都是数字。
10、islower()：判断字符串是否都是小写
11、isspace()：判断字符串是否都是空格
12、istitle()：判断字符串是否都是首字母大写。
13、isupper()：判断字符串是否都是大写。
14、join()：使用分隔符号把提供的参数连接成一个字符串并返回。
>>> sep='-'
>>> myTuple = ('a', 'b', 'c')
>>> myList = ['d', 'e', 'f']
>>> sep.join(myTuple)
'a-b-c'
>>> sep.join(myList)
'd-e-f'
15、replace(old, new[, count])：将字符串中所有的old字符串替换为new字符串，仅仅替换前面count次数出现的字符串会被替换。
>>> 'This is a string'.replace('s', 'p')
'Thip ip a ptring'
>>> 'This is a string'.replace('s', 'p', 2)
'Thip ip a string'
16、split([sep[, maxsplit]])：使用sep作为分隔符，返回一个单词的列表。若sep没有指定，则分隔符默认为空格（包括空字符、\n、\t等），如果指定maxsplit，则最多会做maxsplit次分割。
>>> s = "I am, writing\npython\tbook on line"
>>> print(s)
I am, writing
python book on line
>>> s.split()
['I', 'am,', 'writing', 'python', 'book', 'on', 'line']
17、splitlines([keepends])：返回字符串所有行的列表，以每行的边界符来分隔。
18、strip([chars])：移除字符串首尾位置char。如果没有指定char，则移除空格。另外还有lstrip()移除左边的字符，rstrip()移除右边的字符。
3.3.2 使用%操作符格式化字符串
该语法包含三部分：首先是要格式化的字符串，包含占位符%s,%f,%d等；其次是%；最后是字符串的变量，使用小括号包含多个值（元组）
brand = 'Apple'
exchangeRate = 1.23241
message = 'The price of this %s laptop is %d USD and the exchange \
rate is %4.2f USD to 1 ESR' % (brand, 1299, exchangeRate) print(message)
# The price of this Apple laptop is 1299 USD and the exchange rate is 1.23 USD to 1 ESR
%s表示字符串；
%d表示一个整数，%5d表示字符串长度为5的数字，如"%5d" % (123)将显示" 123"；
%f浮点数，%4.2f表示总长度为4位，2表示2个小数位。
3.3.3 使用format()方法格式化字符串
使用大括号{}作为占位符，在{}内首先写下使用的参数的位置（第几个参数），然后加上冒号，后面跟着格式化符号，在大括号内不应该有任何的空格。
message = 'THe price of this {0:s} laptop is {1:d} USD and \
the exchange rate is {2:4.2f} USD to 1 EUR'.format('Apple',1299,1.234552 )
print(message)
# THe price of this Apple laptop is 1299 USD and the exchange rate is 1.23 USD to 1 EUR
{0:s}是表示用位置为0的变量来替换，它是字符串格式；{1:d}是用第二个变量替换，它是一个整数类型。
{2:4.2f}表示位置2的变量，是一个浮点类型，总长度为4，其中有两位小数点(格式为4.2f)。
如果不想格式化字符串，大括号里面可以为空，解释器会根据大括号内所提供的变量顺序来替换。
3.4 Python中的类型转换
在Python中有三个内建的函数可以进行类型转换，分别是int()、float()、str()。
int()：将一个浮点型或者字符串转换为整形，如int(5.75343)、int("4")，但不能是int('hello')、int('4.223')等
float()：接收整型或者字符串并转换为浮点型。
str()：将整型或者浮点型转换为字符串。
3.5 列表
表示相关数据的集合，listName = [initial values] ，列表声明是使用中括号[]。
userAge = [21, 23, 24, 27, 25]
1、若不使用任何初始值来声明一个列表，仅需要写listName = []。
2、append()往列表的结尾添加元素。
3、使用索引来访问列表的某个值，索引从0开始，最后一个元素从-1开始。例如userAge[0] = 21。
4、切片如2:4，指的是索引从2到4-1的切片，userAge[2:4] = [24, 27]
5、切片的第三个数字表示步长，userAge[1:5:2] = [23, 27]
6、修改列表，userAge[1] = 5, 列表就会变为userAge = [21, 5, 24, 27, 25]
7、删除， del userAge[2]，列表就会变成userAge = [21, 5, 27, 25]，第三个元素被删除了。
8、extent()连接两个列表，将两个列表的元素拼成一个列表。与append()不同，append会把第二个列表当成一个列表元素加到第一个列表中。
>>> myList = ['a', 'b', 'c']
>>> myList1 = [1, 2, 3]
>>> myList.extend(myList1)
>>> print(myList)
['a', 'b', 'c', 1, 2, 3]
>>> myList2 = ['a', 'b', 'c']
>>> myList2.append(myList1)
>>> print(myList2)
['a', 'b', 'c', [1, 2, 3]]
9、in：检查列表中是否存在某个元素，例如'c' in myList。
10、insert()：在列表中的特定位置添加元素。例如myList.insert(1, 'Hi')，在索引位置1的地方添加字符串'Hi'。
11、len()：得到列表中元素的个数。
12、pop()：得到列表中的一个元素，并把他删除，需要索引位置作为参数，默认为最后一个位置。
13、remove()：从列表中移除一个元素。myList.remove('c')从列表中移除'c'元素
14、reverse()：逆序
15、sort()：以字母顺序或者数字顺序来排列
16、sorted()：返回一个新的排序后的列表，而不排序原来的列表。
17、'+'连接列表。不会修改原列表。
18、'*'复制列表。不会修改原列表。
3.6 元组
元组和列表很像，但是元组的值无法修改。使用圆括号()来声明，tupleName = (初始值)。它的初始值在后面的程序中将保持不变。
例如保持一年中各月份的名字：
monthOfYear = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
其索引访问和列表一样。
1、del myTuple：删除整个元组
2、in:检查是否存在某个元素
3、len()：元组的长度
4、'+'和'*'：连接和复制元组，并不会修改元组。
3.7 字典
字典是相关数据对的一个集合，字典的关键字必须是唯一的，可以按照如下声明:dictionaryName = {key:data}，也可以使用dict()函数定义。
>>> userNameAndAge = {"Peter":38, "John":51,
... "Alex":13, "Alvin":"Not Available"}
>>> userNameAndAge
{'Peter': 38, 'John': 51, 'Alex': 13, 'Alvin': 'Not Available'}
>>> userNameAndAge1 = dict(Peter = 38, John = 51,
... Alex = 13, Alvin = "Not Available")
>>> userNameAndAge1
{'Peter': 38, 'John': 51, 'Alex': 13, 'Alvin': 'Not Available'}
1、声明一个空字段，dictionaryName={}。
2、添加元素，dictionaryName[dictionary key]=data。
3、删除元素，del dictionaryName[dictionayr key]。
>>> #声明字段，字段的关键字和值可以是不同的数据类型
>>> myDict = {"One":1.35, 2.5:"Two Point Five", 3:"+", 7.9:2}
>>> #打印整个字典，字典的元素的顺序与声明的顺序是不一样的
>>> #打印关键字为"One"的元素
>>> print(myDict["One"])
1.35
>>> #修改关键字2.5的元素
>>> myDict[2.5] = "Two and a Half"
>>> print(myDict)
{'One': 1.35, 2.5: 'Two and a Half', 3: '+', 7.9: 2}
>>> #添加新的元素
>>> myDict["New item"] = "I'm new"
>>> print(myDict)
{'One': 1.35, 2.5: 'Two and a Half', 3: '+', 7.9: 2, 'New item': "I'm new"}
>>> #删除关键字是"One"的元素
>>> del myDict["One"]
>>> print(myDict)
{2.5: 'Two and a Half', 3: '+', 7.9: 2, 'New item': "I'm new"}
4、clear()：移除字典中的所有元素，并返回一个空的字典。
>>> dic1 = {1:'one', 2:'two'}
>>> dic1
{1: 'one', 2: 'two'}
>>> dic1.clear()
>>> dic1
{}
5、del：删除整个字典。
>>> del dic1
>>> print(dic1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'dic1' is not defined
6、get()：返回给定关键字的值，如果没有找到关键字，则返回None，或者指定返回的值。
>>> dic1 = {1:'one', 2:'two'}
>>> dic1.get(1)
'one'
>>> dic1.get(5)
>>> dic1.get(5, "Not Found")
'Not Found'
7、in：检查字典中是否存在一个元素。
>>> dic1 = {1:'one', 2:'two'}
>>> # 基于关键字
>>> 1 in dic1
True
>>> 3 in dic1
False
>>> # 基于值
>>> 'one' in dic1.values()
True
>>> 'three' in dic1.values()
False
8、items()：以元组的形式返回字典对的列表
>>> dic1 = {1:'one', 2:'two'}
>>> dic1.items()
dict_items([(1, 'one'), (2, 'two')])
9、keys()：返回字典关键字的列表。
>>> dic1.keys()
dict_keys([1, 2])
10、len()：得到字典中元素的总数，如len(dic1)。
11、update()：将一个字典中的关键字-值对添加到另一个字典中，重复的将会被移除。
>>> dic1 = {1:'one', 2:'two'}
>>> dic2 = {1:'one', 3:'three'}
>>> dic1.update(dic2)
>>> print(dic1)
{1: 'one', 2: 'two', 3: 'three'}
>>> print(dic2) # 没有变化
{1: 'one', 3: 'three'}
12、values()：返回字典中值的列表。
>>> dic1 = {1:'one', 2:'two'}
>>> dic1.values()
dict_values(['one', 'two'])
4、程序可交互
1 input()
使用input()在屏幕上显示提示信息，并提示用户输入相关的信息。
>>> myName = input("Please enter your name:")
Please enter your name:Lily
>>> print(myName)
Lily
2 print()
print()函数用于给用户展示信息，可以传入格式化的字符串%和format()两种形式。
3 转义符号"\"
碰到一些特殊的字符而无法打印，比如制表符或者新行等，可以使用"\"来转义字符，如制表符"\t"，换行符"\n"，如果没有斜杠，则会打印出字母t和n。
5、条件语句
5.1 条件语句
常用的比较符：==、!=、<、>、<=、>=。
逻辑运算符：and、or、not。
5.2 if语句
if conditon 1 is met:
do A
elif condition 2 is met:
do B
else:
do C
5.3 内联if
if语句的一种更简单的形式：
do Task A if conditon is true else do Task B
>>> myInt = 10
>>> num1 = 12 if myInt == 10 else 13
>>> print(num1)
12
5.4 for循环
for a in iterable:
print(a)
也可以列出成员的索引值，可以使用enumerate()函数。
for index, myPets in enumerate():
print(index, myPets)
5.5 range()
在一段数字上循环：range(start, end,step)，如果没有start，则以0开始。step没有指定的话，则step=1。
比如range(5)将会发生列表[1, 2, 3, 4, 5]；range(4, 10, 2)会生成列表[4, 6, 8]。
5.6 while循环
如果条件为真的话，则一直循环。
while condition is true:
do A
5.7 break中断
当循环满足某个条件，则使用break退出循环。
>>> j = 0
>>> for i in range(5):
... j = j + 2
... print('i = ', i, 'j = ', j)
... if j == 6:
... break
...
i = 0 j = 2
i = 1 j = 4
i = 2 j = 6
5.8 continue
当满足条件时，continue之后的语句都不会执行，会继续下一个循环。
>>> j = 0
>>> for i in range(5):
... j = j + 2
... print('i = ', i, ', j = ', j)
... if j == 6:
... continue
... print('I will be skipped over if j = 6')
...
i = 0 , j = 2
I will be skipped over if j = 6
i = 1 , j = 4
I will be skipped over if j = 6
i = 2 , j = 6
i = 3 , j = 8
I will be skipped over if j = 6
i = 4 , j = 10
I will be skipped over if j = 6
当j=6时，continue关键字后的那一行将不会打印。
5.9 Try，Except
在错误发生时，可以控制程序执行的方式。
try:
do somethind
except:
when an error occurs
可以在except关键字后制定错误的类型。
IOError：IO相关的原因失败
ImportError：寻找模块失败时
IndexError：索引超出范围
KeyError：无法找到关键字
NameError：无法找到局部或者全局的变量
TypeError：类型不匹配
6、函数和模块
6.1 函数定义
def functionName(parameters):
code detailing
return [expression]
关键字def和return。一个函数中可以有不止一个return，但是一旦执行了return函数就结束了。可以写return或者return None。
下例是一个判断是否有素数：
>>> def checkIfPrime(numberToCheck):
... for x in range(2, numberToCheck):
... if (numberToCheck % x == 0):
... return False
... return True
...
>>> checkIfPrime(13)
True
6.2 变量作用域
局部变量：在函数内定义且只能在函数内访问。
全局变量：在函数外定义且可以在程序中的任何位置访问。
6.3 模块
1、引入模块
import modulename：把整个模块都引入到程序中。例如import random as r
from modulename import name1[, name2[, ...nameN]]，例如fjrom random import randrange.
2、创建模块
把文件以.py的扩展名保存，并放在想要引入的同一个文件夹里面。比如将以下的代码保存为prime.py
def checkIfPrime(numberToCheck):
for x in range(2, numberToCheck):
if (numberToCheck % x == 0):
return False
return True
然后在python的终端中输入以下的代码，就可以调用prime.py模块了
>>> import prime
>>> answer = prime.checkIfPrime(13)
>>> print(answer)
True
7、处理文件
7.1 打开文件
open()函数为打开文件，它需要两个参数，第一个是文件的路径，第二个是模式。
目前的模式有：
1、r模式：只读
2、w模式：只写。若文件不存在，则创建；若文件存在，则已有的内容会被删除
3、a模式：添加。若文件不存在，则创建；若文件存在，则写入的内容会追加到文件末尾。
4、r+模式：读写。
5、rb模式和wb模式：用于处理二进制文件（包含非文字的文件），比如图形或者视频等。
7.2 读文件
>>> f = open('prime.py', 'r')
>>> firstline = f.readline()
>>> secondline = f.readline()
>>> print(firstline)
def checkIfPrime(numberToCheck):
>>> print(secondline)
for x in range(2, numberToCheck):
>>> f.close()
每次调用readline()函数，它都会从文件中读取一行，调用了两次，则会读取两行。
使用for循环读取文本文件：
f = open('file.txt', 'r')
for line in f:
pirnt(line, end = '')
7.3 写入文件
f = open('file.txt', 'a')
f.write('\nThis sentence will be appended.')
f.close()
7.4 通过缓冲大小打开并读取文件
通过缓冲大小来读取文件，这样程序就不用使用太多的内存资源。
inputFile = open('myfile.txt', 'r')
outputFile = open('outputfile.txt', 'w')
msg = inputFile.read(10)
while len(msg): # 只要长度不为0，循环就会继续。直到读完文件。
outputFile.write(msg)
msg = inputFile.read(10) # 写入之后，继续读入下10位的数据
inputFile.close()
outputFile.close()
7.5 删除和重命名文件
remove()：删除一个文件，例如remove('myfile.txt')。
rename()：重命名一个文件，rename('oldfile.txt', 'newfile.txt')
参考：
1、《爱上Python--一日精通Python编程》，Jamie Chan ，新加坡