Python基础
- 前言
- 1.流程控制
- - 1.1 条件语句
  - 1.2 循环语句
  - - 1.2.1 while循环语句
    - 1.2.2 for循环语句
  - 1.3 作业
  - 1.4 拓展-try except语法
- 2.函数
- - 2.1 函数定义
  - 2.2 函数的参数
  - - 2.2.1 位置参数
    - 2.2.2 命名参数
    - 2.2.3 默认参数
    - 2.2.4 可变参数
    - 2.2.5 参数展开
  - 2.3 递归函数
  - - 2.3.1 递归函数定义
    - 2.3.2 斐波拉契数列实现
  - 2.4 作业
  - 2.5 匿名函数
  - - 2.5.1 定义
    - 2.5.2 拓展-sorted()函数
- 总结

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 + num2def subtract(num1, num2):return num1 - num2def multiply(num1, num2):return num1 * num2def divide(num1, num2):if num2 == 0:raise ValueError("Error, divisor cannot be zero!")return num1 / num2if __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 Bodyreturn expression

其中：

function_name是函数的名称，必须符合Python的标识规则，通常使用小写字母和下划线组成，不推荐使用与Python内置函数和关键字相同的名称
parameter_list是函数的参数列表，可以有零个或多个参数，多个参数之间用逗号分隔。参数可以是位置参数(必选参数)或关键字参数(可选参数)
Docstring是函数的文档字符串，用于描述函数的功能和使用方法，通常使用三引号"""包围
return语句用于返回函数的执行结果

示例如下：

def sum_numbers(*numbers):"""计算任意数量的数值的和"""sum = 0for n in numbers:sum += nreturn 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 1else: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 nelse: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)

1. 当begin_token或end_token不在text中时，会返回错误的结果
1. 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)]