devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：从前慢现在也慢 | 2024-08-05 16:03:42

赞

踩

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

什么是切片？

  • 取一个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： 
    1. >>> g = (x * x for x in range(10))
    2. >>> g
    3. <generator object <genexpr> at 0x1022ef630>
  • 要创建一个生成器，也可以使用函数来定义。生成器函数和普通函数的区别在于它使用 yield 语句来产生一个值，而不是使用 return 语句。生成器函数会返回一个生成器对象，这个对象可以用于迭代。例如，定义一个生成器函数，可以使用关键字 def 来定义函数，并在函数体内使用 yield 语句产生一个值。 
    1. def my_generator():
    2.     yield 1
    3.     yield 2
    4.     yield 3
  • 然后通过调用生成器函数，可以将生成器函数赋值给一个变量，这个变量会成为一个生成器对象。例如： 
    my_gen = my_generator()
  • 接下来就使用生成器对象进行迭代。可以使用 for 循环来迭代生成器对象中的值，或者使用 next() 函数来逐个获取生成器对象中的值。例如： 
    1. for value in my_gen:
    2.     print(value)
    3.  
    4. # 或者使用 next() 函数
    5. print(next(my_gen))
    6. print(next(my_gen))
    7. print(next(my_gen))

什么是可迭代对象：Iterable？

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

什么是迭代器Iterator？

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

 怎么构建迭代器？

  • 构建一个迭代器可以通过定义一个类，并实现 __iter__ 和 __next__ 方法来实现。例如： 
    1. class MyIterator:
    2.     def __init__(self, data):
    3.         self.data = data
    4.         self.index = 0
    5.  
    6.     def __iter__(self):
    7.         return self
    8.  
    9.     def __next__(self):
    10.         if self.index < len(self.data):
    11.             value = self.data[self.index]
    12.             self.index += 1
    13.             return value
    14.         else:
    15.             raise StopIteration
    16.  
    17. # 使用迭代器遍历列表
    18. my_list = [1, 2, 3, 4, 5]
    19. my_iterator = MyIterator(my_list)
    20.  
    21. for item in my_iterator:
    22.     print(item)
  • 在上面的示例中，MyIterator 类实现了 __iter__ 和 __next__ 方法。__iter__ 方法返回了迭代器对象自身，而 __next__ 方法返回迭代器中下一个元素。当没有元素时，__next__ 方法会引发 StopIteration 异常，这告诉迭代器已经遍历完所有的元素。

函数可以做参数吗？ 

  • 可以，函数也可以作为参数传递给其他函数。这种能力被称为高阶函数（Higher-order functions）。当函数作为参数传递给其他函数时，可以让代码更加灵活和可复用。例如，可以通过将一个比较函数作为参数来定制排序的方式。 
    1. def compare_by_length(str1, str2):
    2.     return len(str1) - len(str2)
    3.  
    4. def sort_strings(strings, compare_func):
    5.     return sorted(strings, key=compare_func)
    6.  
    7. strings = ['apple', 'banana', 'cherry', 'date']
    8. sorted_strings = sort_strings(strings, compare_by_length)
    9. print(sorted_strings)
  • 在这个例子中，compare_by_length 函数接受两个字符串参数，并返回它们长度的差值。sort_strings 函数接受一个字符串列表和一个比较函数作为参数，然后使用 sorted 函数进行排序，根据比较函数来决定元素的顺序。
  • 在这里，我们使用了 compare_by_length 函数作为比较函数，以便按照字符串的长度进行排序。输出结果将会是 ['date', 'apple', 'cherry', 'banana']，因为按照字符串长度从短到长的顺序排序了字符串列表。

函数作为结果值返回吗？

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

什么是函数闭包？ 

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

什么是函数工厂？ 

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

怎么实现函数工厂？ 

  • 在Python中实现函数工厂可以使用闭包的概念。闭包是一个包含了被定义函数的环境的函数对象，它允许被定义的函数访问并操作闭包环境中的变量。下面是一个示例代码，演示了如何使用函数工厂创建一个计算平方和立方的函数： 
    1. def create_power_function(power):
    2.     def power_function(x):
    3.         return x ** power
    4.     return power_function
    5.  
    6. square = create_power_function(2)
    7. cube = create_power_function(3)
    8.  
    9. print(square(2))  # 输出：4
    10. print(cube(2))    # 输出：8
  • 在这个例子中，create_power_function是一个函数工厂，它接受一个参数power，并返回一个计算乘方的函数power_function。通过调用create_power_function，可以创建不同幂次的计算函数。在这个例子中则是分别创建了平方函数和立方函数。
  • 需要注意的是，在闭包中，每个函数power_function都有自己的power变量的副本。这意味着可以同时创建多个power_function，每个函数有各自的power值，而不会互相影响。

什么是装饰器Decorator？ 

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

怎么实现装饰器？

  • 在Python中，装饰器是一种特殊的函数，它可以用来修改其他函数的功能。实现装饰器的基本步骤如下：
  1. 定义一个装饰器函数，其参数为被装饰的函数（或类）。
  2. 在装饰器函数内部，定义一个内部函数，用于包裹原始函数，并添加额外的功能。
  3. 在内部函数中，调用原始函数，并返回其结果。
  4. 将内部函数作为装饰器函数的返回值。
  • 以下是一个简单的装饰器示例，用于计算函数执行的时间： 
    1. import time
    2.  
    3. def calculate_time(func):
    4.     def wrapper(*args, **kwargs):
    5.         start_time = time.time()
    6.         result = func(*args, **kwargs)
    7.         end_time = time.time()
    8.         execution_time = end_time - start_time
    9.         print(f"函数执行时间：{execution_time}秒")
    10.         return result
    11.     return wrapper
    12.  
    13. @calculate_time
    14. def my_function():
    15.     time.sleep(2)
    16.  
    17. my_function()
  • 输出结果为： 
    函数执行时间：2.0000739097595215秒
  • 在上面的示例中，calculate_time是装饰器函数，它接受一个被装饰的函数作为参数。wrapper是装饰器函数内部定义的包裹函数，它记录函数的执行时间并返回结果。@calculate_time语法将装饰器应用到了my_function函数上，使得调用my_function时会自动执行装饰器函数的逻辑。

 什么是functools.wraps？

  • functools.wraps 是一个装饰器，用于将被装饰函数的元数据复制到装饰函数中，以便在使用装饰器后仍然可以访问原始函数的名称、文档字符串和参数签名等信息。
  • 当使用装饰器来装饰一个函数时，通常会改变原始函数的属性，例如其名称和文档字符串。这可能会导致在调试代码或生成文档时出现问题。为了解决这个问题，functools.wraps 函数提供了一种简单的方式来复制原始函数的属性。
  • 使用 @functools.wraps 装饰器，可以确保装饰器函数具有与原始函数相同的名称、文档字符串和参数签名。这样可以保留原始函数的元数据，使得在调试或生成文档时更容易理解和使用被装饰函数。例如： 
    1. import functools
    2.  
    3. def my_decorator(func):
    4.     @functools.wraps(func)
    5.     def wrapper(*args, **kwargs):
    6.         # 执行装饰器逻辑
    7.         return func(*args, **kwargs)
    8.     return wrapper
    9.  
    10. @my_decorator
    11. def my_function():
    12.     """这是一个被装饰函数"""
    13.     pass
    14.  
    15. print(my_function.__name__)  # 输出 "my_function"
    16. print(my_function.__doc__)   # 输出 "这是一个被装饰函数"
  • 在上面的示例中，my_decorator 是一个装饰器函数，它将 functools.wraps 应用到 wrapper 函数上。这样，wrapper 函数将拥有与被装饰的 my_function 函数相同的名称和文档字符串。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/933079
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号