Python-VBA函数之旅-repr函数

一、repr函数的常见应用场景

二、repr函数使用注意事项

三、如何用好repr函数？

1、repr函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：https://blog.csdn.net/ygb_1024?spm=1010.2135.3001.5421

一、repr函数的常见应用场景

repr函数在Python中有多种实际应用场景，常见的应用场景有：

1、调试和日志记录：当在开发过程中需要记录或调试对象的状态时，repr()函数可以提供一个清晰、易于理解的字符串表示，这有助于识别对象是否按预期被创建和修改。

2、创建有效的Python代码：由于repr()函数通常返回一个有效的Python表达式，因此它可以用于创建或修改Python代码。例如，如果你有一个字典或列表，并希望将其转换为Python源代码中的表示形式，你可以使用repr()函数。

3、自定义对象的字符串表示：通过为自定义类实现__repr__()方法，你可以控制当对象被repr()函数调用时返回的字符串，这对于创建用户友好的输出或确保对象可以被准确地重新创建(通过 eval(repr(obj)))非常有用。

4、数据持久化：虽然repr()函数不应被用作通用的序列化机制(因为有更健壮的库如pickle或 json)，但在某些情况下，将对象转换为repr()字符串可以作为一种简单的持久化方法。例如，如果你有一个简单的数据结构，并且只需要在同一Python环境中重新加载它，那么使用repr()函数可能就足够了。

5、文档和示例：在编写文档或示例代码时，使用repr()函数可以自动获取对象的字符串表示，而无需手动编写它，这有助于确保文档中的示例与实际代码保持一致。

6、用户界面和命令行工具：在构建需要显示对象信息的用户界面或命令行工具时，repr()函数可以提供一个简洁、一致的表示形式。例如，一个命令行工具可能会使用repr()函数来显示其内部数据结构的当前状态。

7、测试和断言：在编写测试时，repr()可以用于比较对象的预期值和实际值，虽然更常见的是使用 `==` 运算符或专门的断言函数(如assertEqual)，但在某些情况下，比较对象的repr()表示可能更方便或更可靠。

8、交互式解释器：在Python的交互式解释器中，当你输入一个表达式并按下回车键时，它通常会显示该表达式的repr()表示，这使得你能够直观地看到表达式的值以及它的类型和其他属性。

注意，虽然repr()函数在许多情况下都很有用，但也有一些限制和注意事项。例如，repr()函数的输出可能包含换行符和引号等特殊字符，这可能会使输出难以阅读或处理。此外，repr()函数的输出通常不是为人类用户设计的，而是为Python解释器设计的，因此，在需要向人类用户显示对象信息时，通常使用str()函数而不是repr()函数。

二、repr函数使用注意事项

在使用Python中的repr()函数时，需牢记以下注意事项：

1、安全性：repr()函数返回的字符串通常是可以被eval()函数安全地执行的(尽管这并不意味着你应该总是使用eval()函数来处理repr()函数的输出，因为eval()函数本身就存在安全风险)，但是，如果你将repr()函数的输出用于其他目的(如文件写入、网络传输等)，则需要确保它不会造成安全问题。

2、可读性：虽然repr()函数返回的字符串通常是机器可读的，但它可能不总是人类可读的，对于复杂的对象，repr()函数的输出可能会很长且难以理解，因此，在需要向用户显示对象信息时，可能需要考虑使用其他方法(如自定义的__str__方法)来生成更友好的输出。

3、避免无限递归：如果你在自定义类的__repr__方法中使用了递归(即调用了自身的__repr__方法)，则需要小心避免无限递归。例如，如果你有两个对象相互引用对方，并且它们的__repr__方法都试图包含对方的repr()表示，那么这将导致无限递归和栈溢出错误。

4、不要用于序列化：虽然repr()可以将对象转换为字符串表示，但它并不是一种通用的序列化方法；对于复杂的对象或包含不可序列化数据(如文件句柄、网络连接等)的对象，repr()的输出可能无法被正确地转换回原始对象，因此，在需要序列化对象时，应该使用专门的序列化库(如pickle、json等)。

5、自定义__repr__方法时要小心：当你为自定义类实现__repr__方法时，需要确保返回的字符串是有效的Python表达式，并且可以被eval()函数安全地执行(尽管你不应该总是依赖eval())，此外，你还应该考虑如何处理类的私有属性和敏感数据，以避免在repr()的输出中泄露这些信息。

6、区分__repr__和__str__：__repr__和__str__都是Python中用于定义对象字符串表示的特殊方法，但它们有不同的用途和约定：__repr__应该返回一个对象的官方、无歧义且通常可评估的字符串表示，而__str__则应该返回一个对用户友好的、易读的字符串表示，在编写自定义类时，你应该同时考虑这两个方法，并根据需要为它们提供不同的实现。

7、避免循环引用：在处理包含循环引用的数据结构时，实现__repr__方法时要特别小心；循环引用可能导致无限递归或无限增长的字符串表示，在这种情况下，您可能需要使用特殊的技巧或算法来生成有效的字符串表示。

三、如何用好repr函数？

要充分利用Python中的repr()函数，需遵循以下建议：

1、理解repr()的目的：repr()函数的目的是返回一个对象的官方字符串表示，这通常是一个有效的Python表达式，可以重新创建该对象(尽管并不总是能精确重建)。

2、为自定义类实现__repr__方法：当你创建自定义类时，实现一个清晰的__repr__方法可以帮助你和其他开发者更容易地理解和调试代码，确保__repr__返回的字符串表示是准确、清晰且易于理解的，考虑包括类的名称和关键属性在字符串表示中。

3、注意安全性：避免将repr()函数的输出直接传递给eval()函数，除非你确定内容是安全的，当处理来自不可信来源的数据时，要特别小心。

4、测试__repr__方法：编写单元测试来验证你的__repr__方法是否返回预期的输出，确保 eval(repr(obj))能够重新创建原始对象(如果适用)。

5、避免无限递归：当处理递归数据结构时，确保__repr__方法有明确的终止条件，以避免无限递归。

6、优化性能：如果repr()的调用成为性能瓶颈，请考虑优化代码或使用其他替代方案，避免在 __repr__方法中执行复杂的计算或操作。

7、保持一致性：对于同一类型的对象，__repr__方法应该始终返回相同格式的字符串表示。

8、考虑使用pprint模块：如果需要更美观或更易读的输出，可以考虑使用pprint模块来打印复杂的数据结构，pprint模块提供了pprint()和pformat()函数，它们可以格式化输出，使其更易于阅读。

9、避免在用户界面中使用repr()：通常，repr()函数返回的字符串表示是为了调试和日志记录而设计的，而不是为了向最终用户显示，在用户界面或向用户显示数据时，请考虑使用str()函数或自定义的格式化方法。

10、遵循PEP8风格指南：当实现__repr__方法时，请遵循 Python 的官方编码风格指南PEP8。例如，确保字符串表示中的类名、属性名和值之间使用适当的空格和标点符号。

总之，只有通过遵循这些建议和实践，你才能更好地利用repr()函数，并在你的Python代码中获得更清晰、更易于理解和调试的字符串表示。

1、repr函数：

1-1、Python：

# 1.函数：repr
# 2.功能：用于将对象转化为供解释器读取的形式，通常表示为可打印的字符串
# 3.语法：repr(object)
# 4.参数：object，表示任何Python对象，你想要获取其repr表示法的对象
# 5.返回值：返回一个对象的官方字符串表示形式，即字符串
# 6.说明：
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(repr))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
# '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', '__text_signature__']

# 用help()函数获取该函数的文档信息
help(repr)

# 应用一：调试和日志记录
# 示例1：简单类与repr()
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age})"
# 使用示例
p = Person("Myelsa", 18)
print(repr(p))
# Person(name='Myelsa', age=18)

# 示例2：使用logging模块与repr()
import logging
class Circle:
    def __init__(self, radius):
        self.radius = radius
    def __repr__(self):
        return f"Circle(radius={self.radius})"
# 配置logging
logging.basicConfig(level=logging.INFO)
# 创建一个Circle对象并使用logging记录其状态
c = Circle(6)
logging.info("Circle object: %s", repr(c))
# INFO:root:Circle object: Circle(radius=6)

# 示例3：调试时打印复杂数据结构
data = [
    {"name": "Myelsa", "age": 18, "city": "Guangzhou"},
    {"name": "Bruce", "age": 6, "city": "Foshan"},
    # ... 更多的字典 ...
]
# 使用repr()查看数据结构
print(repr(data))
# [{'name': 'Myelsa', 'age': 18, 'city': 'Guangzhou'}, {'name': 'Bruce', 'age': 6, 'city': 'Foshan'}]

# 示例4：自定义repr()以隐藏敏感信息
class User:
    def __init__(self, username, password):
        self.username = username
        self._password = password  # 使用下划线前缀表示这是一个“私有”属性
    def __repr__(self):
        return f"User(username={self.username!r}, password=***)"
# 使用示例
u = User("myelsa@example.com", "secret_password")
print(repr(u))
# User(username='myelsa@example.com', password=***)

# 应用二：创建有效的Python代码
# 示例1：基础类型
# 整数
num = 42
print(repr(num))
# 浮点数
float_num = 3.14159
print(repr(float_num))
# 字符串
s = "Hello, world!"
print(repr(s))
# 42
# 3.14159
# 'Hello, world!'

# 示例2：自定义类
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"Point({self.x}, {self.y})"
# 创建一个Point对象
p = Point(1, 2)
# 使用repr()获取其表示，并尝试用eval()重新创建它
p_repr = repr(p)
print(p_repr)  # 输出: 'Point(1, 2)'
try:
    p_new = eval(p_repr)
    print(p_new.x, p_new.y)  # 输出: 1 2
except NameError:
    # 注意：eval()在当前命名空间中找不到Point类时会抛出NameError
    # 为了使eval()工作，需要确保Point类在eval()的命名空间中可用
    pass
# Point(1, 2)
# 1 2

# 示例3：包含复杂数据的类
class Person:
    def __init__(self, name, age, friends=None):
        self.name = name
        self.age = age
        self.friends = friends if friends is not None else []
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age}, friends=[{', '.join(repr(f) for f in self.friends)}])"
# 创建一个Person对象，并为其添加一些朋友
p = Person("Myelsa", 18)
p.friends.append(Person("Bruce", 6))
p.friends.append(Person("Jimmy", 15))
# 使用repr()获取其表示
p_repr = repr(p)
print(p_repr)
# Person(name='Myelsa', age=18, friends=[Person(name='Bruce', age=6, friends=[]), Person(name='Jimmy', age=15, friends=[])])

# 应用三：自定义对象的字符串表示
# 示例1：简单的自定义对象
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age})"
# 创建一个Person对象
p = Person("Myelsa", 18)
# 打印对象的repr()表示
print(repr(p))
# Person(name='Myelsa', age=18)

# 示例2：包含列表的自定义对象
class Team:
    def __init__(self, name, members):
        self.name = name
        self.members = members
    def __repr__(self):
        return f"Team(name={self.name!r}, members=[{', '.join(repr(m) for m in self.members)}])"
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age})"
# 创建一个Team对象，其中members是一个Person对象的列表
p1 = Person("Myelsa", 18)
p2 = Person("Bruce", 6)
t = Team("Developers", [p1, p2])
# 打印对象的repr()表示
print(repr(t))
# Team(name='Developers', members=[Person(name='Myelsa', age=18), Person(name='Bruce', age=6)])

# 示例3：嵌套的自定义对象
class Address:
    def __init__(self, street, city, country):
        self.street = street
        self.city = city
        self.country = country
    def __repr__(self):
        return f"Address(street={self.street!r}, city={self.city!r}, country={self.country!r})"
class Employee:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address
    def __repr__(self):
        return f"Employee(name={self.name!r}, age={self.age}, address={repr(self.address)})"
# 创建一个Address对象和一个Employee对象
a = Address("123 Main St", "Springfield", "USA")
e = Employee("Homer Simpson", 42, a)
# 打印对象的repr()表示
print(repr(e))
# Employee(name='Homer Simpson', age=42, address=Address(street='123 Main St', city='Springfield', country='USA'))

# 应用四：数据持久化
# 示例1：使用repr()和文件进行数据持久化
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age})"
# 创建一个Person对象
p = Person("Myelsa", 18)
# 将对象转换为repr()字符串并保存到文件中
with open("person_data.txt", "w") as file:
    file.write(repr(p))
# 从文件中读取repr()字符串并尝试重新创建对象
# 注意：在实际应用中，你可能需要更健壮的错误处理
with open("person_data.txt", "r") as file:
    data = file.read()
    try:
        p_recreated = eval(data)
        print(repr(p_recreated))  # 输出应该是和原始对象相同的repr()字符串
    except Exception as e:
        print(f"无法重新创建对象：{e}")
# Person(name='Myelsa', age=18)

# 应用五：文档和示例
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        """
        Return a string representation of the Person object that is suitable for
        printing and evaluation.
        Returns:
            str: A string representation of the Person object in the form
                 'Person(name="name", age=age)'.
        Examples:
            >>> p = Person("Myelsa", 18)
            >>> print(p)
            Person(name="Myelsa", age=18)
            >>> eval(repr(p)) == p  # Warning: eval() can be unsafe, use with caution
            True
        """
        return f"Person(name={self.name!r}, age={self.age})"
# 示例：在文档字符串中使用repr()
if __name__ == "__main__":
    p = Person("Bruce", 6)
    print(p)  # 这将调用Person类的__repr__方法
    # 在文档字符串中提到的示例
    print("--- Example from docstring ---")
    print(repr(p))  # 直接调用repr()函数来显示对象表示
    # 注意：虽然eval(repr(p))可以工作，但在实际中应避免使用eval()除非完全信任输入
    # print(eval(repr(p)) == p)  # 这是一个不安全的示例，仅用于说明
    # 更好的方式是使用其他方法来重新创建对象，例如通过类的构造函数
    p_recreated = Person(**eval(repr(p).lstrip('Person(').rstrip(')').split(', ')))
    print(f"Recreated object: {p_recreated}")
    # 注意：上面的方法仍然使用了eval()，但在实践中，你通常会直接传递参数给构造函数

# 应用六：用户界面和命令行工具
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        """
        Return a string representation of the Person object suitable for UI and CLI.
        """
        return f"Person(name={self.name}, age={self.age})"
# 示例：在命令行工具中使用repr()
if __name__ == "__main__":
    # 创建一个Person对象
    person = Person("Myelsa", 18)
    # 在命令行中直接打印对象，这会调用__repr__方法
    print(person)  # 输出: Person(name=Myelsa, age=18)
    # 假设我们有一个简单的命令行界面，用户可以输入命令来查看对象的信息
    def cli_interface():
        while True:
            command = input("Enter command (or 'quit' to exit): ")
            if command == 'quit':
                break
            elif command == 'show_person':
                print(person)  # 使用repr()来显示对象信息
            else:
                print("Unknown command.")
    # 启动命令行界面
    cli_interface()
# 示例：在用户界面(UI)中使用repr()(虽然通常UI会使用更友好的展示方式)
# 但为了演示，我们假设UI通过控制台输出信息
def ui_display(obj):
    # 在UI中，我们可能希望显示更友好的信息，但这里仍然使用repr()作为例子
    print(f"Displayed object: {repr(obj)}")
# 调用UI显示函数
ui_display(person)  # 输出: Displayed object: Person(name=Myelsa, age=18)
# Person(name=Myelsa, age=18)
# Enter command (or 'quit' to exit): show_person
# Person(name=Myelsa, age=18)
# Enter command (or 'quit' to exit): quit
# Displayed object: Person(name=Myelsa, age=18)

# 应用七：测试和断言
import pytest
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person(name={self.name!r}, age={self.age})"
# 示例：在测试中使用repr()进行断言
def test_person_repr():
    # 创建一个Person对象
    person = Person("Myelsa", 18)
    # 使用repr()获取对象的字符串表示
    person_repr = repr(person)
    # 进行断言，验证repr()的结果是否符合预期
    assert person_repr == "Person(name='Myelsa', age=18)", "The repr() of Person is not as expected."
# 运行测试函数
test_person_repr()
def test_person_attributes():
    # 创建一个Person对象
    person = Person("Jimmy", 15)
    # 进行断言，验证对象的属性是否符合预期
    assert person.name == "Jimmy", "The name of the person is not as expected."
    assert person.age == 15, "The age of the person is not as expected."
# 运行测试函数
test_person_attributes()
# Testing started at 12:01 ...
# Launching pytest with arguments E:\python_workspace\pythonProject\test1.py --no-header --no-summary -q in E:\python_workspace\pythonProject
#
# ============================= test session starts =============================
# collecting ... collected 2 items
#
# test1.py::test_person_repr PASSED                                        [ 50%]
# test1.py::test_person_attributes PASSED                                  [100%]
#
# ============================== 2 passed in 0.10s ==============================

# 应用八：交互式解释器
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        """
        Return a string representation of the Person object that is suitable for
        interactive interpreters.
        """
        return f"Person(name={self.name!r}, age={self.age})"
# 创建一个Person对象
p = Person("Myelsa", 18)
# 尝试打印对象，这会隐式地调用__repr__方法
print(p)
# 你也可以显式地调用repr()函数
print(repr(p))
# 在交互式解释器中，你可以直接输入变量名来查看其repr表示
# 输入：p
# 使用repr()在交互式解释器中进行字符串操作或调试
repr_string = repr(p)
print(f"The representation of p is: {repr_string}")
# 你还可以将repr表示用于日志记录、错误消息等
import logging
logging.basicConfig(level=logging.INFO)
logging.info(f"Created a Person object: {p}")
# 输出日志信息，其中包含了p的repr表示
# Person(name='Myelsa', age=18)
# Person(name='Myelsa', age=18)
# The representation of p is: Person(name='Myelsa', age=18)
# INFO:root:Created a Person object: Person(name='Myelsa', age=18)