一、python有许多关键字，一共33个，下面依次说一下。

1.False      4.class      6.finally    17.is         10.return
2.None       9.continue   8.for        21.lambda     5.try
1.True       10.def       11.from      15.nonlocal          8.while
3.and        13.del       14.global    3.not                19.with
19.as        8.elif       8.if         3.or                 20.yield
12.assert    8.else       11.import    16.pass
9.break      5.except     18.in        7.raise
1
2
3
4
5
6
7
False True
布尔类型的值，表示真假，用于判断

None
None是一个特殊的常量。None和False不同。None不是0。None不是空字符串。None和任何其他的数据类型比较永远返回False。None有自己的数据类型NoneType。你可以将None复制给任何变量，但是你不能创建其他NoneType对象

>>> type(None)  
<class 'NoneType'>  
>>> None == 0  
False  
>>> None == ''  
False  
>>> None == None  
True  
>>> None == False  
False
1
2
3
4
5
6
7
8
9
10
and or not
逻辑运算符，与或非

class
定义类的关键字

try except
异常处理关键字，一般连用，用来捕获异常

try:  
   block  
except [exception,[data…]]:  
   block  

try:  
        block  
except [exception,[data...]]:  
   block  
else:  
   block  
1
2
3
4
5
6
7
8
9
10
11
finally
异常处理关键字，有了它，程序始终要执行finally里面的程序代码块，一般用来防止打开文件的过程中产生异常，无法关闭文件
try:
    f = open('xxx')
except:
    do something
finally:
    f.close()
1
2
3
4
5
6
raise
异常处理关键字，显示抛出异常，
class MyException(Exception):pass
try:
    #some code here
    raise MyException
except MyException:
    print "MyException encoutered"
finally:
    print "Arrive finally"
1
2
3
4
5
6
7
8
for while if else elif
for while循环关键字
if 条件判断关键字
else 可与上面两个连用，代表否则
elif 是else if的缩写

break continue
break continue都是终止循环
但break 是直接退出循环
而continue是终止当前这一次循环，继续后面的循环

def return
def 为定义函数的关键字，return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值

from import
在python中用from 或from … import … 导入相关模块，函数

assert
断言，这个关键字用来在运行中检查程序的正确性，条件判断错误会产生异常，和很多其他语言是一样的作用。如

assert len(mylist) >= 1  
1
del
del用于list列表操作，删除一个或者连续几个元素。如：
a = [-1, 3,'aa', 85] # 定义一个list  
del a[0] #删除第0个元素  
del a[2:4] #删除从第2个元素开始，到第4个为止的元素。包括头不包括尾
1
2
3
global
定义全局变量，我的理解就是：要想给全局变量重新赋值，就要global一下全局变量（相当于告诉你：哦，注意了！下面我要设定全局变量的值的），之后在重新赋值。示例如下：
#定义全局变量，变量名全部大写
NAME = "stormjing"

#得到NAME值
def get_NAME():
    return NAME

#重新设定NAME值
def set_NAME(name_value):
    global NAME
    NAME = name_value

print u"输出全局变量NAME的值:",get_NAME()
new_name = "521stormjing"
set_NAME(new_name)#为全局变量重新赋值
print u"输出赋值完的全局变量NMAE的值:",get_NAME()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
nonlocal
nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量,如；
def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

def make_counter_test():
  mc = make_counter()
  print(mc())
  print(mc())
  print(mc())
1
2
3
4
5
6
7
8
9
10
11
12
13
pass
pass的意思就是什么都不做。用途及理解：当我们写一个软件的框架的时候，具体方法啊，类啊之类的都不写，等着后续工作在做。那么就在方法和类里面加上pass，那样编译起来就不会报错了！就像这样：
def test_pass():pass  #如果不加pass，抛出错误：IndentationError: expected an indented block

test_pass()
1
2
3
is
Python中的对象包含三要素：id、type、value
其中id用来唯一标识一个对象，type标识对象的类型，value是对象的值
is判断的是a对象是否就是b对象，是通过id来判断的
==判断的是a对象的值是否和b对象的值相等，是通过value来判断的
>>> a = 1
>>> b = 1.0
>>> a is b
False
>>> a == b
True
>>> id(a)
>>> id(b)
1
2
3
4
5
6
7
8
in
查找列表中是否包含某个元素，或者字符串a是否包含字符串b。需要注意的是：不可以查看list1是否包含list2。
first_list = [1, 2]
second_list = [1, 2, 3]
element = 1
red = 'red'
red_clothes = "red clothes"

print red in red_clothes #true
print first_list in second_list  #false
print element in first_list      #true
1
2
3
4
5
6
7
8
9
with as
as单独没有意思，是这样使用：with…as用来代替传统的try…finally语法的.基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面 返回对象的__exit__()方法。示例如下：
class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self, type, value, trace):
        print "In __exit__()"


def get_sample():
    return Sample()


with get_sample() as sample:
    print "sample:", sample

输出结果：
In __enter__()
sample: Foo
In __exit__()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
yield
用起来和return很像，但它返回的是一个生成器。请看下面的代码：
#理解yield
def test_yield(n):
    for i in range(n):
        yield i*2#每次的运算结果都返回

for j in test_yield(8):
    print j,":",
print u"结束理解yield"   
#利用yield输出斐波那契数列

def fab(max):
    a,b = 0,1
    while a < max:
        yield a
        a, b = b, a+b
print "斐波那契数列！"
for i in fab(20):
    print i,",",
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
lambda
即匿名函数，不用想给函数起什么名字。提升了代码的简洁程度。
g = lambda :"lambda test."
print g()
num1 = lambda x, y=1:x + y
print num1(1)      #多个变量的时候，可以不给有默认值的变量传值
print num1(10,10)  #值得注意的是，如果y没有默认值而且不给它传值的话报错
---------------------
【转载】仅作分享，侵删
作者：stormjing7
原文：https://blog.csdn.net/GodJing007/article/details/84928977

奈斯