上篇➡️[Python基础速成]1-Python规范与核心语法

Python模块

Python 中的模块（Module）是一个包含 Python 定义和语句的文件，文件名就是模块名加上 .py 后缀。
模块可以包含函数、类、变量以及可执行的代码。通过模块，我们可以将代码组织成可重用的单元，便于管理和维护。

即模块具备代码复用、命名空间管理、代码组织作用。

创建模块与导入

使用import语句导入python源文件。

import module1[, module2[,... moduleN]

Python自定义模块（文件）然后导入示例如下：
1.创建一个fibo.py文件

# 斐波那契(fibonacci)数列模块
 
def fib(n):    # 定义到 n 的斐波那契数列
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()
 
def fib2(n): # 返回到 n 的斐波那契数列
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

2.导入使用

# to test the import

import fibo

def test_fib():
    fibo.fib(10)


test_fib()

总的来说和Java的差不多，有点类似Java导入静态类。
Python还支持部分导入，即from…import语句。

from modname import name1[, name2[, ... nameN]]
# 示例
from fibo import fib, fib2

属性__name__

每个模块都有一个__name__ 属性。

如果模块是被直接运行，__name__ 的值为 __main__。

如果模块是被导入的，__name__ 的值为模块名。

比如上面创建的fibo模块，在模块文件内添加

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

如果fibo模块被其他模块执行，则会输出“我来自另一模块”

dir()函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。

import sys

dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

标准模块

模块名	功能描述
math	数学运算（如平方根、三角函数等）
os	操作系统相关功能（如文件、目录操作）
sys	系统相关的参数和函数
random	生成随机数
datetime	处理日期和时间
json	处理 JSON 数据
re	正则表达式操作
collections	提供额外的数据结构（如 defaultdict、deque）
itertools	提供迭代器工具
functools	高阶函数工具（如 reduce、lru_cache）

Python包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

类似Java的Package，包路径+模块名=全路径=唯一性

语法为：

from Package import specific_submodule 

# 示例
# 导入collections.abc包下的Callable模块
from collections.abc import Callable

---

类

Python使用class关键字定义类。

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Python的self类似Java的this，在类中代指类对象本身。

类的专有方法

• __init__()

__inin__()将在类创建新示例时被调用，是构造方法。

#!/usr/bin/python3
 
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

对象

通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

继承

即一个派生类（derived class）继承基类（base class）的字段和方法。

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

# 多继承
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

多态

Python的方法重写（Override）和Java类似，且不需要Java的@Override注解。
Python是动态类型语言，不允许同名方法因参数不同而共存，因此不支持传统重载（Overload）。
但可以使用默认参数或可变参数模拟重载。

class Example:
	# 
    def greet(self, name=None):
        if name:
            print(f"Hello, {name}!")
        else:
            print("Hello, World!")

obj = Example()
obj.greet()          # 输出: Hello, World!
obj.greet("Alice")   # 输出: Hello, Alice!

拷贝

在上一篇，我们有了解到Python对象的传递为“传递引用副本”。

Java严格采用值传递（Pass by Value），对象类型传递引用的副本。因此，Java函数内修改传递的值不会修改原值，通过传递的引用修改对象内容会影响原对象，将引用副本指向新的对象不会影响原应用。
Python的参数传递与Java一致。不可变对象表现为值传递，可变对象表现为“传递引用副本”。

Python按照拷贝内容也分浅拷贝（Shallow Copy）与深拷贝（Deep Copy）。

• 浅拷贝（Shallow Copy）：
  只复制对象的第一层结构，嵌套对象（子对象）仍共享引用。类似Java的“浅克隆”，新对象与原对象指向相同的嵌套对象。
• 深拷贝（Deep Copy）：
  递归复制对象及其所有嵌套对象，生成完全独立的副本。类似Java的“深克隆”，新对象与原对象没有任何共享引用。

Python的copy模块提供了拷贝功能：

• 浅拷贝：copy.copy(obj)
• 深拷贝：copy.deepcopy(obj)

其他方式：

• 列表的切片（如lst[:]）或list(lst)是浅拷贝。
• 字典的dict.copy()是浅拷贝。

示例代码如下：

import copy

# 创建一个包含嵌套列表的复杂对象
original = [1, 2, [3, 4], {'a': 5}]

# 赋值（引用） 和original指向同一对象,修改assigned直接影响original
assigned = original

# 浅拷贝 只复制第一层,嵌套对象仍共享引用，shallow_copied修改嵌套对象会影响original、assigned
shallow_copied = copy.copy(original)

# 深拷贝 完全独立，修改任何层级都不影响original。
deep_copied = copy.deepcopy(original)

# 修改第一层元素
assigned[0] = 99
shallow_copied[0] = 88
deep_copied[0] = 77

# 修改嵌套列表
assigned[2][0] = 999
shallow_copied[2][0] = 888
deep_copied[2][0] = 777

# 修改嵌套字典
assigned[3]['a'] = 555
shallow_copied[3]['a'] = 444
deep_copied[3]['a'] = 333

# 输出结果
print("原始对象:", original)
print("赋值对象:", assigned)
print("浅拷贝:", shallow_copied)
print("深拷贝:", deep_copied)

运行结果为

原始对象: [99, 2, [888, 4], {'a': 444}]
赋值对象: [99, 2, [888, 4], {'a': 444}]
浅拷贝: [88, 2, [888, 4], {'a': 444}]
深拷贝: [77, 2, [777, 4], {'a': 333}]