Python 学习(5) ---- Python 语法规则

迭代器

迭代器是访问集合元素的一种方式，是一个可以记住遍历的位置的对象
迭代器对象从集合的第一个元素开始访问，知道所有的元素被访问完结束，迭代器只能往前不能后退
迭代器有两个基本方法： iter() 和 next()
字符串，列表和元组对象都可以创建迭代器

迭代器有两个基本遍历方法：

lista = [1, 2, 3, 4, 5]
it = iter(lista)# 使用 while 语句 等到截获异常时结束
while True:try:print(next(it), end="")except StopIteration:print("\nprint list end")break# 直接使用 for 语句进行迭代
itb = iter(lista)
for x in itb:print(x, end="")
print("\n")

类的迭代器支持

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 和 __next__()

__iter__() 方法返回一个特殊的迭代器对象，这个跌代器对实现了 __next__() 方法并通过 StopIteration 异常标志迭代的完成

__next__() 方法会返回下一个迭代器对象

class myNumber:def __iter__(self):self.a = 1return selfdef __next__(self):if self.a < 20:x = self.aself.a += 1return xelse:raise StopIterationmyclass = myNumber()
myiter = iter(myclass)#for x in myiter:
#    print(f" {x}", end="")
while True:try:print(f" {next(myiter)}", end="")except StopIteration:print(f"\nmyNumber iter end")break

生成器(Generator)

在 Python 中，使用了 yield 的函数被称为生成器(generator)
yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不会是一次性返回所有结果 和普通函数不同，生成器函数会返回迭代器，只能用于迭代操作

在生成器中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式座位当前迭代的值返回

然后，每次调用生成器的 next()方法或使用 for 进行迭代的时，函数会从上次暂停的地方继续执行，直到遇到 yield 语句
这样，生成器函数可以逐步产生值，而不需要一次性计算返回所有结果

调用生成器函数，返回的是一个迭代器对象
TBD

Python Module

Python 模块(module)， 是一个 python 文件， 以 py 结尾， 包含了 Python 对象定义和 Python 语句
模块能够更有逻辑的组织你的 python 代码， 模块能够定义函数， 类和变量， 也可以包含可执行代码

import 语句

当解释器遇到 import 语句， 模块在当前的搜索路径就会被导入
搜索路径是一个解释器会先进行搜索的所有目录的列表
一个模块只会被导入一次， 不管你执行了多少次 import， 这样可以防止导入模块被一遍又一遍地执行

from … import

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中

from modulename import name1，[name2]，[name3] from lib import fibonacci 

将 fib 里的 fibonacci 单个引入执行

from … import*

将模块的全部内容都导入到当前的命名空间:

from modulename import *

搜索路径的规则如下:

1. 当前目录
2. 如果不在当前目录， python 会搜索 PYTHONPATH 环境变量下的目录
3. 都找不到， python 会查看默认路径， unix 下一般为 /usr/local/lib/python

命名空间和作用域

一个 python 表达式可以访问局部命名空间和全局命名空间， 如果一个局部变量和一个全局变量重名， 则局部变量会覆盖全局变量

Python 会智能猜测一个变量是局部的还是全局的， 它假设任何在函数内赋值的变量都是局部的， 因此要给函数内的全局变量赋值， 必须使用 global 关键字

global VarName 的表达式会告诉 Python， VarName 是一个全局变量， 这样 Python 就不会在局部命名空间里寻找这个变量了

dir 函数:

globals 和 locals 函数:

reload 函数:

python 里的自定义 Packages

包是一个分层次的文件目录结构， 它定义了一个由模块及子包， 简单说， 包就是文件夹， 但是该文件夹下必须存在 __init__.py 文件， 该文件的内容可以为空， __init__.py 用于标志当前文件夹是一个包

Python 异常

try … except

python 异常可以用 try .. except 语句捕捉

try 语句按照下面的方式进行工作:

• 首先, 执行 try 子句( 关键字 try 和 关键字 except 之间的语句)
• 如果没有异常发生，忽略 except 子句， try 子句执行后结束
• 如果在 try 子句的过程中发生了异常, 那么 try 子句余下的部分会被忽略, 如果异常类型和 except 之后的名称相符
  那么对应的 except 子句将被执行
• 如果一个异常没有和任何 except 匹配, 那么这个异常将会被传递到上层 try 中

一个 except 可以处理多个异常, 这些异常将被放在括号里称为一个元组 例如:

try:except(RuntimeError, TypeError, NameError):pass

一个 except 语句可以忽略异常的名称，这意味着它要捕获所有异常，可以使用这种方法打印一个错误信息，再将异常抛出

def exceptDemo():try:f = open("./file.txt")s = f.readline()i = int(s.strip())except OSError as err:print("OS Error: {0}".format(err))except ValueError:print("Value Error: {0}".format(ValueError))except Exception as e:print(f"error：{type(e).__name__} - {e}")print("Unexpected error:", sys.exc_info()[0])print("exiting...")return

try/except … else

try/except 语句后面还有一个可选的 else 语句, 如果使用这个子句, 那么必须放在所有的 except 子句之后
else 子句将在 try 子句没有发生任何异常的时候执行

def exceptElseDemo():try:f = open("./source/example.txt")s = f.readline()i = int(s.strip())except OSError as err:print("OS Error: {0}".format(err))except ValueError:print("Value Error: {0}".format(ValueError))except Exception as e:print(f"error：{type(e).__name__} - {e}")print("Unexpected error:", sys.exc_info()[0])else:print("this in else case")print("exiting...")return

try-finnally 语句

try-finnaly 语句无论是否发生异常都将会执行最后的代码

def exceptElseFinallyDemo():try:f = open("./source/example.txt")s = f.readline()i = int(s.strip())except OSError as err:print("OS Error: {0}".format(err))except ValueError:print("Value Error: {0}".format(ValueError))except Exception as e:print(f"error：{type(e).__name__} - {e}")print("Unexpected error:", sys.exc_info()[0])else:print("this in else case")finally:print("this is in finally demo")print("exiting...")return

with 语句

python 编程中的资源管理是一个重要但是容易被忽视的细节， with 关键字为我们提供了一种优雅的方式处理文件操作，数据库连接等需要明确释放资源的场景

with 是 python 的一个关键字， 用于上下文协议(Context Management protocol)， 简化了资源管理代码，特别是那些需要明确释放和清理的资源(资源，网络连接，数据库连接)

一个常见的情形:

file = open("example.txt"， r)
try:content = file.read()
finally:file.close()

这种写法弊端：

• 容易忘记关闭资源
• 代码冗长
• 异常处理复杂

with 关键字的优势

• 自动资源释放
• 代码简洁
• 异常安全
• 可读性强

with 语句工作原理

上面打开文件的操作改用 with 写法:

with open("python_basic/source/example.txt"， 'r+') as f:content = f.read()
print(content)

with 是使用 python 的上下文管理协议， 该协议要求对象实现两种方法:

1. enter(): 进入上下文时调用，返回后赋给 as 后的变量
2. exit(): 退出上下文调用，处理清理工作

exit() 方法接受三个参数:
exc_type：异常类型
exc_val: 异常值
exc_tb: 移除追踪信息

如果 exit() 返回 true， 表示异常被处理，不会继续传播，返回 False 或者 None， 异常会继续向外传播

# 一次性读取整个文件内容 并返回一个字符串
with open("python_basic/source/example.txt", 'r+') as f:content = f.read()
print(content)print("=========================readline================================")
# readline 每次读取一行
with open("python_basic/source/example.txt", 'r') as f:lines = f.readlines()print("lines type is:{0} size:{1}".format(type(lines), len(lines)))index = 0
for line in lines:print("line[{0}]: {1}".format(index, line), end="")index += 1
print("\n=========================================================")
with open("python_basic/source/example.txt", 'r') as f:line = f.readline()while line:print(line, end="")line = f.readline()print("\n=========================================================")
with open("python_basic/source/example_write.txt", 'w+') as f:f.write("wangchen date:20250810\n")print("write success!")

__name__

`__name__ 是一个内置变量，表示当前模块的名称

__name__ 的值取决于 模块是如何被使用的， 如果作为主程序运行， __name__ 会被设置为 __main__
如果作为子模块被导入， __name__ 会被设置为模块的名称

__main__ 是一个特殊的字符串，用于表示当前模块是作为主程序运行的， __main__ 通常与 __name__ 变量一起使用，以确定模块是被导入还是作为独立脚本运行