import os
def get_all_files(directory):
file_list = []
# os.walk
返回一个生成器,每次迭代时返回当前目录路径、子目录列表和文件列表
for root, dirs, files in os.walk(directory):
for file in files:
file_list.append(os.path.join(root, file))
return file_list
current_directory = os.getcwd()
files = get_all_files(current_directory)
for file in files:
print(file)
迭代器(Iterator)是一种实现了迭代协议的对象,它必须提供一个__iter__()
方法和一个__next__()
方法。通过调用__iter__()
方法,迭代器可以返回自身,并且通过调用__next__()
方法,迭代器可以依次返回下一个元素,直到没有更多元素时抛出StopIteration
异常。迭代器是一种惰性计算的方式,每次只在需要时生成一个元素,从而节省内存空间。可以使用iter()
函数将可迭代对象转换为迭代器。
生成器(Generator)是一种特殊的迭代器,它使用了更为简洁的语法来定义迭代器。生成器可以通过函数中的yield
关键字来实现,当函数执行到yield
语句时,会暂停执行并返回一个值,保存当前状态,下次调用时从上次暂停的位置继续执行。生成器函数可以像普通函数一样接收参数,并且可以包含循环、条件语句等逻辑。生成器是一种非常方便和高效的迭代器实现方式。
下面是生成器和迭代器的区别总结:
总之,生成器是一种特殊的迭代器,它提供了更简洁和方便的语法。生成器可以通过函数中的yield
语句来实现迭代过程,并且可以像普通函数一样编写逻辑。迭代器是一种更通用的概念,可以通过类来实现,需要显式地定义__iter__()
和__next__()
方法。无论是生成器还是迭代器,它们都能够实现按需生成和处理大量数据的能力,提高了代码的效率和可读性。
一个小栗子:
当我们需要遍历一个很大的数据集时,生成器可以帮助我们按需生成数据,而不是一次性加载整个数据集到内存中。
下面是一个简单的例子,我们使用生成器来按需生成斐波那契数列的前n个元素:
def fibonacci_generator(n):
a, b = 0, 1
count = 0
while count < n:
yield a
a, b = b, a + b
count += 1
fibonacci = fibonacci_generator(10)
for num in fibonacci:
print(num)
在上述代码中,我们定义了一个生成器函数fibonacci_generator
,它使用了yield
语句来生成斐波那契数列的元素。每次调用生成器的__next__()
方法时,它会执行到yield
语句处,
返回当前的斐波那契数并暂停执行,保存当前状态。然后,下次调用生成器的__next__()
方法时,它会从上次暂停的位置继续执行,生成下一个斐波那契数。这样,我们可以通过迭代生成器
来按需获取斐波那契数列的元素。当我们遍历生成器对象时,它会依次生成斐波那契数列的元素并打印出来。由于生成器是按需生成数据的,它只在需要时生成一个元素,而不是一次性生成整
个数列。这样可以节省内存空间,特别是当斐波那契数列很大时。总结起来,生成器可以看作是一种特殊的函数,它能够按需生成数据,节省内存空间,并且提供了一种简洁和方便的方式来
实现迭代器。通过使用生成器,我们可以避免一次性加载大量数据到内存中,而是在需要时逐个生成数据,从而提高代码的效率和可扩展性。
可迭代对象(Iterable)是指可以被迭代遍历的对象。在许多编程语言中,迭代是指按照一定的顺序逐个访问集合中的元素的过程。在Python中,可迭代对象是指实现了迭代器协议(Iterator Protocol)的对象。
迭代器协议包含两个方法:
__iter__()方法:该方法返回一个迭代器对象。迭代器对象用于实现具体的迭代逻辑,并且必须包含__next__()方法。
__next__()方法:该方法返回迭代器中的下一个元素。如果没有元素可供返回,它应该引发StopIteration异常。
当我们使用可迭代对象进行迭代时,实际上是通过迭代器对象来完成的。迭代器对象负责追踪当前的迭代状态,并提供下一个元素。迭代器对象会在每次迭代时调用__next__()方法,并返回下一个元素,直到遍历完所有元素或者引发StopIteration异常为止。
Python中许多内置的数据类型和容器都是可迭代对象,例如列表(List)、元组(Tuple)、字典(Dictionary)、集合(Set)等。此外,我们也可以通过自定义类来实现可迭代对象,只需在类中定义__iter__()方法,并在该方法中返回一个迭代器对象即可。
以下是一个示例,展示了如何使用可迭代对象和迭代器对象进行迭代:
# 创建一个可迭代对象
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)
try:
while True:
item = next(my_iter)
print(item)
except StopIteration:
pass
在上述示例中,我们通过调用iter()
函数获取了my_list
的迭代器对象my_iter
,然后使用next()
函数从迭代器对象中获取下一个元素并打印,直到遍历完所有元素或引发
StopIteration
异常为止。可迭代对象的原理是基于迭代器协议的实现,通过迭代器对象的__next__()方法来提供序列中的下一个元素。这种机制使得我们可以方便地对集合中的元素
进行逐个访问和处理,提供了一种统一的迭代接口
自己实现可迭代对象小栗子
class MyIterable:
def __init__(self, data):
self.data = data
def \_\_iter\_\_(self):
self.index = 0
return self
def \_\_next\_\_(self):
if self.index < len(self.data):
item = self.data\[self.index\]
self.index += 1
return item
else:
raise StopIteration
my_iterable = MyIterable([1, 2, 3, 4, 5])
for item in my_iterable:
print(item)
Python 2.x 和 Python 3.x 之间的一些主要区别:
打印函数:在 Python 2.x 中,打印语句是一个关键字,使用类似于 print "Hello"
的语法。而在 Python 3.x 中,print
被改造为一个内置函数,需要使用括号,例如 print("Hello")
。
整数除法:在 Python 2.x 中,整数除法的结果会被截断为整数,例如 5 / 2
的结果是 2
。而在 Python 3.x 中,整数除法的结果将保留小数部分,得到浮点数结果,例如 5 / 2
的结果是 2.5
。如果想要执行截断整数除法,可以使用 //
运算符。
Unicode 字符串:在 Python 2.x 中,字符串类型分为普通字符串和 Unicode 字符串(以 u
前缀表示),这导致字符串处理的一些混乱和困惑。而在 Python 3.x 中,所有字符串都是 Unicode 字符串,普通字符串是以字节表示的,需要使用 b
前缀表示。
xrange
替代 range
:在 Python 2.x 中,range
函数返回的是一个列表,如果需要生成大范围的整数序列,会占用大量内存。而在 Python 3.x 中,range
函数的实现类似于 Python 2.x 中的 xrange
,返回一个迭代器对象,节省了内存。
异常语法:在 Python 2.x 中,捕获异常时使用的语法是 except Exception, e
,将异常对象存储在变量 e
中。而在 Python 3.x 中,使用 except Exception as e
的语法,将异常对象存储在变量 e
中。
input
函数:在 Python 2.x 中,input
函数会将用户输入的内容作为 Python 代码进行解析,存在安全风险。而在 Python 3.x 中,input
函数始终将用户输入的内容作为字符串返回,不进行解析。
除了上述主要区别之外,Python 3.x 还进行了一些其他改进,包括改进的类定义语法、更好的模块管理和导入机制、更一致的异常处理和错误机制等。然而,这也导致了 Python 2.x 代码无法直接在 Python 3.x 中运行,需要进行一些修改和调整。
多线程(Multithreading):
threading
模块来创建和管理线程。通过创建 Thread
类的实例,指定要执行的函数或方法,并调用 start()
方法,可以启动一个线程。多进程(Multiprocessing):
multiprocessing
模块来创建和管理进程。通过创建 Process
类的实例,指定要执行的函数或方法,并调用 start()
方法,可以启动一个进程。总结:
全局解释器锁(Global Interpreter Lock,简称 GIL)是在 CPython 解释器中存在的一个特性。它是一种机制,用于保证同一时刻只有一个线程执行 Python 字节码。虽然 GIL 的存在确保了 CPython 解释器的线程安全性,但也对多线程并发执行带来了一些限制。
以下是对 GIL 的一些详细解释和理解:
GIL 的作用:
GIL 的影响:
解决 GIL 的方法:
multiprocessing
模块、concurrent.futures
模块等,提供了替代方案,使得在某些情况下可以绕过 GIL 的限制。需要注意的是,GIL 只存在于 CPython 解释器中,而其他实现(如 Jython、IronPython)可能没有 GIL。此外,对于许多类型的应用程序,如 I/O 密集型、并发处理不频繁的应用程序,GIL
的影响较小,可以继续使用多线程来实现并发。然而,对于 CPU 密集型任务和需要充分利用多核处理器的应用程序,考虑使用多进程或其他解决方案来规避 GIL。
手机扫一扫
移动阅读更方便
你可能感兴趣的文章