首页 学习学习我爱学习 Python数据分析

# 算法性

算法不等同于数学中的计算方法

# 算法特性

  1. 确定性
  2. 可行性
  3. 有穷性
  4. 输入
  5. 输出

# 评价算法优劣

  1. 正确性
  2. 可读性
  3. 健壮性
  4. 高效性

# 随机数

# 随机整数

  • randint(a, b) ，返回 [a, b] 的随机整数
  • randrange(a, b) ，返回 [a, b) 的随机整数

# 随机浮点数

  • uniform(a, b) ，返回 [a, b] 的随机浮点数
  • random() ，返回 [0, 1) 的随机浮点数
  • a + (b - a) * random() ，返回 [a, b) 的随机浮点数

# 循环

若要在 for 循环正常结束之后，执行某条语句，可以使用

Python
1
2
3
4
for i in range(....):
    xxxxxx
else:
    xxxx

# 切片

  1. 列表切片是左闭右开
  2. s[:k] ，左侧值默认为 00
  3. s[k:] ，右侧值默认为 len(s)
  4. 出现负数的情况：
    1. 最后一个是 −1-1，往前类推
    2. s[:-k] ，返回前 len(s) - k 个
    3. s[-a:-b] ，aa 必须比 bb 大，不然会返回空，不是报错！
    4. s[a:b:c] ，aa - 起始，bb - 终止，cc - 步长
      • c = 0 ，报错
      • c > 0 ，从左向右取
      • c < 0 ，从右向左取

# 元组、列表、字典

特性集合（ set ）列表（ list ）字典（ dict ）元组（ tuple ）
有序性❌ 无序✅ 有序✅ 有序（Python 3.7+）✅ 有序
唯一性✅ 元素唯一❌ 允许重复✅ 键唯一❌ 允许重复
可变性✅ 可增删元素✅ 可修改✅ 可增删键值对❌ 不可变
语法{1, 2, 3}[1, 2, 3]{"a": 1, "b": 2}(1, 2, 3)
空对象set()[]{}()
元素类型必须可哈希（不可变）任意类型键必须可哈希，值任意任意类型

Python
1
2
3
4
5
6
7
a = (1, 2)  # a 是元组 tuple

b = [1, 2]  # b 是列表 list

c = {"a":b} # c 是字典 dict

d = {1, 2}  # d 是集合 set

# 元组

  • 内容不可修改
  • 括号可省略
    Python
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 遍历元组
    t = ('apple', 'banana', 'cherry')  
    for item in t:  
        print(item)  
      
    for i, item in enumerate(t):  
        print(f"索引 {i}: {item}")
        print(t[i])

    # 元组的方法
    t = (1, 2, 3, 2, 4, 2)
    print(t.count(2))  # 输出: 3 (统计元素出现次数)
    print(t.index(3))   # 输出: 2 (返回元素首次出现的索引)

# 列表

  • 列表内元素数据类型可以不同
    Python
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 列表元素变化
    lst = [1, 2, 3]  
    lst[0] = 10         # 修改元素 [10, 2, 3]
    lst[1:3] = [20, 30] # 修改切片 [10, 20, 30]
    lst.append(4)       # 末尾添加 [10, 20, 30, 4]
    lst.insert(1, 15)   # 指定位置插入 [10, 15, 20, 30, 4]

    # 列表排序
    nums = [3, 1, 4, 2]
    nums.sort()                  # 原地排序 [1, 2, 3, 4]
    sorted_nums = sorted(nums)   # 返回新列表 [1, 2, 3, 4]
    words = ['banana', 'apple', 'cherry']
    words.sort(key=len)          # 按长度排序 ['apple', 'banana', 'cherry']

# 浅拷贝

# 特点

• 只复制列表的顶层元素，不会递归复制嵌套的可变对象（如子列表、字典等）
・如果原列表包含可变对象（如子列表），浅拷贝后的嵌套对象与原列表共享引用

Python
1
2
3
4
import copy

original = [1, 2, [3, 4]]
shallow_copy = copy.copy(original)  # 或 original.copy() 或 original[:]

# 示例

Python
1
2
3
4
5
6
7
8
9
10
11
12
original = [1, 2, [3, 4]]
shallow_copy = original.copy()

# 修改浅拷贝的顶层元素
shallow_copy[0] = 10
print(original)      # [1, 2, [3, 4]] → 原列表未受影响
print(shallow_copy)  # [10, 2, [3, 4]]

# 修改浅拷贝的嵌套列表
shallow_copy[2][0] = 30
print(original)      # [1, 2, [30, 4]] → 原列表的嵌套对象被修改！
print(shallow_copy)  # [10, 2, [30, 4]]

# 图示

Show
1
2
3
4
原列表: [1, 2, [3, 4]]
          ↑    ↑
          |    |
浅拷贝: [10, 2, [30, 4]]  # 嵌套列表是共享的！

# 深拷贝

# 特点

• 递归复制所有嵌套的可变对象，完全独立于原列表。
・修改深拷贝后的列表（包括嵌套对象）不会影响原列表。

# 创建方式

Python
1
2
3
4
import copy

original = [1, 2, [3, 4]]
deep_copy = copy.deepcopy(original)

# 示例

Python
1
2
3
4
5
6
7
original = [1, 2, [3, 4]]
deep_copy = copy.deepcopy(original)

# 修改深拷贝的嵌套列表
deep_copy[2][0] = 30
print(original)      # [1, 2, [3, 4]] → 原列表完全不受影响
print(deep_copy)     # [1, 2, [30, 4]]

# 图示

Show
1
2
3
4
原列表: [1, 2, [3, 4]]
          ↑    ↑
          |    |
深拷贝: [1, 2, [30, 4]]  # 嵌套列表也是独立的！

# 深浅拷贝的对比

特性浅拷贝（Shallow Copy）深拷贝（Deep Copy）
复制层级仅顶层所有嵌套层级
嵌套对象共享引用完全独立
内存占用较少较多（递归复制所有嵌套对象）
适用场景简单列表（无嵌套或嵌套不可变）复杂嵌套结构（需完全独立）
修改影响嵌套对象会影响原列表完全不影响原列表

# 列表的排序

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 直接排序原链表
my_list = [3, 1, 4, 1, 5, 9, 2]
my_list.sort()  # 默认升序
my_list.sort(reverse=True)  # 降序

# 按字符串长度排序
words = ["apple", "banana", "cherry", "date"]
words.sort(key=len)

# 按绝对值降序排序，返回新链表
sorted_list = sorted(my_list, key=abs, reverse=True)

# 复杂排序
students = [
    {"name": "Alice", "score": 90},
    {"name": "Bob", "score": 75},
    {"name": "Charlie", "score": 88}
]
# 按分数升序排序
students_sorted = sorted(students, key=lambda x: x["score"])

# 字典

  • 键是唯一的

# 字典排序

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
my_dict = {"b": 2, "a": 1, "c": 3}
sorted_keys = sorted(my_dict)  # 默认按键排序

sorted_items = sorted(my_dict.items())  # 返回 (key, value) 元组列表
print(sorted_items)  # 输出: [('a', 1), ('b', 2), ('c', 3)]

sorted_items_desc = sorted(my_dict.items(), reverse=True)
print(sorted_items_desc)  # 输出: [('c', 3), ('b', 2), ('a', 1)]

sorted_by_value = sorted(my_dict.items(), key=lambda x: x[1])  # 按值升序
print(sorted_by_value)  # 输出: [('a', 1), ('b', 2), ('c', 3)]


people = [
    {"name": "Alice", "age": 25},
    {"name": "Bob", "age": 20},
    {"name": "Alice", "age": 20}
]
# 先按 age 升序，再按 name 升序
sorted_people = sorted(people, key=lambda x: (x["age"], x["name"]))
print(sorted_people)
# 输出: [{'name': 'Alice', 'age': 20}, {'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 25}]

# 集合

  • 集合内元素是无序的
  • 会自动去重
  • 可以动态添加 / 删除元素
  • 内部元素需是不可变类型（整数、元组、字符串）
    Python
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    c = {1, 2, 3}  
      
    # 成员检测  
    print(2 in c)  # 输出 Trueprint(4 in c)  # 输出 False  
    # 元素添加 / 删除  
    c.add(4)       # 添加元素 4c.remove(2)    # 删除元素 2（若不存在会报 KeyError）  
    c.discard(99)  # 安全删除（元素不存在时不报错）  
      
    # 集合运算  
    a = {1, 2, 3}  
    b = {2, 3, 4}  
    print(a | b)  # 并集 → {1, 2, 3, 4}
    print(a & b)  # 交集 → {2, 3}
    print(a - b)  # 差集（在a但不在b）→ {1}
    print(a ^ b)  # 对称差集（仅出现在一个集合中）→ {1, 4}

# Lambda 函数

Python
1
2
3
4
5
6
7
# 定义一个简单的lambda函数，计算平方
square = lambda x: x ​**​ 2
print(square(5))  # 输出: 25

# 等同于普通函数
def square(x):
    return x ​**​ 2