PYTHON专题-（6）python基础的一些高级特性

最新推荐文章于 2024-09-09 18:34:56 发布

代码不行的搬运工

最新推荐文章于 2024-09-09 18:34:56 发布

阅读量1.2k

点赞数 27

分类专栏： python专栏文章标签： python 开发语言

本文链接：https://blog.csdn.net/qq_41914036/article/details/140906344

版权

python专栏专栏收录该内容

14 篇文章 0 订阅

订阅专栏

什么是切片？

取一个list或tuple的部分元素。

什么是迭代？

如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。在Python中，迭代是通过for ... in来完成的。

什么是列表生成式？

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
L = [x * x for x in range(10)]

什么是生成器？

在Python中，一边循环一边计算的机制，称为生成器：generator。生成器会根据需要逐个产生值，而不会一次性生成所有结果。这样可以提高效率，并减少内存消耗。
如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值。注意：生成器对象在迭代完成后再次调用 next() 函数会引发 StopIteration 异常，可以使用 try/except 块来捕获该异常。
也可以使用for循环，因为generator也是可迭代对象。

怎么创建生成器？

创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
要创建一个生成器，也可以使用函数来定义。生成器函数和普通函数的区别在于它使用 yield 语句来产生一个值，而不是使用 return 语句。生成器函数会返回一个生成器对象，这个对象可以用于迭代。例如，定义一个生成器函数，可以使用关键字 def 来定义函数，并在函数体内使用 yield 语句产生一个值。
def my_generator():
    yield 1
    yield 2
    yield 3
然后通过调用生成器函数，可以将生成器函数赋值给一个变量，这个变量会成为一个生成器对象。例如：
my_gen = my_generator()
接下来就使用生成器对象进行迭代。可以使用 for 循环来迭代生成器对象中的值，或者使用 next() 函数来逐个获取生成器对象中的值。例如：
for value in my_gen:
    print(value)

# 或者使用 next() 函数
print(next(my_gen))
print(next(my_gen))
print(next(my_gen))

什么是可迭代对象：`Iterable？`

可迭代对象（Iterable）是指可以被迭代的对象，也就是可以通过循环访问其元素的对象。在Python中，可迭代对象是一种抽象的数据类型，它定义了一个__iter__方法，该方法返回一个迭代器（Iterator）对象。通过调用迭代器对象的__next__方法，可以逐个访问可迭代对象的元素。
常见的可迭代对象包括列表（list）、元组（tuple）、字符串（string）、字典（dict）、集合（set）等。此外，还可以通过自定义类实现可迭代对象，只需要在类中定义__iter__方法并返回一个迭代器对象即可。
通过使用可迭代对象和迭代器，可以更方便地对数据进行遍历和处理，而无需显式的使用循环结构。

什么是迭代器Iterator？

迭代器是用于遍历集合或序列的对象。它是一种数据访问模式，通过迭代器可以一次访问集合中的每个元素，而不需要了解集合的底层实现方式。
迭代器提供了一种统一的接口，使得可以以相同的方式遍历不同类型的集合。通过调用迭代器的next()方法，可以逐个返回集合中的元素，当没有元素可返回时，迭代器会抛出StopIteration异常。迭代器可以用于for循环、列表推导式和生成器等地方。

怎么构建迭代器？

构建一个迭代器可以通过定义一个类，并实现 __iter__ 和 __next__ 方法来实现。例如：
class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            value = self.data[self.index]
            self.index += 1
            return value
        else:
            raise StopIteration

# 使用迭代器遍历列表
my_list = [1, 2, 3, 4, 5]
my_iterator = MyIterator(my_list)

for item in my_iterator:
    print(item)
在上面的示例中，MyIterator 类实现了 __iter__ 和 __next__ 方法。__iter__ 方法返回了迭代器对象自身，而 __next__ 方法返回迭代器中下一个元素。当没有元素时，__next__ 方法会引发 StopIteration 异常，这告诉迭代器已经遍历完所有的元素。

函数可以做参数吗？

可以，函数也可以作为参数传递给其他函数。这种能力被称为高阶函数（Higher-order functions）。当函数作为参数传递给其他函数时，可以让代码更加灵活和可复用。例如，可以通过将一个比较函数作为参数来定制排序的方式。
def compare_by_length(str1, str2):
    return len(str1) - len(str2)

def sort_strings(strings, compare_func):
    return sorted(strings, key=compare_func)

strings = ['apple', 'banana', 'cherry', 'date']
sorted_strings = sort_strings(strings, compare_by_length)
print(sorted_strings)
在这个例子中，compare_by_length 函数接受两个字符串参数，并返回它们长度的差值。sort_strings 函数接受一个字符串列表和一个比较函数作为参数，然后使用 sorted 函数进行排序，根据比较函数来决定元素的顺序。
在这里，我们使用了 compare_by_length 函数作为比较函数，以便按照字符串的长度进行排序。输出结果将会是 ['date', 'apple', 'cherry', 'banana']，因为按照字符串长度从短到长的顺序排序了字符串列表。

函数作为结果值返回吗？

可以！在Python中，函数可以作为结果值返回。这是因为在Python中，函数被视为一种对象，可以像任何其他对象一样进行操作和传递。因此，可以在一个函数中定义另一个函数，并将其作为结果返回。这种功能在编写高阶函数（Higher-order functions）和函数式编程中非常有用。

什么是函数闭包？

函数闭包是指在函数内部定义的函数，该函数可以访问并修改外部函数的变量，并且这些变量的生命周期会超过外部函数的执行。在函数闭包中，内部函数可以引用外部函数的变量，即使外部函数已经执行完毕，内部函数仍然可以访问和修改外部函数的变量。这是因为在函数闭包中，外部函数的变量被保存在内部函数的环境中，该环境被称为闭包。
闭包可以实现一些高级功能，如函数工厂和装饰器。

什么是函数工厂？

函数工厂是一种设计模式，它是一个用来创建函数的函数。它接受一些参数，并根据这些参数动态地生成并返回一个新的函数。
函数工厂的目的是通过参数化创建函数，以便在需要时能够根据不同的需求生成不同的函数。这种方式可以增加代码的灵活性和可重用性。通过使用函数工厂，我们可以避免编写多个相似的函数，而只需要提供不同的参数即可生成需要的函数。

怎么实现函数工厂？

在Python中实现函数工厂可以使用闭包的概念。闭包是一个包含了被定义函数的环境的函数对象，它允许被定义的函数访问并操作闭包环境中的变量。下面是一个示例代码，演示了如何使用函数工厂创建一个计算平方和立方的函数：
def create_power_function(power):
    def power_function(x):
        return x ** power
    return power_function

square = create_power_function(2)
cube = create_power_function(3)

print(square(2))  # 输出：4
print(cube(2))    # 输出：8
在这个例子中，create_power_function是一个函数工厂，它接受一个参数power，并返回一个计算乘方的函数power_function。通过调用create_power_function，可以创建不同幂次的计算函数。在这个例子中则是分别创建了平方函数和立方函数。
需要注意的是，在闭包中，每个函数power_function都有自己的power变量的副本。这意味着可以同时创建多个power_function，每个函数有各自的power值，而不会互相影响。

什么是装饰器Decorator？

在Python中，函数装饰器是一种特殊的函数，用于修改其他函数的行为。它们是通过将被装饰的函数作为参数传递给装饰器函数，并将其替换为返回的新函数来实现的。本质上，decorator就是一个返回函数的高阶函数。
函数装饰器可以用于许多用途，例如添加日志记录、计时器、验证等功能，而无需修改原始函数的代码。装饰器可以在不影响函数调用方式的情况下，对函数进行额外的操作。使用装饰器可以提高代码的可重用性和可维护性，同时使代码更加简洁和优雅。

怎么实现装饰器？

在Python中，装饰器是一种特殊的函数，它可以用来修改其他函数的功能。实现装饰器的基本步骤如下：

定义一个装饰器函数，其参数为被装饰的函数（或类）。
在装饰器函数内部，定义一个内部函数，用于包裹原始函数，并添加额外的功能。
在内部函数中，调用原始函数，并返回其结果。
将内部函数作为装饰器函数的返回值。
以下是一个简单的装饰器示例，用于计算函数执行的时间：
import time

def calculate_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"函数执行时间：{execution_time}秒")
        return result
    return wrapper

@calculate_time
def my_function():
    time.sleep(2)

my_function()
输出结果为：
函数执行时间：2.0000739097595215秒
在上面的示例中，calculate_time是装饰器函数，它接受一个被装饰的函数作为参数。wrapper是装饰器函数内部定义的包裹函数，它记录函数的执行时间并返回结果。@calculate_time语法将装饰器应用到了my_function函数上，使得调用my_function时会自动执行装饰器函数的逻辑。

什么是functools.wraps？

functools.wraps 是一个装饰器，用于将被装饰函数的元数据复制到装饰函数中，以便在使用装饰器后仍然可以访问原始函数的名称、文档字符串和参数签名等信息。
当使用装饰器来装饰一个函数时，通常会改变原始函数的属性，例如其名称和文档字符串。这可能会导致在调试代码或生成文档时出现问题。为了解决这个问题，functools.wraps 函数提供了一种简单的方式来复制原始函数的属性。
使用 @functools.wraps 装饰器，可以确保装饰器函数具有与原始函数相同的名称、文档字符串和参数签名。这样可以保留原始函数的元数据，使得在调试或生成文档时更容易理解和使用被装饰函数。例如：
import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 执行装饰器逻辑
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """这是一个被装饰函数"""
    pass

print(my_function.__name__)  # 输出 "my_function"
print(my_function.__doc__)   # 输出 "这是一个被装饰函数"
在上面的示例中，my_decorator 是一个装饰器函数，它将 functools.wraps 应用到 wrapper 函数上。这样，wrapper 函数将拥有与被装饰的 my_function 函数相同的名称和文档字符串。