摘要

python3.x中有35个关键字，比python2.x增加了6个: False True None async await和nonlocal 且删除了exec与print。

python3.8中：

python2.7中：

详解(按新版图一顺序)：

(1)False 和 True ： 布尔值，0和1

(2)None： 空

(3)and、not 和 or： 逻辑与，逻辑非，逻辑或。

(4)as：三种用法如下

(1)起到别称的作用

>>> from decimal import Decimal as D #用自定义的D代替Decimal方法，便于下面的书写。

>>> D(0.1)+D(0.2)

Decimal('0.3000000000000000166533453694')

(2)经典的with as 用法，with后面紧跟着的对象，会调用它的__enter__方法，返回的对象会

赋值给temp

>>>with object as temp：

(3)与except组合起来，看下面，捕获到Exception对象会赋值给e

>>>try:

>>>pass

>>>except Exception as e:

>>>pass

(5)assert:断言，用于判断变量或条件表达式是否为真。

assert 断言在意义上相当于 if-not-raise，如果表达式为假，就会发生异常。

简单用法示例如下：

>>> assert 2+2==4 #正确的表达式无返回值

>>> assert 2+2==5

Traceback (most recent call last):

File "", line 1, in

AssertionError #错误的报错AssertionError

>>> assert 2+2==4,"正确啦啦啦"

>>> assert 2+2==5,"错误啦啦啦"

Traceback (most recent call last):

File "", line 1, in

AssertionError: 错误啦啦啦 #自定义的错误返回值

(6)async 和 await: 协程和挂起协程

本人新手难以理解—— 详情参考：

https://www.cnblogs.com/dhcn/p/9032461.html

(7)break 和 continue: 前者结束循环，后者结束当前当次循环。

for s in "python":

if s=='t':

continue

print(s,end='')

>>>pyhon

for s in "python":

if s=='t':

break

print(s,end='')

>>>py

(8)class：用于定义类。

(9)def:用于定义函数或方法。

(10)del：删除变量或序列的值。

(11)if,elif,else : python中的条件分支语句

(12)try ,except, finally：异常处理语句

try:

alm=int(input("请输入一个整数： "))

print(alm+1)

except:

print("输入错误")

finally: #finally中的语句无论是否发生异常，都会执行

print("程序结束")

>>>10

>11

>程序结束

>>>jsd

>输入错误

>程序结束

另：常见异常

(13)for 和 while：遍历循环和无限循环。

(14)from 和 import :用于导入模块或引用库。

(15)global 和 nonlocal：全局变量和外层变量。

global：

a="qaq"

def foo():

global a

a=10

print(a+1)

print(a) #运行函数前

foo() #函数运行，函数里使用global关键字改变了全局变量a的值

print(a) #函数运行后

>qaq

>11

>10

nonlocal：首先，要明确 nonlocal 关键字是定义在闭包里面的。

尽管可以层层向外(上)查找变量，但是! python2 只支持最里层作用域(局部变量)和全局命令空间(gloabl)，也就是说内部函数不能给定义在外部函数中的局部变量重新赋值(函数嵌套的情况下)，python3 中，可以使用nonlocal 声明完成修改。(https://www.jb51.net/article/108183.htm)

x="qaq"

def one():

x=1

def two():

x=2

print("two: ",x)

two()

print("one: ",x)

one()

print("global: ",x)

>two: 2

>one: 1

>global: qaq

加入关键字nonlocal后

x="qaq"

def one():

x=1

def two():

nonlocal x 将第一层函数的值1变成了2

x=2

print("two: ",x)

two()

print("one: ",x)

one()

print("global: ",x)

>two: 2

>one: 2

>global: qaq

通过nonlocal把上一层函数的值改变了。

只将以上代码中的nonlocal替换成global观察：

x="qaq"

def one():

x=1

def two():

global x

x=2

print("two: ",x)

two()

print("one: ",x)

one()

print("global: ",x)

>2

>1

>2 #全局变量被替换

结果中全局变量被替换成2，而函数one()中的x值并未改变。

global 是对整个环境下的变量起作用，而不是对函数类的变量起作用。

(16)in：判断变量是否在序列中。

(17)is：判断变量是否为某个类的实例。

(18)lambda：定义匿名函数：

详情参考：https://www.cnblogs.com/hf8051/p/8085424.html

>>> g=lambda x,y:x+y

>>> g(3,4)

7

(19)pass：空的类、方法或函数的占位符。

def foo():

pass

foo()

关键字pass属于占位关键字，一般是在开发中先用它占据函数体确定整个模块的基本框架，之后再删去pass填充函数体。pass的合理使用可以方便我们组织编程。当程序运行到pass时不会执行任何操作，解释器会把pass当做一条咸鱼而不去理会。

(20)raise: 除了常见的try–except异常处理语句，raise可以主动抛出一个异常，定义异常信息内容：

raise NameError([str]) : raise 异常类型(异常参数)

通过raise 引发异常时，raise 后面的操作将不会被执行 常见用法如下：

主动抛出一个异常

while 1:

def number():

a = int(input('输入第一个数：'))

b = int(input('输入第二个数：'))

if a < b:

raise Exception("a < b")

print("a>b") # 如果atry:

number()

except Exception as e:

print(e)

#运行结果：

>>>输入第一个数：2

>>>输入第二个数：8

a < b 第一个print语句并未被执行

>>>输入第一个数：6

>>>输入第二个数：2

a>b

自己创建一个异常类

class InputError(Exception): # 创建一个新的exception类来抛出自己的异常。

# 异常应该继承自 Exception 类，包括直接继承，或者间接继承

def __init__(self, errorinfor):

self.error = errorinfor

def __str__(self):

return self.error

def score():

grade = int(input('你的成绩是：'))

if grade <= 0 or grade >= 150:

raise InputError('考试分数只能在0-150')

try:

score()

except InputError as e:

print(e)

>>>你的成绩是：156

>考试分数只能在0-150

(21)return：用于函数返回计算结果

(22)with：简化python的语句。

with语句可用于对try except finally 的优化，让代码更加美观，

fo=open ('file_name',"r")

try:

print(fo.read())

except:

pass

finally:

fo.close() #文件关闭非常有必要

**等价于下面**：

with open('file_name','r') as fp: #with自带关闭，异常也能自动关闭

print(fp.read())

进程线程之间互斥对象。

支持上下文其他对象

友情链接：

https://www.jianshu.com/p/5b01fb36fd4c

https://www.cnblogs.com/Xjng/p/3927794.html

(23)yield：yield主要是用来创造生成器。

在python中我们把含有yield语句的函数称之为生成器，生成器对象必然是迭代(类)，生成器对象是一种用普通函数的方法定义的迭代器，yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器，当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象。可以用"next()"方法或者for循环进行迭代执行。

def r(n):

print("hellow world")

while n>0:

print("before")

yield n

n -=1

print("after")

foo=r(3)

print(foo)

#运行后

#返回值

>>> foo.__next__() #用next方法执行一次

hellow world

before

3

>>> foo.__next__() #再次用next方法执行一次

after

before

2

>>> foo.__next__() #继续向下执行

after

before

1

>>> foo.__next__() #再次执行，当不再满足循环条件，返回内定的异常

after

Traceback (most recent call last):

File "", line 1, in

foo.__next__()

StopIteration

>>>

同样的将上面主程序中的yield换成return比较如下：

def r(n):

print("hellow world")

while n>0:

print("before")

return n

n -=1

print("after")

foo=r(3)

print(foo)

#结果如下

hellow world

before

3

根据结果可以看出，程序遇到return后返回值，就不会再运行下面的内容了，就已经彻底结束了，而遇到yield时候，只是相当于暂停、挂起的状态，并未结束…

友情链接：https://blog.csdn.net/libbyandhelen/article/details/78957369#commentBox

(具体的关于生成器和迭代器，以及相关知识和两者区别我有时间会再写一篇专门介绍，还需多多学习，多多实践)