python生成器迭代器内置方法魔法方法

Li_cson

已于 2023-07-07 08:59:14 修改

阅读量110

点赞数 1

文章标签： python

于 2023-07-07 08:58:32 首次发布

本文链接：https://blog.csdn.net/m0_69965569/article/details/131589161

版权

文章详细介绍了JavaScript中的生成器和迭代器的概念及区别，包括生成器如何在函数执行过程中暂停和恢复，以及迭代器如何提供顺序访问集合元素的方式。同时，文章还列举了Python的一些内置函数，如print、len、type等，并简述了Python面向对象编程中的几个魔法方法，如__init__、__str__等，用于对象初始化和自定义对象的行为。

摘要由CSDN通过智能技术生成

一、什么是生成器什么是迭代器有什么区别？

1.生成器

生成器（Generator）是一种特殊类型的函数，它可以在函数执行过程中暂停和恢复。生成器函数使用function*语法进行定义，并使用yield关键字来指定函数的暂停点。

生成器函数的执行不会立即返回结果，而是返回一个迭代器（Iterator）。通过调用迭代器的next()方法，可以逐步执行生成器函数，并在每次调用yield时暂停函数的执行并返回一个值。

以下是一个简单的生成器函数的示例：

function* myGenerator() {
  yield 'Hello';
  yield 'World';
  yield '!';
}

const generator = myGenerator();

console.log(generator.next().value); // 输出: 'Hello'
console.log(generator.next().value); // 输出: 'World'
console.log(generator.next().value); // 输出: '!'
console.log(generator.next().value); // 输出: undefined

在上面的示例中，myGenerator是一个生成器函数，它定义了三个yield语句来指定函数的暂停点。通过调用myGenerator()创建一个生成器对象generator，然后使用generator.next().value来逐步执行生成器函数并获取每个yield语句返回的值。

生成器函数的主要优点是它们可以生成一系列值，而不需要一次性生成所有值。这对于处理大量数据或需要逐步生成结果的场景非常有用。生成器还可以与迭代器协议结合使用，从而可以通过for...of循环或使用扩展运算符来迭代生成器的值。

需要注意的是，生成器函数的执行可以通过return语句提前终止，并且在生成器函数中可以捕获和处理异常。生成器还可以通过yield*语句委托给另一个生成器函数，从而实现生成器的组合和嵌套。

2.什么是迭代器

迭代器（Iterator）是一种对象，它提供了一种顺序访问集合（如数组或对象）中元素的方式，而无需暴露集合的内部实现细节。

迭代器对象必须实现一个next()方法，该方法返回一个包含两个属性的对象：value和done。value表示当前迭代的值，done表示迭代是否已完成。当迭代器完成迭代时，done为true，否则为false。

以下是一个简单的迭代器对象的示例：

const myArray = [1, 2, 3];
const iterator = myArray[Symbol.iterator]();

console.log(iterator.next()); // 输出: { value: 1, done: false }
console.log(iterator.next()); // 输出: { value: 2, done: false }
console.log(iterator.next()); // 输出: { value: 3, done: false }
console.log(iterator.next()); // 输出: { value: undefined, done: true }

在上面的示例中，myArray是一个数组，我们通过调用数组的Symbol.iterator方法来获取一个迭代器对象iterator。然后，我们可以通过调用iterator.next()来逐步访问数组中的元素。每次调用next()方法，都会返回一个包含当前元素的值和迭代是否已完成的对象。

迭代器的主要优点是它提供了一种一致的方式来访问不同类型的集合，而无需关心集合的内部结构。迭代器还可以与生成器函数结合使用，从而实现更复杂的迭代逻辑。

在JavaScript中，许多内置的数据结构（如数组、字符串、Set和Map）都实现了迭代器接口，因此可以直接使用for...of循环或使用扩展运算符来迭代这些数据结构的值。此外，开发者还可以自定义实现迭代器接口，以便在自定义的数据结构上进行迭代操作。

3、生成器迭代器有什么区别？

定义和用途：
1. 生成器是一种特殊类型的函数，使用function*语法定义，可以在函数执行过程中暂停和恢复。生成器函数通过yield关键字来指定函数的暂停点，用于逐步生成一系列值。
2. 迭代器是一种对象，用于提供一种顺序访问集合中元素的方式，而无需暴露集合的内部实现细节。迭代器对象必须实现next()方法，用于返回当前迭代的值和迭代是否已完成。
返回值：
1. 生成器函数在执行时会返回一个生成器对象，该对象可以通过调用next()方法来逐步执行生成器函数，并返回每个yield语句的值。生成器函数的返回值是一个迭代器对象。
2. 迭代器对象的next()方法返回一个包含当前迭代的值和迭代是否已完成的对象。
使用方式：
1. 生成器函数可以通过yield语句逐步生成一系列值，可以使用for...of循环或扩展运算符来迭代生成器的值。
2. 迭代器对象可以通过调用next()方法逐步访问集合中的元素，也可以使用for...of循环或扩展运算符来迭代迭代器的值。
实现方式：
1. 生成器函数使用function*语法进行定义，并使用yield关键字来指定函数的暂停点。
2. 迭代器对象可以通过实现迭代器接口来自定义实现，或者使用JavaScript中内置的数据结构（如数组、字符串、Set和Map）的迭代器。

虽然生成器和迭代器在某些方面有相似之处，但它们的主要目的和使用方式略有不同。生成器主要用于逐步生成一系列值，而迭代器主要用于提供一种顺序访问集合中元素的方式。在实际开发中，可以根据具体需求选择使用生成器或迭代器

二、python的内置函数

以下是每个内置函数对应的Python脚本：

print()：

print("Hello, World!")

len()：

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)

type()：

my_variable = 10
variable_type = type(my_variable)
print(variable_type)

str()：

my_number = 42
my_string = str(my_number)
print(my_string)

int()：

my_string = "42"
my_number = int(my_string)
print(my_number)

float()：

my_string = "3.14"
my_float = float(my_string)
print(my_float)

list()：

my_tuple = (1, 2, 3, 4, 5)
my_list = list(my_tuple)
print(my_list)

dict()：

my_dict = dict(name="John", age=25)
print(my_dict)

tuple()：

my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(my_tuple)

set()：

my_list = [1, 2, 3, 4, 4, 5, 5]
my_set = set(my_list)
print(my_set)

range()：

my_range = range(1, 10)
for num in my_range:
    print(num)

input()：

name = input("Enter your name: ")
print("Hello, " + name + "!")

max()：

my_list = [1, 2, 3, 4, 5]
maximum = max(my_list)
print(maximum)

min()：

my_list = [1, 2, 3, 4, 5]
minimum = min(my_list)
print(minimum)

sum()：

my_list = [1, 2, 3, 4, 5]
total = sum(my_list)
print(total)

abs()：

number = -10
absolute = abs(number)
print(absolute)

round()：

number = 3.14159
rounded = round(number, 2)
print(rounded)

sorted()：

my_list = [5, 2, 4, 1, 3]
sorted_list = sorted(my_list)
print(sorted_list)

zip()：

names = ["John", "Alice", "Bob"]
ages = [25, 30, 35]
zipped = zip(names, ages)
for name, age in zipped:
    print(name, age)

help()：

help(print)

三、python的魔法方法

__init__()：初始化方法，在创建对象时调用，用于初始化对象的属性。

class MyClass:
    def __init__(self, name):
        self.name = name

my_object = MyClass("John")
print(my_object.name)

__str__()：返回对象的字符串表示，可用于自定义对象的打印输出。

class MyClass:
    def __init__(self, name):
        self.name = name
    
    def __str__(self):
        return f"MyClass object with name: {self.name}"

my_object = MyClass("John")
print(my_object)

__len__()：返回对象的长度，可用于自定义对象的长度计算。

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __len__(self):
        return len(self.items)

my_list = MyList([1, 2, 3, 4, 5])
print(len(my_list))

__getitem__()：获取对象的指定元素，可用于自定义对象的索引访问。

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __getitem__(self, index):
        return self.items[index]

my_list = MyList([1, 2, 3, 4, 5])
print(my_list[2])

__setitem__()：设置对象的指定元素，可用于自定义对象的索引赋值。

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __setitem__(self, index, value):
        self.items[index] = value

my_list = MyList([1, 2, 3, 4, 5])
my_list[2] = 10
print(my_list.items)

__delitem__()：删除对象的指定元素，可用于自定义对象的索引删除。

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __delitem__(self, index):
        del self.items[index]

my_list = MyList([1, 2, 3, 4, 5])
del my_list[2]
print(my_list.items)

__iter__()：返回一个可迭代对象，可用于自定义对象的迭代。

class MyList:
    def __init__(self, items):
        self.items = items
    
    def __iter__(self):
        return iter(self.items)

my_list = MyList([1, 2, 3, 4, 5])
for item in my_list:
    print(item)

__next__()：返回迭代器的下一个元素，可用于自定义对象的迭代。

class MyList:
    def __init__(self, items):
        self.items = items
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index < len(self.items):
            value = self.items[self.index]
            self.index += 1
            return value
        else:
            raise StopIteration

my_list = MyList([1, 2, 3, 4, 5])
for item in my_list:
    print(item)

__call__()：使对象可以像函数一样被调用。

class MyFunction:
    def __call__(self, *args, **kwargs):
        print("Calling MyFunction")

my_function = MyFunction()
my_function()

__eq__()：定义对象的相等性比较。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

point1 = Point(1, 2)
point2 = Point(1, 2)
print(point1 == point2)