SQL基础语法

SELECT 语句用于从数据库中检索数据。基本语法如下：

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE condition;

• SELECT：指定要检索的列。
• FROM：指定要查询的表。
• WHERE：用于过滤记录，指定条件。

DELETE 语句用于删除表中的记录。基本语法如下：

1
2

DELETE FROM table_name
WHERE condition;

• DELETE FROM：指定要删除记录的表。
• WHERE：用于指定要删除的记录条件。

UPDATE 语句用于修改表中的现有记录。基本语法如下：

1
2
3

UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

• UPDATE：指定要更新记录的表。
• SET：指定要修改的列及其新值。
• WHERE：用于指定要更新的记录条件。

INSERT INTO 语句用于向表中插入新记录。基本语法如下：

1
2

INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);

• INSERT INTO：指定要插入记录的表及其列。
• VALUES：指定要插入的值。

ALTER TABLE 语句用于修改表的结构，例如添加、删除或修改列。基本语法如下：

1
2

ALTER TABLE table_name
ADD column_name datatype;

• ALTER TABLE：指定要修改的表。
• ADD：用于添加新列。

1
2

ALTER TABLE table_name
DROP COLUMN column_name;

• DROP COLUMN：用于删除列。

1
2

ALTER TABLE table_name
MODIFY COLUMN column_name datatype;

• MODIFY COLUMN：用于修改列的数据类型。

SQL 筛选数据

WHERE 子句用于根据指定条件筛选记录。可以使用比较运算符和逻辑运算符来构建复杂的条件。

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE condition1 AND condition2 OR condition3;

比较运算符包括：

• =：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

逻辑运算符包括：

• AND：与
• OR：或
• NOT：非

LIKE 运算符用于在 WHERE 子句中进行模糊匹配。

1
2
3

SELECT column1, column2, ...
FROM table_name
WHERE column_name LIKE pattern;

DISTINCT 关键字用于返回唯一不同的值，去除重复记录。

1
2

SELECT DISTINCT column1, column2, ...
FROM table_name;

• DISTINCT：用于去除重复记录。

LIMIT 子句用于限制返回的记录数。

1
2
3

SELECT column1, column2, ...
FROM table_name
LIMIT number;

• LIMIT：指定返回的最大记录数。

OFFSET 子句用于指定从哪一行开始返回记录，常与 LIMIT 一起使用。

1
2
3

SELECT column1, column2, ...
FROM table_name
LIMIT number OFFSET offset_value;

• OFFSET：指定跳过的记录数。

HAVING 子句用于对分组后的数据进行过滤，通常与 GROUP BY 一起使用。

1
2
3
4

SELECT column1, COUNT(*)
FROM table_name
GROUP BY column1
HAVING COUNT(*) > value;

• HAVING：用于过滤分组后的记录。

SQL 排序数据

ORDER BY 子句用于对结果集进行排序。可以按一个或多个列进行排序，默认按升序排序，可以使用 DESC 指定降序排序。

1
2
3

SELECT column1, column2, ...
FROM table_name
ORDER BY column1 ASC, column2 DESC;

• ORDER BY：指定排序的列。
• ASC：升序排序（默认）。
• DESC：降序排序。

SQL 聚合函数

SQL 提供了多种聚合函数，用于对数据进行汇总计算。常用的聚合函数包括：

• COUNT()：计算记录数。
• SUM()：计算数值列的总和。
• AVG()：计算数值列的平均值。
• MIN()：获取数值列的最小值。
• MAX()：获取数值列的最大值。

1
2

SELECT COUNT(column_name), SUM(column_name), AVG(column_name), MIN(column_name), MAX(column_name)
FROM table_name;

• 如果记录中包含 NULL 值，聚合函数会忽略这些值进行计算。

SQL 分组数据

GROUP BY 子句用于将结果集按一个或多个列进行分组。

1
2
3
4

-- 该查询按 column1 分组，并计算每个组的记录数
SELECT column1, COUNT(*)
FROM table_name
GROUP BY column1;

• GROUP BY：指定分组的列。

SQL 连接表

JOIN 语句用于根据相关列将两个或多个表中的记录结合起来。常用的连接类型包括：

• INNER JOIN：返回两个表中匹配的记录。
• LEFT JOIN：返回左表中的所有记录，以及右表中匹配的记录。
• RIGHT JOIN：返回右表中的所有记录，以及左表中匹配的记录。
• FULL JOIN：返回两个表中的所有记录。

1
2
3
4

SELECT columns
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

• INNER JOIN：指定要连接的两个表及其连接条件。
• ON：指定连接条件。

SQL 子查询

子查询是嵌套在另一个 SQL 查询中的查询。它们可以用于在主查询中提供数据。

1
2
3

SELECT column1, column2
FROM table_name
WHERE column3 IN (SELECT column3 FROM another_table WHERE condition);

• IN：用于指定子查询返回的值列表。
• 子查询可以出现在 SELECT、FROM、WHERE 等子句中。

Python 基础操作(部分)

Python 数据类型

Python 支持多种数据类型，常见的包括：

• 整数（int）：表示整数值，例如 5、-3
• 浮点数（float）：表示带小数的数值，例如 3.14、-0.5
• 字符串（str）：表示文本数据，例如 "Hello, World!"
• 布尔值（bool）：表示真或假，取值为 True 或 False
• 列表（list）：有序可变的集合，例如 [1, 2, 3]
• 元组（tuple）：有序不可变的集合，例如 (1, 2, 3)
• 字典（dict）：键值对的集合，例如 {"key": "value"}
• 集合（set）：无序不重复的集合，例如 {1, 2, 3}

列表操作

• 创建列表：

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

• 访问元素：

  1 2	first_element = my_list[0] # 访问第一个元素 last_element = my_list[-1] # 访问最后一个元素

• 添加元素：

  1 2	my_list.append(6) # 在末尾添加元素 my_list.insert(2, 2.5) # 在索引2位置插入元素

• 删除元素：

  1 2	my_list.remove(3) # 删除值为3的元素 popped_element = my_list.pop() # 删除并返回最后一个元素

• 列表切片：

  1	sub_list = my_list[1:4] # 获取索引1到3的子列表

• 遍历列表：

  1 2	for item in my_list: print(item)

• 列表长度：

  1	length = len(my_list) # 获取列表长度

• 合并列表：

  1 2	another_list = [7, 8, 9] combined_list = my_list + another_list # 合并两个列表

• 排序列表：

  1 2	my_list.sort() # 原地排序列表 sorted_list = sorted(my_list) # 返回一个新的排序列表

• 反转列表：

  1 2	my_list.reverse() # 原地反转列表 reversed_list = my_list[::-1] # 返回一个新的反转列表

• 查找元素索引：

  1	index = my_list.index(4) # 查找值为4的元素索引

• 列表统计值：

  1 2 3 4

  count = my_list.count(2) # 统计值为2的元素出现次数 avg = sum(my_list) / len(my_list) # 计算列表平均值 MAX = max(my_list) # 获取列表最大值 MIN = min(my_list) # 获取列表最小值

字典操作

• 创建字典：

  1	my_dict = {"name": "Alice", "age": 30, "city": "New York"}

• 访问值：

  1	name = my_dict["name"] # 访问键"name"对应的值

• 添加或更新键值对：

  1 2	my_dict["age"] = 31 # 更新键"age"的值 my_dict["country"] = "USA" # 添加新的键值对

• 删除键值对：

  1 2	del my_dict["city"] # 删除键"city"及其对应的值 age = my_dict.pop("age") # 删除键"age"并返回其值

• 遍历字典：

  1 2	for key, value in my_dict.items(): print(f"{key}: {value}")

• 获取所有键：

  1	keys = my_dict.keys() # 获取所有键

• 获取所有值：

  1	values = my_dict.values() # 获取所有值

• 检查键是否存在：

  1 2	if "name" in my_dict: print("Name exists in the dictionary")

• 字典长度：

  1	length = len(my_dict) # 获取字典长度

math库

• math.sqrt(x)：计算平方根。
• math.pow(x, y)：计算 x 的 y 次幂。
• math.sin(x)：计算 x 的正弦值（x 以弧度为单位）。
• math.cos(x)：计算 x 的余弦值（x 以弧度为单位）。
• math.tan(x)：计算 x 的正切值（x 以弧度为单位）。
• math.log(x)：计算 x 的自然对数。
• math.log10(x)：计算 x 的以10为底的对数。
• math.exp(x)：计算 e 的 x 次幂。
• math.ceil(x)：向上取整。
• math.floor(x)：向下取整。
• math.pi：圆周率常量 π。
• math.e：自然对数的底数 e。

Numpy库

• 创建数组：

  1 2	array_1d = np.array([1, 2, 3, 4, 5]) # 创建一维数组 array_2d = np.array([[1, 2, 3], [4, 5, 6]]) # 创建二维数组

• 数组属性：

  1 2 3

  shape = array_2d.shape # 获取数组形状 dtype = array_1d.dtype # 获取数组数据类型 size = array_1d.size # 获取数组元素数量

• 数组运算：

  1 2 3 4 5

  sum_array = np.sum(array_1d) # 计算数组元素和 mean_array = np.mean(array_1d) # 计算数组元素平均值 max_value = np.max(array_1d) # 获取数组最大值 min_value = np.min(array_1d) # 获取数组最小值 std_dev = np.std(array_1d) # 计算数组标准差

• 数组索引和切片：

  1 2	element = array_2d[0, 1] # 访问二维数组的元素 sub_array = array_2d[:, 1] # 获取二维数组的第二列

• 数组形状操作：

  1 2	reshaped_array = array_2d.reshape(3, 2) # 重塑数组形状 flattened_array = array_2d.flatten() # 展平数组为一维

• 数组连接：

  1	concatenated_array = np.concatenate((array_1d, array_1d)) # 连接两个数组

• 数组分割：

  1	split_arrays = np.split(array_1d, 2) # 将数组均等分割为两个子数组

• 生成特殊数组：

  1 2 3

  zeros_array = np.zeros((3, 4)) # 创建一个3x4的零数组 ones_array = np.ones((2, 5)) # 创建一个2x5的全1数组 identity_matrix = np.eye(4) # 创建一个4x4的单位矩阵

Pandas库

• 创建数据框：

  1 2 3

  import pandas as pd data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]} df = pd.DataFrame(data)

• 读取数据：

  1 2	df = pd.read_csv('file.csv') # 从CSV文件读取数据 df = pd.read_excel('file.xlsx') # 从Excel文件读取数据

• 查看数据：

  1 2 3 4

  df.head() # 查看前5行数据 df.tail() # 查看后5行数据 df.info() # 查看数据框信息 df.describe() # 查看数据统计信息

• 选择数据：

  1 2 3 4

  column = df['Name'] # 选择单列 subset = df[['Name', 'Age']] # 选择多列 row = df.iloc[0] # 选择第一行 rows = df.iloc[0:3] # 选择前3行

• 过滤数据：

  1	filtered_df = df[df['Age'] > 30] # 过滤年龄大于30的行

• 添加列：

  1	df['Salary'] = [50000, 60000, 70000] # 添加新列

• 删除列：

  1	df.drop('Salary', axis=1, inplace=True) # 删除列

• 处理缺失值：

  1 2	df.dropna(inplace=True) # 删除缺失值行 df.fillna(0, inplace=True) # 用0填充缺失值

• 分组数据：

  1	grouped = df.groupby('Age').mean() # 按年龄分组并计算平均值

• 排序数据：

  1	sorted_df = df.sort_values(by='Age') # 按年龄排序

• 保存数据：

  1 2	df.to_csv('output.csv', index=False) # 保存为CSV文件 df.to_excel('output.xlsx', index=False) # 保存为Excel文件