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 = 1
	    return self
	
	def __next__(self):
	    if self.a < 20:
	        x = self.a
	        self.a += 1
	        return x
	    else:
	        raise StopIteration

myclass = 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 *

搜索路径的规则如下:

当前目录
如果不在当前目录， python 会搜索 PYTHONPATH 环境变量下的目录
都找不到， 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 语句捕捉
except01

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 语句无论是否发生异常都将会执行最后的代码
except03

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

except02

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 的上下文管理协议，该协议要求对象实现两种方法:

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

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

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

with

# 一次性读取整个文件内容 并返回一个字符串
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!")