• sticky是sticky 值越大，顶置的文章越靠前

  • thumbnail: “IMAGE_LINK”

    redefine对首页文章添加缩略图

  • 摘要

    excerpt: “这是文章摘要 This is the excerpt of the post”或者直接设置为false

  • massage: 文章的密码的提示，但是似乎没有什么用，总是显示Hey,password is required here.

装饰器

装饰器（decorators）是 Python 中的一种高级功能，它允许你动态地修改函数或类的行为。

装饰器是一种函数，它接受一个函数作为参数，并返回一个新的函数或修改原来的函数。

装饰器的语法使用 @decorator_name来应用在函数或方法上。

  • 装饰器函数1，无返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    # 装饰器函数1，无返回值
    def decorate_fun2(original_fun):
        # 传入函数original_fun作为参数
        def add_print(*args,**kwargs):
            # 使用不定长参数
            print("在调用原始函数【前】添加的新功能")
            original_fun(*args,**kwargs)
            #调用原来的函数
            print("在调用原始函数【后】添加的新功能")
        return add_print
    # 装饰器通过 @ 符号应用在函数定义之前
    @decorate_fun2
    def print_msg(a,b):
        print("a的值：",a)
        print("b的值：",b)

    print_msg(1,2)

  • 装饰器函数2,带有返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    # 装饰器函数2,带有返回值
    def decorate_fun2(original_fun):
        # 传入函数original_fun作为参数
        def add_print(*args,**kwargs):
            # 使用不定长参数
            print("在调用原始函数【前】添加的新功能")

            # 调用原来的函数.有返回值
            result=original_fun(*args,**kwargs)

            print("在调用原始函数【后】添加的新功能")
            # 返回值
            return result
        return add_print
    # 装饰器通过 @ 符号应用在函数定义之前
    @decorate_fun2
    def add(a,b):
        print("a的值：",a)
        print("b的值：",b)
        return a+b

    add_return_value=add(3,4)  # 输出带有装饰器的函数的返回值
    print('带有返回值的装饰器函数返回值：',add_return_value)

  • 装饰器函数3,修改返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    # 装饰器函数3,修改返回值
    def decorate_fun3(original_fun):
        # 传入函数original_fun作为参数
        def add_print(*args,**kwargs):
            # 使用不定长参数
            print("在调用原始函数【前】添加的新功能")

            # 调用原来的函数.有返回值
            result=original_fun(*args,**kwargs)*2

            print("在调用原始函数【后】添加的新功能")
            # 返回值
            return result
        return add_print
    # 装饰器通过 @ 符号应用在函数定义之前
    @decorate_fun3
    def mutil(a,b):
        print("a的值：",a)
        print("b的值：",b)
        print(f"原来函数的返回值应该是:{a*b}")
        return a*b

    add_return_value=mutil(5,6)  # 输出带有装饰器的函数的返回值
    print('带有修改后的乘法装饰器函数返回值：',add_return_value)

  • 装饰器函数4,带参数的装饰器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    def repeat(n):
        def decorate_fun4(original_fun):
            def add_print(*args,**kwargs):
                for _ in range(n):  # _表示丢弃参数，不关心参数的取值
                    # 调用原来的函数
                    original_fun(*args,**kwargs)

            return add_print
        return decorate_fun4

    # 重复三次
    @repeat(3)
    def print_msg():
        print("原始函数打印的信息")

    print_msg() # 调用装饰器函数，会重复三次

队列和栈

列表里面的.pop()和.append()实现了栈的功能。

栈是一种后进先出（LIFO, Last-In-First-Out）数据结构，意味着最后添加的元素最先被移除。列表提供了一些方法，使其非常适合用于栈操作，特别是 append() 和 pop() 方法。

队列是一种先进先出(FIFO, First-In-First-Out)的数据结构，意味着最早添加的元素最先被移除。

使用列表时，如果频繁地在列表的开头插入或删除元素，性能会受到影响，因为这些操作的时间复杂度是 O(n)。为了解决这个问题，可以使用Python 提供了 collections.deque实现队列操作或者坚持使用列表来实现队列。

  • collections.deque实现队列

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    from collections import deque

    # 创建一个空队列
    queue = deque()

    # 向队尾添加元素
    queue.append('a')
    queue.append('b')
    queue.append('c')

    print("队列状态:", queue)  # 输出: 队列状态: deque(['a', 'b', 'c'])

    # 从队首移除元素
    first_element = queue.popleft()
    print("移除的元素:", first_element)  # 输出: 移除的元素: a
    print("队列状态:", queue)            # 输出: 队列状态: deque(['b', 'c'])

    # 查看队首元素（不移除）
    front_element = queue[0]
    print("队首元素:", front_element)    # 输出: 队首元素: b

    # 检查队列是否为空
    is_empty = len(queue) == 0
    print("队列是否为空:", is_empty)     # 输出: 队列是否为空: False

    # 获取队列大小
    size = len(queue)
    print("队列大小:", size)            # 输出: 队列大小: 2

  • 使用list.pop(0)实现队列

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # 1. 创建队列
    queue = []
    # 2. 向队尾添加元素
    queue.append('a')
    queue.append('b')
    queue.append('c')
    print("队列状态:", queue)  # 输出: 队列状态: ['a', 'b', 'c']
    # 3.使用 pop(0) 方法从队首移除元素：
    first_element = queue.pop(0)
    print("移除的元素:", first_element)  # 输出: 移除的元素: a
    print("队列状态:", queue)            # 输出: 队列状态: ['b', 'c']
    # 
    front_element = queue[0]
    print("队首元素:", front_element)    # 输出: 队首元素: b

zip函数

zip() 函数用于将可迭代的对象(list、tuple、set、dict、str)作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

同时注意：zip()函数和unzip()返回的是一个对象,这个对象只能迭代一次，也就是说，一旦用list转化后，这个对象就被消耗掉了，而list函数转化为列表后会得到一个元组构成的列表。

  • zip压缩

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [7, 8, 9, 10, 11]

    # 直接调用zip函数返回的是一个zip对象
    zipped1 = zip(a, b)
    print("zipped1的类型是:", type(zipped1))
    print("zipped1", zipped1)

    # 用zip函数接受的列表如果不等长，元素个数与最短的列表一致
    zipped2 = zip(a, c)
    print("zipped2转换为列表后的长度：", len(list(zipped2)))

    # 用list()函数转换后，返回一个由元组组成的列表
    zipped1_to_list = list(zipped1)
    print("zipped1_to_list的类型是:", type(zipped1_to_list))
    print("zipped1_to_list:", zipped1_to_list)

  • unzip解压缩

    • 正确解压缩

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    a = [1, 2, 3]
    b = [4, 5, 6]
    # 直接调用zip函数返回的是一个zip对象
    zipped1 = zip(a, b)  # 返回zip对象,只能迭代一次
    unzip=zip(*zipped1)   # 解压缩以后立即赋值给unzip,防止被消耗掉
    unzip_to_list=list(unzip)   # 转换为列表后立即赋值，防止被消耗掉，此时得到一个元组列表

    print(unzip_to_list) # 输出[(1, 2, 3), (4, 5, 6)]
    ori_a,ori_b=unzip_to_list # 只有两个元素，直接赋值给ori_a,ori_b
    print(ori_a,ori_b)   # 输出(1, 2, 3) (4, 5, 6)

    • 错误的方式

      • zip和unzip返回的是一个zip对象，而不是一个元组列表！

        1
        2
        3
        4
        5
        # 错误方法1
        ori_a, ori_b = zip(*zipped1)
        # 实际上，zip(*zipped1)会返回由a,b构成的元组列表的zip格式，即[(1, 2, 3), (4, 5, 6)]对应的zip格式
        print('ori_a:', ori_a)
        print('ori_b:', ori_b)

      • zip对象只能迭代一次

        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        # 错误方法2
        unzip=zip(*list(zipped1))

        print(unzip) 
        print(list(unzip))  # 用了list方法，unzip就被消耗掉了
        print(len(list(unzip))) #返回0
        unzip=list(unzip)
        ori_a, ori_b =unzip[0],unzip[1] #报错

        print('ori_a:', ori_a)
        print('ori_b:', ori_b)
        # unzip是一个zip对象，它只能被迭代一次。一旦它被转换为列表，unzip对象就被消耗了，再次调用list(unzip)将会返回一个空列表

        ori_b)

        unzip是一个zip对象，它只能被迭代一次。一旦它被转换为列表，unzip对象就被消耗了，再次调用list(unzip)不起作用。

``

Python中的__name__和__main__

当 Python 解释器读取一个 Python 文件时，它首先设置一些特殊变量，然后执行文件中的代码。

其中一个变量叫作 __name__。

规则如下：

  • 现在执行的文件，其__name__的值被设置为main

  • 如果代码是从另一个模块导入模块，则 __name__ 变量将被设置为该模块的名称。

  • 如果A.py导入了模块B.py，A.py会执行导入的所有部分

  • 如果导入模块的某些变量和执行的程序的某些变量有冲突，比如导入的模块module.py中定义a=1,但是执行文件中定义a=2,在用from mudule import *之后，就会产生冲突，

    此时看from mudule import *和a=2的顺序，以最后一个为准，谁在后谁是最终的a的值。

参考文章：