用Python中的for循环和whlie循环分别绘制出一个正三角形

在Python中，我们可以使用`for`循环和`while`循环结合控制台打印字符的方式来绘制正三角形。这里分别给出两种方法：

**使用for循环（迭代法）：**

def draw_triangle(n):
    for i in range(1, n+1):
        print(' ' * (n-i) + '*' * (2*i-1))  # 打印空格和星号

# 绘制5行的正三角形
draw_triangle(5)

**使用while循环（逐行打印）：**

def draw_triangle_recursive(n):
    row = ''  # 当前行
    i = 0
    while i < n:
        if i == n - 1:  # 最后一行，全打印星号
            row += '*' * (i*2+1)
        else:  # 其他行，交替星号和空格
            row += ' ' * ((n - i - 1) // 2) + '*' * (2*i + 1)
        print(row)
        i += 1

# 绘制5行的正三角形
draw_triangle_recursive(5)

相关问题

python利用while和for循环绘制一个边长为9的实心三角形

在Python中，我们可以使用`while`或`for`循环结合字符串连接的方式来绘制一个边长为9的实心三角形。这里是一个示例：

def draw_triangle(length):
    # 初始化空字符串用于存储每一行的字符
    triangle = ""

    # 使用 while 循环来绘制前半部分的上三角形
    for i in range(1, length + 1):
        # 每行有i个'*'
        triangle += '*' * i
        # 每两行之间插入换行符
        if i != length:
            triangle += '\n'

    # 使用 while 循环绘制下半部分的倒置等腰三角形
    i = length - 1
    while i >= 0:
        triangle += '*' * i
        i -= 1
        if i > 0:
            triangle += '\n'

    return triangle

# 绘制边长为9的实心三角形
solid_triangle = draw_triangle(9)
print(solid_triangle)

在程序中，我们首先定义了目标和智能体的初始位置和速度，以及智能体的速度和角速度上限，智能体之间的距离阈值和势场法中的常数。然后，我们循环运行直到目标被成功包围。在每个时间步长中，我们计算每个智能体对目标的距离和方向，并根据势场法计算每个智能体的速度和角速度。如果智能体与目标的距离小于阈值，则停止追逐。在最后一步中，我们计算每个智能体到平均位置的向量，然后根据势场法计算每个智能体的速度和角速度，以形成正三角形的队形来包围目标。我们绘制每个智能体的路径。写出python程序

以下是一个简单的 Python 程序，用于模拟多智能体系统围捕目标：

import numpy as np
import matplotlib.pyplot as plt

# 定义目标位置和速度
target_pos = np.array([0, 0])
target_vel = np.array([0, 0])

# 定义智能体的数量、初始位置和速度，以及速度和角速度上限
num_agents = 4
agent_pos = np.random.uniform(-10, 10, size=(num_agents, 2))
agent_vel = np.zeros((num_agents, 2))
agent_vel_limit = 1.0
agent_ang_vel_limit = 0.2

# 定义智能体之间的距离阈值和势场法中的常数
distance_threshold = 2.0
k_att = 0.1
k_rep = 5.0

# 定义终止条件
done = False

# 循环运行，直到目标被成功包围
while not done:
    # 计算每个智能体到目标的距离和方向
    dist_to_target = np.linalg.norm(agent_pos - target_pos, axis=1)
    dir_to_target = (target_pos - agent_pos) / np.maximum(dist_to_target, 1e-6).reshape(-1, 1)

    # 计算每个智能体对目标的吸引力和斥力
    att_force = k_att * dir_to_target
    rep_force = np.zeros_like(att_force)
    for i in range(num_agents):
        for j in range(num_agents):
            if i != j:
                dist_ij = np.linalg.norm(agent_pos[i] - agent_pos[j])
                dir_ij = (agent_pos[j] - agent_pos[i]) / np.maximum(dist_ij, 1e-6)
                if dist_ij < distance_threshold:
                    rep_force[i] -= k_rep * dir_ij / np.maximum(dist_ij, 1e-6)
    force = att_force + rep_force

    # 计算每个智能体的速度和角速度
    vel = agent_vel + force
    vel_norm = np.linalg.norm(vel, axis=1)
    vel = vel / np.maximum(vel_norm.reshape(-1, 1), agent_vel_limit)
    ang_vel = np.random.uniform(-agent_ang_vel_limit, agent_ang_vel_limit, size=num_agents)

    # 更新每个智能体的位置和速度
    agent_pos += vel
    agent_vel = vel

    # 判断是否成功包围目标
    if np.all(np.abs(np.mean(agent_pos, axis=0) - target_pos) < 1e-2):
        done = True

    # 绘制每个智能体的路径
    for i in range(num_agents):
        plt.plot(agent_pos[i, 0], agent_pos[i, 1], 'b.')
    plt.plot(target_pos[0], target_pos[1], 'ro')
    plt.xlim([-15, 15])
    plt.ylim([-15, 15])
    plt.show(block=False)
    plt.pause(0.01)

# 形成正三角形的队形来包围目标
avg_pos = np.mean(agent_pos, axis=0)
for i in range(num_agents):
    dir_to_avg = (avg_pos - agent_pos[i]) / np.maximum(np.linalg.norm(avg_pos - agent_pos[i]), 1e-6)
    att_force = k_att * dir_to_avg
    rep_force = np.zeros_like(att_force)
    for j in range(num_agents):
        if i != j:
            dir_ij = (agent_pos[j] - agent_pos[i]) / np.maximum(np.linalg.norm(agent_pos[j] - agent_pos[i]), 1e-6)
            rep_force -= k_rep * dir_ij
    force = att_force + rep_force
    vel = force
    vel_norm = np.linalg.norm(vel)
    vel = vel / np.maximum(vel_norm, agent_vel_limit)
    ang_vel = np.random.uniform(-agent_ang_vel_limit, agent_ang_vel_limit)
    agent_pos[i] += vel
    agent_vel[i] = vel

# 绘制最终的队形
for i in range(num_agents):
    plt.plot(agent_pos[i, 0], agent_pos[i, 1], 'b.')
plt.plot(target_pos[0], target_pos[1], 'ro')
plt.xlim([-15, 15])
plt.ylim([-15, 15])
plt.show()

这个程序使用势场法来模拟每个智能体对目标的吸引力和斥力，并计算每个智能体的速度和角速度。程序还绘制了每个智能体的路径，以及最终形成的正三角形队形。