04_Python中的35个关键字

查看Python中的关键字

import keyword

print(keyword.kwlist)  # 返回一个包含Python关键字的列表

    """执行结果

        ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',

        'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global',

        'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',

        'return', 'try', 'while', 'with', 'yield']

    """

1.False

布尔类型的值,表示假

    None    空字符串    空元祖     空列表     空字典     空集合     0  # 真值都是False

    None    str()           tuple()     list()       dict()       set()       int()  # 真值都是False

    None    ""               ()             []             {}           set()        0  # 真值都是False

2.None

None是一个特殊的常量,None和False不同,None不是0,None不是空字符串

    None和任何其他数据类型比较永远返回False,None有自己的数据类型NoneType,None可以赋值给任何变量,但是不能创建其他NoneType对象

    示例:

        In [13]: type(None)

        Out[13]: NoneType

In [14]: None == 0

        Out[14]: False

In [15]: None == ""

        Out[15]: False

In [16]: None == None

        Out[16]: True

In [17]: None == False

        Out[17]: False

3.True

布尔类型的值,表示真,与False相反

    非0为真

4.and

逻辑判断语句,and左右两边都为真,则判断结果为真,否则都是假

    示例:

        # 左边为真时,返回右边的值

        1 and 5  # 5

        # 左边为假时, 返回左边的值

        0 and 5  # 0

5.as

常结合with使用,常用于打开文件操作,也用于在导入模块时给模块起别名

    示例:

        import multiprocessing as muti

with open("文件路径", "w") as f:

            f.write("hello world!")

6.assert

断言,用来在运行中检查程序的正确性,和其他语言一样的作用

    示例:

        mylist = []

        assert len(mylist) >= 1 # 抛出异常 AssertionError

        print("继续执行")

7.asymc 和 await

async:

        修饰将普通函数和生成器函数包装成异步函数和异步生成器

        异步函数的特点是能在函数执行过程中挂起,去执行其他异步函数,等到挂起条件假设挂起条件是 sleep(5),也就是5秒到了再回来执行

    await:

        1.用来用来声明程序挂起,比如异步程序执行到某一步时需要等待的时间很长,就将此挂起去执行其他的异步程序

        2.wait 后面只能跟异步程序或有__await__属性的对象,因为异步程序与一般程序不同

            假设有两个异步函数async a 和 async b

            a中的某一步有 await,当程序碰到关键字 await b()后,异步程序挂起后去执行另一个异步b程序,即从函数内部跳出去执行其他函数

            当挂起条件消失后,不管b是否执行完,要马上从b程序中跳出来,回到原程序执行原来的操作

            如果 await 后面跟的b函数不是异步函数,那么操作就只能等b执行完再返回,无法在b执行的过程中返回

            如果要在b执行完才返回,也就不需要用 await 关键字了,直接调用b函数就行

            所以这就需要await后面跟的是异步函数了,在一个异步函数中,可以不止一次挂起,也就是可以用多个 await

from time import sleep
from time import time

def demo1():
    """demo1方案
        假设我们有三台洗衣机,现在有三批衣服需要分别放到这三台洗衣机里面洗
        运行demo1(),那么需要10秒钟才能把全部衣服洗完,大部分时间都花在挨个地等洗衣机上了
    """

    def washing1():
        sleep(3)  # 第一台洗衣机,需要洗3秒才能洗完
        print('washer1 finished')  # 洗完的时候,通过打印告知

    def washing2():
        sleep(2)  # 第二台洗衣机,需要洗3秒才能洗完
        print('washer2 finished')

    def washing3():
        sleep(5)  # 第三台洗衣机,需要洗3秒才能洗完
        print('washer3 finished')

    washing1()
    washing2()
    washing3()

def demo2():
    """demo2方案
        现在我们想要避免无谓的等待,为了提高效率,我们将使用 async
        washing1/2/3()本是普通函数,现在我们用async把它们升级为异步函数
        注: 一个异步的函数,有个更标准的称呼,我们叫它"协程"(coroutine)
    """

    async def washing1():
        sleep(3)
        print('washer1 finished')

    async def washing2():
        sleep(2)
        print('washer2 finished')

    async def washing3():
        sleep(5)
        print('washer3 finished')

    washing1()
    washing2()
    washing3()
    """打个比方便于理解demo2
        从正常人的理解来看,我们现在有了异步函数,但是却忘了定义应该什么时候"离开"一台洗衣
        机,去看看另一个洗衣机,这就会导致,我们一边看着第一台洗衣机,一边想着是不是该去开第二台洗衣机
        但又不敢去,最终还是花了10秒的时间才把衣服洗完
        PS: 其实 demo2() 是无法运行的,Python 会直接警告:
            RuntimeWarning: coroutine 'demo2.<locals>.washing1' was never awaited
            RuntimeWarning: coroutine 'demo2.<locals>.washing2' was never awaited
            RuntimeWarning: coroutine 'demo2.<locals>.washing3' was never awaited
    """

def demo3():
    """demo方案
        吸取了demo2的教训,告诉自己洗衣服的过程是"可等待的"(awaitable)
        在开启第一台洗衣机洗衣服的时候,我们可以去开别的洗衣机
    """

    async def washing1():
        await sleep(3)  # 注意这里加入了 await
        print('washer1 finished')

    async def washing2():
        await sleep(2)
        print('washer2 finished')

    async def washing3():
        await sleep(5)
        print('washer3 finished')

    washing1()
    washing2()
    washing3()
    """demo3方案
        尝试运行一下,我们会发现还是会报错(报错内容和demo2一样),报错原因分析如下
        1.第一个问题是, await 后面必须跟一个 awaitable 类型或者具有 __await__ 属性的对象
            这个 awaitable, 并不是我们认为 sleep() 是 awaitable 就可以 await 了
            常见的 awaitable 对象应该是: await asyncio.sleep(3)
            asyncio 库的 sleep() 机制与 time.sleep() 不同,前者是"假性睡眠",后者是会导致线程阻塞的"真性睡眠"
            await an_async_function()  # 一个异步的函数,也是可等待的对象
            以下是不可等待的示例验证:
                await time.sleep(3)
                x = await 'hello'  # <class 'str'> doesn't define '__await__'
                x = await 3 + 2  # <class 'int'> dosen't define '__await__'
                x = await None  # ...
                x = await a_sync_function()  # 普通的函数,是不可等待的
        2.第二个问题是,如果我们要执行异步函数,不能用这样的调用方法:
            washing1()
            washing2()
            washing3()
        而应该用 asyncio 库中的事件循环机制来启动,具体见 demo4 的最终方案
    """

def demo4():
    """demo4方案
        这是最终我们想要的实现
    """
    import asyncio  # 引入 asyncio 库

    async def washing1():
        await asyncio.sleep(3)  # 使用 asyncio.sleep() 它返回的是一个可等待的对象
        print('washer1 finished')

    async def washing2():
        await asyncio.sleep(2)
        print('washer2 finished')

    async def washing3():
        await asyncio.sleep(5)
        print('washer3 finished')

    """事件循环机制分为以下几步骤
        1.创建一个事件循环
        2.将异步函数加入事件队列
        3.执行事件队列,直到最晚的一个事件被处理完毕后结束
        4.最后建议用 close() 方法关闭事件循环,以彻底清理 loop 对象防止误用
    """
    # 1.创建一个事件循环
    loop = asyncio.get_event_loop()

    # 2.将异步函数加入事件队列
    tasks = [
        washing1(),
        washing2(),
        washing3(),
    ]

    # 3.执行事件队列,直到最晚的一个事件被处理完毕后结束
    loop.run_until_complete(asyncio.wait(tasks))

    # # 执行事件队列也可以这样写,运行的效果是一样的
    # tasks = [
    #     loop.create_task(washing1()),
    #     loop.create_task(washing2()),
    #     loop.create_task(washing3()),
    # ]

    # 4.如果不再使用 loop,则调用 close关闭事件循环,类似于文件读写结束时的 close() 操作
    loop.close()
    """最终的打印效果
        washer2 finished
        washer1 finished
        washer3 finished
        elapsed time = 5.126561641693115
    """

if __name__ == '__main__':
    start = time()  # 为验证是否真的缩短了时间,做一下记时

    # demo1()  # 需花费10秒
    # demo2()  # 会报错: RuntimeWarning: coroutine ... was never awaited
    # demo3()  # 会报错: RuntimeWarning: coroutine ... was never awaited
    demo4()  # 需花费5秒多一点点

    end = time()
    print('elapsed time = ' + str(end - start))

示例说明:

8.break

break语句用来终止循环语句,即使循环条件没有成为False或者序列还没有被完全递归也会停止循环语句
    如果break的是for或while循环,任何对应的循环else子句块都不会执行

    示例:

        for i in range(10):

            if i == 5:

                print("break跳出当前层循环")

                break

        else:  # for条件不成立时执行else子句块

            print("break后不会执行else子句块")

9.class

定义类的关键字

    示例:

        class Cat():

            """定义一个猫类"""

            pass

tom_obj = Cat()  # 实例化一个猫类对象tom_obj

10.continue

continue语句被用来告诉python解释器跳过当前循环块中的剩余语句,然后继续进行下一轮循环

    示例:

        j = 0

        for i in range(5):

            if i == 3:

                continue  # 当i = 3时,跳过j += i,进入下一轮循环

            j += i

        print("j的值是:%d" % j)  # j的值是:7

11.def

定义函数

    示例:

        def func():

                print("hello world!")

# 函数名(): 表示调用函数

        func()  # "hello world!"

12.del

删除一个对象,常用于列表操作,删除一个或者连续几个元素

    示例:

        a = [1, 3, 'a', 65, 97, True]  # 定义一个列表

        del a[0]  # 删除第0个元素

        del a[2:4]  # 删除从第二个元素(包含第二个元素)开始,到第四个元素结束(不包含第四个元素)

        print(a)  # [3, 'a', True]

13.elif

和if配合使用,当某个条件满足时执行

    示例:

        choice = input("请输入数字(0-2): ")

        if choice == "0":

            quit()

        elif choice == "1":

            print("查询")

        elif choice == "2":

            print("修改")

        else:

            print("输入有误")

14.else

与if语句配合使用,表示当所有条件都不满足是执行

    语法:

        if 真值表达式:

            pass

        else:

            真值表达式为假时执行

15.except

配合try语句用来捕获异常

    示例:

        try:

            num = int(input(">>>"))

            num = 100 / num

        except Exception as e:

            print("Exception(万能异常): ", e)

16.finally

异常处理使用的关键字与try连用,finally里面的代码无论如何始终都会被执行

    示例:

        try:

            age = int(input("请输入年龄: "))

        except Exception as e:

            raise

        else:

            print("没有异常时执行else子句")

        finally:

            print("无论有无异常都会执行finally子句")

17.for

for循环可以遍历任何序列对象,例如一个字符串或者一个列表

    示例:

        for i in "python":

            print("当前字母是:%s" % i)

        li = ["Coco", "Cat", "Tom"]

for k, v in enumerate(li):

            print("第%s位是: %s" % (k, v))

18.from

from 模块名 import 变量名,方法名  # 导入模块中的某个方法或变量

    示例:

        from sys import path  # 导入sys模块中的环境变量path

19.global

声明局部作用域的变量是全局变量

    示例:

        num = 0

        def nums():

            global num

            num += 1

nums()

        print(num)  # 1

20.if

if语句用来检验一个条件是否满足

    如果条件真值为真,则运行一块语句(称为if...块);条件真值为为假,则处理另外一块语句(称为else...块),else从句是可选的

    示例:

        num = input("请输入数字: ")

        if num.isdigit():

            print("是数字")

        else:

            print("不是数字")

21.import

import 模块名  # 导入模块

    示例:

        import sys

        print("path: %s" % sys.path)

22.in

成员运算符

    for i in 可迭代对象  # 是另一种循环语句,它在一个序列的对象上逐一使用序列中的每个项目

    示例:

        a = 1

        if a in [1, 2, 3]:

            print("a在列表中")  # a在列表中

for i in range(10):

            print(i, end=",")  # 0,1,2,3,4,5,6,7,8,9

23.is

python中的对象包含三个要素: id用来唯一标识一个对象, type标识对象的类型, value是对象的值

    is: 身份运算符就是用来判断a对象是否就是b对象,是通过id来判断的

    ==: 判断的是a对象的值是否和b对象的值相等,是通过value来判断的

    示例:

        In [5]: a = 1

In [6]: b = 1.0

In [7]: a is b

        Out[7]: False

In [8]: a == b

        Out[8]: True

In [9]: id(a)

        Out[9]: 4439228176

In [10]: id(b)

        Out[10]: 4476212464

24.lambda

匿名函数,函数式编程风格提升了代码的简洁程度

    示例1:

        In [23]: g = lambda x: x + 1

In [24]: g(1)

        Out[24]: 2

In [25]: g(2)

        Out[25]: 3

    示例2:

        lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        # filter函数筛选满足条件的结果

        res = filter(lambda x: x % 2 == 0, lst)

        list(res)  # [2, 4, 6, 8, 10]

# map函数对可迭代对象的每个值进行计算再返回计算后的结果

        list(map(lambda x: x * 2 + 10, lst))  # [12, 14, 16, 18, 20, 22, 24, 26, 28, 30]

# reduce函数会对参数序列中元素进行累积

        from functools import reduce

        reduce(lambda x, y: x + y, lst)  # 55

25.nonlocal

nonlocal关键字用来在函数或其他作用域中使用外层变量,不能使用到全局变量

    示例:

        def make_counter():

            count = 0

            def counter():

                nonlocal count

                count += 1

                return count

            return counter

ret = make_counter()

        print(ret())  # 1

26.not

用于逻辑判断,取反

    示例:

        lst = []

        if not lis:  # lst真值为假,not取反为真则if成立

            print("空列表")

27.or

逻辑判断,or两边有一个为真,判断结果就是真

    示例:

        # 左边为真,则返回左边的值

        1 or 5  # 1

        # 左边为假,则返回右边的值

        0 or {}  # {}

28.pass

pass的意思是什么都不要做,作用是为了弥补语法和空定义上的冲突

    它的好处体现在代码编写中可以先写好软件的架构,然后再填好架构具体函数和类的内容,如果没有pass,编译器会报错

    示例:

        def func():

            pass

29.raise

主动抛出异常

In [3]: class MyException(Exception):
   ...:     pass
   ...:
   ...:
   ...: try:
   ...:     # some code here
   ...:     raise MyException("raise主动抛出异常")
   ...: finally:
   ...:     print("Arrive finally")
   ...:
Arrive finally
---------------------------------------------------------------------------
MyException                               Traceback (most recent call last)
<ipython-input-3-5d8028611e2a> in <module>
      5 try:
      6     # some code here
----> 7     raise MyException("raise主动抛出异常")
      8 finally:
      9     print("Arrive finally")

MyException: raise主动抛出异常

30.return

用于返回函数的返回值 return,如果没有定义函数的返回值,那么就会得到一个结果是None的对象,即空值
    示例:

        def func(x, y):

            print(x, y)

res = func(2, 3)  # 打印 2 3

        res is None  # True

31.try

try语句和except语句来捕获异常,把通常的语句块放在try块中,而把错误处理的语句放在except块中

    示例:

        try:

            # 提示用户数据一个整数

            num = int(input("请输入一个整数: "))

            # 使用8除以用户输入的整数并输出

            print("8除以%d的结果是: %.2f" %(num, 8/num))

        except ValueError:

            print("值错误,请输入正确的整数")

        except Exception as e:

            print("万能异常捕获: %s" % e)

        else:

            print("没有异常时执行我")

        finally:

            print("无论有没有异常都会执行到我")

32.while

while语句重复执行一块语句,while时循环语句的一种,while语句中有一个可选的else从句

    示例:

        i = 0

        count = 0

        while i <= 10:

            if i == 5:

                i += 1

                break  # 彻底停止循环,不会执行后面的else从句块

            count += i

            i += 1

        else:  # while条件不成立的时候执行else从句块

            print("正常循环条件不满足退出循环时执行else从句,循环内容break时不会执行到else从句")

        print(count)  # 10

33.with

with可以用来简化try...finally语句

    主要用法是实现一个类的__enter__()和__exit__()来实现上下文管理

    示例:

        class A:

            def __init__(self):

                print('init')

def __enter__(self):

                print('before')

def __exit__(self, exc_type, exc_val, exc_tb):

                print('after')

with A() as a:

            print('123')

        """执行结果

            init

            before

            123

            after

        """

34.yield

yield用起来像return,yield告诉程序要求函数返回一个生成器

    示例:

        def create_generator():

            mylist = range(10)

            for i in mylist:

                yield i * i

g = create_generator()

        for i in g:

            print(i, end=" ")  # 0 1 4 9 16 25 36 49 64 81