Python-VBA函数之旅-iter函数

目录

一、iter函数的常见应用场景：

二、iter函数使用注意事项：

三、如何用好iter函数？

1、iter函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

一、iter函数的常见应用场景：

        在Python中，iter()函数具有广泛的应用场景，主要用于创建迭代器对象，这些对象可以逐个访问集合的元素而不需要一次性加载整个集合到内存中，常见的应用场景有：

1、遍历可迭代对象：对于任何可迭代的对象，如列表、元组、字符串、字典、集合等，都可以使用iter()函数获取其迭代器，然后通过迭代器逐个访问其元素，这在处理大量数据或需要按顺序访问数据的场景中非常有用。

2、逐行读取大型文件：对于大型文本文件，使用迭代器可以逐行读取文件内容，而不是一次性将整个文件加载到内存中，这不仅可以节省内存，还可以提高代码的效率。

3、实现惰性求值：生成器是一种特殊的迭代器，它只在需要时生成值，从而节省了内存。通过结合使用`iter()`函数和生成器表达式或生成器函数，可以实现惰性求值，即只在需要时才计算并返回结果，这在处理大量数据或计算密集型任务时非常有用，因为它可以避免不必要的计算和资源浪费。

4、表示无限序列：迭代器可以用于表示无限序列，因为它们只在需要时生成数据，而不需要事先知道序列的长度，例如，可以使用迭代器来表示斐波那契数列或素数序列等。

5、自定义迭代器：通过实现`__iter__()`和`__next__()`方法，可以创建自定义的迭代器类，这允许你定义自己的迭代逻辑，并在需要时返回特定的元素，自定义迭代器在处理复杂数据结构或实现特定算法时非常有用。

6、与for循环结合使用：在for循环中，Python会自动处理迭代器的创建和迭代过程，但是，有时你可能需要更精细地控制迭代过程，例如提前终止迭代或跳过某些元素，在这种情况下，你可以使用iter()函数和next()函数来手动控制迭代过程，并与for循环结合使用。

        总之，iter()函数在Python编程中具有广泛的应用场景，它提供了一种灵活且高效的方式来处理可迭代对象并控制迭代过程。

二、iter函数使用注意事项：

        在Python中使用iter()函数时，需注意以下几点：

1、确保对象是可迭代的：在调用iter()函数之前，你需要确保传入的对象是可迭代的，可迭代对象包括列表、元组、字符串、字典、集合以及任何实现了`__iter__()`方法的自定义对象，如果你尝试对一个不可迭代的对象使用iter()函数，Python会抛出一个TypeError异常。

2、避免重复迭代：迭代器只能从头至尾遍历一次，一旦迭代器耗尽(即所有元素都被访问过)，再次尝试获取元素将引发StopIteration异常，因此，如果你需要多次遍历同一个集合，你应该在每次遍历之前重新创建迭代器。

3、处理StopIteration异常：当你使用next()函数从迭代器中获取元素时，一旦迭代器耗尽，就会引发StopIteration异常，你通常需要捕获这个异常来避免程序崩溃；在Python中，for循环会自动处理这个异常，因此在大多数情况下你不需要显式地捕获它，但是，如果你手动使用next()函数，你应该确保正确处理这个异常。

4、避免无限循环：当使用iter()函数结合自定义的`__iter__()`和`__next__()`方法创建迭代器时，需要确保迭代器在某个时刻能够引发StopIteration异常，以避免无限循环，否则，程序可能会陷入死循环，无法继续执行。

5、不要混淆iter()和iterable：iter()函数用于获取一个迭代器的对象，而一个可迭代对象(iterable)是一个实现了`__iter__()`方法的对象，这两者并不相同；可迭代对象可以被转换为迭代器对象，而迭代器对象则用于遍历可迭代对象的元素。

6、避免迭代中修改集合：在迭代一个集合(如列表或字典)时，直接修改该集合可能会导致不可预测的行为或错误，例如，在迭代列表时删除元素可能会导致迭代器跳过某些元素或引发异常。如果你需要在迭代过程中修改集合，最好先创建集合的副本，然后在副本上进行操作。

7、性能考虑：虽然迭代器在处理大型数据集时非常有用，但它们并不总是最快的解决方案，在某些情况下，使用列表推导式或生成器表达式可能会更高效，因此，在选择使用迭代器时，需要考虑性能需求。

        总之，只有遵循这些注意事项，你才能够更安全、更有效地在Python中使用iter()函数和迭代器。

三、如何用好iter函数？

        在Python中，iter()函数是一个强大的工具，用于获取可迭代对象的迭代器，从而可以遍历集合的元素，用好iter()函数的相关建议如下：

1、理解迭代器概念：迭代器是一个可以记住遍历的位置的对象，它可以从头到尾访问数据集合的元素，但是只能前进不能后退；迭代器实现了`__iter__()`和`__next__()`方法，`__iter__()`方法返回迭代器对象本身，而`__next__()`方法返回下一个元素，并在没有更多元素时引发StopIteration异常。

2、识别可迭代对象：在使用iter()函数之前，首先要确保你正在处理的对象是可迭代的。内置的可迭代对象包括列表、元组、字典、集合、字符串等；自定义的类也可以实现`__iter__()`方法，从而变得可迭代。

3、创建迭代器：使用iter()函数可以很容易地创建迭代器，例如，`my_iter = iter(my_list)`将创建一个可以遍历`my_list`的迭代器。

4、使用next()函数遍历元素：一旦你有了迭代器，就可以使用next()函数来获取集合中的下一个元素，当没有更多元素时，next()将引发StopIteration异常，你可以使用`try-except`块来捕获这个异常，以便在迭代完成时执行一些清理操作或退出循环。

5、结合for循环使用：尽管你可以手动使用iter()和next()来遍历集合，但在大多数情况下，使用for循环会更方便和简洁，for循环内部会自动处理迭代器的创建和元素的获取，直到遇到StopIteration异常为止。

6、处理无限迭代器：有些迭代器表示无限序列，例如生成器，在这种情况下，你需要确保有一个明确的退出条件或限制迭代次数，以避免无限循环。

7、自定义迭代器：如果需要，你可以通过实现`__iter__()`和`__next__()`方法来创建自定义的迭代器类，这允许你控制迭代过程，例如实现特定的迭代逻辑或添加额外的功能。

8、理解迭代器的优势：迭代器的一个主要优势是它们支持懒惰计算，即只在需要时生成值，这对于处理大型数据集或执行复杂计算特别有用，因为它可以节省内存并提高效率。

1、iter函数：
1-1、Python：
  1. # 1.函数：iter
  2. # 2.功能：
  3. # 2-1、用于根据指定的可迭代集合对象生成一个迭代器
  4. # 2-2、用于根据指定的可调用对象来生成一个迭代器
  5. # 3.语法：
  6. # 3-1、iter(object)
  7. # 3-2、iter(object, sentinel)
  8. # 4.参数：
  9. # 4-1、object:单参数形式出现，则是支持迭代的集合对象，即任意可迭代对象；若指定了sentinel参数，则必须是一个可调用的对象
  10. # 4-2、sentinel:若此参数出现，则object必须是一个可调用的对象
  11. # 5.返回值：返回一个迭代器iterator对象
  12. # 6.说明：
  13. # 7.示例：
  14. # 利用dir()函数获取函数的相关内置属性和方法
  15. print(dir(iter))
  16. # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
  17. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
  18. # '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
  19. # '__str__', '__subclasshook__', '__text_signature__']
  20.  
  21. # 利用help()函数获取函数的文档信息
  22. help(iter)
  23.  
  24. # 应用一：遍历可迭代对象
  25. # 示例1：遍历列表
  26. my_list = [1, 2, 3, 4, 5]
  27. it = iter(my_list)
  28. try:
  29.     while True:
  30.         print(next(it))
  31. except StopIteration:
  32.     print("遍历结束")
  33. # 1
  34. # 2
  35. # 3
  36. # 4
  37. # 5
  38. # 遍历结束
  39.  
  40. # 示例2：遍历字符串
  41. my_string = "Myelsa"
  42. it = iter(my_string)
  43. try:
  44.     while True:
  45.         print(next(it))
  46. except StopIteration:
  47.     print("遍历结束")
  48. # M
  49. # y
  50. # e
  51. # l
  52. # s
  53. # a
  54. # 遍历结束
  55.  
  56. # 示例3：遍历字典的键
  57. my_dict = {'a': 1, 'b': 2, 'c': 3}
  58. it = iter(my_dict)
  59. try:
  60.     while True:
  61.         print(next(it))
  62. except StopIteration:
  63.     print("遍历结束")
  64. # a
  65. # b
  66. # c
  67. # 遍历结束
  68.  
  69. # 示例4：遍历字典的值
  70. my_dict = {'a': 1, 'b': 2, 'c': 3}
  71. it = iter(my_dict.values())
  72. try:
  73.     while True:
  74.         print(next(it))
  75. except StopIteration:
  76.     print("遍历结束")
  77. # 1
  78. # 2
  79. # 3
  80. # 遍历结束
  81.  
  82. # 示例5：使用自定义可迭代对象
  83. class MyIterable:
  84.     def __init__(self, start, end):
  85.         self.value = start
  86.         self.end = end
  87.     def __iter__(self):
  88.         return self
  89.     def __next__(self):
  90.         if self.value < self.end:
  91.             current = self.value
  92.             self.value += 1
  93.             return current
  94.         else:
  95.             raise StopIteration
  96. # 创建一个自定义可迭代对象
  97. my_iterable = MyIterable(0, 5)
  98. # 使用iter()和next()遍历它
  99. it = iter(my_iterable)
  100. try:
  101.     while True:
  102.         print(next(it))
  103. except StopIteration:
  104.     print("遍历结束")
  105. # 0
  106. # 1
  107. # 2
  108. # 3
  109. # 4
  110. # 遍历结束
  111.  
  112. # 应用二：逐行读取大型文件
  113. # 打开文件，准备读取
  114. with open('file.txt', 'r') as file:
  115.     # 获取文件对象的迭代器
  116.     line_iter = iter(file)
  117.     try:
  118.         # 循环调用next()直到抛出StopIteration异常
  119.         while True:
  120.             line = next(line_iter)
  121.             print(line, end='')
  122.     except StopIteration:
  123.         # 当没有更多行时，捕获StopIteration异常并退出循环
  124.         print("\n文件读取完毕")
  125. # 121314536273838390
  126. # 123
  127. # 456
  128. # 789
  129. # 587
  130. # 1024
  131. # 文件读取完毕
  132.  
  133. # 应用三：实现惰性求值
  134. # 示例1：计算一个无限序列的平方数
  135. # 使用生成器表达式创建一个生成器
  136. square_gen = (x ** 2 for x in iter(int, 1))  # iter(int, 1) 创建了一个无限迭代器，从0开始递增，直到触发StopIteration（通过传递哨兵值1）
  137. # 使用next()函数惰性求值，获取平方数序列的前几个数
  138. print(next(square_gen))  # 输出: 0
  139. print(next(square_gen))  # 输出: 1
  140. print(next(square_gen))  # 输出: 4
  141. print(next(square_gen))  # 输出: 9
  142. # ... 可以继续调用next()获取更多的平方数
  143. # 如果我们想要获取前N个平方数，可以这样做：
  144. N = 10
  145. squares = [next(square_gen) for _ in range(N)]
  146. print(squares)  # 输出前10个平方数
  147.  
  148. # 示例2：创建一个自定义的迭代器类，并在其__iter__方法中使用iter()来实现惰性求值
  149. class LazySquares:
  150.     def __init__(self, start=0):
  151.         self.start = start
  152.     def __iter__(self):
  153.         return (x ** 2 for x in iter(int, 1))
  154. # 创建一个LazySquares对象
  155. lazy_squares = LazySquares()
  156. # 获取LazySquares对象的迭代器
  157. sq_iter = iter(lazy_squares)
  158. # 使用next()函数惰性求值，获取平方数序列的前几个数
  159. print(next(sq_iter))  # 输出: 0
  160. print(next(sq_iter))  # 输出: 1
  161. print(next(sq_iter))  # 输出: 4
  162. print(next(sq_iter))  # 输出: 9
  163. # ... 可以继续调用next()获取更多的平方数
  164.  
  165. # 应用四：表示无限序列
  166. # 示例1: 无限自然数序列
  167. def natural_numbers():
  168.     n = 1
  169.     while True:
  170.         yield n
  171.         n += 1
  172. # 创建无限自然数序列的迭代器
  173. nat_nums_iter = iter(natural_numbers())
  174. # 打印前几个自然数
  175. for _ in range(10):
  176.     print(next(nat_nums_iter))
  177. # 1
  178. # 2
  179. # 3
  180. # 4
  181. # 5
  182. # 6
  183. # 7
  184. # 8
  185. # 9
  186. # 10
  187.  
  188. # 示例2: 无限平方数序列
  189. def square_numbers():
  190.     n = 1
  191.     while True:
  192.         yield n ** 2
  193.         n += 1
  194. # 创建无限平方数序列的迭代器
  195. sq_nums_iter = iter(square_numbers())
  196. # 打印前几个平方数
  197. for _ in range(10):
  198.     print(next(sq_nums_iter))
  199. # 1
  200. # 4
  201. # 9
  202. # 16
  203. # 25
  204. # 36
  205. # 49
  206. # 64
  207. # 81
  208. # 100
  209.  
  210. # 示例3: 无限斐波那契数列
  211. def fibonacci():
  212.     a, b = 0, 1
  213.     while True:
  214.         yield a
  215.         a, b = b, a + b
  216. # 创建无限斐波那契数列的迭代器
  217. fib_iter = iter(fibonacci())
  218. # 打印前几个斐波那契数
  219. for _ in range(10):
  220.     print(next(fib_iter))
  221. # 0
  222. # 1
  223. # 1
  224. # 2
  225. # 3
  226. # 5
  227. # 8
  228. # 13
  229. # 21
  230. # 34
  231.  
  232. # 应用五：自定义迭代器
  233. # 示例1: 自定义迭代器用于遍历列表
  234. class MyListIterator:
  235.     def __init__(self, data):
  236.         self.index = 0
  237.         self.data = data
  238.     def __iter__(self):
  239.         return self
  240.     def __next__(self):
  241.         if self.index < len(self.data):
  242.             result = self.data[self.index]
  243.             self.index += 1
  244.             return result
  245.         else:
  246.             raise StopIteration
  247. # 使用自定义迭代器
  248. my_list = [1, 2, 3, 4, 5]
  249. my_iter = MyListIterator(my_list)
  250. # 使用iter()函数获取迭代器
  251. iter_obj = iter(my_iter)
  252. # 打印列表中的元素
  253. for item in iter_obj:
  254.     print(item)
  255. # 1
  256. # 2
  257. # 3
  258. # 4
  259. # 5
  260.  
  261. # 示例2: 自定义迭代器用于遍历文件行
  262. class FileLineIterator:
  263.     def __init__(self, file_path):
  264.         self.file = open(file_path, 'r')
  265.         self.line = self.file.readline()
  266.     def __iter__(self):
  267.         return self
  268.     def __next__(self):
  269.         if self.line:
  270.             line = self.line
  271.             self.line = self.file.readline()
  272.             return line.strip()
  273.         else:
  274.             self.file.close()
  275.             raise StopIteration
  276. # 使用自定义迭代器遍历文件行
  277. file_path = 'file.txt'
  278. file_iter = FileLineIterator(file_path)
  279. # 使用iter()函数获取迭代器
  280. iter_obj = iter(file_iter)
  281. # 打印文件的每一行
  282. for line in iter_obj:
  283.     print(line)
  284. # 121314536273838390
  285. # 123
  286. # 456
  287. # 789
  288. # 587
  289. # 1024
  290.  
  291. # 示例3: 自定义迭代器用于生成偶数序列
  292. class EvenNumberIterator:
  293.     def __init__(self, start=0):
  294.         self.number = start
  295.     def __iter__(self):
  296.         return self
  297.     def __next__(self):
  298.         if self.number % 2 == 0:
  299.             result = self.number
  300.             self.number += 1
  301.             return result
  302.         else:
  303.             self.number += 1
  304.             return self.__next__()
  305. # 使用自定义迭代器生成偶数
  306. even_iter = EvenNumberIterator()
  307. # 使用iter()函数获取迭代器
  308. iter_obj = iter(even_iter)
  309. # 打印前几个偶数
  310. for _ in range(10):
  311.     print(next(iter_obj))
  312. # 0
  313. # 2
  314. # 4
  315. # 6
  316. # 8
  317. # 10
  318. # 12
  319. # 14
  320. # 16
  321. # 18
  322.  
  323. # 应用六：与for循环结合使用
  324. # 示例1: 遍历列表
  325. my_list = [1, 2, 3, 4, 5]
  326. # 使用iter()函数获取列表的迭代器
  327. list_iter = iter(my_list)
  328. # 使用for循环遍历迭代器
  329. for item in list_iter:
  330.     print(item)
  331. # 1
  332. # 2
  333. # 3
  334. # 4
  335. # 5
  336.  
  337. # 示例2: 遍历字典的键
  338. my_dict = {'a': 1, 'b': 2, 'c': 3}
  339. # 使用iter()函数获取字典键的迭代器
  340. dict_keys_iter = iter(my_dict.keys())
  341. # 使用for循环遍历字典的键
  342. for key in dict_keys_iter:
  343.     print(key)
  344. # a
  345. # b
  346. # c
  347.  
  348. # 示例3: 遍历字典的值
  349. my_dict = {'a': 1, 'b': 2, 'c': 3}
  350. # 使用iter()函数获取字典值的迭代器
  351. dict_Values_iter = iter(my_dict.values())
  352. # 使用for循环遍历字典的值
  353. for Value in dict_Values_iter:
  354.     print(Value)
  355. # 1
  356. # 2
  357. # 3
  358.  
  359. # 示例4: 遍历自定义迭代器的元素
  360. class MyCustomIterator:
  361.     def __init__(self, start, end):
  362.         self.current = start
  363.         self.end = end
  364.     def __iter__(self):
  365.         return self
  366.     def __next__(self):
  367.         if self.current < self.end:
  368.             result = self.current
  369.             self.current += 1
  370.             return result
  371.         else:
  372.             raise StopIteration
  373. # 创建自定义迭代器的实例
  374. my_custom_iter = MyCustomIterator(0, 5)
  375. # 使用iter()函数获取迭代器（实际上这一步是可选的，因为my_custom_iter本身就是一个迭代器）
  376. custom_iter = iter(my_custom_iter)
  377. # 使用for循环遍历自定义迭代器的元素
  378. for item in custom_iter:
  379.     print(item)
  380. # 0
  381. # 1
  382. # 2
  383. # 3
  384. # 4
  385.  
  386. # 示例4: 遍历文件的行
  387. with open('file.txt', 'r') as file:
  388.     # 使用iter()函数获取文件行的迭代器
  389.     line_iter = iter(file)
  390.     # 使用for循环遍历文件的每一行
  391.     for line in line_iter:
  392.         print(line.strip())
  393. # 121314536273838390
  394. # 123
  395. # 456
  396. # 789
  397. # 587
  398. # 1024
1-2、VBA：
略，待后补。
2、推荐阅读：

1、Python-VBA函数之旅-issubclass()函数

Python算法之旅：Algorithm

Python函数之旅：Functions 

个人主页：神奇夜光杯-CSDN博客 
文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览61131 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/138170372"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！