python3之35个关键字详解
一、 python35个关键字列举:
help("keywords")
查看运行结果：
2. if、elif、else
3. for、while
4. True、False
5. continue、break
6. pass
7. try、except、finally、raise
8. import、from、as
9. def、return
10. class
11. lambda
12. del
13. global、nonlocal
14. in、is
15. None
16. assert
17. with
18. yield
19. async、await
二、关键字详解：
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)
查看运行结果：
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},是一个中老年人")
查看运行结果：
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
查看运行结果：
True：关键字True与1相同。
False：关键字False与0相同。
# 4. True、False（布尔变量）
print(3 > 5)
print("p" in "python")
查看运行结果：
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="|")
查看运行结果：
循环，函数定义，类定义或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)
查看运行结果:
import：用于导入模块。
from：用于从模块中导入指定的部分，按需要导入指定子类或函数，减少不必要的资源浪费。
as：用于创建别名。
# 8.import、from、as（模块导入）
from time import sleep as s
print(time.ctime())
s(3)
print(time.ctime())
查看运行结果:
def：用于创建（或定义）一个函数。
return：用于结束所定义的函数，并返回值。
# 9.def、return（函数）
def fun_sum(x, y):
return x + y
my_sum = fun_sum(3, 5)
print(my_sum)
查询运行结果：
class关键字用于创建（或定义）一个类。
# 10. class（类）
class Student:
name = "xiaoming"
age = 14
s = Student()
name = s.name
age = s.age
print(name, age)
查看运行结果:
lambda关键字用于创建一个 特殊的“匿名函数”
# 11. lambda（匿名函数）
g = lambda x: x ** 2
print(g(3))
查看运行结果:
其他lambda函数使用可参考:https://www.cnblogs.com/mrwhite2020/p/16500321.html
在Python中，一切皆对象。del关键字主要用于删除对象，还可以用于删除变量，列表或列表的一部分等
# 12. del（删除对象）
x = 1
del x
list1 = [1, 2, 3]
del list1[1]
print(list1)
查看运行结果:
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（判断语句）
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)
查看运行结果：
None关键字用于定义一个空值（根本没有值），与0，False或空字符串不同。 None是其自身的数据类型（NoneType）
# 15.None（空值）
x = None
print(x)
y = [2, 3, 1].reverse()
print(y)
查看运行结果：
调试代码时，使用assert关键字。主要用于测试代码中的条件是否为True，如果为False，将引发AssertionError
# 16. assert（测试代码）
x = 10
try:
assert x == 10
print(f"测试成功")
assert x == 11
except:
print(f"测试失败，x正确值为{x}")
查看运行结果：
with常和open使用，用于读取或写入文件
# 17. with（文件处理）
with open("test001.txt", "r") as f:
print(f.readl())
查看运行结果：
yield关键字结束一个函数，返回一个生成器，用于从函数依次返回值。
# 18. yield（生成器）
def yield_test():
yield 10
print(yield_test())
print(next(yield_test()))
查看运行结果：
（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
