python基础语法
一、标识符
在Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
在Python中的标识符是区分大小写的。
在Python中以下划线开头的标识符是有特殊意义的。
1.以单下划线开头_foo的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import *而导入。
2.以双下划线开头的__foo代表类的私有成员；
3.以双下划线开头和结尾的__foo__代表Python里特殊方法专用的标识，如__init__()代表类的构造函数。
代码示例：
class person:
name = ""
age = 0
_gender = ""
__father = ""
def __init__(self, name, age):
self.name = name
self.age = age
print "初始化"
二、保留字
Python中有31个保留字，这些保留字不能用作常数或者变数，或者任何其他标识符名称。所有Python的关键字只包含小写字母。
序号
保留字
说明
1
and
用于表达式运算，逻辑与操作。
2
as
用于类型转换。
3
assert
断言，用于判断变量或条件表达式的值是否为真。
4
break
中断循环语句的执行。
5
class
用于定义类。
6
continue
继续执行下一次循环。
7
def
用于定义函数或方法。
8
del
删除变量或序列的值。
9
elif
条件语句，与if、else结合使用。
10
esle
条件语句，与if、elif结合使用。也可用于异常和循环语句。
11
except
包含捕获异常后的操作代码块，与try、finally结合使用。
12
exec
用于执行Python语句。
13
for
for循环语句。
14
finally
用于异常语句，出现异常后，始终要执行finally包含的代码块。
15
from
用于导入模块，与import结合使用。
16
global
定义全局变量。
17
if
条件语句，与else、elif结合使用。
18
import
用于导入模块，与from结合使用。
19
in
判断变量是否存在序列中。
20
is
判断变量是否为某个类的实例。
21
lambda
定义匿名函数。
22
not
用于表达式运算，逻辑与操作。
23
or
用于表达式运算，逻辑或操作。
24
pass
空的类，函数，方法的占位符。
25
print
打印语句。
26
raise
异常抛出操作。
27
return
用于从函数返回计算结果。
28
try
包含可能会出现异常的语句，与except，finally结合使用。
29
while
循环语句。
30
with
简化Python语句。
31
yield
用于从函数依次返回值。
32
保留字
说明
三、代码规范
1、PEP8
为了写出优雅的代码，Python中经常使用PEP8规范，规定如下：
1.缩进与换行，每级缩进使用4个空格。
2.限制所有行的最大长度为79个字符。
3.空行
(1)顶层函数和类之间使用两个空行。
(2)类的方法之间使用一个空行。
(3)在函数中使用空行来表示不同的逻辑段落。
4.导入通常应当使用单独的行。
(1)导入总是位于文件的顶部，在模块注释和文档字符串之后，在模块的全局变量与常量之前。
(2)导入按照以下顺序分组：
standard library imports 标准库导入
related third party imports 相关第三方导入
local application/library specific imports 本地应用程序/库的特定导入
每组导入之间使用空行隔开。
5.下面的情况，避免多余空格。
(1)紧贴着圆括号、方括号和花括号。
(2)紧贴在逗号、分号或冒号之前。
(3)紧贴在函数调用的参数列表的圆括号的开括号前。
(4)紧贴在索引或切片的方括号的开括号前。
(5)在赋值语句的运算符周围，不要为了对齐而使用多个空格。
2、语句
1.在Python中，一行为一条语句，不需要分号标识。
2.在Python中，可以同一行显示多条语句，只需用分号“;”隔开即可。
3.在Python中，可以使用反斜杠(\)将一行语句分为多行解释。但是语句包含的{}、[]、()中的内容不需要使用多行连接符。
代码示例：
print "hello";print "world"
item_one = 3
item_tow = 4
item_three = 5
total = item_one + \
item_tow + \
item_three
print total
hello
world
12
3、缩进
Python中使用缩进来表示作用范围，所以Python中缩进格式要严格遵循结构。
代码示例：
num = 2 + 3 + 4
if num > 5:
print "大于"
else:
print "小于"
大于
4、注释
1.使用#作为单行注释。
2.使用三个单引号或者三个双引号作为多行注释。
代码如下：
# 这是单行注释
'''这是单引号多行注释'''
"""这是双引号多行注释"""
四、变量
1、声明变量
1.Python中的变量/常量不需要声明符直接写即可。
2.Python中的变量/常量不区分类型。同一个变量可以被多次赋值为不同类型的值。
3.Python中的变量通常用小写表示。
4.Python中的常量通常用大写表示。
Python中的常量并不会受到保护，如果真的改是不会报错的，所以可以认为Python中并不真正存在语言意义上的常量，而是约定通过大写的变量标明它是一个常量，后续不要修改。
代码示例：
x = "abc"
print "x is {}".format(x)
x = 123
print "x is {}".format(x)
x = y = z = 999
print "x is {},y is {}, z is {}".format(x, y, z)
x, y, z = 1, 2, 'a'
print "x is {},y is {}, z is {}".format(x, y, z)
x is abc
x is 123
x is 999,y is 999, z is 999
x is 1,y is 2, z is a
format()函数配合花括号{}使用，可以起到占位符的作用。
Python中变量互换值不像其他语言那样需要三方变量，这里使用了一种语法糖。
代码示例：
a = "x"
b = "y"
a, b = b, a
print "a is {}, b is {}".format(a, b)
a is y, b is x
2、作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。
两种最基本的变量作用域如下：全局变量、局部变量。
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
五、数据类型
虽然Python中的引用没有数据类型，但是Python是有数据类型的概念的。
Python中有5大标准数据类型，分别是：Number(数字)、String(字符串)、List(列表)、Tuple(元祖)、Dictionary(字典)。
这里介绍的内容如下：
Number
String
布尔类型
空值
这里有几个函数，在判断类型和内存的时候会用到：
id(obj)：查看对象的内存地址。
type(obj)：查看对象的类型。
1、Number(数字)
Python Number 数据类型用于存储数值。
Number数据类型是不允许改变的，这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
Python支持四种不同的Number类型：
1.整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
2.长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
3.浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 10^2 = 250)
4.复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
代码示例：
x = 1 #整型
x = 2L #长整型
x = 3.1415 #浮点型
#复数
x = complex(32, 64)
print x
x = 32 + 64j
print x
(32+64j)
(32+64j)
2、String(字符串)
Python中可以用单引号、双引号、三引号来声明字符串直接量。
在声明字符串直接量时单引号和双引号没什么区别。'abc'和"abc"等价。
而三引号声明的字符串中可以包含任意字符，这些字符会被直接当作字符串的内容。
Python中并不存在类似java中char的字符类型，想要表示一个字符，写成一个长度为1的字符串即可。
Python中字符串是有下标的，下标从0开始。Python中String类型是不可变类型的对象。
Python中len()函数可以查看字符串的长度。
代码示例：
x = 'abc'
print id(x)
x = "abc"
print id(x)
x = '''abc'''
print len(x)
print id(x)
x = """abc"""
print id(x)
x = "b"
print id(x)
41772656
41772656
3
41772656
41772656
39430944
由上述代码可以看出，四种引号声明的对象是一样的效果。String对象是不可变的。
1.转义字符
Python中使用反斜杠(\)作为转义字符
转义字符
说明
\
续行符
\
反斜杠符号
'
单引号
"
双引号
\a
响铃
\b
退格
\e
转义
\000
空格
\n
换行
\v
纵向制表符
\t
横向制表符
\r
回车
\f
换页
\oyy
八进制数，yy代表的字符。例如：\o12代表换行
\xyy
十六进制数，yy代表的字符。例如：\x0a代表换行
\other
其他的字符以普通格式输出。
2.字符串操作符
+：字符串连接。
*：重复输出字符串
[index]：通过索引获取字符串中的字符。此方法只能用于获取，不能用于更改字符串的某个字符。
[indexbegin:indexend:step]：截取字符串中的一部分。setp不写默认为1。indexbegin不写默认为0。indexend不写，默认为字符串的长度。
in：成员运算符。如果字符串中包含指定的字符，返回True。否则返回False。
not in：成员运算符。如果字符串中不包含指定字符，返回True。否则返回False。
r/R：原始字符串。所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"(可以大小写)以外，与普通字符串有着几乎完全相同的语法。
代码示例：
a = "Hello"
b = "Workd"
print a + b
print a * 2
print a[1]
print a[-2]
print a[1:3]
print a[0:4:2]
print a[:2]
print a[::-1] #反转字符串
print "H" in a
print "H" not in b
print r'\n',R'\n'
HelloWorkd
HelloHello
e
l
el
Hl
He
olleH
True
True
\n \n
3.格式化字符串
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
代码示例：
print "My name is %s and age is %d !" % ("xh", 25)
My name is xh and age is 25 !
格式化符号：
格式化符号
说明
%c
格式化字符以及ASCII码
%s
格式化字符串
%d
格式化整数
%u
格式化无符号整数
%o
格式化无符号八进制数
%x
格式化无符号十六进制数
%X
格式化无符号十六进制数(大写)
%f
格式化浮点数字，可指定小数点后的精度。
%e
用科学计数法格式化浮点小数
%E
用科学计数法格式化浮点数，同%e的作用。
%g
%f和%e的简写
%G
%f和%E的简写
%p
用十六进制数格式化变量的地址
辅助指令：
符号
说明
*
定义宽度或者小数点精度
-
用作左对齐
+
在正数前面显示加号
在正数前面显示空格
#
在八进制数前面显示零，在十六进制前面显示0x或者0X
0
显示的数字前面填充0而不是默认的空格
%
%% 输出一个单一的%
(var)
映射变量
m.n
m是显示的最小总宽度，n是小数点后的位数
4.三引号
python中三引号可以将复杂的字符串进行复制：
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号(通常都是成对的用)。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。
5.字符串函数
Python中提供了很多操作字符串的函数，这些函数是字符串的使用更加便捷。以下将介绍常见的字符串操作：
string = "My name is xinghan, I am very happy!"
# 将起始字符大写，其他字符一律小写
string.capitalize()
'My name is xinghan, i am very happy!'
# 将字符串按照指定宽度居中显示，默认两端填补空格，也可以指定符号填补。
string.center(100)
string.center(100,"%")
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%My name is xinghan, I am very happy!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'
# 计数函数，用于统计一个字符串中出现的指定字符的个数。
string.count('a')
4
# 判断字符串以指定字符结尾
string.endswith('ppy!')
True
# 判断字符串是否以指定字符开始
string.startswith('My')
True
# 查找字符，找到返回下标，不存在返回-1。支持指定查找开始位置。
string.find('i')
string.find('i', 9)
12
# 查找字符，找到返回下标，不存在将报错。支持指定查找开始位置。
string.index('i', 9)
12
# 大小写转换
string.upper() #转成大写
string.lower() #转成小写
'my name is xinghan, i am very happy!'
# 标题判断，如果一个字符串中，首字母大写，其他字母全部小写，则判定为标题
string.istitle()
False
# 判断大小写
string.isupper()
string.islower()
False
# 去空,将字符串两端包含的空格，换行等空白去掉。不会去除中间的。
string.strip()
# 仅去除左边的空格
string.lstrip()
# 仅去除右边的空格
string.rstrip()
'My name is xinghan, I am very happy!'
# 将字符串中的大小写互换。
string.swapcase()
'mY NAME IS XINGHAN, i AM VERY HAPPY!'
3、boolen(布尔)
直接量只有两个True、False。
布尔类型的与或非and、or、not。
Python中指定任何非0和非空(null)值为true，0 或者 null为false。
代码示例：
flg1 = True
flg2 = False
print not flg1
print flg1 and flg2
print flg1 or flg2
False
False
True
4、空值
Python中的空值，不使用null，而是使用None来表示。
5、类型转换
Python中各个数据类型是可以互相转换的，转换方法如下：
index(x[,base])：将x转换为一个整型。
long(x[,base])：将x转换为一个长整型。
float(x)：将x转换为一个浮点数。
complex(real[,imag])：创建一个复数。
str(x)：将对象x转换为字符串。
repr(x)：将对象x转换为表达式字符串。
eval（str)：用来计算在字符串中的有效Python表达式，并返回一个对象。
tuple(s)：将序列s转换为一个元组。
list(s)：将序列s转换为一个列表。
chr(x)：将一个整数转换为一个字符。
unichr(x)：将一个整数转换为Unicode字符。
ord(x)：将一个字符转换为它的整数值。
hex(x)：将一个整数转换为一个十六进制字符串。
oct(x)：将一个整数转换为一个八进制字符串。
六、运算符
Python中有7种运算符，分别是：
算术运算符
比较运算符
赋值运算符
位运算符
逻辑运算符
成员运算符
身份运算符
1、算术运算符
算术运算符有以下几种：
+加：两个对象相加。例如：a + b输出结果30。
-减：得到负数或是一个数减去另一个数。例如：a - b输出结果-10。
*乘：两个数相乘或是返回一个被重复若干次的字符串。例如：a * b输出结果200。
/除：x除以y。例如：b / a输出结果2。
%取模：返回除法的余数。例如：b % a输出结果0。
**幂：返回x的y次幂。例如：a**b为10的20次方，输出结果100000000000000000000。
//取整除：返回商的整数部分。例如：9//2输出结果4，9.0//2.0输出结果4.0。
代码示例：
a = 20
b = 10
print a + b
print a - b
print a * b
print a / b
print a % b
print a ** b
print a // b
30
10
200
2
0
10240000000000
2
2、比较运算符
比较运算符又称为关系运算符，有以下几种：
==等于：比较对象是否相等
!=不等于：比较两个对象是否不相等
<>不等于：比较两个对象是否不相等
>大于：判断大小。
>=大于等于：判断是否大于等于。
<=小于等于：判断是否小于等于。
代码示例：
a = 10;b = 20
print a == b
print a != b
print a <> b
print a > b
print a < b
print a >= b
print a <= b
False
True
True
False
True
False
True
3、赋值运算符
Python中有以下几种赋值运算符：
=：简单的赋值运算符。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
4、位运算符
Python中有以下几种位运算符：
&按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0(a & b) 输出结果 12 ，二进制解释：0000 1100
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61 ，二进制解释：0011 1101
~按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。(~a ) 输出结果 -61 ，二进制解释：1100 0011，在一个有符号二进制数的补码形式。
^按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49 ，二进制解释：0011 0001
<
>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。a >> 2 输出结果 15 ，二进制解释： 0000 1111
5、逻辑运算符
Python中有以下几种逻辑运算符：
and与
or或
not非
三种逻辑运算分为布尔型逻辑运算，和非布尔型逻辑运算。
布尔型的逻辑运算是正常的运算，很好理解。
非布尔型的逻辑运算需要遵循以下几点：
非布尔型所有为空值的认为是False，非空值都为True。
运算过程中都是短路逻辑运算，and和or能判断出正确结果，那么返回最后一个判断条件的值。
非布尔型的not运算返回的都是True或False。
代码示例：
# number逻辑运算
x = 10; y = 20
print x and y
print x or y
print not x
20
10
False
# String的逻辑运算
x = "a"; y = "b"
print x and y
print x or y
print not x
b
a
False
#String与Number的逻辑运算
x = 10 ; y = "a"
print x and y
print x or y
a
10
6、成员运算符
Python中提供了两种成员运算符：
in：如果指定的序列中找到值，则返回True，否则返回False。
not in：如果指定的序列中没有找到值，返回True，否则返回False。
代码示例：
# 字符串成员判断
a = "x"; b = "xyz"
print a in b
print a not in b
True
False
# 序列成员判断
a = "x"; b = ["x", "y", "z"]
print a in b
print a not in b
True
False
7、身份运算符
Python中提供了两种身份运算符：
is：判断两个标识符是否是统一对象。
is not：普安段两个标识符是否是不同对象。
代码示例：
a = 1;b = 1
print a is b
print a is not b
True
False
8、运算符优先级
Python中运算符的优先级从高到低如下：
1.**指数 (最高优先级)
2.~、+、-按位翻转，一元加号和减号 (最后两个的方法名为 +@ 和 -@)
3.*、/、%、//乘，除，取模和取整除
4.+、-加法减法
5.>>、<
6.&位 'AND'
7.^、|位运算符
8.<=、、>=比较运算符
9.<>、==、!=等于运算符
10.=、%=、/=、//=、-=、+=、*=、**=赋值运算符
11.is、is not身份运算符
12.in、not in成员运算符
13.not、or、and逻辑运算符
七、拷贝和赋值
Python中的拷贝和赋值，针对对象，有不同层次的流程，具体如下。
1、直接赋值
直接赋值其实就是将对象的引用给到变量。
如下图：

2、浅拷贝(copy)
只是拷贝父对象，不会拷贝对象内部的子对象。
如下图：

3、深拷贝(deepcopy)
完全拷贝父对象以及子对象。此时的拷贝，两个对象完全脱离了关系，是两个独立的对象，不会互相影响。
如下图：

八、流程控制
Python中提供了和其他语言一样的流程控制语句。其中包含：
条件判断
循环
1、条件判断语句
Python中的条件判断语句由if、elif、else组合搭配构成。其语法大致有如下两种：
if condition:
do somthing
else:
do somthing
if condition:
do somthing
elif condition:
do somthing
else:
do somthing
在Python中，任意值都可作为条件，所有类型的空值为False，除空值之外其他全为True。
assert断言
在程序编写过程中，经常使用断言来判断代码逻辑执行的正确与否。
代码示例：
age = 10
assert age = 20 # 不是预期的效果就会报错，导致程序中断，就可以缩小程序出错的范围。
File "", line 2
assert age = 20 # 不是预期的效果就会报错，导致程序中断，就可以缩小程序出错的范围。
^
SyntaxError: invalid syntax
2、循环语句
Python中的循环语句包含两种，分别是：
while
for
1.while循环
while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
有如下两种语法：
while condition:
do somthing
while condition:
do somthing
else:
do somthing
判断条件可以是任何表达式，任何非零、或非空(null)的值均为true。
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立。如果判断条件永远为True，那么循环将永远执行下去，形成无线循环。
2.for循环
for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法如下：
for interating_var in sequence:
do somthing
for index in range:
do somthing
代码示例：
data = [1,2,3,4]
for i in data:
print i,
1 2 3 4
for i in range(10):
print i,
0 1 2 3 4 5 6 7 8 9
在python中，for…else表示：for中的语句和普通的没有区别，else中的语句会在循环正常执行完(即for不是通过break跳出而中断的)的情况下执行，while … else 也是一样。
代码示例：
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num % i == 0: # 确定第一个因子
j = num / i # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break # 跳出当前循环
else: # 循环的 else 部分
print num, '是一个质数'
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数
3.循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
可以在循环体内嵌套相同的循环体，如在for循环中嵌入for循环，在while循环中嵌入while循环；也可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环，可以在for循环中嵌入while循环。
代码示例：
i = 2
while(i < 100):
j = 2
while(j <= (i / j)):
if not(i%j): break
j = j + 1
if (j > i / j) : print i, " 是素数",
i = i + 1
print "Good bye!"
2 是素数 3 是素数 5 是素数 7 是素数 11 是素数 13 是素数 17 是素数 19 是素数 23 是素数 29 是素数 31 是素数 37 是素数 41 是素数 43 是素数 47 是素数 53 是素数 59 是素数 61 是素数 67 是素数 71 是素数 73 是素数 79 是素数 83 是素数 89 是素数 97 是素数 Good bye!
# 乘法口诀表
for a in range(1,10):
for b in range(1,a + 1):
print "%d*%d=%d\t" % (b,a,b * a),
print '\n'
1*1=1
1*2=22*2=4
1*3=32*3=63*3=9
1*4=42*4=83*4=124*4=16
1*5=52*5=103*5=154*5=205*5=25
1*6=62*6=123*6=184*6=245*6=306*6=36
1*7=72*7=143*7=214*7=285*7=356*7=427*7=49
1*8=82*8=163*8=244*8=325*8=406*8=487*8=568*8=64
1*9=92*9=183*9=274*9=365*9=456*9=547*9=638*9=729*9=81
4.循环控制语句
break
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
代码示例：
for letter in 'Python': # 第一个实例
if letter == 'h':
break
print '当前字母 :', letter
var = 10 # 第二个实例
while var > 0:
print '当前变量值 :', var
var = var -1
if var == 5: # 当变量 var 等于 5 时退出循环
break
print "Good bye!"
当前字母 : P
当前字母 : y
当前字母 : t
当前变量值 : 10
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
Good bye!
continue
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
代码示例：
for letter in 'Python': # 第一个实例
if letter == 'h':
continue
print '当前字母 :', letter
var = 10 # 第二个实例
while var > 0:
var = var - 1
if var == 5:
continue
print '当前变量值 :', var
print "Good bye!"
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : o
当前字母 : n
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!
pass
pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
代码示例：
# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '当前字母 :', letter
print "Good bye!"
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!
5.推导式
所谓推导式，就是一种从一个数据序列构件另一个数据序列的方法。
代码示例：
number = list(range(10))
number
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
列表推导式
代码示例：
# 利用列表进行列表推导
li = [i * 10 for i in number]
li
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
字典推导式
代码示例：
# 利用列表进行字典key推导
di = {i : "b" for i in number}
di
{0: 'b',
1: 'b',
2: 'b',
3: 'b',
4: 'b',
5: 'b',
6: 'b',
7: 'b',
8: 'b',
9: 'b'}