直接在jupyter写笔记然后导出md格式真的太好用了

---

本文笔记来自小破站视频BV1K14y1c75e

---

Python 基础

1. 变量

1.1 三种基本变量类型

# 字符串 str
str_v = "123"

# 数字 int或float
num_v = 11
float_v = 12.0

# 布尔型 bool
bool_v = True

1.1.1 字符串

f字符串：在字符串中插入变量

iou = 0.98
print(f"iou is {iou}")

iou is 0.98

转义字符：仅在print中生效

message = "The shop sells:\n\tlychee,\n\tfritters,\n\tfried fish."

print(message)

'The shop sells:\n\tlychee,\n\tfritters,\n\tfried fish.'

print(message)

The shop sells:lychee,fritters,fried fish.

1.1.2 布尔型

基于高级变量类型生成

# 以集合为例 其他都一样
set_v = {1,2,3}
print(2 in set_v)
print(2 not in set_v)

True
False

not and or 非与或

同c中的 ! && || 不赘述

1.1.3 基础变量的强制类型转换

print(str(num_v))
print(str(float_v))
print(str(bool_v))

11
12.0
True

print(int(float_v))
print(int(str_v))
print(int(bool_v))

12
123
1

print(float(num_v))
print(float(str_v))
print(float(bool_v))

11.0
123.0
1.0

1.2 四种高级变量类型

# 集合 set
set_v = {1,3,2,4}

# 元组 tuple
tuple_v = (1,2,3)

# 列表 list
list_v = [1,2,3]

# 字典 dict
dict_v = {'a':1, 'b':2, 'c':3}

1.2.1 集合

无序、不可重复。集合出现的次数稀少，它更多是被看作字典的索引，即数据的标签。后续pandas库可以代替集合，还有字典。

另外集合不能存储可变对象（列表、集合、字典、含有可变类型元素的元组），因为集合要求所有元素必须是可哈希的。

可以通过set函数或大括号创建集合

set([1,1,2,6,4,5,5])

{1, 2, 4, 5, 6}

{1,2,3,2,1}

{1, 2, 3}

注意请勿使用大括号创建空集合，否则会被误认为字典

1.2.2 元组

可以通过规范括号法或者省略括号法来创建元组

(1,2,3)

(1, 2, 3)

1,2,3

(1, 2, 3)

高级变量类型可以容纳所有的变量类型

'a', 1, True, {1,2,3}, (1,2,3), {'a':1, 'kk':2, '2': "ok"}

('a', 1, True, {1, 2, 3}, (1, 2, 3), {'a': 1, 'kk': 2, '2': 'ok'})

元组拆分法

# 极速创建新变量
a,b,c = 1,2,3
print(a,b,c)

1 2 3

# 极速交换变量
a,b = 1,2
b,a = a,b
print(a,b)

2 1

# 只要前两个变量
value = 11,12,23,12,23,34
a, b, *rest = value
print(a,b,rest)

11 12 [23, 12, 23, 34]

1.2.3 列表

由若干个有序元素的变量组成。列表可以容纳各种数据类型，但是列表要单独存储每一个元素的变量类型，列表越大约占空间。后续numpy库将代替列表。

list_v = ['xxx', 12, True, (1,2,2,2), set([1,2,3]), {'a':1, 'b':2}]
list_v

['xxx', 12, True, (1, 2, 2, 2), {1, 2, 3}, {'a': 1, 'b': 2}]

访问列表元素

# 通过索引访问列表元素
print(list_v[0])
print(list_v[5])
# 索引-1表示倒数第一个元素
print(list_v[-1])
print(list_v[-6])

xxx
{'a': 1, 'b': 2}
{'a': 1, 'b': 2}
xxx

修改列表元素

list_v[-2]=(99,88,77)
list_v

['xxx', 12, True, (1, 2, 2, 2), (99, 88, 77), {'a': 1, 'b': 2}]

切片————访问部分元素
切片的索引类似于数学上的左闭右开区间 [ , )

[ a, b, c, d, e ]|  |  |  |  | 0  1  2  3  4
-5 -4 -3 -2 -1

list_v = ['a', 'b', 'c', 'd', 'e']
# 切片有两种理解方式
# 若两个参数st和ed都是正数[st,ed] 就理解为从st开始切到ed
print(list_v[1:4])       # 从1开始切到4前
print(list_v[1: ])       # 从1开始切到结尾 or 切除开头一个
print(list_v[ :4])       # 从开头切到4前
# 若两个参数一正一负[a:-b] 可以理解为切除开头a个和结尾b个，除此之外都按照第一个理解方式来理解
print(list_v[2:-2])      # 从2开始切到-2前 or 切除开头两个和结尾两个
print(list_v[2: ])       # 从2开始切到结尾 or 切除开头两个
print(list_v[ :-2])      # 从开头切到-2前 or 切除结尾两个

['b', 'c', 'd']
['b', 'c', 'd', 'e']
['a', 'b', 'c', 'd']
['c']
['c', 'd', 'e']
['a', 'b', 'c']

# 有3个参数时，第三个参数就是每个x个元素采样一次
list_v = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list_v[ : :2])
print(list_v[ : :3])
print(list_v[1:-1:2]) # 切除一头一尾后 每隔2个元素采样一次

['a', 'c', 'e', 'g']
['a', 'd', 'g']
['b', 'd', 'f']

注意：对列表切片之后会生成一个新的独立的对象。为此，numpy的切片被设定为原对象的一个视图，不会在内存中创建一个新的对象

列表元素的添加

使用+ *来添加原列表

list_v = [1,2,3]
print(list_v + [4,6])     # 尾部新增元素
print(list_v * 2)         # 复制两倍的自己

[1, 2, 3, 4, 6]
[1, 2, 3, 1, 2, 3]

1.2.4 字典

可以理解为升级版的列表，就是自定义索引的列表。字典中的元素值可以是任何数据类型变量，但字典的键只能是数或者字符串，常常是字符串。

xjtu = {'CS': 'A+','SE': 'A-','EE': 'B+','ME': 'A+'
}
xjtu

{'CS': 'A+', 'SE': 'A-', 'EE': 'B+', 'ME': 'A+'}

# 添加元素
xjtu['Math'] = 'A'
xjtu['Bio'] = 'A'
xjtu['Phys'] ='B+'
xjtu['Psych'] ='B-'
xjtu

{'CS': 'A+','SE': 'A-','EE': 'B+','ME': 'A+','Math': 'A','Bio': 'A','Phys': 'B+','Psych': 'B-'}

# 修改元素
xjtu['SE'] = 'B+'
xjtu

{'CS': 'A+','SE': 'B+','EE': 'B+','ME': 'A+','Math': 'A','Bio': 'A','Phys': 'B+','Psych': 'B-'}

# 删除元素
del xjtu['Math']
xjtu

{'CS': 'A+','SE': 'B+','EE': 'B+','ME': 'A+','Bio': 'A','Phys': 'B+','Psych': 'B-'}

1.2.5 高级变量之间的转换

基本结构

set([1,2,3])                              # 转化为 集合
tuple([1,2,3])                            # 转化为 元组
list({1,2,3})                             # 转化为 列表
dict(zip( ('a','b','c'), {1,2,3} ))         # 转化为 字典

{'a': 1, 'b': 2, 'c': 3}

注意：转为字典尽量不要使用集合，因为集合无序，会造成错误。

dict(zip({'a','b','c'}, {1,2,3}))    # 顺序被打乱

{'b': 1, 'c': 2, 'a': 3}

2. 语句

2.1 if-else

# 示例1: 成绩等级评定
score = 85
if score >= 90:grade = "A"
elif score >= 80:grade = "B"
elif score >= 70:grade = "C"
elif score >= 60:grade = "D"
else:grade = "F"print(f"分数 {score} 的等级是: {grade}")

分数 85 的等级是: B

三元表达式

# 传统写法
age = 20
if age >= 18:status = "成人"
else:status = "未成年"# 三元表达式写法
status = "成人" if age >= 18 else "未成年"
print(status) # 另一个例子
x = 10
y = 20
max_value = x if x > y else y
print(f"最大值是: {max_value}") 

成人
最大值是: 20

与高级数据类型的结合，这里以列表为例

# 检查列表是否包含特定元素
fruits = ["apple", "banana", "orange"]
if "banana" in fruits:print("列表中有香蕉")
else:print("列表中没有香蕉")# 检查列表是否为空
my_list = []
if my_list:print("列表不为空")
else:print("列表为空")

列表中有香蕉
列表为空

2.2 for

# 遍历列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
for fruit in fruits:print(f"我喜欢吃{fruit}")# 带索引遍历列表
for index, fruit in enumerate(fruits): # index fruit顺序不能反print(f"[{index}]: {fruit}")

我喜欢吃苹果
我喜欢吃香蕉
我喜欢吃橙子
我喜欢吃葡萄
[0]: 苹果
[1]: 香蕉
[2]: 橙子
[3]: 葡萄

# 遍历字符串
word = "Python"
for char in word:print(char)

P
y
t
h
o
n

# 遍历字典
student = {"姓名": "小明", "年龄": 20, "专业": "计算机"}# 遍历键
for key in student:print(f"{key}")# 遍历键值对
for key, value in student.items():print(f"{key}: {value}")

姓名
年龄
专业
姓名: 小明
年龄: 20
专业: 计算机

# 遍历数字序列
for i in range(5): print(i)

0
1
2
3
4

# 指定起始和结束值
for i in range(2, 6): print(i)

2
3
4
5

# 指定步长
for i in range(0, 10, 2): print(i)

0
2
4
6
8

# 倒序循环
for i in range(5, 0, -1):print(i)

5
4
3
2
1

# else - 循环正常结束执行（非break退出）
for num in range(3):print(num)
else:print("循环正常结束")

0
1
2
循环正常结束

# 同时遍历多个列表
names = ["小明", "小红", "小刚"]
scores = [90, 85, 95]
subjects = ["数学", "英语", "语文"]for name, score, subject in zip(names, scores, subjects):print(f"{name}的{subject}成绩是{score}分")

小明的数学成绩是90分
小红的英语成绩是85分
小刚的语文成绩是95分

2.3 while

count = 1
while count <= 5:print(f"计数: {count}")count += 1
print("循环结束")

计数: 1
计数: 2
计数: 3
计数: 4
计数: 5
循环结束

在循环语句中，continue break 的用法同c语言

2.4 列表推导式

基本结构：

# 传统方式：创建平方数列表
squares = []
for i in range(5):squares.append(i ** 2)
print(squares)  # 列表推导式
squares = [i ** 2 for i in range(5)]
print(squares) 

[0, 1, 4, 9, 16]
[0, 1, 4, 9, 16]

# 条件过滤
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
short_fruits = [fruit for fruit in fruits if len(fruit) <= 5]
print(short_fruits)

['apple', 'date']

# if-else列表推导式
numbers = [1, 2, 3, 4, 5]
result = ["偶数" if num % 2 == 0 else "奇数" for num in numbers]
print(result) 

['奇数', '偶数', '奇数', '偶数', '奇数']

3. 函数

基本结构

def my_func(v):'''文档字符串，用于解释函数：这是我的函数'''return v

打印文档字符串

my_func.__doc__

'文档字符串，用于解释函数：这是我的函数'

函数可以吞吐各个类型的变量

x = my_func(3)
x

3

可以利用元组吞吐多个值

def my_counter(a,b):return a+b, a*bx = my_counter(2,5)
x

(7, 10)

可以吞吐任意数量的参数

def menu(*args):return argsinfo = menu('fish','soup','beef','noodles')    
info

('fish', 'soup', 'beef', 'noodles')

可以同时传入普通参数和一个任意数量参数

def stu_info(name, num, *hobbies):return name, num, hobbiesname, num, hb = stu_info('xxx', '22123', 'singing', 'dancing', 'dyno')
print(f"{name} 学号{num}，喜欢{hb}")

xxx 学号22123，喜欢('singing', 'dancing', 'dyno')

同时传入普通参数和一个任意数量的键值对参数

def comment(com1, com2, **kwargs):'''先评价cs，再评价ee，可以自行补充'''kwargs['CS'] = com1kwargs['EE'] = com2return kwargs

关键字调用，可以不按顺序写

def introduce(name, age, city):print(f"我叫{name}，今年{age}岁，来自{city}")# 位置参数调用（必须按顺序）
introduce("张三", 25, "北京")# 混合使用（位置参数必须在关键字参数之前）
introduce("钱七", city="杭州", age=40)

我叫张三，今年25岁，来自北京
我叫钱七，今年40岁，来自杭州

带默认值的关键字参数

def create_user(name, age, role="user", active=True):print(f"创建用户: {name}, 年龄: {age}, 角色: {role}, 状态: {'活跃' if active else '禁用'}")# 使用默认值
create_user("Alice", 25)  # 角色: user, 状态: 活跃# 覆盖默认值
create_user("Bob", 30, role="admin")
create_user("Charlie", 35, active=False)
create_user("David", 40, role="moderator", active=True)# 关键字调用可以跳过有默认值的参数
create_user("Eve", 45, active=False)  # 角色使用默认值user

创建用户: Alice, 年龄: 25, 角色: user, 状态: 活跃
创建用户: Bob, 年龄: 30, 角色: admin, 状态: 活跃
创建用户: Charlie, 年龄: 35, 角色: user, 状态: 禁用
创建用户: David, 年龄: 40, 角色: moderator, 状态: 活跃
创建用户: Eve, 年龄: 45, 角色: user, 状态: 禁用

4. 类

4.1 创建和使用类

类的本质是在一堆函数之间传递参数。

类的名称首字母必须大写。

类中的函数叫方法，一个类包含一个 __init__ 方法（必须包含） + 很多自定义方法

class Counter:'''一台可以加减的计算器'''def __init__(self, a, b):'''公共变量'''self.a = aself.b = bdef add(self):return self.a + self.bdef sub(self):return self.a - self.b

# 创建类的实例
cnt = Counter(5,6)     # 创建一个类的实例 cnt
print(cnt.a, cnt.b)    # 访问属性
print(cnt.sub())       # 调用方法

5 6
-1

函数内部的变量与外部是两个空间，可以把self理解为船，使得自定义方法能在类里面互通，将需要互通的变量作为self的属性进行传递。

4.2 属性的默认值

可以给self的属性一个默认值，此时默认值不用写进__init()__的参数列表里

class Man:def __init__(self, name, age):self.name = nameself.age = ageself.gender = 'M'           # 默认属性

xxx = Man('Mauri', 20)
print(xxx.name)
print(xxx.age)
print(xxx.gender)

Mauri
20
M

修改属性的默认值

xxx.gender = 'MTF'
print(xxx.gender)

MTF

4.3 继承

子类 class 类名(父类名)

# 父类
class Counter:'''一台可以加减的计算器'''def __init__(self,a,b):'''公共变量'''self.a = aself.b = bdef add(self):return self.a - self.b       # 假设这里父类的加法写错了def sub(self):return self.a - self.b# 子类
class CounterPlus(Counter):'''可以加减乘除的高级计算器'''def __init__(self,a,b):super().__init__(a,b)             # 调用父类的构造函数def mul(self):return self.a * self.bdef div(self):return self.a / self.bdef add(self):return self.a + self.b        # 覆写父类的加法

cnt = CounterPlus(5,6)
print(cnt.a, cnt.b)
print(cnt.add())
print(cnt.mul())
print(cnt.sub())

5 6
11
30
-1

4.4 掠夺

一个类可以通过掠夺获得很多其他类的方法

# 一个无辜的类
class CounterBasic:'''一台可以加减的计算器'''def __init__(self,a,b):'''公共变量'''self.a = aself.b = bdef add(self):return self.a + self.b       def sub(self):return self.a - self.b# 掠夺者
class CounterEvil(Counter):'''一台原先只可以乘除的计算器，现在他要掠夺加减方法了'''def __init__(self,a,b):self.a = aself.b = b        self.counter = CounterBasic(a,b)def mul(self):return self.a * self.bdef div(self):return self.a / self.b

cnt = CounterEvil(3,4)
print(cnt.mul())
print(cnt.div())
print(cnt.counter.add())
print(cnt.counter.sub())

12
0.75
7
-1

掠夺的本质是将另一个类的实例当作self的属性使用，相当于创建了一个内部的类的实例。此外，掠夺者和被掠夺者可以拥有同名方法，调用起来互不冲突。