Python 大二复习提纲

unit 1

1. 注释、变量命名、缩进

• 注释:
  • 单行注释：用 # 标记。
  • 多行注释：用三引号 ''' 或 """ 包围
• 变量命名: 可以使用字母、数字、下划线，但不能以数字开头。

name = "John"  # 合法
_age = 30      # 合法
2data = 50     # 非法，不能以数字开头

• 缩进: Python中用于区分代码块，通常是4个空格。

2. 数据输入字符串函数input()

​user_input = input("Enter something: ")
print(f"You entered: {user_input}")

3. 字符串解析函数eval()

• 功能: 解析并执行一个字符串表达式，并返回结果。
• 特点: 能将输入的字符串解析为对应的数据类型（如数字、列表等）。
• 注意: 使用时需确保输入安全，因为eval()可以执行任意代码。

x = eval("10 + 20")  # 解析并执行字符串中的表达式
print(x)  # 输出 30
​
expression = input("Enter an expression: ")
print(eval(expression))

4. 输出函数print()

换行输出，不换行输出print（str,end=’,’）

print("Hello", end=',')  # 不换行继续下一条print
print("World!") # 默认换行输出
print("python!")

unit 2 变量

变量、数据类型、赋值语句

变量：

• 变量不必事先声明、无须指定类型、直接赋值使用
• 变量及关键字区分大小写，字母下划线开头

数据类型：

• 数值（整型int，浮点型float）
• 字符串str
• 列表list
• 元组tuple
• 集合set
• 字典dict

赋值

多变量赋值: a, b = 5, 6

列表赋值传地址：赋值后，两个变量指向同一列表对象。

# 列表赋值传地址
original_list = [1, 2, 3]
new_list = original_list  # 指向同一列表对象
original_list[0] = 99
print(new_list)  # new_list也会变成[99, 2, 3]
​
# 当你想改变original_list时不改变new_list，可以使用列表的复制来创建new_list，这样它们就会指向不同的对象。这可以通过切片操作或者list()函数来实现
# 使用切片操作
original_list = [1, 2, 3]
new_list = original_list[:]
original_list[0] = 99
print(new_list)  # new_list 仍然是 [1, 2, 3]
​
# 使用list()函数
original_list = [1, 2, 3]
new_list = list(original_list)
original_list[0] = 99
print(new_list)  # new_list 仍然是 [1, 2, 3]

各算数运算符

• +、-、*、/、**、%及应用
• ** 为幂运算，% 为模运算。

数值运算内置函数

# 内置函数
numbers = [10, 20, 30, 40, 50]
print(sum(numbers))  # sum
print(max(numbers))  # max
print(min(numbers))  # min
print(round(3.756))  # round 四舍五入

类型转换函数:int(字符串,进制)、float()、list()、set()、dict()

# 进制转换示例
print(int('101', 2))  # 二进制转十进制 5
print(int('21', 8))   # 八进制转十进制 17
print(int('1A', 16))  # 十六进制转十进制 26
​
s = "100"
n = int(s)  # 字符串到整型 100
f = float(s)  # 字符串到浮点型 100.0
l = list(s)  # 字符串到列表 ['1', '0', '0']
print(n, f, l)

字符串的索引、切片、修改

# 字符串索引和切片
s = "Hello, World!"
print(s[7])     # W
print(s[0])  # H
print(s[0:5])   # Hello
print(phrase[5:])  # , World!
print(phrase[:5])  # Hello
​
# 由于字符串是不可变的（immutable），你不能直接修改字符串中的单个字符。但是，你可以通过创建一个新的字符串来“修改”原字符串。这通常涉及到字符串的拼接或使用其他方法，如列表转换等。
s = "Hello, World!"
# 假设你想将第一个字符'H'改为'J'
# 方法1: 通过拼接
new_s = 'J' + s[1:]
print(new_s)
​
# 方法2: 转换为列表，修改后再转回字符串
s_list = list(s)
s_list[0] = 'J'
# join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
new_s = ''.join(s_list)
print(new_s)

内置字符串处理函数str、len

print(str(123))   # 数字到字符串 123
print(len("python"))  # 字符串长度 6

字符串处理常用方法：split()、join()、replace()、strip()

text = "hello world"
print(text.split(' '))  # 分割 ['hello', 'world']
print(','.join(["Python", "Java", "C"]))  # 连接 thon,Java,C
print(text.replace("hello", "hi"))  # 替换 hi world
print(" hello ".strip())  # 移除空白字符   hello

格式化输出方法format()

name = "Python"
version = 3.9
print("Language: {}, Version: {}".format(name, version))

unit 3 循环

range()函数使用，步长

for i in range(0, 10, 2):  # 从0到9，步长为2,注意这个10是不包括的哈！！！
   print(i)

# for循环进行各种迭代，遍历结构可以是字符串、文件、组合数据类型或range()函数

# 遍历字符串
for char in "Python":
   print(char)
​
# 遍历列表
numbers = [1, 2, 3, 4, 5]
for number in numbers:
   print(number)
​
# 遍历字典
dict = {"name": "Python", "version": 3.9}
for key in dict:
   print(key, dict[key])
​
# 遍历 range()，只有一个参数默认从0开始，步长为1
for i in range(5):
   print(i)

while循环 循环条件、循环变量

n = 5
while n > 0:
   print(n)
   n -= 1

for循环、while循环中else子句【仅循环正常结束后执行】、continue、break的使用

# for循环和else   输出：0 1 2 Done！
for i in range(3):
   print(i)
else:
   print("Done!")
​
# while和else   输出：3 2 1 Done！
n = 3
while n > 0:
   print(n)
   n -= 1
else:
   print("Done！")
​
# while循环使用continue和break
n = 0
while n < 5:
   n += 1
   if n == 3:
       continue  # 跳过3
   if n == 5:
       break  # 跳出循环
   print(n)

分支语句：单分支、双分支、多分支

# 单分支
x = 10
if x > 5:
   print("x is greater than 5")
​
# 双分支
if x < 20:
   print("x is less than 20")
else:
   print("x is 20 or more")
​
# 多分支
if x < 10:
   print("x is less than 10")
elif x < 20:
   print("x is between 10 and 20")
else:
   print("x is 20 or more")

==与=

x = 5  # 赋值
print(x == 5)  # 比较

random库的使用

随机数生成方法random、randint、choice、sample

import random

# random() 返回0.0到1.0之间的随机浮点数。
print(random.random())

# randint(a, b) 返回a到b之间的随机整数，包括两端。
print(random.randint(1, 10))

# choice(sequence) 从非空序列返回一个随机元素。
items = [1, 2, 3, 4, 5]
print(random.choice(items))

# sample(population, k) 从总体序列或集合中返回k长度的列表。
print(random.sample(items, 2))

unit 4 函数

函数的定义、调用、参数传递（引用传递（传值、传地址））、可变参数应用（打包传递）

• 函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段。
• 定义: 使用def关键字。
• 调用: 直接使用函数名和参数调用。

# 定义函数    f表示格式化字符串字面值，允许你在字符串内包含表达式
def greet(name):
    return f"Hello, {name}!"
# 调用函数
print(greet("Alice"))

参数传递

• 引用传递: 函数内的参数名称为局部作用域的变量。
• 当你传递不可变对象（int, float, bool, string, tuple）时，理解为值传递；
• 传递可变对象（如list, dict, set）时，理解为引用传递。

理解可变与不可变对象的关键在于理解对象的身份（identity）、类型（type）和值（value）这三者的区别。

• 身份: 每个对象都有一个唯一的身份标识自己，你可以把它理解为对象的内存地址。在Python中，可以使用id()函数查看。
• 类型: 指的是对象的数据类型，例如int, float, str等。
• 值: 指的是对象所代表的数据或信息。

当我们说一个对象如整数（int）是不可变的，我们是指它的值不能改变。确切地说，当你创建了一个整数对象，比如x = 5，你实际上是创建了一个值为5的整数对象，并让变量x指向它。当你随后执行x = 10，你并没有改变原来的整数对象的值从5到10，而是创建了一个新的整数对象，值为10，并更新了x的引用。

x = 5
print(id(x))  # 比如 140704575562112
x = 10
print(id(x))  # 比如 140704575562432
​
lst = [1, 2, 3]
print(id(lst))  # 比如 139922743704128
lst.append(4)
print(id(lst))  # 仍然是 139922743704128

可变参数应用（打包传递）

• 使用*args接收任意数量的位置参数，使用**kwargs接收任意数量的关键字参数。

# 任意数量参数
def function_with_var_args(*args):
   for arg in args:
       print(arg)
​
function_with_var_args(1, 'two', 3)
​
# 任意数的关键字参数，其实就把kwargs看成一个字典
def greet(**kwargs):
   for key, value in kwargs.items():
       print(f"{key}: {value}")
​
greet(name="John", age=22, city="New York")

解包（针对列表、元组等）

# 解包允许将列表、元组等数据结构中的元素“解包”并分配给变量。
numbers = [1, 2, 3]
a, b, c = numbers
print(a, b, c)

函数调用参数的缺省值

# 缺省值
def greet(name, msg="Good morning!"):
   print(f"Hello, {name}, {msg}")
​
greet("Alice")  # 使用默认的msg
greet("Bob", "How do you do?")  # 提供新的msg

函数中全局变量的定义使用：global

x = 5
​
def modify_global():
   global x #声明为全局变量，替代上面的x
   x = 10
​
modify_global()
print(x)  # 输出 10

lambda函数的定义与使用

lambda是一个创建匿名函数的关键字，在Python中，它是一个简洁的定义函数的方法。lambda函数通常用于需要一个函数，但又不想费神去命名一个函数的场合，常用于小的、一次性的函数。标准的函数定义比lambda要更丰富，但对于简化代码lambda非常有用。

• 结构：lambda arguments: expression
• 只能有一个表达式，不允许有多个。
• 表达式的计算结果是函数的返回值。

square = lambda x: x * x
print(square(5))

lambda函数在排序函数中的使用

形式就是sorted([xxx], key=lambda x: expresion)

# point是列表，每个元素都是一个元组
points = [(1, 2), (15, 1), (5, -1), (10, 4)]
# 比较的key是point[1]
points_sorted = sorted(points, key=lambda point: point[1])
print(points_sorted) # [(5, -1), (15, 1), (1, 2), (10, 4)]

内置函数map的使用

# map()函数根据提供的函数对指定序列做映射
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared)) # 输出: [1, 4, 9, 16]

unit 5列表

序列类型的12个通用操作符和函数， +、*、in等

              在Python中，序列类型（如列表、元组和字符串）支持多种操作符和函数。以下是12个通用操作符和函数的简要说明和示例：

1. + (连接): 把两个序列连接起来。
2. \* (重复): 重复序列的元素多次。
3. in (成员资格): 检查元素是否属于序列。
4. not in: 检查元素是否不属于序列。
5. s[i] (索引): 访问序列的第i个元素。
6. s[i:j] (切片): 访问序列中一定范围的元素。
7. s[i:j:k] (步长切片): 访问序列中一定范围的元素，按照步长k。
8. len(s): 返回序列的长度。
9. min(s): 返回序列中的最小值。
10. max(s): 返回序列中的最大值。
11. s.index(x[, i[, j]]): 返回序列s从i开始到j结束中第一次出现元素x的索引。
12. s.count(x): 返回序列s中x出现的总次数。

# + 和 * 操作符
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # 输出合并后的列表 [1, 2, 3, 4, 5, 6]
print(list1 * 3)      # 输出重复3次的列表 [1, 2, 3, 1, 2, 3, 1, 2, 3]
​
# in 和 not in
print(1 in list1)     # True
print(10 not in list1) # True
​
# len(), min(), max()
print(len(list1))     # 3
print(min(list1))     # 1
print(max(list1))     # 3
​
# index(),count()
print(list1.index(1))  # 找出1的索引 -- 0
print(list1.index(1, 2))  # 从索引2之后找1 --这里报错1 is not in list
print(list1.index(2, 1, 2))  # 在索引1到2之间找2   --1
print(list1.count(2))  # 计算2在列表中出现的次数 --1

组合数据类型相关的内置函数：sorted()（sort()的差别）

• sort():
  • 仅适用于列表。
  • 对列表进行原地排序，改变原列表。
  • 返回值为None。
• sorted():
  • 适用于所有可迭代类型。
  • 返回新的排好序的列表，不改变原始数据。
  • 更加通用。

# sort 和 sorted
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 使用 sort() 对原列表排序
numbers.sort()
print("Sorted with sort():", numbers)  # numbers 被改变

# 使用 sorted() 对列表排序
new_numbers = sorted([3, 1, 4, 1, 5, 9, 2, 6])
print("Sorted with sorted():", new_numbers)  # 返回新的排序列表，原列表不变

列表

# 列表的创建，赋值（地址），列表的索引
# 使用[]创建
my_list = [10, 'python', 20]
print(my_list[1])     # python
# 使用 list() 创建列表
empty_list = list()  # 创建空列表
print(empty_list)

iterable = "Python"  # 字符串也是可迭代对象，字符串转列表
list_from_iterable = list(iterable)
print(list_from_iterable)  # ['P', 'y', 't', 'h', 'o', 'n']


# 列表的访问（包括元素修改）与切片
print(my_list[:2])    # [10, 'python']
my_list[2] = 'Java'   # [10, 'Java', 20]

# 列表中的常用方法:sort()、append()、pop()、insert()、remove()、
my_list.append(30)
my_list.insert(1, 'hello')
print(my_list)        # [10, 'hello', 'python', 20, 30]
my_list.sort()
print(my_list)   # 注意：这将按字符排序，因为列表中既有数字又有字符串

unit 6 元组

元组的创建及访问（多变量赋值）

     元组是不可变的序列类型，它可以包含多种类型的元素。元组用圆括号()表示，元素之间用逗号,分隔。

# 创建元组
my_tuple = (1, 2, 3)
print(my_tuple)

# 创建空元组
empty_tuple = ()
print(empty_tuple)

# 单个元素元组创建，注意逗号
single = (1,)  # 正确的单个元素元组表示
not_a_tuple = (1)  # 这不是元组，只是一个普通的整数1
print(single)

# 访问元组
print(my_tuple[1])  # 输出 2
print(my_tuple[0:2])  # 输出 (1, 2)

# 多变量赋值
a, b, c = my_tuple
print(a, b, c)  # 输出 1 2 3


# 特别注意元组的元素不能修改、追加等
try:
    my_tuple[1] = 100  # 尝试修改元组的元素
except TypeError as e:
    print(e)

# 非标准表示元组（如省略括号）
tuple_without_parentheses = 1, 2, 3
print(tuple_without_parentheses)

内置函数zip的用法

# zip：将可迭代的对象(list,String,Tuple,Dictionary,Set,File...)作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 使用iter()函数来测试一个对象是否可迭代。如果对象是可迭代的，iter()将返回一个迭代器
my_list = [1, 2, 3]
my_iter = iter(my_list)  # 正常运行，因为列表是可迭代的
​
​
# zip通常用于同时遍历两个或多个序列，也可以用来创建字典。
numbers = [1, 2, 3]
letters = ['a', 'b', 'c']
zipped = zip(numbers, letters)
print(list(zipped))  # 输出 [(1, 'a'), (2, 'b'), (3, 'c')]

unit 7集合列表字典【没太懂】

集合的概念、创建方法、对集合中元素的要求

概念

• 集合（Set）是一个无序的不重复元素集。它基本功能包括关系测试和消除重复元素。

创建方法

# 使用大括号创建集合
my_set = {1, 2, 3}
print(my_set)
​
# 使用set()函数从其他数据结构转换
my_list = [1, 2, 2, 3, 4]
my_set_from_list = set(my_list)
print(my_set_from_list)  # 输出 {1, 2, 3, 4}

元素要求

• 集合中的元素必须是不可变的，如整数、浮点数、字符串、元组等。
• 集合本身是可变的，可以添加或删除元素。

键的要求

• 字典中的键必须是不可变类型，如字符串、数字或元组。
• 键必须是唯一的

特点：无顺序、不重复

利用set()去重复

# 使用set()去除重复元素
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = set(numbers)
print(unique_numbers)  # 输出: {1, 2, 3, 4, 5}

集合元素操作方法：

集合并交差运算符、元素添加add()、删除remove()

A = {1, 2, 3}
B = {3, 4, 5}
print(A | B)  #并集 输出: {1, 2, 3, 4, 5}
print(A & B)  #交集 输出: {3}
print(A - B)  #差集 输出: {1, 2}
print(A ^ B)  #对称差集 输出: {1, 2, 4, 5}
​
A.add(6)  # 添加
print(A)  # 输出: {1, 2, 3, 6}
​
A.remove(6) # 删除 注意这里只会删除第一个匹配的，如果有多个匹配不会删掉后面的
print(A)  # 输出: {1, 2, 3}

zip函数：利用zip生成字典（将两个列表）、联合两个列表的使用

keys = ['name', 'age', 'job']
values = ['Alice', 25, 'Engineer']
​
# 利用zip函数生成字典
info_dict = dict(zip(keys, values))
print(info_dict)  # 输出: {'name': 'Alice', 'age': 25, 'job': 'Engineer'}

整合一下：

# 成员判断in
my_dict = {'name': 'Alice', 'age': 25}
print('name' in my_dict)  # True
​
# 字典元素的添加
my_dict['location'] = 'New York'
print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'location': 'New York'}
​
# 字典中的get()方法
print(my_dict.get('age'))  # 25
print(my_dict.get('birthday', 'Not Found'))  # 'Not Found'
​
# 字典元素的迭代方法：items()、keys()、values()
# 注意不使用这三个方法，直接针对字典元素的操作是对键的操作
# items()： 迭代字典中的键值对。返回的是一个元组，第一个元素是键，第二个元素是对应的值。
for key, value in my_dict.items():
   print(key, value)
​
# keys()：迭代字典的键，而不是键值对或值
# 在这种情况下，如果你想访问对应的值，你需要使用键来索引字典，如my_dict[key]。
for key in my_dict.keys():
   print(key)
​
# values()
for value in my_dict.values():
   print(value)

​

列表推导式、集合、字典生成式（包括其中的判断条件进行选择）

# 列表推导式
numbers = [1, 2, 3, 4, 5]
squares = [n**2 for n in numbers if n > 2]
print(squares)  # 输出: [9, 16, 25]
​
# 集合生成式
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_squares = {n**2 for n in numbers}
print(unique_squares)  # 输出: {16, 1, 9, 25, 4}
​
# 字典生成式
squares_dict = {n: n**2 for n in numbers}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

unit 8 文件

文件的类型、打开方式（读、写、追加）及相应指针位置

文件的类型

• 文本文件（.txt, .py, .csv, .json等）: 存储的是普通的文本数据。
• 二进制文件（.bin, .dat等）: 存储的是二进制数据，如图片、视频等。

打开方式

• 读模式 ('r'): 仅用于读取文件。如果文件不存在，抛出错误。
• 写模式 ('w'): 用于写入文件。如果文件存在，覆盖原有内容；如果文件不存在，创建新文件。
• 追加模式 ('a'): 用于向文件末尾追加内容。如果文件不存在，创建新文件。

相应指针位置

• 在读模式('r')下，指针默认位于文件的开始位置。
• 在写模式('w')或追加模式('a')下，指针会位于文件的开始或末尾，分别覆盖文件或追加内容。

文件的打开、关闭方法、with open 打开文件可自动关闭

打开文件

• 使用open()函数，语法：open(filename, mode)
• with语句可以自动管理文件的上下文环境，无需显式调用close()方法。

with open('example.txt', 'r') as file:
    content = file.read()
# 文件此时已自动关闭

关闭文件

• 使用close()方法。确保在完成文件操作后调用，释放系统资源。

文件的读写

读文件：

# f.read(): 读取整个文件
with open('example.txt', 'r') as file:
   content = file.read()
   print(content)
​
# f.readlines(): 逐行读取文件内容，返回一个列表，列表中的每个元素代表一行。
with open('example.txt', 'r') as file:
   for line in file.readlines():
       print(line.strip())  # strip() 移除行尾换行符

写文件：

# f.write(string): 将字符串写入文件。
with open('example.txt', 'w') as file:
   file.write("Hello, World!")
​
# f.writelines(list): 将一个字符串列表写入文件。
with open('example.txt', 'a') as file:
   file.write("\nAppending a new line.")

CSV文件格式的特点及用途

特点:

• 由逗号分隔的值（Comma-Separated Values）。
• 每行一个数据记录，每条记录由字段组成。
• 通常用于表示表格数据。

用途:

• 数据导出导入。
• 与表格软件（如Excel）和数据库兼容。

CSV库中文件的读写

import csv
​
# 读：csv.reader()
with open('example.csv', 'r') as file:
   csv_reader = csv.reader(file)
   for row in csv_reader:
       print(row)  # row 是一个列表
       
# 写：使用csv.writer()
rows = [['Name', 'Age'], ['Alice', 24], ['Bob', 19]]
​
with open('example.csv', 'w', newline='') as file:
   csv_writer = csv.writer(file)
   csv_writer.writerows(rows)  # 写入多行
   
# 在写CSV文件时，如果不指定newline=''，则每次writerow()被调用时，都会在行尾添加额外的空行，因为默认行为是转换换行符。所以，为了避免这种情况，通常建议在写CSV文件时使用newline=''。

JSON文件格式的用途

• 数据交换格式，轻量级，易于人阅读和编写，也易于机器解析和生成。
• 常用于Web应用间的数据传输。

JSON库中的文件读写及序列化反序列化dump()、load()【dump注意后面没有s，服了没题考了是吧】

import json
​
data = {
   "name": "Alice",
   "age": 25,
   "city": "New York"
}
# (序列化)写JSON文件 --dump()
with open('data.json', 'w') as file:
   json.dump(data, file)  # 写入JSON数据:将Python对象编码成JSON字符串并写入文件
​
# (反序列化)读JSON文件 --load()
with open('data.json', 'r') as file:
   data = json.load(file)  # 读取JSON数据：从文件读取JSON字符串并解码成Python对象
   print(data) # {'name': 'Alice', 'age': 25, 'city': 'New York'}

CSV与JSON转换算法

【todo： rows = list(reader)的作用是什么？和直接使用reader有什么区别？】

CSV转JSON

import csv
import json
​
# CSV to JSON
# 1. 读取CSV文件内容。
# 2. 将每行CSV转换为字典（假设第一行是列名）,将这些字典添加到列表中。
with open('data.csv', 'r') as f:
   # 为什么用字典：字典的每个键值对可以清晰地表示每个CSV字段及其对应的值，使得数据更加结构化。
   reader = csv.DictReader(f) # 每行都是一个字典
   rows = list(reader) # 转成字典列表
​
# 3. 使用`json.dump()`将列表转换为JSON格式。
with open('data.json', 'w') as f:
   json.dump(rows, f)

JSON转CSV

import json
import csv
​
# JSON to CSV
# 1. 读取JSON文件，解析为Python对象。
with open('data.json', 'r') as f:
   data = json.load(f)  # 字典列表
​
# 2. 创建CSV的writer对象。
# 3. 将Python对象转换为CSV行并写入文件。
with open('data.csv', 'w', newline='') as f:
   # 将字典写入csv文件
   # fieldnames指定列名(即键)，data[0].keys()表示使用列表中第一个字典的键作为列名
   writer = csv.DictWriter(f, fieldnames=data[0].keys())
   writer.writeheader() #写首行的列名
   writer.writerows(data) # 写入所有数据，data在这里是一个字典的列表

unit 9 import

import、import…as、from…import

              import语句用于将一个模块的内容导入到另一个模块或脚本中，让你可以使用那个模块提供的函数、类、变量等。

# import
# 作用: 导入模块。
# 语法: import module_name
# 特点: 导入整个模块，使用时需要通过模块名引用，如
import math
print(math.sqrt(4))  # 使用math模块中的sqrt函数

# import...as
# 作用: 导入模块并给模块指定别名。
# 语法: import module_name as alias
import math as m
print(m.sqrt(4))  # 使用别名m代替模块名math

# from…import
# 作用: 从模块中导入指定的部分。
# 语法: from module_name import some_function
# 特点: 可以直接导入模块的特定部分，不需要通过模块名引用。
from math import sqrt
print(sqrt(4))  # 直接使用sqrt函数，不需要通过math.sqrt

扩展库安装的操作命令:pip install、pip list

# pip install
# 作用: 安装Python包。
# 语法: pip install package_name
# 特点: 是Python的包管理工具，可以从Python Package Index（PyPI）等仓库中安装包。

pip install numpy  # 安装numpy包

# pip list
# 作用: 列出已安装的包。
# 语法: pip list
# 特点: 显示当前环境中安装的所有包及其版本。
pip list  # 显示所有已安装的包

unit 10 面向对象

面向对象概念

类、对象及创建

• 类（Class）: 是对一类具有相同属性和方法的对象的抽象。它定义了这类对象的行为和属性。
• 对象（Object）: 是类的实例。对象可以拥有类中定义的属性和方法。
• 创建: 使用class关键字定义类，通过类名加括号创建对象（实例）。

class MyClass:
   # 构造函数:用于在创建对象时初始化它的属性
   def __init__(self, value):  
       self.my_attribute = value
​
   def my_method(self):
       return self.my_attribute
​
# 创建对象
obj = MyClass(10)
print(obj.my_method())  # 调用方法

私有成员及访问

• 私有成员: 在Python中，以双下划线__开始的命名（但不以双下划线结尾，注意和特殊方法区分）被视为私有成员。它们不能从外部直接访问，只能通过类内部的方法访问。

class MyClass:
   def __init__(self, password):
       self.__private_password = password  # 私有属性
​
   def get_password(self):
       return self.__private_password  # 通过方法访问私有属性
​
obj = MyClass("secret")
print(obj.get_password())

类中的特殊方法及含义、运算符重载

• 特殊方法: Python中以双下划线__开始和结尾的方法，如__init__, __str__等。它们有特殊的意义和用法。
  • __init__(self, ...): 构造器，当一个实例被创建的时候调用的初始化方法。
  • __str__(self): 当使用print语句时或str()被使用时调用，返回一个字符串表示。
  • __repr__(self): 返回对象的字符串表示，通常可以用这个字符串来重新创建这个对象。它是给开发者用的。
  • __len__(self): 对序列类型定义长度，返回容器中元素的数量。
  • __del__(self): 析构方法，当对象被删除时调用。
  • __add__(self, other), __sub__(self, other), __mul__(self, other), 等: 运算符重载方法，定义加减乘等运算的行为。
  • __getitem__(self, key), __setitem__(self, key, value): 允许对象使用索引操作，如字典或列表。
• 运算符重载: 特殊方法可以用来重载或定义运算符的行为。

class Point:
   def __init__(self, x=0, y=0):
       self.x = x
       self.y = y
​
   # 定义了+运算符的行为
   def __add__(self, other):
       x = self.x + other.x
       y = self.y + other.y
       return Point(x, y)
​
   # 定义对象的字符串表示
   def __str__(self):
       return f"Point({self.x}, {self.y})"
​
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 + p2)  # 使用重载的+运算符

类的继承（包括多继承）

• 继承: 继承是面向对象编程的一个基本特性，允许创建一个“子类”继承一个或多个“父类”的属性和方法。
• 多继承: Python支持多继承，意味着一个子类可以继承多个父类。

class Parent1:
   def method_a(self):
       return "Parent1 method"
​
class Parent2:
   def method_b(self):
       return "Parent2 method"
​
# 多继承，继承格式：class 子类(父类):
class Child(Parent1, Parent2):
   pass
​
child_obj = Child()
print(child_obj.method_a())  # 从Parent1继承
print(child_obj.method_b())  # 从Parent2继承

同名方法的引用次序

              在多继承中，如果存在同名的方法，Python会按照特定的次序（称为方法解析顺序或MRO）来搜索它们。

class A:
   def do_something(self):
       print("Method Defined In: A")
​
class B(A):
   def do_something(self):
       print("Method Defined In: B")
​
class C(A):
   def do_something(self):
       print("Method Defined In: C")
​
class D(B, C):
   pass
​
d_instance = D()
d_instance.do_something()  # 输出取决于MRO
# MRO是指定类的方法解析顺序，它可以通过查看类的__mro__属性来查看
# 在这里会输出：Method Defined In: B
# 因为B在D的MRO中排在C前面，所以会先调用B的方法

父类构造函数的调用（包括多个父类）

# 子类可以通过`super()`函数调用父类的构造函数
class Parent:
   def __init__(self, value):
       self.value = value
​
class Child(Parent):
   def __init__(self, value, child_value):
       super().__init__(value)  # 调用父类的构造函数
       self.child_value = child_value
​
child = Child(10, 20)
print(child.value)  # 继承自父类
print(child.child_value)  # 子类自己的属性
​
# 继承多个父类的时候，通常使用`super()`来调用父类的构造函数，也是根据MRO决定调用哪个父类的方法
class Base1:
   def __init__(self):
       print("Base1.__init__")
​
class Base2:
   def __init__(self):
       print("Base2.__init__")
​
class Child(Base1, Base2):
   def __init__(self):
       super().__init__()  # 只会调用第一个父类Base1的__init__
       Base2.__init__(self)  # 明确调用Base2的构造函数
​
child = Child()

unit 11 库

numpy库: 用途

Numpy（Numerical Python）是Python中的一个开源数值计算扩展库。它是Python科学计算的基础包，用于快速有效地处理大型数据集和进行复杂的数学运算。以下是Numpy的一些主要用途：

1. 多维数组: 提供了一个强大的N维数组对象ndarray。
2. 广播功能: 对不同大小的数组进行数学运算的一种方法。
3. 整合C/C++/Fortran代码的工具: 这些工具非常适用于在Python中包装C/C++/Fortran代码。
4. 线性代数、傅里叶变换和随机数生成: Numpy提供了很多内建的函数进行高级数学和随机数操作。

numpy数组的创建、矩阵的创建（array,arange方法）、reshape()方法

Numpy数组的创建

• array: 使用numpy.array可以从列表等数据结构创建数组。
• arange: 类似于Python的range函数，用于生成数组。

import numpy as np
​
# 使用array创建数组
array1 = np.array([1, 2, 3, 4, 5])
print("Array from list:", array1) # [1 2 3 4 5]
​
# 使用arange创建数组
array2 = np.arange(10)  # 类似于range(10)
print("Array using arange:", array2) # [0 1 2 3 4 5 6 7 8 9]
​
# 矩阵的创建：可以简单地通过二维数组来表示。
matrix = np.array([[1, 2], [3, 4]])
print("Matrix:\n", matrix)
# [[1 2]
# [3 4]]

# reshape在不改变数据的条件下修改形状。
array3 = np.arange(6).reshape((2, 3))  # 从0到5的数改变为2x3的数组
print("Reshaped array:\n", array3)
# [[0 1 2]
# [3 4 5]]

数组的运算：+、-、*、@（矩阵乘）

import numpy as np
# 元素级的运算
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
​
print("a + b:", a + b)  # [5 7 9]
print("a - b:", a - b)  # [-3 -3 -3]
print("a * b:", a * b)  # 元素乘 [ 4 10 18]
​
# 矩阵乘法
c = np.array([[1, 2], [3, 4]])
d = np.array([[5, 6], [7, 8]])
​
print("c @ d:\n", c @ d)  # 矩阵乘法
# [[19 22]
# [43 50]]

unit 12生态【没实践】

Python生态：

wordcloud 、turtle 、pandas 、jieba 、 math

1. wordcloud（词云）

用途: wordcloud是一个词云生成器，用于在Python中创建词云图。它可以将文本中的词语按照频率或重要性转换为视觉引人注目的图形表达。

特点:

• 根据文本中词语的频率来调整大小。
• 容易定制，包括颜色、形状和字体。
• 常用于文本数据可视化，特别是在文本分析和自然语言处理中。

2. turtle（海龟图形）

用途: turtle是Python的一个标准库，用于引入孩子们和初学者到编程的世界。主要用于简单的图形绘制和交互式教学。

特点:

• 提供了一个画布(canvas)，用户可以在上面命令一个或多个“海龟”绘图。
• 适合于教学初级编程概念，如循环、函数和条件。
• 通过移动、旋转等操作来绘制各种图形。

3. pandas（数据分析）

用途: pandas是一个开源的数据分析和处理库，广泛用于Python中的数据分析、数据清洗、数据探索等。

特点:

• 提供快速、灵活的数据结构，如DataFrame和Series。
• 有助于进行数据的清洗、转换、分析等操作。
• 支持不同的数据格式读取和转换，如CSV、Excel文件等。

4. jieba（中文分词）

用途: jieba是一个中文文本分词工具，广泛用于处理中文文本。

特点:

• 支持三种分词模式：精确模式、全模式、搜索引擎模式。
• 支持添加自定义词典。
• 适合中文文本的分词、关键词提取、词性标注等。

5. math（数学运算）

用途: math是Python的标准库之一，提供了许多数学函数的实现。

特点:

• 提供基本的数学运算，如三角函数、对数函数和其他常用数学函数。
• 包括数学常数的定义，如π和e。
• 适用于需要数学计算的场景，尤其是在科学计算和工程领域。

5个实验相关问题

思维提升：

生态组件的使用思路，能描绘具体的应用场景

用组合数据类型描述应用场景；用面向对象或模块化的方法设计并实现相关任务

题型

一、选择题 10*2

二、填空题 5*2

三、阅读程序 6*5

四、程序填空题 5*2

五、应用编程题 2*10

六、思维提升题 10

小测

UNIT 1 基础概念

关键字：

A. import 是Python中的关键字，用于导入模块。

B. raise 也是Python中的关键字，用于引发异常。

C. final 不是Python中的关键字，它是Java中的关键字，用于表示一个不可继承的类或不可覆盖的方法。

D. with 是Python中的关键字，用于创建上下文管理器，通常用于资源管理

-------------------------------------------------------------------------------

abs():求模

-------------------------------------------------------------------------------

在IDLE交互模式下，一个下划线 "_" 确实表示解释器中最后一次显示的内容或最后一次语句正确执行的输出结果。这是一个方便的特性，可以用来引用最后一次操作的结果，例如：

>>> 5 + 3
8
>>> _ * 2
16

在上面的示例中，首先执行了 5 + 3，然后使用下划线 _ 引用了上一次的结果，然后将其乘以 2。

-------------------------------------------------------------------------------

在Python3中下列__语句是非法的。 选择一项：

A. a, b = b, a：这是一种交换两个变量值的常见方式。

B. m, n = 'ab'：这将把字符串 'ab' 的每个字符分配给变量 m 和 n。

D. m, n = 3, 4：这将分别给变量 m 和 n 分配值 3 和 4。

C. m=(n=a+1)：在 Python 中，赋值语句应该使用等号 =，而不是 = 嵌套在括号中。正确的方式是：m = n = a + 1

-------------------------------------------------------------------------------

max = x > y ? x : y ❌ python没有三目运算符{可以使用条件表达式来模拟三目运算符的功能}

if (x > y) print(x) ❌ if后面少了:

-------------------------------------------------------------------------------

Python 3.x语句 print(1, 2, 3, sep=':') 的输出结果为 1:2:3

查看变量内存地址的Python内置函数是 id()

已知 x = 3，并且id(x)的返回值为 496103280，那么执行语句 x += 6 之后，表达式 id(x) == 496103280 的值为 False

Print()是内置函数,可以显示输出数据,与print()函数一样【❌ 盗版货】

可以使用datatype()测试字符串的类型【❌ type()】

print(str1.find(str2, 5))的意思:从str1的索引5往后找str2所在的位置

-------------------------------------------------------------------------------

name="Python语言程序设计课程"

print(name[0],name[2:-2],name[-1])

--结果：P ython语言程序设计课 程【左开右闭】

val=pow(2,1000),请用一行代码返回val结果的长度值.【len(str(val))转成str再用len】

证明3+4j是合法的Python表达式 -- 根据Python的语法规则，我们可以将数字、运算符和标识符组合在一起形成合法的表达式。

UINT 2

eval()里面可以处理表达式，但是1，2，3根本不是一个表达式，所以它会抛出异常，然后注意这里的reverse是只能用于列表

-------------------------------------------------------------------------------

由于异常处理结构try...except...finally...中finally里的语句块总是被执行的，所以把关闭文件的代码放到finally 块里肯定是万无一失，一定能保证文件被正确关闭并且不会引发任何异常。

表达式 3<5>2 的值为 TRUE

Python 支持连续比较操作符，它们可以链接在一起以形成复合条件。在这个表达式中，首先比较 3 < 5，这是真的，然后比较 5 > 2

-------------------------------------------------------------------------------

假设random模块已导入，那么表达式 random.sample(range(10), 20) 的作用是生成20个不重复的整数。

表达式 random.sample(range(10), 20) 尝试从0到9（共10个数字）的范围中随机选择20个不重复的整数。但是，这里存在一个逻辑问题。由于 range(10) 生成的序列只包含10个数字（从0到9），所以不可能从中选取20个不重复的整数。尝试这样做将会引发一个异常，因为 random.sample 函数要求样本数量不得超过原始序列中的元素数量。

-------------------------------------------------------------------------------

Range(5),0~5,步长为1，结束值不包含在内的，所以是包含0-4

for i in "345":

print(i) # 输出3 4 5

-------------------------------------------------------------------------------

try-except可以捕获所有类型的程序错误--【语法错误不行】

try-except在程序中不可替代【nono哒哟】

分支结构可以向已经执行过的语句部分跳转.【❌，而是根据条件执行不同的代码路径】

在 Python 中,没有 switch-case 语句【✔】

Python 中的 pass 是空语句,一般用作占位语句【✔】

每个 if 条件后要使用冒号(:)【✔】

除字典类型外，所有标准对象均可以用于布尔测试【× 字典值也可以】

-------------------------------------------------------------------------------

表达式 sorted(random.sample(range(5), 5)) 的值为【[0,1,2,3,4]】

①range(5) 创建一个整数序列，包含 0 到 4。

②random.sample(range(5), 5) 随机从这个序列中选择 5 个不重复的元素，例如 [2, 0, 4, 3, 1]。

③sorted([2, 0, 4, 3, 1]) 对这个列表进行排序，得到 [0, 1, 2, 3, 4]。{sorted() 函数通常会返回一个列表}

-------------------------------------------------------------------------------

语法错误，我们不用；来对可迭代对象进行分隔集合，而是，

UINT3 列表与列表推导式

表达式 list('[1, 2, 3]') 的值是['[', '1', ',', '2', ',', '3', ']']

已知 x = [1, 2, 3, 2, 3]，执行语句 x.remove(2) 之后，x的值为[1,3,2,3]

表达式 sorted([111, 2, 33], key=lambda x: -len(str(x))) 的值为[111,33,2]

-------------------------------------------------------------------------------

已知 x = [1,2,3,4,5]，那么执行语句 x[1::2] = sorted(x[1::2], reverse=True) 之后，x的值为

切片操作 list(range(6))[::2] 的执行结果是 [0, 2, 4]。

x= list(range(7))

del x[1:3]

[0, 3, 4, 5, 6]【再说一次，左开右闭】

已知 x = [3,5,3,7]，那么表达式 [x.index(i) for i in x if i==3] 的值为

已知 x = [3, 7, 5]，那么执行语句 x = x.sort(reverse=True)之后，x的值为[7, 5, 3]。

Insert(索引，值)

式 list(map(lambda x: x+5, [1, 2, 3, 4, 5]))  -- 简单题不做，学学格式，还能这么写

已知 x = 'abcd' 和 y = 'abcde'，那么表达式 [ i==j for i,j in zip(x,y)] 的值为[True, True, True, True]。

已知 x = [3, 5, 7]，那么执行语句 x[len(x):] = [1, 2]之后，x的值为【[3,7,5,1,2]】

x[len(x):] 表示从列表 x 的末尾（索引为 len(x)）开始插入新的元素，而 [1, 2] 是要插入的元素

表达式 list(map(list,zip(*[[1, 2, 3], [4, 5, 6]]))) 的值为

表达式 list(map(list,zip(*[[1, 2, 3], [4, 5, 6]]))) 的值为【[[1,4],[2,5],[3,6]]】

已知列表 x = [1, 2]，那么表达式 list(enumerate(x)) 的值为 [(0,1),(1,2)],enumerate【获取索引和对应值】

对于数字n，如果表达式 0 not in [n%d for d in range(2, n)] 的值为True则说明n是素数。

UINT4 文件

文本文件是可以迭代的，可以使用for line in fp类似的语句遍历文件对象fp中的每一行。

二进制文件也可以使用记事本或其他文本编辑器打开，但是一般来说无法正常查看其中的内容。

以写模式打开的文件无法进读操作。

A JSON是双引号  D是dump不是dumps

使用pickle进行序列化得到的二进制文件使用struct也可以正确地进行反序列化。

对字符串信息进行编码以后，必须使用同样的或者兼容的编码格式进行解码才能还原本来的信息。

复制readme.txt到dst.txt

with open('readme.txt') as src, open('dst.txt', 'w' ) as dst:

dst.write(src.read())。

A不是强制要求，C的话肯定啊不然数据都乱套了

A readline是读取整个文件返回列表，每行都是一个列表元素，而不是迭代器

C不是生成器，而是每次调用读取文件的下一行并返回它

D open默认就是r

Python标准库os中用来列出指定文件夹中的文件和子文件夹列表的方法是os.listdir()

使用上下文管理关键字with可以自动管理文件对象，不论何种原因结束该关键字中的语句块，都能保证文件被正确关闭。

使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。【❌：开头】

文件对象tell() 正确方法用来返回文件指针的当前位置

假设os模块已导入，那么列表推导式 [filename for filename in os.listdir('C:\\Windows') if filename.endswith('.exe')] 的作用是列出C:\Windows文件夹中所有扩展名为.exe的文件。

Python的主程序文件python.exe属于二进制文件。

UINT5 类与继承

定义类时，在一个方法前面使用装饰器进行修饰，则该方法属于类方法

通过装饰器@property正确可以将类中的方法当作属性成员进行访问。

定义类时，在一个方法前面使用@staticmethod进行修饰，则该方法属于静态方法。

在Python中定义类时，与特殊方法名__floordiv__()对应的运算符为 //

在Python定义类时，与运算符“**”对应的特殊方法名为 __pow__()

在Python中，不论类的名字是什么，构造方法的名字都是 __init__

如果定义类时没有编写析构函数，Python将提供一个默认的析构函数进行必要的资源清理工作。

Python中一切内容都可以称为对象。

只可以动态为对象增加数据成员，而不能为对象动态增加成员方法。【❌，都可以】

Python支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则Python解释器将从左向右按顺序进行搜索。

在设计派生类时，基类的私有成员默认是不会继承的。

定义类时所有实例方法的第一个参数用来表示对象本身,在类的外部通过对象名来调用实例方法时不需要为该参数传值.

 在类定义的外部没有任何办法可以访问对象的私有成员。【❌】--对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。// Python中没有严格意义上的私有成员。

会报错，因为类定义中的方法默认为实例方法，这意味着它们期望接收至少一个参数通常称为self，它是一个指向实例本身的引用。改成def A(self)

UINT6 函数

在定义函数时，某个参数名字前面带有一个*符号表示可变长度参数，可以接收任意多个普通实参并存放于一个元组之中

表达式 list(filter(lambda x:x>2, [0,1,2,3,0,0])) 的值为【[3]】

调用以下函数返回的值( ) –【None】

def myfun():

pass

我猜你会做错

如果函数中没有return语句或者return语句不带任何返回值，那么该函数的返回值为 None

已知formatter = 'good {0}'.format，那么表达式list(map(formatter, ['morning','afternoon']))的值为['good morning', 'good afternoon']

UINT？ 集合

表达式type({3})的值为 set

表达式 {1, 3, 2} > {1, 2, 3} 的值为True。【❌真超子集，还要包含没有的】

语句set(dict(zip([1, 2], [3, 4])))的结果为

表达式 {1, 2, 3} - {3, 4, 5} 的值为差集操作。

差集操作会返回第一个集合中存在但在第二个集合中不存在的元素。【{1，2}】

已知 x = {1, 2, 3}，那么执行语句 x.add(3) 之后，x的值为{1, 2, 3, 3}。【❌，集合元素唯一】

Sorted 可以对任何可迭代器进行排序，返回列表

字典和集合属于无序序列.

字典、列表可以作为集合的元素。【❌字典元素可变，集合元素不可变】

set([1, 3, 4, 5, 2, 3, 6, 7])和集合{1, 3, 4, 5, 2, 3, 6, 7}相等.

表达式{*range(4), 4, *(5, 6, 7)}的值为{0,1,2,3,4,5,6,7}

已知x = [1, 2, 3]，那么表达式not (set(x*100)&set(x))的值为False

给定一个列表li = [1,2,3,1,2],请利用集合通过一条语句去除其中的重复数,最终以列表的形式进行输出.这条语句是print(list(set(li)))

UINT? 字典

print(list({'a':1, 'b':2, 'c':3}))输出结果为( )【只保留键['a', 'b', 'c']】

字典的默认方法都是对键使用的：已知 x = {1:2, 2:3, 3:4}，那么表达式 sum(x) 的值为 6

给定字典d, 以下可以清空字典并保留变量的是 clear

表达式sorted({'a':3, 'b':9, 'c':78})的值为【[‘a’,’b’,’c’]】

假设有列表a = ['name', 'age', 'sex']和b = ['Dong', 38, 'Male']，请使用一个语句将这两个列表的内容转换为字典，并且以列表a中的元素为“键”，以列表b中的元素为“值”，这个语句可以写为c = dict(zip(a, b))。

字典的值可以是任何类型的，字典的键只能是不可变型【列表、集合、字典就不行，其他的都可以】

能够获得字典键值对数量：len(dict)

已知 x = {1:2, 2:3}，那么表达式 x.get(2, 4) 的值为 3【get获得特定键】

字典可以作为集合的元素。【❌集合要求不可变，字典只有键不可变】

已知x = {1:1, 2:2}，那么执行语句x[3] = 3之后，表达式sorted(x.items())的值为{(1, 1), (2, 2), (3, 3)}。【❌sorted会返回列表，不是{}而是[]】

已知 x = {'a':'b', 'c':'d'}，那么表达式 'a':'b' in x 的值为True。【不合法

result = ('a', 'b') in x.items()，x.items()返回的是键值对】

已知字典 x = {i:str(i+3) for i in range(5)}，那么表达式 sum(item[0] for item in x.items()) 的值为10

x = {0: '3', 1: '4', 2: '5', 3: '6', 4: '7'}

0+1+2+3+4=10

UINT？元组

元组不能用append，可以用+，元组是不可变的！！！

可以进行切片，可以包含任意类型元素，是有序序列【咩用啊】

执行语句 x,y,z = map(str, range(3)) 之后，变量y的值为 ‘1’【注意是str】

表达式(i**2 for i in range(100))的结果是个元组。【❌：生成器】

必须要有，除非没元素

代码

集合

输入两个数：a, b = map(int, input().split())

表示范围：for num in range(a, b + 1):


# 集合可以直接找到最大值最小值

s = {-32, 3, -55, 234, 21}
print(s)
print(max(s))
print(min(s))

元组

输入多个转成列表scores = list(map(float, input().split()))

原地排序scores.sort()

列表可以直接用sum和len average = sum(scores) / len(scores)

格式输出：print(f"{average:.2f}")

找字母在字符串的索引位置

def find(string, chars):
    char_list = chars.split()
    results = []
    for index, char in enumerate(string):
        if char in char_list:
            results.append((index, char))
    for index, char in sorted(results, reverse=True):
        print(index, char)


str = input()
ch = input()
find(str, ch)

字母替换

# 输入字符串
input_str = input()

# 初始化一个空字符串来存储替换后的结果
result_str = ""

# 遍历输入字符串的每个字符
for c in input_str:
    if c in original_letters:
        index = original_letters.index(c)
        result_str += replacement_letters[index]
    else:
        result_str += c

# 输出结果
print(result_str)

函数

生成随机数：target = random.randint(1,100)

判断字符串：isupper，islower，isdigit

返回元组：return (count, lowercase, digit, other)

字典的话默认是比较键，除非用.items()才用值

Input().split()返回的是列表，所以可以用for直接遍历

列表

直接读取一行并进行多个变量赋值

line = input().strip()

parts = line.split()
name, gender, age = parts



列表元素加权和

def weighted_count(lst, depth=1):
    count = 0
    for item in lst:
        if isinstance(item, list):
            count += weighted_count(item, depth + 1)
        else:
            count += depth
    return count



字符串转列表/字典就用eval

nested_list = eval(input_str)  # 将输入的字符串转换为嵌套列表

字典：通过[]（键）找到对应的值 stu[name]

或者for item in 字典: item[0],item[1]

特定排序：sorted_industries = sorted(industry_count.items(), key=lambda x: x[1], reverse=True)

实验

一个字典，假设键为string，值为列表，我要怎么取到具体的列表值

Stu[string值][列表序号]

计算空间距离distance = math.sqrt(sum((p2 - p1) ** 2 for p1, p2 in zip(points[0], points[1])))