Python 学习笔记01

分类：Coding 作者：sakisaka_saya

__iter__ 和 __call__ 是什么?

__iter__ 和 __call__ 是 Python 中的两个魔术方法（或称为“特殊方法”），它们分别用于使对象支持迭代和使对象可以像函数一样被调用。以下是这两个方法的详细解释：

1. __iter__ 方法

__iter__ 方法让一个对象变成可迭代的对象。可迭代对象是指可以通过 for 循环逐一遍历其元素的对象，通常是列表、元组、字典等类型。通过实现 __iter__ 方法，你可以让自定义的对象也支持迭代。

  • 作用：它返回一个迭代器（即实现了 __next__ 方法的对象），可以用来逐一返回对象的元素。

示例：

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end

    def __iter__(self):
        # 返回一个迭代器对象
        self.current = self.start
        return self

    def __next__(self):
        if self.current < self.end:
            self.current += 1
            return self.current - 1
        else:
            raise StopIteration  # 抛出停止迭代异常

# 使用 MyRange 类
my_range = MyRange(0, 5)
for num in my_range:
    print(num)

输出：

0
1
2
3
4

解释：

  • __iter__ 方法返回的是迭代器对象本身。
  • __next__ 方法会返回下一个元素，并在没有元素时抛出 StopIteration 异常，告诉 Python 迭代已经结束。

2. __call__ 方法

__call__ 方法使得一个对象可以像函数一样被调用。这意味着你可以在对象实例后面加上圆括号并传递参数，Python 会自动调用 __call__ 方法。

  • 作用：当你调用一个对象时，Python 会自动调用该对象的 __call__ 方法。如果 __call__ 方法实现了参数处理功能，那么你可以通过传入不同的参数来控制对象的行为。

示例：

class Adder:
    def __init__(self, x):
        self.x = x

    def __call__(self, y):
        return self.x + y

# 创建一个对象
add_five = Adder(5)

# 调用对象，就像调用一个函数
result = add_five(10)
print(result)  # 输出 15

输出：

5

解释：

  • __call__ 方法使得 add_five 对象可以像函数一样被调用，传递参数 10 后，返回的结果是 15。

小结：

  • __iter__ 使得一个对象可以被迭代，通过实现该方法并返回一个迭代器，可以用 for 循环遍历对象的元素。
  • __call__ 使得一个对象可以像函数一样被调用，允许你通过 () 语法调用对象，传递参数并控制对象的行为。

这两个魔术方法在不同的场景中非常有用，特别是当你需要自定义类的行为时。

双引号前面加字母是什么

在 Python 中，双引号前面加字母 主要是用来表示不同类型的字符串，通常与 字节串（bytes） 和 Unicode 字符串 的表示方式有关。以下是常见的用法：

1. **b"..." 或 B"..."：字节串（bytes）

  • 字节串（bytes） 是一个包含字节（不是字符）序列的对象，用于表示原始二进制数据。
  • 在 Python 中，用 b 或 B 前缀标识字节串，它告诉 Python 这是一个由字节组成的字符串，而不是普通的文本字符串。

示例：

# 字节串（byte string）
byte_str = b"Hello, World!"
print(byte_str)  # 输出: b'Hello, World!'

# 类型
print(type(byte_str))  # 输出: <class 'bytes'>

字节串的特点：

  • 每个字符的值在 0 到 255 之间。
  • 字节串常用于处理二进制文件（例如图像、音频文件）或与低级系统接口进行交互。

2. u"..."：Unicode 字符串（在 Python 2.x 中使用）

  • 在 Python 2.x 中，u 前缀用来表示 Unicode 字符串，能够存储多字节字符（如中文、日文等）。
  • 在 Python 3.x 中，所有的字符串（默认 str）都已经是 Unicode 字符串了，因此不再需要使用 u 前缀，直接用双引号或单引号表示即可。

示例（Python 2.x）：

# Unicode 字符串（在 Python 2 中）
unicode_str = u"Hello, 你好"
print(unicode_str)  # 输出: u'Hello, 你好'

3. f"..."：格式化字符串（f-string）

  • Python 3.6 引入了 f 前缀用于格式化字符串，使得在字符串中插入变量变得更加简单。
  • f 表示“格式化字符串”，你可以在字符串中使用 {} 来插入表达式。

示例：

name = "Python"
version = 3.9
formatted_str = f"Welcome to {name} {version}!"
print(formatted_str)  # 输出: Welcome to Python 3.9!

4. r"..." 或 R"..."：原始字符串（raw string）

  • 原始字符串 会忽略所有转义字符（如 \n、\t 等），这在处理正则表达式或路径时非常有用。
  • r 或 R 前缀用于表示原始字符串，后面跟随的字符串中的所有字符都会被原样输出，而不进行转义。

示例：

# 原始字符串
raw_str = r"Hello\nWorld"
print(raw_str)  # 输出: Hello\nWorld（没有换行符）

5. b"..." 和 r"..." 组合使用

  • 有时，你可能会看到 br"..." 或 Rb"..."，这表示字节串和原始字符串的组合。它会创建一个字节串，并且字符串中的转义字符会被忽略。

示例：

# 字节串和原始字符串组合
br_str = br"Hello\nWorld"
print(br_str)  # 输出: b'Hello\\nWorld'（没有转义换行符）

总结：

  • b"..."：表示字节串，存储原始二进制数据。
  • u"..."：表示 Unicode 字符串（仅在 Python 2 中需要，Python 3 默认所有字符串都是 Unicode）。
  • f"..."：格式化字符串，允许在字符串中插入变量。
  • r"..." 或 R"..."：原始字符串，忽略转义字符。
  • br"..." 或 Rb"..."：字节串和原始字符串的组合。

这些字母前缀是 Python 提供的一些特性，用于方便地处理不同类型的字符串数据。

RESTful是什么

RESTful 是一种基于 REST (Representational State Transfer) 架构风格的 Web 服务设计方法。它主要用于创建高效、可扩展的 Web 服务接口，特别是在客户端和服务器之间进行通信时，符合一些简单而严格的约束条件。

REST（代表性状态转移）定义

REST 是由 Roy Fielding 在他的博士论文中首次提出的，它是 Web 架构的一种风格，强调在客户端和服务器之间进行无状态通信。REST 的目标是利用 HTTP 协议来定义一种简单而标准的 API 设计方式，使得 Web 服务具备高效性、可扩展性和可维护性。

RESTful 的主要特点

  1. 无状态性 (Stateless)：

    • 每次请求都必须包含所有的信息，服务器不会存储客户端的任何状态信息。
    • 也就是说，服务器在处理请求时不依赖于任何前一个请求的信息。
    • 每个请求的响应必须是自包含的，客户端和服务器之间没有持久连接。

    • 客户端-服务器架构 (Client-Server)：

    • RESTful 架构遵循客户端与服务器分离的原则。客户端和服务器之间通过 HTTP 协议通信，客户端负责用户界面的显示，服务器负责业务逻辑和数据存储。

    • 这种架构可以提高系统的可扩展性和可维护性。

    • 统一接口 (Uniform Interface)：

    • RESTful API 的接口是统一的，客户端通过 HTTP 请求与服务器进行交互。常见的 HTTP 方法有 GET、POST、PUT、DELETE 等。

    • 统一接口的目标是简化系统架构，提高系统的可理解性和可移植性。

    • 可缓存性 (Cacheable)：

    • 由于 RESTful API 使用的是 HTTP 协议，响应可以标记为可缓存的或不可缓存的。这可以提高系统的性能和响应速度。

    • 在客户端和中间缓存之间缓存响应结果，减少服务器的负担。

    • 分层系统 (Layered System)：

    • RESTful 服务可以由多个层组成，客户端不能知道是否直接与原始服务器通信，还是与代理或中间缓存服务器通信。

    • 这种设计有助于提高可扩展性和安全性。

    • 按需代码 (Code on Demand)：

    • 服务器可以通过返回可执行的代码（如 JavaScript）来扩展客户端的功能。

    • 这个特性是可选的，并不常见。

RESTful 设计中的常见概念

  1. 资源 (Resources)：

    • RESTful 服务将“资源”作为核心概念，资源可以是任何可以通过 URL 唯一标识的对象，例如用户、订单、商品等。
    • 每个资源通过一个唯一的 URL（即资源的 URI）来访问。

    • HTTP 方法 (HTTP Methods)：

    • RESTful 使用 HTTP 方法来定义对资源的操作，常见的 HTTP 方法有：

      • GET：获取资源。
      • POST：创建新资源。
      • PUT：更新现有资源。
      • DELETE：删除资源。

    • 状态转移 (State Transfer)：

    • 客户端和服务器通过请求和响应来进行状态转移。例如，客户端通过请求获取服务器的数据，服务器根据请求返回相应的资源。

    • 请求和响应格式 (Request & Response Format)：

    • 请求和响应通常使用标准格式如 JSON 或 XML。JSON 格式特别常见，因为它轻量、易于处理。

RESTful API 的示例

假设有一个管理“用户”的 RESTful API，API 的 URL 设计通常类似这样：

  • GET /users：获取所有用户的列表。
  • GET /users/{id}：根据用户的 ID 获取单个用户的详细信息。
  • POST /users：创建一个新的用户。
  • PUT /users/{id}：更新某个 ID 的用户信息。
  • DELETE /users/{id}：删除某个 ID 的用户。

RESTful API 的 URL 设计原则

  • URL 应该是名词，表示资源。
  • URL 不应该包含动词（因为 HTTP 方法已经表示了动作）。
  • URL 应该具有层次结构，表示资源之间的关系。

例子

GET /users           --> 获取所有用户
GET /users/123       --> 获取 ID 为 123 的用户
POST /users          --> 创建新用户
PUT /users/123       --> 更新 ID 为 123 的用户
DELETE /users/123    --> 删除 ID 为 123 的用户

总结

RESTful 是一种简单而强大的 Web 服务架构风格，它利用 HTTP 协议的内置方法来定义资源的操作，使得系统更加简洁、可维护和扩展。通过遵循 REST 的原则，开发者可以设计出高效、可扩展的 Web API，使得客户端和服务器之间的通信更加灵活和高效。

session和cookies都是什么

Session 和 Cookies 是 Web 开发中用于存储用户信息、保持会话状态的两种常见机制。它们之间有很多相似之处，但也存在一些重要的区别。让我们详细了解它们。

Cookies

定义

Cookies 是由服务器发送到浏览器并保存在用户设备上的小型文本文件。每次用户请求同一个服务器时，浏览器会自动将这些 cookies 附带在 HTTP 请求中发送回服务器。它们通常用于存储一些简单的信息，比如用户身份、用户偏好设置、会话标识符等。

特点

  1. 存储位置：

    • 存储在客户端（即用户的浏览器）中。
    • 每个 cookie 都有一个有效期，过期后会被删除。

    • 生命周期：

    • 会话 cookies：在浏览器关闭时被删除。

    • 持久 cookies：存储在浏览器中，直到设置的过期时间到达。

    • 用途：

    • 识别用户：存储登录信息或身份标识符。

    • 会话跟踪：在多个页面请求之间保持用户会话状态。
    • 个人化设置：存储用户的偏好设置，如语言选择、主题颜色等。

    • 容量限制：

    • 每个 cookie 的大小通常为 4 KB 左右，浏览器通常允许每个域名存储多个 cookies。

    • 安全性：

    • Cookies 是客户端存储的，因此它们可能被恶意用户篡改或盗取。

    • 可以设置 Secure（仅通过 HTTPS 传输）和 HttpOnly（不可通过 JavaScript 访问）来增强安全性。
    • 示例：
Set-Cookie: user_id=12345; expires=Fri, 31 Dec 2025 23:59:59 GMT; path=/;

Session

定义

Session 是服务器端存储的用户会话数据。当用户访问一个网站时，服务器会为每个用户分配一个唯一的会话 ID。这个 ID 通常通过 cookies 或 URL 参数传递给客户端，以便客户端和服务器之间能够关联请求和相应的会话数据。

特点

  1. 存储位置：

    • 存储在服务器端。服务器会为每个用户生成一个会话 ID，将其与相关数据存储在内存或数据库中。

    • 生命周期：

    • 会话通常在用户关闭浏览器时结束，也可以在特定的时间内自动过期（例如 30 分钟不活动后自动注销）。

    • 会话的持续时间可以通过服务器端设置来控制。

    • 用途：

    • 存储用户相关的信息，比如登录状态、购物车内容等。

    • 保证数据的安全性，因为数据存储在服务器端，客户端只能访问到会话 ID。

    • 容量限制：

    • 存储在服务器端，容量通常比 cookies 更大，可以存储更多的信息。

    • 安全性：

    • 因为数据存储在服务器端，通常比 cookies 更安全。

    • 但是，如果 session ID 被盗取，攻击者仍然可以伪造用户身份。

    • 示例：

    • 客户端通过 cookie 或 URL 中的参数传递会话 ID。例如：

Set-Cookie: session_id=abcdef123456; path=/;

Session 和 Cookies 的对比

特性 Cookies Session
存储位置 存储在客户端（浏览器） 存储在服务器端
生命周期 可以设置过期时间；会话 cookie 会在浏览器关闭时失效 会话通常在用户关闭浏览器时或超时后过期
容量 每个 cookie 的大小通常为 4 KB 通常没有容量限制，依赖服务器资源
访问方式 浏览器和服务器都可以访问 服务器访问，客户端通常只能通过 session ID
安全性 可能被篡改，容易被攻击（如 XSS、CSRF） 服务器端存储，更安全，但 session ID 可能会被盗用
用途 存储简单数据（如用户登录信息） 存储较复杂的数据（如用户的购物车、登录状态等）
性能 浏览器会在每次请求时发送 cookie，增加网络负担 会话数据存储在服务器端，客户端只需发送 session ID

什么时候使用 Cookies，什么时候使用 Session？

  • Cookies 适合存储不敏感的数据，比如：

    • 用户偏好设置（语言、主题等）。
    • 用户的浏览历史、未登录状态下的购物车等。
    • 需要跨多个浏览器标签页或会话持续存在的数据。

    • Session 适合存储敏感数据，比如：

    • 用户的登录状态。

    • 购物车数据或支付信息等。
    • 临时的用户数据，需要在整个会话中持续的内容。

总之，Cookies 主要用于存储小块的、非敏感数据，而 Session 主要用于存储用户会话中的重要信息，并且通常会话数据会在服务器端保持更长时间。

Ajax 和 表单（Form）

Ajax 和 表单（form） 都是 Web 开发中常用的技术，它们各自有不同的用途，但也可以结合使用以提升用户体验。以下是关于 Ajax 和表单的详细介绍，并讨论它们如何结合使用。

表单（Form）

定义

HTML 表单是用于收集用户输入的网页元素，通常由 <form> 标签创建。表单提交时，用户的输入数据会通过 HTTP 请求（通常是 POST 或 GET 请求）发送到服务器进行处理。

  • 表单基本结构
<form action="/submit" method="POST">
  <label for="username">Username:</label>
  <input type="text" id="username" name="username" required>

  <label for="email">Email:</label>
  <input type="email" id="email" name="email" required>

  <button type="submit">Submit</button>
</form>

关键属性：

  • action：指定提交数据的服务器 URL。
  • method：指定提交数据的 HTTP 方法（GET 或 POST）。
  • input：定义了用户可以输入数据的表单控件（如文本框、密码框、按钮等）。

传统表单提交

  • 当用户填写表单并点击“提交”按钮时，表单会发送 HTTP 请求（默认情况下是 GET 或 POST）到服务器，服务器处理请求后返回一个响应页面（通常是重定向或结果页面）。
  • 这种方式的缺点是每次提交表单时页面会刷新。

Ajax（Asynchronous JavaScript and XML）

定义

Ajax 是一种在不重新加载整个页面的情况下，与服务器交换数据并更新部分网页内容的技术。它使用 JavaScript 发送 HTTP 请求，而无需刷新页面。

基本原理

  1. 创建 XMLHttpRequest 对象：这个对象用于向服务器发送请求。
  2. 发送请求到服务器：可以使用 GET 或 POST 方法。
  3. 处理服务器响应：通过 JavaScript 动态更新页面内容，而不重新加载整个页面。

示例代码

// 创建 XMLHttpRequest 对象
let xhr = new XMLHttpRequest();

// 配置请求（GET 方法，请求的 URL）
xhr.open('GET', '/data', true);

// 设置请求成功回调函数
xhr.onload = function () {
  if (xhr.status === 200) {
    // 请求成功，处理响应数据
    document.getElementById('content').innerHTML = xhr.responseText;
  } else {
    // 请求失败
    console.error('Request failed with status: ' + xhr.status);
  }
};

// 发送请求
xhr.send();

Ajax 的优点

  • 异步通信：页面不会重新加载，提升了用户体验。
  • 局部更新：可以局部更新页面内容，无需整个页面刷新。
  • 提高性能：避免了不必要的页面刷新和数据加载。

结合使用：表单与 Ajax

传统表单提交时，会导致整个页面刷新，而使用 Ajax 提交表单数据，可以实现无刷新提交，提高用户体验。下面是一个结合 Ajax 和表单的示例，展示如何使用 Ajax 提交表单数据并处理响应。

Ajax 提交表单的步骤

  1. 阻止表单的默认提交行为。
  2. 通过 JavaScript 获取表单数据。
  3. 通过 Ajax 将数据发送到服务器。

  4. 处理服务器响应并在页面上显示结果。

  5. 示例：使用 Ajax 提交表单

<form id="myForm">
  <label for="username">Username:</label>
  <input type="text" id="username" name="username" required>

  <label for="email">Email:</label>
  <input type="email" id="email" name="email" required>

  <button type="submit">Submit</button>
</form>

<div id="result"></div>
  • JavaScript 代码（通过 Ajax 提交表单）
// 获取表单元素
document.getElementById('myForm').addEventListener('submit', function(event) {
  event.preventDefault();  // 阻止表单的默认提交行为

  // 获取表单数据
  let formData = new FormData(this);

  // 创建 XMLHttpRequest 对象
  let xhr = new XMLHttpRequest();

  // 配置请求（POST 方法）
  xhr.open('POST', '/submit', true);

  // 设置请求成功回调函数
  xhr.onload = function() {
    if (xhr.status === 200) {
      // 请求成功，显示响应内容
      document.getElementById('result').innerHTML = 'Form submitted successfully: ' + xhr.responseText;
    } else {
      // 请求失败
      document.getElementById('result').innerHTML = 'Error: ' + xhr.status;
    }
  };

  // 发送表单数据
  xhr.send(formData);
});

解释

  1. event.preventDefault()：阻止表单的默认提交行为（即页面刷新）。
  2. FormData(this)：创建一个 FormData 对象，它包含了表单中的所有字段和输入数据。
  3. xhr.open()：配置 Ajax 请求，这里我们使用 POST 方法来提交表单数据到服务器 /submit URL。
  4. xhr.send(formData)：将表单数据发送到服务器。
  5. xhr.onload：服务器返回响应时触发，使用响应数据更新页面。

Ajax 提交表单的优势

  1. 无刷新提交：表单提交不会刷新整个页面，增强用户体验。
  2. 实时反馈：用户提交表单后，可以立即显示提交结果，而不需要等待页面刷新。
  3. 控制请求和响应：开发者可以控制请求的发送和服务器的响应，可以使用 Ajax 动态更新页面中的部分内容。

总结

  • 传统表单提交：页面会刷新，提交数据后返回新的页面。
  • Ajax 提交表单：避免页面刷新，在后台异步提交表单数据并动态更新页面内容。
  • 结合 Ajax 和表单：通过 Ajax 提交表单数据，无需页面刷新，可以在页面上即时展示结果，提升用户体验。

通过 Ajax 和表单的结合使用，可以大大提升 Web 应用的交互性和用户体验。

什么是ORM

ORM（Object-Relational Mapping）

ORM（对象关系映射） 是一种技术，它允许开发者以面向对象的方式操作数据库中的数据，而无需直接编写 SQL 查询语句。ORM 通过将对象（例如类和实例）与数据库表进行映射，使得程序能够以对象的方式来访问数据库中的数据，简化了数据库操作并提高了开发效率。

ORM 的基本概念

  1. 对象（Object）：
    • 在面向对象编程中，对象是类的实例。它包含属性（字段）和方法（操作）。
  2. 关系（Relational）：
    • 数据库通常使用表格的形式存储数据，每个表由若干行（记录）和列（字段）组成。
  3. 映射（Mapping）：
    • 映射指的是将对象的属性与数据库表的字段关联起来，操作对象时，ORM 会自动生成相应的 SQL 查询。

简单来说，ORM 就是将数据库中的表映射为类，将表中的行映射为类的实例，将字段映射为对象的属性。

ORM 的工作原理

  1. 对象与表的映射： ORM 框架会将数据库中的表与程序中的类进行映射，使得每一张表都有一个对应的类，而每个类的实例对应数据库中的一行数据。

  2. 属性与字段的映射： 类的属性会与数据库表的字段相对应。当你创建一个对象并设置其属性时，ORM 会根据这个对象生成对应的 SQL 语句，插入、更新或查询数据库。

  3. 自动化 SQL 生成： ORM 会根据你操作对象的方式自动生成 SQL 语句，免去开发者编写复杂的 SQL 查询。

  4. 数据库交互： 通过 ORM，你可以使用面向对象的方式进行 CRUD（增、删、改、查）操作，ORM 会将这些操作转化为底层的 SQL 查询与数据库交互。

ORM 的优势

  1. 简化数据库操作：

    • 通过 ORM，开发者不需要编写 SQL 语句，可以通过对象的属性和方法来操作数据库，降低了代码的复杂度。

    • 提高开发效率：

    • ORM 自动化生成 SQL 语句，开发者只需关心数据的业务逻辑，不必考虑低层的数据库操作。

    • 跨数据库兼容性：

    • 许多 ORM 框架支持不同类型的数据库（如 MySQL、PostgreSQL、SQLite 等），你可以在不改变应用逻辑的情况下切换数据库。

    • 可维护性：

    • ORM 将数据库操作与应用程序逻辑分离，提高了代码的可读性和可维护性。

    • 安全性：

    • ORM 在构造 SQL 查询时自动进行参数化，防止了 SQL 注入等安全问题。

ORM 的缺点

  1. 性能问题：

    • 在处理复杂查询时，ORM 生成的 SQL 语句可能不如手写的 SQL 高效，特别是在大量数据和复杂查询的情况下。

    • 学习曲线：

    • 对于刚开始使用 ORM 的开发者来说，理解和掌握 ORM 框架的用法可能需要一定的时间和精力。

    • 过度抽象：

    • ORM 在进行数据库操作时会对 SQL 语句进行封装，可能导致开发者对数据库操作的控制力下降。特别是在进行复杂的数据库查询时，手写 SQL 可能更加灵活。

常见的 ORM 框架

1. Django ORM (Python)

  • Django 提供了一个强大的 ORM 系统，可以自动映射数据库中的表与模型类，并支持常见的 CRUD 操作。你只需要定义类并声明字段，Django ORM 就会自动为你生成 SQL。
from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

# 创建一个新书籍
author = Author.objects.create(name="George Orwell")
book = Book.objects.create(title="1984", author=author)

# 查询书籍
books = Book.objects.filter(author__name="George Orwell")

2. SQLAlchemy (Python)

  • SQLAlchemy 是一个功能强大的 ORM 库，它不仅支持 ORM，还支持直接执行 SQL 查询，适合需要更灵活控制数据库操作的场景。
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String)

# 创建数据库连接
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# 创建作者
author = Author(name="J.K. Rowling")
session.add(author)
session.commit()

# 查询作者
authors = session.query(Author).filter_by(name="J.K. Rowling").all()

3. Hibernate (Java)

  • Hibernate 是 Java 中最流行的 ORM 框架之一，提供了完整的 ORM 支持，可以自动生成 SQL，并且支持复杂的数据库操作。

4. Entity Framework (C#)

  • Entity Framework 是 .NET 中的 ORM 框架，它使得开发者能够用面向对象的方式与数据库交互，支持 LINQ 查询。

ORM 和 SQL 的区别

特性 ORM SQL
编写方式 使用面向对象的方式，操作数据库对象 直接编写 SQL 查询语句
数据库操作 自动生成 SQL 语句并执行 开发者手动编写 SQL 查询
性能 适用于大多数简单查询，但复杂查询可能较慢 高效，灵活，适合复杂查询
学习曲线 相对简单，面向对象开发者易上手 需要掌握 SQL 语法，复杂查询可能较难
控制力 提供抽象，降低了直接控制数据库的能力 完全控制数据库，适合高级用户
跨数据库兼容性 支持多种数据库，易于切换数据库 需要针对不同的数据库调整 SQL 查询

总结

  • ORM 提供了一种简化的方式来操作数据库，它将对象与关系型数据库表之间建立了映射关系，使得开发者能够以面向对象的方式进行数据库操作，避免直接编写 SQL 语句。
  • ORM 带来了更高的开发效率、更好的安全性和更强的可维护性，但在处理复杂查询时可能存在性能瓶颈。
  • ORM 是适用于大部分常见场景的优秀工具，但在一些复杂或性能要求极高的情况下，手写 SQL 查询可能会更加合适。

用法 return 'Student : {}>'.format(self.name)

这行代码是 Python 中字符串格式化的一种方式，它使用了 str.format() 方法来格式化字符串。具体来说，return 'Student : {}>'.format(self.name) 的作用是返回一个字符串，其中 {} 这个占位符会被 self.name 的值替代。

解释

  1. 字符串格式化：

    • 'Student : {}>' 是一个字符串，其中 {} 是占位符，表示将来会插入某个值。
    • .format(self.name) 是调用字符串的 format() 方法，将 self.name 的值替换到字符串中的 {} 位置。

    • self.name：

    • self.name 是类实例的属性，通常是表示学生名字的字符串。self 是类的实例，name 是该实例的属性。

    • self.name 可能是通过类的构造函数（__init__ 方法）或其他方法设置的。

    • 返回值：

    • format() 方法会返回一个新的字符串，将 self.name 的值嵌入到原始字符串 'Student : {}>' 中的 {} 部分。

举个例子

假设我们有一个表示学生的类 Student，其代码如下：

class Student:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return 'Student : {}>'.format(self.name)
  • 这个类定义了一个构造函数 __init__，接受一个 name 参数来初始化学生的名字。
  • __repr__ 是 Python 中的一个特殊方法，它定义了如何表示类的实例。当你打印该类的实例时，Python 会调用 __repr__ 方法来获取实例的字符串表示。

使用示例

student = Student('Alice')
print(student)
  • 当你创建 student 对象并打印时，Python 会自动调用 __repr__ 方法。
  • 在 __repr__ 方法中，'Student : {}>'.format(self.name) 会将 self.name （即 'Alice'）插入到字符串中，输出结果为：
Student : Alice>

总结

这行代码的作用是通过字符串格式化将类实例的属性（如学生的名字）插入到一个字符串中，并返回这个格式化后的字符串。这样，当我们打印类的实例时，会显示一个自定义的、有意义的字符串表示。

hasattr 方法

在 Python 中，hasattr() 是一个内置函数，用于检查对象是否具有指定的属性。它的返回值是一个布尔值：如果对象拥有指定名称的属性，则返回 True，否则返回 False。

函数原型

hasattr(object, name)
  • object：要检查的对象。
  • name：属性的名称（以字符串形式提供）。

返回值

  • 如果对象 object 具有名为 name 的属性，则返回 True。
  • 如果对象没有该属性，则返回 False。

使用场景

hasattr() 方法常用于动态检查对象是否具有某个属性，特别是在不知道对象是否具备某个特定属性的情况下，可以避免直接访问该属性时抛出 AttributeError 错误。

示例

1. 检查对象是否具有指定属性

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person('Alice', 30)

# 检查 p 对象是否有属性 'name'
print(hasattr(p, 'name'))  # 输出: True

# 检查 p 对象是否有属性 'gender'
print(hasattr(p, 'gender'))  # 输出: False

2. 动态调用属性

hasattr() 方法通常和 getattr() 或 setattr() 一起使用，以动态地访问或设置对象的属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person('Bob', 25)

# 动态获取属性
if hasattr(p, 'name'):
    print(getattr(p, 'name'))  # 输出: Bob
else:
    print('No such attribute')

# 动态设置属性
if not hasattr(p, 'gender'):
    setattr(p, 'gender', 'Male')

print(p.gender)  # 输出: Male

3. 检查方法是否存在

除了检查属性，hasattr() 还可以用于检查对象是否具有某个方法。例如：

class MyClass:
    def greet(self):
        print("Hello!")

obj = MyClass()

# 检查是否有方法 greet
if hasattr(obj, 'greet'):
    obj.greet()  # 输出: Hello!
else:
    print("Method not found")

总结

hasattr() 是一个非常有用的工具，用于在程序运行时动态地检查对象是否包含某个属性或方法。它常常与 getattr() 和 setattr() 一起使用，在不确定对象结构的情况下提供安全的属性访问方式。

暂无评论，快来抢沙发吧～

Skateboard｜滑板
Music｜音乐
Coding