第一章：最新版零基础学习 PYTHON 教程（第五节

Python 中的关键字是保留字，不能用作变量名、函数名或任何其他标识符。

Python 中的关键字列表

关键词

描述

关键词

描述

关键词

描述

and
它是一个逻辑运算符
False
表示将导致不为真的表达式。
nonlocal
它是一个非局部变量

as
它用于创建别名
finally
它的使用有例外
not
它是一个逻辑运算符

assert
它用于调试
for
它用于创建循环
or
它是一个逻辑运算符

break
打破循环
from
导入模块的特定部分
pass
当用户不使用时使用 pass

想要执行任何代码

class
它用于定义一个类
global
它用于声明全局变量
raise
raise 用于引发异常或错误。

continue
跳过循环的下一次迭代
if
创建条件语句
return
return用于结束执行

def
它用于定义函数
import
它用于导入模块
true
表示结果为 true 的表达式。

del
它用于删除一个对象
is
用于测试两个变量是否相等
try
Try用于处理错误

elif
条件语句，与 else-if 相同
in
检查元组、列表等中是否存在某个值。
while
While循环用于执行语句块

else
它用在条件语句中
lambda
用于创建匿名函数
with
with语句用于异常处理

except
try-except用于处理这些错误
None
它代表一个空值
yield
Yield 关键字用于创建生成器函数

关键词	描述	关键词	描述	关键词	描述
and	它是一个逻辑运算符	False	表示将导致不为真的表达式。	nonlocal	它是一个非局部变量
as	它用于创建别名	finally	它的使用有例外	not	它是一个逻辑运算符
assert	它用于调试	for	它用于创建循环	or	它是一个逻辑运算符
break	打破循环	from	导入模块的特定部分	pass	当用户不使用时使用 pass 想要执行任何代码
class	它用于定义一个类	global	它用于声明全局变量	raise	raise 用于引发异常或错误。
continue	跳过循环的下一次迭代	if	创建条件语句	return	return用于结束执行
def	它用于定义函数	import	它用于导入模块	true	表示结果为 true 的表达式。
del	它用于删除一个对象	is	用于测试两个变量是否相等	try	Try用于处理错误
elif	条件语句，与 else-if 相同	in	检查元组、列表等中是否存在某个值。	while	While循环用于执行语句块
else	它用在条件语句中	lambda	用于创建匿名函数	with	with语句用于异常处理
except	try-except用于处理这些错误	None	它代表一个空值	yield	Yield 关键字用于创建生成器函数

获取所有Python关键字的列表

我们还可以使用下面的代码获取所有关键字名称。

Python3

# 导入 "keyword" 模块用于关键字操作
import keyword

# 使用 "kwlist()" 一次性打印所有关键字
print("关键字列表如下：")
print(keyword.kwlist)

输出：

# 关键字列表如下：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', ...]

让我们借助一些好的示例来详细讨论每个关键字。

True、False、无关键字

True：该关键字用于表示布尔值 true。如果语句为真，则打印“True”。
False：该关键字用于表示布尔值 false。如果语句为假，则打印“False”。
None：这是一个特殊常量，用于表示空值或空值。重要的是要记住，0，任何空容器（例如空列表）都不会计算为 None。
它是其数据类型的对象——NoneType。无法创建多个 None 对象并将它们分配给变量。

True, False, and None (真、假和无 )

Python3

# 这行代码会输出True，因为在Python中，False被当作0处理，所以False == 0的结果是True。  
print(False == 0)  
  
# 这行代码会输出True，因为在Python中，True被当作1处理，所以True == 1的结果是True。  
print(True == 1)  
  
# 这行代码会输出3，因为在Python中，True被当作1处理，所以True + True + True的结果就是1 + 1 + 1，即3。  
print(True + True + True)  
  
# 这行代码会输出1，因为在Python中，True被当作1处理，而False被当作0处理，所以True + False + False的结果就是1 + 0 + 0，即1。  
print(True + False + False)  
  
# 这行代码会输出False，因为在Python中，None和0是不相等的，所以None == 0的结果是False。  
print(None == 0)  
  
# 这行代码会输出False，因为在Python中，None和空列表[]是不相等的，所以None == []的结果是False。  
print(None == [])

输出

True
True
3
1
False
False

and, or, not, in, is(和、或、不、在、是)

and：这是 Python 中的逻辑运算符。“and”返回第一个假值。如果没有找到返回最后。“和”的真值表如下所示。

3 和 0返回 0

3 和 10返回 10

10 或 20 或 30 或 10 或 70 返回10

对于使用C等语言的程序员来说，上述语句可能会有点困惑，其中逻辑运算符总是返回布尔值（0 或 1）。以下几行直接来自解释这一点的 Python文档：

表达式 x 和 y 首先计算 x；如果 x 为 false，则返回其值；否则，计算 y 并返回结果值。

表达式 x 或 y 首先计算 x；如果 x 为真，则返回其值；否则，计算 y 并返回结果值。

请注意，既不也不限制它们返回的值和类型为 False 和 True，而是返回最后评估的参数。这有时很有用，例如，如果 s 是一个字符串，如果它为空，则应将其替换为默认值，则表达式 s 或 'foo' 会产生所需的值。因为 not 必须创建一个新值，所以无论其参数的类型如何，它都会返回一个布尔值（例如，not 'foo' 生成 False 而不是 ”。）

or：这是 Python 中的逻辑运算符。“or” 返回第一个 True 值。如果没有找到返回最后。“或”的真值表如下所示。

3 或 0返回 3

3 或 10返回 3

0 或 0 或 3 或 10 或 0 返回3

not：该逻辑运算符反转真值。“不”的真值表如下所示。
in：该关键字用于检查容器是否包含值。该关键字还用于循环遍历容器。
is：该关键字用于测试对象同一性，即检查两个对象是否占用相同的内存位置。

示例：and、or、not、is 和 in 关键字

Python

# 逻辑运算
# 或 (返回 True)
print(True or False)

# 逻辑运算
# 与 (返回 False)
print(False and True)

# 逻辑运算
# 非 (返回 False)
print(not True)

# 使用 "in" 检查
if 's' in 'geeksforgeeks':
    print("s 是 geeksforgeeks 的一部分")
else:
    print("s 不是 geeksforgeeks 的一部分")

# 使用 "in" 遍历
for i in 'geeksforgeeks':
    print(i, end=" ")

print("\r")

# 使用 is 检查对象标识
# 字符串是不可变的（分配后无法更改）
# 因此占用相同的内存位置
print(' ' is ' ')

# 使用 is 检查对象标识
# 字典是可变的（一旦分配就可以更改）
# 因此占用不同的内存位置
print({} is {})

输出：

True
False
False
s is part of geeksforgeeks
g e e k s f o r g e e k s 
True
False

迭代关键字 – for、while、break、 continue

for：该关键字用于控制流程和for循环。
while：与“for”类似，用于控制流程和for循环。
Break： “break”用于控制循环的流程。该语句用于跳出循环并将控制权传递给紧随循环之后的语句。
continue： “继续”也用于控制代码流程。该关键字会跳过循环的当前迭代，但不会结束循环。

示例：For、while、break、continue 关键字

Python3

# 使用 for 循环
for i in range(10):

    print(i, end=" ")

    # 当 i 等于 6 时，终止循环
    if i == 6:
        break

print()

# 循环从 1 到 10
i = 0
while i < 10:

    # 如果 i 等于 6，
    # 继续下一次迭代而不打印
    if i == 6:
        i += 1
        continue
    else:
        # 否则打印 i 的值
        print(i, end=" ")

    i += 1

输出

0 1 2 3 4 5 6 
0 1 2 3 4 5 7 8 9

条件关键字 – if、else、elif

if：是决策的控制语句。真值表达式强制控制进入“if”语句块。
else：这是一个用于决策的控制语句。错误表达式强制控制进入“else”语句块。
elif：这是一个用于决策的控制语句。它是“ else if ”的缩写

示例：if、else 和 elif 关键字

Python3

# Python 程序示例，演示 if-elif-else 条件语句
#!/usr/bin/python

i = 20
if (i == 10):
    print("i is 10")
elif (i == 20):
    print("i is 20")
else:
    print("i 不在范围内")

输出

```
i is 20
```

def(定义)

def 关键字用于声明用户定义的函数。

示例：def 关键字

Python3

# def关键字用于定义一个函数  
# def fun():  
def fun():  
    # print()函数用于输出文本到控制台  
    # "Inside Function"是输出的文本内容  
	print("Inside Function")  
  
# 调用fun()函数  
fun()

输出

Inside Function

Return Keywords – Return, Yield(退货关键词 – 退货、产量)

return ：该关键字用于从函数返回。
Yield ：该关键字的使用方式与 return 语句类似，但用于返回生成器。

示例：Return 和 Yield 关键字

Python3

# 使用def关键字定义一个名为fun的函数  
# Return keyword  
def fun():  
 # 初始化变量S为0  
 # 该变量将用于存储累加的结果  
	S = 0  
  
 # 使用for循环遍历range(10)，即0到9的整数序列  
	for i in range(10):  
 # 将当前循环变量i的值累加到S中  
		S += i  
 # 使用return关键字返回S的值，并结束函数的执行  
	return S  
  
 # 调用fun()函数并打印其返回值  
print(fun())  
  
# Yield Keyword  
  
  
# 定义第二个名为fun的函数，与前面的fun函数不同  
def fun():  
 # 初始化变量S为0，与前一个fun函数相同  
	S = 0  
  
 # 使用for循环遍历range(10)，与前一个fun函数相同  
	for i in range(10):  
 # 将当前循环变量i的值累加到S中，与前一个fun函数相同  
		S += i  
 # 使用yield关键字返回S的值，并暂停函数的执行，等待下一次迭代时继续执行  
		yield S  
  
 # 使用for循环遍历fun()函数的返回值序列，并打印每个值  
for i in fun():  
 print(i)

输出

class(班级)

class关键字用于声明用户定义的类。

示例：类关键字

Python3

# Python3程序演示如何实例化一个类

class Dog:

    # 一个简单的类属性
    attr1 = "哺乳动物"
    attr2 = "狗"

    # 一个示例方法
    def fun(self):
        print("I'm a", self.attr1)
        print("I'm a", self.attr2)

# 驱动代码
# 实例化对象
Rodger = Dog()

# 通过对象访问类属性和方法
print(Rodger.attr1)
Rodger.fun()

输出

mammal
I'm a mammal
I'm a dog

with（和）

with关键字用于将代码块的执行包装在上下文管理器定义的方法中。该关键字在日常编程中使用不多。

示例：使用关键字

Python3

# 使用with语句来打开文件
with open('file_path', 'w') as file:  # 打开文件'file_path'以写入模式 ('w')
    file.write('hello world !')  # 向文件中写入字符串'hello world !'

as（作为）

as关键字用于为导入的模块创建别名。即为导入的模块指定一个新名称。例如，将 math 导入为 mymath。作为

示例：作为关键字

Python3

# 导入math模块并使用别名gfg
import math as gfg  # 导入math模块并将其别名设置为gfg

# 调用gfg模块中的factorial函数，计算5的阶乘并打印结果
print(gfg.factorial(5))  # 输出5的阶乘结果

输出

pass（经过）

pass是python中的null语句。遇到这种情况时什么也不会发生。这用于防止缩进错误并用作占位符。

示例：传递关键字

Python3

n = 10  # 定义变量n并赋值为10

for i in range(n):  # 使用循环迭代从0到n-1的值

    # pass可以用作占位符，当以后需要添加代码时使用
    pass  # 什么都不做，仅作为占位符，保持代码结构完整

输出

Lambda（拉姆达)

Lambda关键字用于创建内联返回函数，内部不允许使用任何语句。

示例：Lambda 关键字

Python3

# Lambda关键字
g = lambda x: x*x*x  # 创建一个匿名函数g，它接受一个参数x并返回x的立方

print(g(7))  # 调用函数g，传入参数7，计算7的立方并打印结果

输出

import（进口于）

import：该语句用于将特定模块包含到当前程序中。
from ：通常与 import 一起使用，from 用于从导入的模块中导入特定功能。

示例：导入、来自关键字

Python3

# 使用import关键字导入math模块中的factorial函数
from math import factorial  # 从math模块中导入factorial函数

# 使用import关键字导入整个math模块
import math  # 导入整个math模块

# 使用math模块中的factorial函数计算10的阶乘并打印结果
print(math.factorial(10))  # 输出10的阶乘结果

# 使用from关键字导入的factorial函数计算10的阶乘并打印结果
print(factorial(10))  # 输出10的阶乘结果

输出

3628800
3628800

异常处理关键字——try、 except、 raise、finally 和assert

try ：该关键字用于异常处理，用于捕获代码中使用关键字 except 的错误。检查“try”块中的代码，如果有任何类型的错误，则执行 except 块。
except ：如上所述，它与“try”一起使用来捕获异常。
finally ：无论“try”块的结果是什么，总是执行名为“finally”的块。
raise：我们可以使用 raise 关键字显式引发异常
assert：该函数用于调试目的。通常用于检查代码的正确性。如果一个语句被评估为 true，则不会发生任何事情，但是当它为 false 时，则会引发“ AssertionError ”。还可以打印一条包含错误的消息，以逗号分隔。

示例：try、 except、 raise、finally 和assert 关键字

Python3

# 初始化数字
a = 4  # 设定变量a的值为4
b = 0  # 设定变量b的值为0

# 在try块中没有异常，不会引发异常
try:
    k = a // b  # 引发除以零的异常
    print(k)

# 处理除以零异常
except ZeroDivisionError:
    print("不能除以零")

finally:
    # 无论是否引发异常，此块始终执行
    print('这总是会执行的')

# 使用assert关键字检查是否为0
print("a / b的值是：")
assert b != 0, "除以0错误"
print(a / b)

# 使用raise关键字
# 如果字符串不相等，则引发用户定义的异常
temp = "geeks for geeks"
if temp != "geeks":
    raise TypeError("两个字符串不同。")

输出

不能除以零
这总是会执行的
a / b的值是：
Traceback (most recent call last):
  File "your_script.py", line 19, in <module>
    print(a / b)
ZeroDivisionError: division by zero

Python3

# 使用raise关键字
# 如果字符串不相等，则引发用户定义的异常
temp = "geeks for geeks"
if temp != "geeks":
    raise TypeError("两个字符串不同。")

输出

Traceback (most recent call last):
  File "your_script.py", line 5, in <module>
    raise TypeError("两个字符串不同。")
TypeError: 两个字符串不同。

del（德尔）

del 用于删除对对象的引用。任何变量或列表值都可以使用 del 删除。

示例：del 关键字

Python3

my_variable1 = 20  # 定义变量my_variable1并赋值为20
my_variable2 = "GeeksForGeeks"  # 定义变量my_variable2并赋值为"GeeksForGeeks"

# 检查my_variable1和my_variable2是否存在
print(my_variable1)  # 打印变量my_variable1的值
print(my_variable2)  # 打印变量my_variable2的值

# 删除变量my_variable1和my_variable2
del my_variable1  # 删除变量my_variable1
del my_variable2  # 删除变量my_variable2

# 检查my_variable1和my_variable2是否存在
# 注意：在此处将会引发NameError异常，因为变量已被删除，不存在
print(my_variable1)  # 尝试打印已删除的变量my_variable1会引发异常
print(my_variable2)  # 尝试打印已删除的变量my_variable2会引发异常

输出

20
GeeksForGeeks
NameError: name 'my_variable1' is not defined

global（全球、非本地）

global：该关键字用于将函数内的变量定义为全局范围。
non-local ：此关键字的工作方式与 global 类似，但与全局不同，此关键字声明一个变量以指向外部封闭函数的变量（在嵌套函数的情况下）。

示例：全局和非本地关键字

Python3
```
# 全局变量
a = 15  # 定义变量a并赋值为15
b = 10  # 定义变量b并赋值为10

# 执行加法操作的函数
def add():
	c = a + b
	print(c)

# 调用函数
add()

# 使用nonlocal关键字
def fun():
	var1 = 10

	def gun():
		# 明确告诉Python它必须访问fun函数中初始化的var1
		# 使用关键字nonlocal
		nonlocal var1
		
		var1 = var1 + 10
		print(var1)

	gun()
fun()
```
这段代码首先定义了全局变量a和b，然后定义了一个名为add的函数，该函数执行a和b的加法操作并打印结果。接着，调用了add函数，输出了加法结果。

然后，定义了一个名为fun的函数，在其中定义了一个局部变量var1。在fun函数内部，定义了另一个名为gun的函数，使用nonlocal关键字明确告诉Python它必须访问fun函数中初始化的var1。gun函数对var1进行增加操作并打印结果。最后，调用fun函数，执行了gun函数，输出了var1的增加结果。

输出

25
20

这是代码的执行输出。首先，全局变量a和b的值分别为15和10。然后，调用add函数，它执行a和b的加法操作并打印结果，所以输出为25。

接着，定义了一个名为fun的函数，在其中初始化了一个局部变量var1，其值为10。在fun函数内部，定义了另一个名为gun的函数，使用nonlocal关键字明确告诉Python它必须访问fun函数中初始化的var1。gun函数对var1进行加法操作（var1 = var1 + 10）并打印结果，所以输出为20。

最后，调用fun函数，执行了gun函数，输出了var1的增加结果。