目录
Python基础
前言
手写AI推出的全新保姆级从零手写自动驾驶CV课程，链接。记录下个人学习笔记，仅供自己参考。
本次课程为第二课，主要讲解Python中的流程控制(条件和循环语句)以及函数(定义和函数参数)
课程大纲可看下面的思维导图。
1.流程控制
内容：认识控制流程，判断、循环
1.1 条件语句
Python中的条件语句包括if、elif和else关键字，if语句的基本语法如下：
if condition1:
statement
elif condition2:
statement
elif condition3:
statement
else:
statement
1.2 循环语句
1.2.1 while循环语句
Python中的while循环语句用于重复执行一段代码，直到条件变为False为止，while的基本语法如下：
while condition:
statement
while循环语句可以和break语句一起使用来提前结束循环
1.2.2 for循环语句
Python中的for循环语句可以对序列和可迭代对象进行遍历，语法格式如下：
for variable in Iterator:
statement
其中，Iterator指的是支持迭代操作的对象，包括字符串、列表、元组、集合、字典等。variable是在每次循环中接收可迭代对象中的元素。
示例代码如下，遍历整数序列求和：
sum = 0
for i in range(1, 11):
sum += i
print("1到10的和为：", sum)
此外，for循环语句还支持break和continue关键字，同于控制循环的执行流程。break用于终止整个循环，continue用于跳过当前循环，进入下一次循环。
for还可以和列表进行其它的配合，如
list = [i for i in iterator]
这种方式使用了列表推导式，通过对iterator进行遍历，生成一个新的列表
list = [i for i in range(0, 5, 2) if i != 4]
这种方式是在列表推导式的基础上，添加了一个条件表达式
1.3 作业
作业4：写一个计算器，输入表达式，输出计算结果
运行效果如下：
示例代码如下：
# 两数的四则运算
while True:
# 获取输入表达式
expression = input("mycalc>")
# 获取+、-、*、/
operators = '+-*/'
index = [i for i in range(len(expression)) if expression[i] in operators]
# 如果存在四则运算符
if index:
num1 = int(expression[:index[0]])
num2 = int(expression[index[0]+1:])
if expression[index[0]] == "+":
print(num1+num2)
elif expression[index[0]] == "-":
print(num1-num2)
elif expression[index[0]] == "*":
print(num1*num2)
elif expression[index[0]] == "/" and num2 != 0:
print(num1/num2)
else:
print("Error, divisor cannot be zero! Please try again")
优化：使用函数封装以及try except优化，示例代码如下(Suggestion from chatGPT)
def add(num1, num2):
return num1 + num2
def subtract(num1, num2):
return num1 - num2
def multiply(num1, num2):
return num1 * num2
def divide(num1, num2):
if num2 == 0:
raise ValueError("Error, divisor cannot be zero!")
return num1 / num2
if __name__ == "__main__":
while True:
# 获取表达式
expression = input("mycala>")
# 获取+、-、*、/
operators = '+-*/'
index = [i for i in range(len(expression)) if expression[i] in operators]
# 如果存在四则运算符
if index:
num1 = int(expression[:index[0]])
num2 = int(expression[index[0]+1:])
operator = expression[index[0]]
# 根据不同的运算符调用不同的函数进行计算
try:
if operator == "+":
result = add(num1, num2)
elif operator == "-":
result = subtract(num1, num2)
elif operator == "*":
result = multiply(num1, num2)
elif operator == "/":
result = divide(num1, num2)
print(result)
except ValueError as e:
print(e)
继续优化:
- 输入的表达式只能包含两个操作数，不能进行多个数的计算
- 多个表达式意味着需要考虑*和/的优先级，复杂度提高
优化的示例代码如下：(from chatGPT)
while True:
# 获取表达式并去除空格
expression = input("mycalc>")
# 使用eval函数计算表达式
try:
result = eval(expression)
print(result)
except ZeroDivisionError:
print("Error, divisor cannot be zero! Please try again")
except:
print("Invalid expression! Please try again")
说明
eval函数可以将包含数学运算符的字符串转换为实际的数学运算结果try except是Python中异常处理的语法结构，用于处理可能会出现的异常代码块。
1.4 拓展-try except语法
try except是Python中异常处理的语法结构，用于处理可能会出现的异常代码块。具体来说try语句包含了要尝试执行的代码块，而except语句包含了在出现异常时要执行的代码块。如果在try代码块中出现了异常，那么程序会跳转到except代码块，并执行其中的代码。
try语句的基本结构如下：
try:
# 尝试执行的代码块
except:
# 发生异常时要执行的代码块
其中except可以指定不同的异常类型，以便更精确地处理异常。例如，下面代码处理了除以零异常：
try:
x = 1 / 0
except ZeroDivisionError:
print("除以零错误！")
除了指定具体的异常类型之外，也可以使用except语句来捕获所以异常，例如：
try:
# 尝试执行的代码块
except Exception as e:
# 发生异常时要执行的代码块
在except中，可以使用as关键字来将异常对象赋值给一个变量，以便更详细地了解异常信息。
此外，还可以使用else来指定在没有发生异常时要执行的代码块，例如：
try:
# 尝试执行的代码块
except:
# 发生异常时要执行的代码块
else:
# 没有发生异常时要执行的代码块
最后，还可以使用finally子句来指定不管是否发生异常都要执行的代码块，例如：
try:
# 尝试执行的代码块
except:
# 发生异常时要执行的代码块
finally:
# 不管是否发生异常都要执行的代码块
这在需要释放资源或清理状态时非常有用
2.函数
内容：认识函数的定义、位置参数和命名参数、可变参数、参数的展开(from chatGPT)
2.1 函数定义
在Python中，函数的定义需要使用def关键字，基本的语法格式如下：
def function_name(parameter_list):
"""
Docstring
"""
# Function Body
return expression
其中：
function_name是函数的名称，必须符合Python的标识规则，通常使用小写字母和下划线组成，不推荐使用与Python内置函数和关键字相同的名称parameter_list是函数的参数列表，可以有零个或多个参数，多个参数之间用逗号分隔。参数可以是位置参数(必选参数)或关键字参数(可选参数)Docstring是函数的文档字符串，用于描述函数的功能和使用方法，通常使用三引号"""包围return语句用于返回函数的执行结果
示例如下：
def sum_numbers(*numbers):
"""
计算任意数量的数值的和
"""
sum = 0
for n in numbers:
sum += n
return sum
# 调用函数
result = sum_numbers(1, 2, 3, 4, 5)
print(result) # 15
2.2 函数的参数
在Python中，函数参数可分为四种类型：位置参数、命名参数、默认参数和可变参数
2.2.1 位置参数
位置参数是指函数调用时按照定义的位置传递的参数。例如：
def func(a, b):
print(a, b)
func(1, 2) # 输出: 1 2
在这个例子中，参数1被传递给了a，参数2被传递给了b。由于参数的位置是固定的，所以这些参数被称为位置参数。
2.2.2 命名参数
在Python中，还可以使用命名参数(关键字参数)指定参数的值，而不需要按照函数定义时参数的位置进行传递，例如：
def func(a, b):
print(a, b)
func(b=2, a=1) # 输出: 1 2
在这个例子中，我们通过b=2，a=1来指定参数的值。因为参数的值是根据名称指定的，所以这些参数被称为命名参数。
2.2.3 默认参数
默认参数是指在定义函数时为参数提供默认值，如果在调用函数时没有指定参数的值，就使用默认值。例如：
def func(a=1, b=2):
print(a, b)
func() # 输出: 1 2
func(3) # 输出: 3 2
func(b=5) # 输出: 1 5
func(6, b=7) # 输出: 6 7
在这个例子中，参数a的默认值为1，参数b的默认值为2。如果没有指定参数的值，则使用默认值。如果指定了某些参数的值，则只有指定的参数会使用这些值，而其它参数仍然使用默认值。
2.2.4 可变参数
可变参数是指能够接受不定数量的参数的函数。在Python中，有两种类型的可变参数：*args和**kwargs。
*args：接受不定数量的位置参数，这些参数被组合成一个元组。例如：
def func(*args):
print(args)
func(1, 2) # 输出: (1, 2)
在这个例子中，参数1，2被组合成了一个元组，并作为参数传递给函数func()
**kwargs：接受不定数量的关键字参数，这些参数被组合成一个字典。例如：
def func(**kwargs):
print(kwargs)
func(a=1, b=2) # 输出: {'a': 1, 'b': 2}
在这个例子中，参数a，b被组合成了一个字典，并作为参数传递给函数func()
2.2.5 参数展开
在Python中，使用展开操作符*和**可以将可迭代对象(例如列表、元组、字典等)中的元素展开成函数的参数，用于函数调用。
*可以将一个可迭代对象中的元素展开为位置参数，传递给函数。例如：
def my_func(a, b):
print(a, b)
my_list = [1, 2]
my_func(*my_list) # 输出：1 2
**可以将一个字典中的键值对展开成关键字参数，传递给函数。例如：
def my_func(a, b):
print(a, b)
my_dict = {'a': 1, 'b': 2}
my_func(**my_dict) # 输出：1 2
*和**可以混合使用将位置参数和关键字参数同时展开。例如：
def my_func(a, b, c):
print(a, b, c)
my_list = [1, 2]
my_dict = {'c': 3}
my_func(*my_list, **my_dict) # 输出：1 2 3
2.3 递归函数
2.3.1 递归函数定义
Python中的递归函数指在函数内部调用自身的函数。递归函数通常需要满足两个条件：基本情况和递归情况。基本情况指满足某个条件时直接返回结果，递归情况则是指在函数内部调用自身，通常是将问题规模缩小到一个更小的子问题。
例如，下面的代码时一个求阶乘的递归函数：
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)
在上述代码中，当n等于1时，直接返回1，这就是基本情况。递归情况则是将问题规模缩小到n-1的阶乘，这里通过factorial(n-1)实现。递归函数的执行过程是将问题不断地拆分成更小的子问题，直到最终的基本情况被满足，然后将所有子问题结果合并起来得到最终的结果。
2.3.2 斐波拉契数列实现
定义：斐波拉契数列是一个非常经典的数列，它的前两项为0和1，从第三项开始，每一项都是前两项的和，即0,1,1,2,3,5,8,13,…
实现：斐波拉契数列的实现包含循环和递归两种方法
实现1.循环方法
def fibonacci1(n):
if n<=1:
return n
else:
fib_list = [0, 1]
for i in range(2, n+1):
fib_list.append(fib_list[-1] + fib_list[-2])
return fib_list
实现2.递归方法
def fibonacci(n):
if n == 1:
return [0, 1]
else:
fib_list = fibonacci(n-1)
fib_list.append(fib_list[-1] + fib_list[-2])
return fib_list
递归函数是指在函数中调用函数本身的一种技术。代码简单但看得有点迷糊，自己画了个简单图示并理解了下(不知道理解是否正确😂)
递归就是一个套娃的过程，为了便于理解画了个图示，假设此时n=5，不同的颜色来表示不同的flib函数，
- n=5时，调用灰色的fib函数，程序运行到第5行进入新的fib函数(套的第一层)
- 新的fib函数即n=4.，也就是蓝色的fib函数，同理运行到第5行又进入新的fib函数(套的第二层)
- 继续上述过程，n=3，也就是绿色的fib函数，运行到第5行跳转(套的第三层)
- 继续，n=2，也就是橙色的fib函数，运行到第5行跳转(套的第四层)
- 继续，n=1，也就是黄色的fib函数，此时满足条件n==1，返回[0,1]的一个列表
- 开始往回走了，n=2，此时fib_list=[0,1]，运行到第六行fib_list=[0,1,1]，将结果返回到上一层(脱的第一层)
- n=3，此时fib_list=[0,1,1]，运行到第六行fib_list=[0,1,1,2]，继续将结果返回到上一层(脱的第二层)
- n=4，此时fib_list=[0,1,1,2]，运行到第六行fib_list=[0,1,1,2,3]，继续返回给上一层(脱的第三层)
- n=5，此时fib_list=[0,1,1,2,3]，运行到第六行fib_list=[0,1,1,2,3,5]，将最终的结果返回(脱的第四层)
2.4 作业
作业5：定义一个函数extract(text, begin_token, end_token)，返回text中，以begin_token开始end_token结束的中间内容
示例代码如下：
def extract(text, begin_token, end_token):
begin_index = text.find(begin_token)
end_index = text.find(end_token)
return text[begin_index+len(begin_token):end_index]
print(extract("爱听歌的周同学呀", "爱听歌的", "呀"))
运行效果如下：
存在的问题：(from chatGPT)
-
- 当begin_token或end_token不在text中时，会返回错误的结果
-
- begin_token和end_token必须按照顺序一次出现在text中，否则无法正确提取中间内容。
优化：
def extract(text, begin_token, end_token):
begin_index = text.find(begin_token)
if begin_index == -1:
raise ValueError("begin_token not found")
end_index = text.find(end_token, begin_index+len(begin_token))
if end_index == -1:
raise ValueError("end_token not found")
return text[begin_index+len(begin_token):end_index]
print(extract("我爱Python,Python是一门很有用的语言", "Python", "语言"))
2.5 匿名函数
2.5.1 定义
Python中的匿名函数又称为lambda函数，是一种不需要定义函数名的函数。lambda函数的语法如下：
lambda arguments: expression
其中arguments表示函数的参数，可以有多个，使用逗号分隔。expression表示函数的表达式，可以是任何有效的表达式。lambda函数的返回值是一个函数对象。
lambda函数的简单示例如下：
sum = lambda x, y: x + y
print(sum(3, 5)) # 输出：8
在这个例子中，我们创建了一个lambda函数，将它赋值给了变量sum。这个函数接受两个参数x和y，共返回它们的和。我们通过调用sum(3,5)来调用这个函数，并输出结果8。
lambda函数通常用于需要简单函数的场景，可以简化代码，并提高代码的可读性。例如，使用lambda函数对列表进行排序：
data = [('apple', 3), ('banana', 2), ('orange', 4)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data) # 输出：[('banana', 2), ('apple', 3), ('orange', 4)]
在这个例子中，我们使用了lambda函数作为sorted()函数的key参数，以元组的第二个元素作为排序的关键字。
不由的想起检测器的NMS算法之前需要将boxes按照置信度的大小进行排序，其代码如下：
...
# boxes-->[1,25200,85] box->[left, top, right, bottom, confidence, img_id, label]
boxes = sorted(boxes.tolist(), key=lamda x:x[4], reverse=True)
return NMS(boxes)
...
2.5.2 拓展-sorted()函数
在Python中，Sorted()函数用于对可迭代对象进行排序，返回一个新的已排序的列表，而不改变原始对象。
sorted()函数有以下几个参数：
- iterable：必选参数，表示要排序的可迭代对象，可以是列表、元组、集合、字典等
- key：可选参数，表示用于排序的关键字函数，用于比较两个元素的大小关系。默认值为
None，表示使用元素本身的值进行比较。 - reverse：可选参数，表示是否降序排列。默认值为
False，表示升序排列。
sorted()函数使用示例如下：
# 对列表进行升序排列
nums = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_nums = sorted(nums)
print(sorted_nums) # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
# 对字典按值进行升序排列
d = {'apple': 3, 'banana': 2, 'orange': 4}
sorted_d = sorted(d.items(), key=lambda x: x[1])
print(sorted_d) # [('banana', 2), ('apple', 3), ('orange', 4)]
上面的代码中，第一个示例是对列表进行排序，不需要使用关键字函数key。第二个示例是对字典按值进行排序，使用了关键字函数key，并且使用匿名函数lambda来定义比较元素大小的规则，即按照每个元素的第二个值进行升序排列。其中d.items()方法将字典转换为元组列表。
总结
本次课程内容方面主要学习了Python中的流程控制和函数，流程控制方面掌握了
for与列表构成带条件的列表推导式，同时回顾了Python中异常处理的语法结构try excepy。函数方面掌握了各种传递函数参数的方法，以及两种特殊的函数：递归函数和匿名函数。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
