03、自动驾驶编程语言与工具Python篇

第一步：安装Python

如果你还没有安装Python，可以按照以下步骤进行安装：

1. 访问 Python官网。

2. 下载适合你操作系统的Python版本（建议使用最新的稳定版本）。

3. 安装过程中，确保勾选“Add Python to PATH”。

第二步：运行你的第一个Python程序

1. 打开一个Python IDE或代码编辑器

你可以使用IDLE、VSCode、PyCharm等。推荐使用VSCode或PyCharm，它们提供了丰富的插件和调试工具。

2. 创建一个新的Python文件

创建一个扩展名为.py的文件，例如hello.py。

3. 编写你的第一个Python程序

在文件中输入以下代码：

print("Hello, World!")

4. 运行程序

保存文件后，在终端或命令行中运行以下命令（假设你的文件名是hello.py）：

python hello.py

你应该会看到输出：

Hello, World!

第三步：变量和数据类型

1. 变量

在Python中，变量不需要声明类型，可以直接赋值使用。

# 整数变量 
a = 10 
# 浮点数变量 
b = 3.14 
# 字符串变量 
c = "Hello" 
# 布尔值变量 
d = True 
print(a) 
print(b) 
print(c) 
print(d)

2. 数据类型

Python有多种数据类型，我们来看几个常见的数据类型及其操作。

整数和浮点数

x = 5 # 整数 
y = 2.5 # 浮点数 
# 基本运算 
print(x + y) # 加法 
print(x - y) # 减法 
print(x * y) # 乘法 
print(x / y) # 除法 
print(x // y) # 地板除 
print(x % y) # 取余 
print(x ** y) # 幂

字符串

str1 = "Hello" 
str2 = "World" # 字符串拼接 
print(str1 + " " + str2) # 字符串重复 
print(str1 * 3) # 字符串长度 
print(len(str1)) # 字符串索引 
print(str1[0]) # 第一个字符 
print(str1[-1]) # 最后一个字符 
# 字符串切片 
print(str1[1:4]) # 从第2个字符到第4个字符

第四步：控制结构

1. 条件语句

使用if、elif和else进行条件判断。

a = 10 
b = 20 
if a > b: 
    print("a is greater than b") 
elif a < b: 
    print("a is less than b") 
else: 
    print("a is equal to b")

2. 循环语句

Python支持for和while循环。

for循环

for i in range(5): 
    print(i) # 输出 0 1 2 3 4

while循环

count = 0 
while count < 5: 
    print(count) 
    count += 1 # 输出 0 1 2 3 4

第五步：函数

1. 定义和调用函数

    函数是可以重复使用的代码块，用于执行特定任务。

def greet(name):
    return f"Hello, {name}!"

#调用函数
print(greet("Alice"))
print(greet("Bob"))

2. 函数参数和返回值

函数可以接受参数，并返回值。

def add(x,y)
    return x + y
result = add(2, 3)
print(result) #输出5

3. 默认参数值

函数参数可以有默认值。

def greet(name, message="Hello"):
    return f"{message},{name}!"
print(greet("Alice"))
print(greet("Bob","Hi"))

4. 可变参数

使用*args和**kwargs来接收可变数量的参数

def greet(*names):
    for name in names:
        print(f"Hello, {name}!")

greet("Alice", "Bob", "Charlie")

def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="New York")

第六步：数据结构

1. 列表（list）

列表是有序的可变序列，可以存储任意类型的元素。

fruits = ["apple","banana","cherry"]
#访问元素
print(fruits[0]) #输出 apple
#修改元素
fruits[1] = "blueberry"
print(fruits) #输出["apple","blueberry","cherry"]
#添加元素
fruits.append("data")
print(fruits) #输出['apple','blueberry','cherry','date']
#删除元素
fruits.remove("blueberry")
print(fruits) #输出[‘apple’,'cherry','date']

2.元组(tuple)

元组是有序的不可变序列

coordinates = (10.0, 20.0)
#访问元素
print(coordinates[0]) #输出10.0
#元组不可变，无法修改元素
#coordinates[0] = 15.0 #这会引发错误

3.字典(dictionary)

字典是无序的键值对集合

person = {"name":"Alice", "age":30,"city":"New York"}
#访问值
print(person["name"]) #输出Alice
#修改值
person["age"] = 31
print(person) #输出{'name':'Alice' , 'age':31, 'city':'New York'}
#添加键值对
person["email"] = "alice@example.com" 
print(person) # 输出 {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'} 
# 删除键值对 
del person["city"] 
print(person) # 输出 {'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}

4.集合（set）

集合是无序的不重复元素集合

colors = {"red","green","blue"}
#添加元素
colors.add("yellow")
print(colors) #输出{'red','green','blue','yellow'}

#删除元素
colors.remove("green")
print(colors) #输出{'red','blue','yellow'}

第七步：模块和包

1. 导入模块

Python提供了许多内置模块，可以通过import语句导入使用。

import math
print(math.sqrt(16)) #输出 4.0

可以使用"from...import..."语法导入特定功能

from math import pi
print(pi) #输出 3.1415926535

2.标准库

Python标准库包含了丰富的模块，如'os','sys','datetime'等。

import os
print(os.getcwd()) #输出当前工作目录

3.创建和使用自定义模块

你可以创建自己的模块并在其他Python文件中使用。

创建一个名为mymodule.py的文件，内容如下：

def greet(name):
    return f"Hello, {name}!"

然后在另一个文件中导入并使用这个模块：

import mymodule
print(mymodule.greet("Alice"))  # 输出 Hello, Alice!

4. 包的结构

包是包含多个模块的目录，目录中必须包含一个__init__.py文件。创建一个包的示例如下：

目录结构：

mypackage/
    __init__.py
    module1.py
    module2.py

module1.py文件中

def func1():
    return "Function 1"

module2.py文件中

def func2():
    return "Function 2"

在另一个文件中使用包：

from mypackage import module1, module2

print(module1.func1())  # 输出 Function 1
print(module2.func2())  # 输出 Function 2

第八步：面向对象编程

1. 类和对象

类是对象的蓝图，可以定义属性和方法。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

# 创建对象
p1 = Person("Alice", 30)
p2 = Person("Bob", 25)

print(p1.greet())  # 输出 Hello, my name is Alice and I am 30 years old.
print(p2.greet())  # 输出 Hello, my name is Bob and I am 25 years old.

2. 继承

子类可以继承父类的属性和方法，并可以扩展或重写它们。

class Employee(Person):
    def __init__(self, name, age, employee_id):
        super().__init__(name, age)
        self.employee_id = employee_id

    def work(self):
        return f"{self.name} is working with employee ID {self.employee_id}."

e1 = Employee("Charlie", 28, "E12345")
print(e1.greet())  # 输出 Hello, my name is Charlie and I am 28 years old.
print(e1.work())   # 输出 Charlie is working with employee ID E12345.

3. 多态

多态允许不同类的对象通过相同的接口调用各自的方法。

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

def make_sound(animal):
    print(animal.speak())

d = Dog()
c = Cat()

make_sound(d)  # 输出 Woof!
make_sound(c)  # 输出 Meow!

4. 封装和私有属性

可以使用前导双下划线定义私有属性。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age

    def greet(self):
        return f"Hello, my name is {self.__name} and I am {self.__age} years old."

p = Person("Alice", 30)
print(p.greet())
# print(p.__name)  # 这会引发错误，无法直接访问私有属性

第九步：异常处理

异常处理用于捕获和处理运行时错误，确保程序的正常执行。

1. 异常的捕获和处理

使用try、except、finally进行异常处理。

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
finally:
    print("This block will always execute.")

2. 自定义异常

你可以定义自己的异常类。

class CustomError(Exception):
    pass

def check_value(value):
    if value < 0:
        raise CustomError("Value cannot be negative!")

try:
    check_value(-1)
except CustomError as e:
    print(e)

第十步：迭代器和生成器

1. 迭代器

迭代器是实现了迭代协议的对象，包括__iter__()和__next__()方法。

class MyIterator:
    def __init__(self, max):
        self.max = max
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.max:
            self.current += 1
            return self.current - 1
        else:
            raise StopIteration

for i in MyIterator(5):
    print(i)  # 输出 0 1 2 3 4

2. 生成器

生成器是使用yield关键字的函数，返回一个生成器对象。

def my_generator(n):
    for i in range(n):
        yield i

gen = my_generator(5)
for i in gen:
    print(i)  # 输出 0 1 2 3 4

第十一步：文件和数据处理

1. 读写文本文件

你可以使用open函数读写文本文件。

# 写入文件
with open("example.txt", "w") as file:
    file.write("Hello, World!\n")
    file.write("This is a test file.\n")

# 读取文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

2. 读写CSV文件

使用csv模块处理CSV文件。

import csv
# 写入CSV文件
with open("example.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["Name", "Age", "City"])
    writer.writerow(["Alice", 30, "New York"])
    writer.writerow(["Bob", 25, "Los Angeles"])

# 读取CSV文件
with open("example.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

3. 读写JSON数据

使用json模块处理JSON数据。

import json

# 写入JSON文件
data = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}
with open("example.json", "w") as file:
    json.dump(data, file)

# 读取JSON文件
with open("example.json", "r") as file:
    data = json.load(file)
    print(data)

第十二步：正则表达式

正则表达式用于匹配字符串模式，使用re模块。

import re

# 匹配模式
pattern = r"\d+"
text = "There are 123 apples and 456 oranges."

# 查找所有匹配
matches = re.findall(pattern, text)
print(matches)  # 输出 ['123', '456']

# 替换匹配
replaced_text = re.sub(pattern, "NUMBER", text)
print(replaced_text)  # 输出 There are NUMBER apples and NUMBER oranges.

第十三步：网络编程

使用requests库进行HTTP请求。

import requests

# 发送GET请求
response = requests.get("https://jsonplaceholder.typicode.com/posts")
print(response.status_code)  # 输出 200
print(response.json())       # 输出 JSON 响应内容

# 发送POST请求
data = {
    "title": "foo",
    "body": "bar",
    "userId": 1
}
response = requests.post("https://jsonplaceholder.typicode.com/posts", json=data)
print(response.status_code)  # 输出 201
print(response.json())       # 输出 创建的资源

第十四步：数据库操作

1. 使用SQLite

使用sqlite3模块操作SQLite数据库。

import sqlite3

# 连接数据库
conn = sqlite3.connect("example.db")
cursor = conn.cursor()

# 创建表
cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    age INTEGER
)
""")

# 插入数据
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Alice", 30))
cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Bob", 25))
conn.commit()

# 查询数据
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 关闭连接
conn.close()

2. 使用SQLAlchemy

使用SQLAlchemy操作数据库，提供ORM支持。

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建数据库引擎
engine = create_engine("sqlite:///example.db")
Base = declarative_base()

# 定义模型
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

# 创建表
Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
user1 = User(name="Alice", age=30)
user2 = User(name="Bob", age=25)
session.add(user1)
session.add(user2)
session.commit()

# 查询数据
users = session.query(User).all()
for user in users:
    print(user.name, user.age)

# 关闭会话
session.close()

第十五步：并发编程

1. 多线程编程

使用threading模块实现多线程。

import threading

def print_numbers():
    for i in range(5):
        print(i)

# 创建线程
thread1 = threading.Thread(target=print_numbers)
thread2 = threading.Thread(target=print_numbers)

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

2. 多进程编程

使用multiprocessing模块实现多进程。

import multiprocessing

def print_numbers():
    for i in range(5):
        print(i)

# 创建进程
process1 = multiprocessing.Process(target=print_numbers)
process2 = multiprocessing.Process(target=print_numbers)

# 启动进程
process1.start()
process2.start()

# 等待进程完成
process1.join()
process2.join()

3. 异步编程

使用asyncio模块实现异步编程。

import asyncio

async def print_numbers():
    for i in range(5):
        print(i)
        await asyncio.sleep(1)

# 创建事件循环
loop = asyncio.get_event_loop()

# 执行协程
tasks = [print_numbers(), print_numbers()]
loop.run_until_complete(asyncio.gather(*tasks))

# 关闭事件循环
loop.close()

第十六步：科学计算和数据分析

1. NumPy

NumPy是一个用于科学计算的库，提供支持大量的多维数组与矩阵运算，以及大量的数学函数库。

import numpy as np

# 创建数组
a = np.array([1, 2, 3, 4, 5])
print(a)

# 创建多维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
print(b)

# 基本运算
print(a + 1)  # 输出 [2 3 4 5 6]
print(a * 2)  # 输出 [ 2  4  6  8 10]

# 矩阵运算
c = np.array([[1, 2], [3, 4]])
d = np.array([[5, 6], [7, 8]])
print(np.dot(c, d))  # 矩阵乘法

2. Pandas

Pandas是一个用于数据操作和分析的库，提供了DataFrame数据结构。

import pandas as pd

# 创建Series
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)

# 创建DataFrame
data = {
    "A": [1, 2, 3, 4],
    "B": [5, 6, 7, 8],
    "C": ["a", "b", "c", "d"]
}
df = pd.DataFrame(data)
print(df)

# 读取CSV文件
df = pd.read_csv("example.csv")
print(df)

# 数据选择与过滤
print(df["A"])          # 选择列
print(df[0:2])          # 选择行
print(df[df["A"] > 2])  # 条件过滤

3. Matplotlib

Matplotlib是一个用于绘制图表的库。

import matplotlib.pyplot as plt

# 绘制简单的折线图
x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]
plt.plot(x, y)
plt.xlabel("x-axis")
plt.ylabel("y-axis")
plt.title("Simple Line Plot")
plt.show()

# 绘制柱状图
categories = ["A", "B", "C"]
values = [10, 20, 15]
plt.bar(categories, values)
plt.xlabel("Categories")
plt.ylabel("Values")
plt.title("Simple Bar Chart")
plt.show()