【基础】Python基础语法解析与示例

# 2.1 数据类型与转换

### 2.1.1 内置数据类型

Python 中内置了多种数据类型，用于表示不同类型的数据。常见的数据类型包括：

- 整数（int）：表示整数，例如 123、-456
- 浮点数（float）：表示浮点数，例如 3.14、-2.718
- 字符串（str）：表示文本数据，例如 "Hello World"、'Python'
- 布尔值（bool）：表示真假值，只有 True 和 False 两个值
- 列表（list）：表示有序的可变集合，元素可以是任何类型
- 元组（tuple）：表示有序的不可变集合，元素可以是任何类型
- 字典（dict）：表示无序的可变集合，键值对形式存储数据
- 集合（set）：表示无序的不可变集合，元素唯一

# 2. Python数据类型与变量

### 2.1 数据类型与转换

#### 2.1.1 内置数据类型

Python提供了丰富的内置数据类型，包括：

| 数据类型 | 描述 |
|---|---|
| 整数 (int) | 整数，包括正整数、负整数和零 |
| 浮点数 (float) | 浮点数，包括小数和科学计数法 |
| 字符串 (str) | 由字符组成的序列 |
| 布尔值 (bool) | True或False |
| 列表 (list) | 有序可变序列 |
| 元组 (tuple) | 有序不可变序列 |
| 字典 (dict) | 键值对集合 |
| 集合 (set) | 无序且不重复元素的集合 |

#### 2.1.2 数据类型转换

Python支持显式和隐式数据类型转换。

**显式转换**使用内置函数进行，如：

int("123")  # 将字符串转换为整数
float("3.14")  # 将字符串转换为浮点数
str(123)  # 将整数转换为字符串

**隐式转换**在某些操作中自动进行，如：

1 + 2.5  # 整数和浮点数相加，结果为浮点数
"abc" + "def"  # 字符串连接，结果为字符串

### 2.2 变量与作用域

#### 2.2.1 变量定义与赋值

变量用于存储数据，通过赋值操作（=）定义：

name = "John Doe"  # 定义一个字符串变量
age = 30  # 定义一个整数变量

#### 2.2.2 作用域与生命周期

变量的作用域是指它可以被访问的代码范围。Python有局部作用域和全局作用域：

**局部变量**在函数或代码块内定义，仅在该范围内可见。

**全局变量**在函数或代码块外定义，在整个程序中可见。

变量的生命周期从定义开始，到程序执行结束或变量被删除为止。

# 3.1 条件语句

条件语句用于根据条件执行不同的代码块。Python 中有三种基本的条件语句：`if`、`elif` 和 `else`。

#### 3.1.1 if 语句

`if` 语句用于检查一个条件是否为真，如果是，则执行该语句块中的代码。语法如下：

if condition:
    # 代码块

其中，`condition` 是一个布尔表达式，如果为真，则执行代码块。

**示例：**

number = 10

if number > 5:
    print("Number is greater than 5")

在这个示例中，如果 `number` 大于 5，则会打印 "Number is greater than 5"。

#### 3.1.2 elif 和 else 语句

`elif` 语句用于检查其他条件，如果前面的 `if` 条件不满足。`else` 语句用于检查所有其他情况。语法如下：

if condition1:
    # 代码块
elif condition2:
    # 代码块
else:
    # 代码块

**示例：**

number = 5

if number > 10:
    print("Number is greater than 10")
elif number > 5:
    print("Number is greater than 5")
else:
    print("Number is less than or equal to 5")

在这个示例中，如果 `number` 大于 10，则会打印 "Number is greater than 10"。如果 `number` 大于 5 但小于或等于 10，则会打印 "Number is greater than 5"。否则，会打印 "Number is less than or equal to 5"。

### 3.2 循环语句

循环语句用于重复执行代码块，直到满足特定条件。Python 中有两种基本的循环语句：`for` 和 `while`。

#### 3.2.1 for 循环

`for` 循环用于遍历序列中的每个元素。语法如下：

for item in sequence:
    # 代码块

其中，`sequence` 是一个可迭代对象（例如列表、元组或字符串），`item` 是序列中的每个元素。

**示例：**

numbers = [1, 2, 3, 4, 5]

for number in numbers:
    print(number)

在这个示例中，`for` 循环将遍历 `numbers` 列表中的每个元素并打印它们。

#### 3.2.2 while 循环

`while` 循环用于只要条件为真就重复执行代码块。语法如下：

while condition:
    # 代码块

其中，`condition` 是一个布尔表达式，如果为真，则执行代码块。

**示例：**

number = 1

while number <= 5:
    print(number)
    number += 1

在这个示例中，`while` 循环将继续执行代码块，直到 `number` 大于 5。

# 4. Python实践应用

### 4.1 文件操作

#### 4.1.1 文件读写操作

Python提供了丰富的文件操作函数，允许我们轻松地对文件进行读写操作。

# 打开文件，指定读写模式（'r'：读，'w'：写，'a'：追加）
file = open("filename.txt", "r")

# 读取文件内容
content = file.read()

# 关闭文件
file.close()

**代码逻辑分析：**

* `open()` 函数打开指定文件，并返回一个文件对象。
* `read()` 方法读取文件内容并返回一个字符串。
* `close()` 方法关闭文件，释放系统资源。

#### 4.1.2 文件属性与权限

文件对象具有属性和权限，可用于获取文件信息和控制文件访问。

| 属性/权限 | 描述 |
|---|---|
| `name` | 文件名 |
| `mode` | 文件打开模式 |
| `closed` | 文件是否已关闭 |
| `readable()` | 文件是否可读 |
| `writable()` | 文件是否可写 |
| `seekable()` | 文件是否可定位 |

**代码块：**

# 获取文件属性
print(file.name)
print(file.mode)
print(file.closed)

# 检查文件权限
print(file.readable())
print(file.writable())
print(file.seekable())

**逻辑分析：**

* `name` 属性返回文件名。
* `mode` 属性返回文件打开模式。
* `closed` 属性返回一个布尔值，指示文件是否已关闭。
* `readable()`、`writable()` 和 `seekable()` 方法返回布尔值，指示文件是否具有相应的权限。

### 4.2 网络编程

#### 4.2.1 网络通信基础

Python提供了一个强大的网络编程库 `socket`，允许我们建立和管理网络连接。

**TCP 和 UDP 协议：**

* TCP（传输控制协议）：一种面向连接的协议，提供可靠的数据传输。
* UDP（用户数据报协议）：一种无连接的协议，提供低延迟的数据传输。

#### 4.2.2 Socket编程实例

**服务器端：**

import socket

# 创建一个 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定套接字到一个地址和端口
server_socket.bind(('localhost', 8000))

# 监听传入连接
server_socket.listen()

# 接受客户端连接
client_socket, client_address = server_socket.accept()

# 从客户端接收数据
data = client_socket.recv(1024)

# 向客户端发送数据
client_socket.send(b'Hello, world!')

# 关闭套接字
server_socket.close()
client_socket.close()

**客户端：**

import socket

# 创建一个 TCP 套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接到服务器
client_socket.connect(('localhost', 8000))

# 向服务器发送数据
client_socket.send(b'Hello, server!')

# 从服务器接收数据
data = client_socket.recv(1024)

# 打印接收到的数据
print(data.decode())

# 关闭套接字
client_socket.close()

**逻辑分析：**

* 服务器端使用 `socket.socket()` 创建一个 TCP 套接字，并使用 `bind()` 和 `listen()` 方法绑定到一个地址和端口，等待客户端连接。
* 客户端使用 `socket.socket()` 创建一个 TCP 套接字，并使用 `connect()` 方法连接到服务器。
* 服务器端使用 `accept()` 方法接受客户端连接，并返回一个新的套接字对象和客户端地址。
* 服务器端和客户端使用 `recv()` 和 `send()` 方法进行数据交换。
* 最后，双方关闭套接字以释放系统资源。

### 4.3 数据库编程

#### 4.3.1 数据库连接与操作

Python提供了 `sqlite3` 模块，用于与 SQLite 数据库进行交互。

**连接数据库：**

import sqlite3

# 连接到数据库
conn = sqlite3.connect('database.db')

# 创建一个游标对象
cursor = conn.cursor()

**执行 SQL 语句：**

# 执行一个 SQL 查询
cursor.execute("SELECT * FROM users")

# 获取查询结果
results = cursor.fetchall()

#### 4.3.2 SQL语句执行与结果处理

**SQL 查询语法：**

| 语句 | 描述 |
|---|---|
| `SELECT` | 从表中选择数据 |
| `INSERT` | 向表中插入数据 |
| `UPDATE` | 更新表中的数据 |
| `DELETE` | 从表中删除数据 |

**结果处理：**

* `fetchall()` 方法返回所有查询结果。
* `fetchone()` 方法返回下一行查询结果。
* `rowcount` 属性返回受影响的行数。

**代码块：**

# 插入数据
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", (name, email))

# 更新数据
cursor.execute("UPDATE users SET name = ? WHERE id = ?", (new_name, user_id))

# 删除数据
cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))

# 提交更改
conn.commit()

**逻辑分析：**

* `execute()` 方法执行 SQL 语句，并可以传递参数。
* `fetchall()` 方法返回所有查询结果，以元组列表的形式。
* `rowcount` 属性返回受影响的行数。
* `commit()` 方法将更改提交到数据库。

# 5.1 面向对象编程

### 5.1.1 类与对象

**类：**

- 类是面向对象编程中的基本构建块，它定义了对象的属性和方法。
- 使用 `class` 关键字定义类，其语法如下：

class ClassName:
    # 类属性
    class_attribute = value

    # 构造函数
    def __init__(self, *args, **kwargs):
        # 对象属性
        self.object_attribute = value

    # 类方法
    @classmethod
    def class_method(cls, *args, **kwargs):
        # 使用 cls 访问类属性和方法

    # 静态方法
    @staticmethod
    def static_method(*args, **kwargs):
        # 不使用 cls 访问类属性和方法

**对象：**

- 对象是类的实例，它拥有类的属性和方法。
- 使用 `ClassName()` 创建对象：

object = ClassName()

### 5.1.2 继承与多态

**继承：**

- 继承允许一个类（子类）从另一个类（父类）继承属性和方法。
- 使用 `class Subclass(Superclass)` 语法实现继承。

**多态：**

- 多态是指子类可以覆盖父类的方法，从而实现不同的行为。
- 子类覆盖父类的方法时，使用 `super()` 关键字调用父类方法。

**代码示例：**

# 定义父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Animal speaks")

# 定义子类
class Dog(Animal):
    def speak(self):
        print("Dog barks")

# 创建对象
dog = Dog("Buddy")
dog.speak()  # 输出："Dog barks"