直接在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*b
x = my_counter(2,5)
x
(7, 10)
可以吞吐任意数量的参数
def menu(*args):
return args
info = menu('fish','soup','beef','noodles')
info
('fish', 'soup', 'beef', 'noodles')
可以同时传入普通参数和一个任意数量参数
def stu_info(name, num, *hobbies):
return name, num, hobbies
name, 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'] = com1
kwargs['EE'] = com2
return 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 = a
self.b = b
def add(self):
return self.a + self.b
def 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 = name
self.age = age
self.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 = a
self.b = b
def 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.b
def div(self):
return self.a / self.b
def 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 = a
self.b = b
def 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 = a
self.b = b
self.counter = CounterBasic(a,b)
def mul(self):
return self.a * self.b
def 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的属性使用，相当于创建了一个内部的类的实例。此外，掠夺者和被掠夺者可以拥有同名方法，调用起来互不冲突。