python3之35个关键字详解

一、 python35个关键字列举:

help("keywords")查看运行结果：

1. and、or、not

2. if、elif、else3. for、while4. True、False5. continue、break6. pass7. try、except、finally、raise8. import、from、as9. def、return10. class11. lambda12. del13. global、nonlocal14. in、is15. None16. assert17. with18. yield19. async、await

二、关键字详解：

1. and、or、not （逻辑运算符）

and：如果两个语句都返回True，则返回值将仅为True，否则它将返回False。or：如果其中一条语句返回True，则返回值为True，否则它将返回False。not：如果语句不是True，则返回值为True，否则返回False。

# 1. and、or、not （逻辑运算符）

a = 5 > 3 and 1 < 2

b = 5 > 3 or 1 > 2

c = not (5 < 3)

print(a, b, c)

查看运行结果：

2. if、elif、else（条件语句）

if：用于创建条件语句（if语句），并且仅当条件为True时，才允许执行if代码块。elif：在条件语句（if语句）中使用，是else if的缩写。else：在条件语句（if语句）中使用，并确定在if条件为False时该执行的代码。

# 2.if、elif、else（条件语句）

age = int(input("请输入您的年龄："))

if age < 18:

print(f"您的岁数是{age},是一个未成年人")

elif age < 40:

print(f"您的岁数是{age},是一个青年人")

else:

print(f"您的岁数是{age},是一个中老年人")

查看运行结果：

3. for、while（循环语句）

for：用于创建一个for循环，它可以用来遍历序列，例如列表，元组等。while：用于定义while循环，while循环将继续，直到while的条件为False。

# 3. for、while（循环语句）

languages = ["python", "java", "ruby"]

for i in languages: print(i,end="|")

print("-----分隔符-----")

a = 0

while a < 10:

print(a, end="|")

a += 1

查看运行结果：

4. True、False（布尔变量）

True：关键字True与1相同。False：关键字False与0相同。

# 4. True、False（布尔变量）

print(3 > 5)

print("p" in "python")

查看运行结果：

5. continue、break（循环控制）

continue：continue关键字用于在for循环（或while循环）中结束当前迭代，并继续进行下一个迭代。break：break关键字用于中断for循环或while循环。

# continue、break（循环控制）

for i in range(10):

if i == 5:

continue

print(i, end="|")

print()

for i in range(10):

if i == 5:

break

print(i, end="|")

查看运行结果：

6. pass（代码的占位符）

循环，函数定义，类定义或if语句中不允许使用空代码，则可以使用pass；当执行pass语句时，不会有任何影响，只是占位作用代表空白代码

# 6. pass（代码的占位符）

def fun1():

pass

if 5 > 3:

pass

7. try、except、finally、raise（异常）

try：在try…except块中使用，它定义了一个代码块，并在没有问题的情况下执行块。如果包含任何错误，可以为不同的错误类型定义不同的块。except：在try… except块中使用。 如果try块引发错误，并在有问题的情况下执行对应的代码块。finally：在try…except块中使用。它定义了一个代码块，当try…except…else块结束时，该代码块将运行。无论try块是否引发错误，都将执行finally代码块。raise：raise关键字用于引发异常，可以定义引发哪种错误，以及向用户显示错误信息。

def div(x, y):

result = None

if (not isinstance(x, int)) and (not isinstance(x, float)) and (not isinstance(y, int)) and (

not isinstance(y, float)):

raise Exception("抛出一个异常,输入非数字!")

result = x / y

return result

div("哈哈", "我")

查看运行结果:

def div(x, y):

result = None

try:

result = x / y

print(f"运算结果为{result}")

except Exception:

print("除数为0，异常！")

finally:

print("此语句必定指定")

return result

div(1, 2)

print("-----split-----")

div(1, 0)

查看运行结果:

8. import、from、as（模块导入）

import：用于导入模块。from：用于从模块中导入指定的部分，按需要导入指定子类或函数，减少不必要的资源浪费。as：用于创建别名。

# 8.import、from、as（模块导入）

from time import sleep as s

print(time.ctime())

s(3)

print(time.ctime())

查看运行结果:

9. def、return（函数）

def：用于创建（或定义）一个函数。

return：用于结束所定义的函数，并返回值。

# 9.def、return（函数）

def fun_sum(x, y):

return x + y

my_sum = fun_sum(3, 5)

print(my_sum)

查询运行结果：

10. class（类）

class关键字用于创建（或定义）一个类。

# 10. class（类）

class Student:

name = "xiaoming"

age = 14

s = Student()

name = s.name

age = s.age

print(name, age)

查看运行结果:

11. lambda（匿名函数）

lambda关键字用于创建一个 特殊的“匿名函数”

# 11. lambda（匿名函数）

g = lambda x: x ** 2

print(g(3))

查看运行结果:

其他lambda函数使用可参考:https://www.cnblogs.com/mrwhite2020/p/16500321.html

12. del（删除对象）

在Python中，一切皆对象。del关键字主要用于删除对象，还可以用于删除变量，列表或列表的一部分等

# 12. del（删除对象）

x = 1

del x

list1 = [1, 2, 3]

del list1[1]

print(list1)

查看运行结果:

13. global、nonlocal（声明变量作用域）

global关键字用于创建一个全局变量。nonlocal关键字用于声明一个非局部变量，用于标识外部作用域的变量。

# 13. global、nonlocal（声明变量作用域）

x = 10

def global_test():

global x

x = 5

return x

def nonlocal_test():

count = 0

def test2():

nonlocal count

count += 1

return count

return test2

num1 = global_test()

print(num1)

print(x)

print("---分割线---")

val = nonlocal_test()

print(val())

print(val())

print(val())

查看运行结果：

14. in、is（判断语句）

# 14. in、is（判断语句）

print("h" in "hello")

print(2 not in [1, 2, 3])

l1 = [1, 2, 3]

l2 = l1.copy()

l3 = l1

print(l1 is l2)

print(l1 is l3)

查看运行结果：

15. None（空值）

None关键字用于定义一个空值（根本没有值），与0，False或空字符串不同。 None是其自身的数据类型（NoneType）

# 15.None（空值）

x = None

print(x)

y = [2, 3, 1].reverse()

print(y)

查看运行结果：

16. assert（测试代码）

调试代码时，使用assert关键字。主要用于测试代码中的条件是否为True，如果为False，将引发AssertionError

# 16. assert（测试代码）

x = 10

try:

assert x == 10

print(f"测试成功")

assert x == 11

except:

print(f"测试失败，x正确值为{x}")

查看运行结果：

17. with（文件处理）

with常和open使用，用于读取或写入文件

# 17. with（文件处理）

with open("test001.txt", "r") as f:

print(f.readl())

查看运行结果：

18. yield（生成器）

yield关键字结束一个函数，返回一个生成器，用于从函数依次返回值。

# 18. yield（生成器）

def yield_test():

yield 10

print(yield_test())

print(next(yield_test()))

查看运行结果：

19. async、await（多线程）

（1）协程（Coroutine），也可以被称为微线程，是一种用户态内的上下文切换技术。简而言之，其实就是通过一个线程实现代码块相互切换执行

yield，生成器，借助生成器的特点也可以实现协程代码

async & awiat，在Python3.5中引入的两个关键字，结合asyncio模块可以更方便的编写协程代码

（2）async 用来声明一个函数为异步函数，异步函数的特点是能在函数执行过程中挂起，去执行其他异步函数，等到挂起条件（假设挂起条件是sleep(5)）消失后，也就是5秒到了再回来执行

（3）await 用来用来声明程序挂起，比如异步程序执行到某一步时需要等待的时间很长，就将此挂起，去执行其他的异步程序。await 后面只能跟异步程序或有__await__属性的对象，因为异步程序与一般程序不同

（4）举例说明：

假设有两个异步函数async a，async b，a中的某一步有await，当程序碰到关键字await b()后，异步程序挂起后去执行另一个异步b程序，就是从函数内部跳出去执行其他函数，当挂起条件消失后，不管b是否执行完，要马上从b程序中跳出来，回到原程序执行原来的操作。如果await后面跟的b函数不是异步函数，那么操作就只能等b执行完再返回，无法在b执行的过程中返回。如果要在b执行完才返回，也就不需要用await关键字了，直接调用b函数就行。所以这就需要await后面跟的是异步函数了。在一个异步函数中，可以不止一次挂起，也就是可以用多个await。

（5）程序示范：

# 19. async、await（多线程）

async def test2(i):

r = await other_test(i)

print(i, r)

async def other_test(i):

r = requests.get(i)

print(i)

await asyncio.sleep(4)

print(time.time() - start)

return r

url = ["https://segmentfault.com/p/1210000013564725",

"https://www.jianshu.com/p/83badc8028bd",

"https://www.baidu.com/"]

loop = asyncio.get_event_loop()

task = [asyncio.ensure_future(test2(i)) for i in url]

start = time.time()

loop.run_until_complete(asyncio.wait(task))

endtime = time.time() - start

print(endtime)

loop.close()

查看运行结果：

20. 参考案例：

https://blog.csdn.net/weixin_43413709/article/details/110820501

https://www.php.cn/python-tutorials-490200.html

https://blog.csdn.net/weixin_43413709/article/details/110820501