1. Python3的33个保留字详解

Python3系列共有33个保留字。保留字（Keyword），也称为关键字，指被编程语言内部定义并保留使用的标识符。程序猿编写程序时不能定义与保留字相同的标识符。掌握一门编程语言首先要熟记其所对应的保留字。

Python 3中保留字的含义：

1、True

布尔类型，在python3中是对象，True表示真，相对于False。

2、False

布尔类型，在python3中是对象，False表示假，相对于True。

3、None

python3中的常量None的特殊性在于它既不是0或者False,也不是空字符串，它是一个空值对象。其数据类型为NoneType，遵循单例模式，是唯一的，因而不能创建None对象。所有赋值为None的变量都相等，并且None与其他任何非None的对象比较的结果都为False。

4、and

逻辑判断语句"与’，and左右两边都为真，则判断结果为真，否则都是假。

5、as

1） 自定义命名：import requests as rs；给包、函数、变量重命名，这样方便调用

import pandas as pd

# 使用pandas包中的read_csv()函数读取csv文件
data = pd.read_csv('data.csv')

# 输出data的前5行数据
print(data.head())

在上面的代码中，我们使用as关键字为pandas模块取了一个别名pd，这样我们就可以使用pd代替pandas来调用模块中的函数和方法。这种方式可以让代码更加简洁易懂。

2）结合with…as使用

with关键字可以用来简化try…finally语句的使用，确保在使用完一个资源后，该资源会被正确地关闭或释放。比如，我们经常使用with来打开和关闭文件。具体示例如下：

with open('example.txt', 'w') as f:
    f.write('hello world')

上述代码中，with关键字打开了一个文件，并将文件对象赋值给f。当with代码块结束时，Python会自动关闭文件，无需手动调用f.close()。

6、assert

assert语句是Python中的一种断言语句，用于在代码中检查某些条件是否满足，如果不满足则抛出异常。具体的语法格式为：

assert <condition>, <message>

其中，<condition> 是需要检查的条件，如果条件不成立，就会抛出 AssertionError 异常；<message> 是可选的错误消息，可以在抛出异常时一起输出。

下面是一个简单的示例，演示了如何使用 assert 语句：

def divide(x, y):
    assert y != 0, "除数不能为零"
    return x / y

print(divide(6, 3))
print(divide(3, 0))

这个代码定义了一个 divide 函数，用于计算两个数的商。在函数中使用了 assert 语句来检查除数是否为零，如果除数为零，就会抛出 AssertionError 异常。

如果运行上面的代码，你会看到如下输出：

2.0
Traceback (most recent call last):
  File "test.py", line 7, in <module>
    print(divide(3, 0))
  File "test.py", line 2, in divide
    assert y != 0, "除数不能为零"
AssertionError: 除数不能为零
#这个输出显示了第一次调用 divide 函数的结果（2.0），以及第二次调用 divide 函数时抛出的异常（AssertionError: 除数不能为零）。

7、break

Python break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

break 关键字示例

while True:

time.sleep(2) # 睡眠2秒

print("运行到这里：第一层循环")

while True:

print("运行到这里：第二层循环")

break

备注：break会跳出第二层循环，就是说break关键字只会停止最内一层循环，外层的循环是不受影响的。

8、class

python中的类定义，是对象的声明。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def print_info(self):
        print("Name:", self.name)
        print("Age:", self.age)

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def print_info(self):
        super().print_info()
        print("Grade:", self.grade)

这个例子定义了两个类：Person和Student。Student是Person的子类，它继承了Person的属性和方法，并且还定义了自己的属性和方法。在这个例子中，Person类有两个属性：name和age，以及一个方法print_info，它用来打印出一个人的姓名和年龄。Student类在继承了Person类的所有属性和方法之后，还增加了一个grade属性，并且重写了print_info方法，以打印出学生的成绩。

#调用这些类的方法可以使用以下代码：

person = Person("John", 30)
person.print_info()

student = Student("Jane", 20, "A")
student.print_info()

这将会输出以下内容：

Name: John
Age: 30

Name: Jane
Age: 20
Grade: A

9、continue

跳出本次循环，在本次循环后面的语句则不执行;

while True:

time.sleep(2) # 睡眠2秒

print("运行到这里：第一层循环")

i = 0

while True:

time.sleep(2) # 睡眠2秒

print("运行到这里：第二层循环")

if i > 5:

print("i大于5的时候，不执行本次循环的后面的代码，但是不会跳出本层循环")

continue

i = i + 1

10、def

python中的函数定义，可以直接定义函数，也可以定义类里面的函数。

11、del

删除对象

Python中的del关键字可以用于删除变量、列表元素、字典键值对等。

以下是一些del代码的用例：

删除变量：

a = 1
del a  # 删除变量a

删除列表元素：

lst = [1, 2, 3]
del lst  # 删除列表中第一个元素

删除字典键值对：

dct = {'a': 1, 'b': 2}
del dct['a']  # 删除字典中键为'a'的键值对

12、if else elif

判断语句

if 表达式:

Statement

# 表达式为真（True）,那么就执行Statement.如果表达式为假（False），那么就不执行Statement

13、else

判断语句，对应if语句

if 表达式:

if

Statement1

else

Statement2

# 表达式为真（True）,那么就执行Statement1.如果表达式为假（False），那么就执行Statement2。

14、elif

判断语句，是else if缩写版，更加简洁，它是if语句的一部分，用于在满足多个条件时执行不同的代码块。elif可以出现在if语句的中间或结尾，用于检查更多的条件。

下面是一个简单的Python elif代码用例：

num = 10
if num > 10:
    print("num is greater than 10")
elif num < 10:
    print("num is less than 10")
else:
    print("num is equal to 10")

15、try

try语句是Python中用于异常处理的重要机制之一。当我们执行一段代码时，如果遇到异常，程序会立即停止，并抛出相应的异常信息。如果没有使用try语句来捕获和处理异常，程序将无法继续执行下去。因此，try语句能够使我们的程序更加健壮和可靠。

下面是一个使用try语句来处理异常的代码示例：

try:
    # 可能会出现异常的代码块
    num1 = int(input("请输入第一个数字："))
    num2 = int(input("请输入第二个数字："))
    result = num1 / num2
    print("两个数字相除的结果是：", result)
except ValueError:
    # 处理输入不是数字的异常
    print("输入的不是数字，请重新输入！")
except ZeroDivisionError:
    # 处理除数为0的异常
    print("除数不能为0，请重新输入！")
except Exception as e:
    # 处理其他所有类型的异常
    print("程序出现了异常：", e)
else:
    # 如果没有发生异常，执行该代码块
    print("程序执行完毕！")
finally:
    # 不管是否发生异常，都会执行该代码块
    print("程序已经结束。")

上述代码中，我们使用了try-except语句来捕获和处理可能出现的异常。在try语句块中，我们尝试获取用户输入的两个数字，并计算它们的商，如果在这个过程中发生了异常，则会被相应的except语句捕获并处理。如果没有发生任何异常，则会执行else语句块中的代码。最后，不管是否发生异常，都会执行finally语句块中的代码。

16、except

异常处理语句，同上

17、finally

异常处理语句，同上上

18、for

循环语句

for i in range(5):

print("i = ", i)

19、from

Python中的from语句是用来从模块中导入指定的部分到当前的命名空间中。以下是from语句的详细代码用例：

假设有一个名为math_module.py的模块，该模块中定义了以下函数：

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def multiply(x, y):
    return x * y

def divide(x, y):
    return x / y

现在我们想要在另一个文件中使用该模块中的函数，可以使用以下代码：

from math_module import add, subtract

print(add(2, 3))  # 输出 5
print(subtract(5, 2))  # 输出 3

这里的from语句将math_module模块中的add和subtract函数导入到当前的命名空间中，因此我们可以直接调用它们。除了导入指定的函数之外，我们还可以使用通配符*来导入模块中的所有内容。例如：

from math_module import *

print(add(2, 3))  # 输出 5
print(subtract(5, 2))  # 输出 3
print(multiply(4, 2))  # 输出 8
print(divide(10, 5))  # 输出 2.0

这里的*表示导入模块中的所有内容，因此我们可以直接调用所有函数。

20、global

在 Python 中，global 是一个关键字，用于指示一个变量在函数内部和外部都是全局变量，即可以在函数外部访问该变量，也可以在函数内部修改该变量。

以下是一个简单的代码示例：

count = 0

def increase_count():
    global count
    count += 1

increase_count()
print(count)  # 输出 1

在这个例子中，我们定义了一个全局变量 count，然后定义了一个函数 increase_count，该函数通过使用 global 关键字来告诉 Python count 是一个全局变量，然后将 count 的值加一。最后我们调用了 increase_count 函数，并打印出 count 的值。

21、import

包导入操作，详见19.from 用法

22、in

Python中的in是一个成员运算符，用于判断某个元素是否存在于一个集合中。具体用法如下： 

# 列表
my_list = [1, 2, 3, 4, 5]
if 3 in my_list:
    print("3存在于my_list中")
else:
    print("3不存在于my_list中")

# 字符串
my_string = "Hello, world!"
if "world" in my_string:
    print("world存在于my_string中")
else:
    print("world不存在于my_string中")

# 字典
my_dict = {"a": 1, "b": 2, "c": 3}
if "a" in my_dict:
    print("a存在于my_dict的键中")
else:
    print("a不存在于my_dict的键中")

上述代码演示了in运算符在列表、字符串和字典中的使用方法。如果元素存在于集合中，则in运算符返回True，否则返回False。

23、is

python的is详细代码用例

在Python中，is是一个比较操作符，用于比较两个对象是否是同一个对象，即比较两个对象的内存地址是否相同。如果两个对象的内存地址相同，则返回True；否则返回False。以下是is的详细代码用例：

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a is b)  # False，a和b虽然元素相同，但是它们的内存地址不同
print(a is c)  # True，a和c指向同一个对象
print(b is c)  # False，b和c指向不同的对象

x = 10
y = 10

print(x is y)  # True，x和y指向同一个整数对象

24、lambda

lambda是Python的一个匿名函数，它可以在不使用def和return关键字的情况下创建简单的函数。lambda表达式的基本语法如下：

lambda 参数列表: 表达式

lambda表达式有一个返回值，这个返回值就是表达式的值，因此我们可以将其赋值给一个变量，或者直接调用这个lambda表达式。下面是一个简单的使用lambda表达式求平方的示例代码：

square = lambda x: x * x
print(square(5))  # 输出25

在这个例子中，我们定义了一个lambda表达式，它接受一个参数x，并返回x的平方。我们将这个lambda表达式赋值给变量square，并调用它来计算5的平方。
除了上面的示例，lambda表达式还可以用于各种场景，例如对列表进行排序、筛选等操作。下面是一些常见的使用lambda表达式的代码用例：

# 对列表进行排序
lst = [(1, 2), (3, 1), (5, 4), (2, 3)]
lst.sort(key=lambda x: x)  # 按照元组的第二个元素排序
print(lst)  # 输出[(3, 1), (1, 2), (2, 3), (5, 4)]

# 使用filter函数过滤列表中的元素
lst = [1, 2, 3, 4, 5, 6]
new_lst = list(filter(lambda x: x % 2 == 0, lst))  # 过滤出偶数
print(new_lst)  # 输出[2, 4, 6]

# 使用map函数对列表中的元素进行操作
lst = [1, 2, 3, 4, 5]
new_lst = list(map(lambda x: x * x, lst))  # 对每个元素求平方
print(new_lst)  # 输出[1, 4, 9, 16, 25]

25、nonlocal

nonlocal是在Python3.2之后引入的一个关键字，它是用在封装函数中的，且一般使用于嵌套函数的场景中。在Python 2.x中，闭包只能读外部函数的变量，而不能改写它。

在 Python 中，如果要在函数内部嵌套一个函数，我们有时可能会需要在内部函数中修改外部函数的变量。此时我们就可以使用 nonlocal 关键字。nonlocal 关键字可以让我们在内部函数中修改嵌套外部函数的变量，而不是创建一个新的同名变量。

以下是一个简单的示例代码：

def outer():
    x = "local"
    
    def inner():
        nonlocal x
        x = "nonlocal"
        print("inner:", x)
    
    inner()
    print("outer:", x)

outer()

运行结果为：

inner: nonlocal
outer: nonlocal

在这个例子中，我们定义了一个外部函数 outer()，其中包含一个内部函数 inner()。在 inner() 函数中，我们声明了 x 为 nonlocal 变量，并将其修改为 “nonlocal”。在 outer() 函数中，我们打印了修改后的 x 值。

26、not

逻辑操作符，"非’；

"and’、"or’和"not’的优先级是not>and>or；

非0或者非False才返回True。

27、or

逻辑操作符，"或’；

或运算符会触发短路现象，即第一个条件为真，则返回第一个条件的值；

# 判断x是否大于5或y是否小于10
x = 6
y = 8
if x > 5 or y < 10:
    print("x大于5或y小于10")

# 判断字符串s是否为空或长度小于等于3
s = ""
if not s or len(s) <= 3:
    print("字符串为空或长度小于等于3")

# 判断列表lst是否为空或长度大于10
lst = [1, 2, 3]
if not lst or len(lst) > 10:
    print("列表为空或长度大于10")

28、pass

在Python中，pass是一个空语句，什么也不做，只是占据一行代码的位置。在编写代码时，有时需要使用pass来占位，表示这里暂时什么也不做，但是保留这个位置很重要。

下面是一些关于pass的示例代码：

1.pass的基本用法：

if x > 0:
    # do something
else:
    pass # do nothing

2.pass用于占位符：

def my_function():
    pass # to be implemented

3.pass用于跳过代码块：

for i in range(10):
    if i % 2 == 0:
        pass # skip even numbers
    else:
        print(i)

4.pass用于空类定义：

class MyClass:
    pass # to be implemented

29、raise。

python异常机制。有时候python自带异常不够用，如同java，python也可以自定义异常，并且可以手动抛出，raise关键字就是python主动抛异常设定的关键字。

它的一般格式如下：

raise [Exception [, args [, traceback]]]

其中，Exception是指引发的异常类型，args是指异常参数，traceback是指异常的traceback对象。

下面是一个简单的例子，示范如何使用raise语句来引发一个自定义的异常：

class MyException(Exception):
    pass

try:
    raise MyException("My custom exception")
except MyException as e:
    print(e)

该代码定义了一个自定义异常类MyException，然后使用raise语句引发了该异常，并在except语句中捕获并打印了异常信息。

除了自定义异常之外，Python也内置了许多标准异常类，比如ZeroDivisionError、TypeError等。我们可以使用raise语句来引发这些标准异常类中的任意一个。例如：

try:
    x = 1 / 0
except ZeroDivisionError as e:
    raise TypeError("Division by zero is not allowed") from e

该代码在try语句中进行了一次除零运算，引发了ZeroDivisionError异常。然后在except语句中使用raise语句引发了一个新的异常TypeError，并将原来的异常对象作为from子句的参数传递给新的异常对象。这样做可以保留原始异常的traceback信息，便于调试。

30、return。

保留函数最终的值，并终结程序运行；

31、while。

循环语句。while 后接条件，若条件为真则运行后面的代码块。

32、with

Python中的with语句可以让代码更加简洁、易读，同时还能自动管理资源的分配和释放。常见的使用场景包括文件操作、数据库连接、网络请求等。

下面是一个使用with语句操作文件的示例代码：

with open('test.txt', 'r') as f:
    data = f.read()
    print(data)

上述代码中，with语句打开了一个文件并赋值给变量f，当with语句块结束时，Python会自动关闭文件资源，无需手动调用close()方法。

其他一些常见的with语句用法包括：

1.使用with语句操作数据库连接：

import sqlite3

with sqlite3.connect('example.db') as conn:
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM table')
    data = cursor.fetchall()
    print(data)

2.用with语句操作网络请求：

import requests

with requests.Session() as s:
    response = s.get('http://www.example.com')
    print(response.text)

33、yield

任何使用yield的函数都称之为生成器，而生成器通常可理解成迭代器。

在 Python 中，yield 用于生成器函数，它可以使函数返回一个迭代器对象，每次调用迭代器的 __next__() 方法时，就会执行生成器函数中的代码，直到遇到 yield 关键字，将 yield 后面的值返回，并暂停函数的执行，等待下一次迭代。以下是一个简单的示例：

def my_generator():
    yield 1
    yield 2
    yield 3

gen = my_generator()
print(next(gen)) # 输出 1
print(next(gen)) # 输出 2
print(next(gen)) # 输出 3

在这个示例中，我们定义了一个生成器函数 my_generator()，其中使用了三个 yield 关键字，分别返回了 1、2、3。然后我们使用该函数创建了一个迭代器对象 gen，并依次调用了其 __next__() 方法，输出了每次迭代的结果。

以下是一个更复杂的示例，展示了如何使用 yield 实现斐波那契数列的生成器函数：

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

gen = fibonacci()
for i in range(10):
    print(next(gen))

在这个示例中，我们定义了一个无限循环的生成器函数 fibonacci()，其中使用了 yield 返回了斐波那契数列中的每个数。然后我们使用该函数创建了一个迭代器对象 gen，并使用 for 循环调用其 __next__() 方法，输出了前 10 个斐波那契数列的数。

引用说明

《Python数据分析从入门到精通》 张啸宇 李静 编著