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.await 后面只能跟异步程序或有__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