6、打印图形。 ******** ****** **** **用python

以下是打印图形的Python代码：

# 打印矩形
for i in range(4):
    for j in range(8):
        print('*', end='')
    print()

# 打印直角三角形
for i in range(5):
    for j in range(i+1):
        print('*', end='')
    print()

# 打印倒直角三角形
for i in range(5):
    for j in range(5-i):
        print('*', end='')
    print()

输出结果：

********
********
********
********
*****
****
***
**
*
*****
****
***
**
*

相关问题

oralce打印图形*

你可以使用以下代码来打印一个星号图形：

def print_star_shape(rows):
    for i in range(rows):
        for j in range(i+1):
            print("*", end=" ")
        print()

rows = int(input("请输入行数："))
print_star_shape(rows)

你可以根据需要输入图形的行数，然后程序会打印出相应行数的星号图形。希望这能帮到你！如果有任何其他问题，请随时提问。

用python写一个A*算法

### 回答1：

答：A*算法是一种启发式搜索算法，用来从一个起始点搜索到一个终止点。用Python来实现A*算法，首先需要定义一个节点类，其中包括父节点、当前节点和搜索代价；然后，可以初始化一个起始节点，然后把它放入一个开放列表，表示未知评估的节点；接着，从这个开放列表中取出一个节点，进行启发式评估，计算出它的预估代价，然后把它的所有可能的子节点放入开放列表中；最后，从节点中找到最终的终止节点，重构路径，从起始节点到终止节点，即可得到最短路径。

### 回答2：
A*算法是一种在图形表示空间中寻找最佳路径的启发式搜索算法。下面是一个用Python编写的简单示例：

import heapq

class Node:
    def __init__(self, x, y, end_x, end_y):
        self.x = x
        self.y = y
        self.g = 0
        self.h = abs(end_x - x) + abs(end_y - y)
        self.f = self.g + self.h
        self.parent = None
    
    def __lt__(self, other):
        return self.f < other.f

def astar(start_x, start_y, end_x, end_y, grid):
    open_list = []
    closed_list = []

    start_node = Node(start_x, start_y, end_x, end_y)
    heapq.heappush(open_list, start_node)

    while open_list:
        current_node = heapq.heappop(open_list)
        closed_list.append(current_node)

        if current_node.x == end_x and current_node.y == end_y:
            return construct_path(current_node)

        neighbors = get_neighbors(current_node, grid)
        for neighbor in neighbors:
            if neighbor in closed_list:
                continue

            g_score = current_node.g + 1
            if neighbor in open_list:
                if g_score < neighbor.g:
                    neighbor.g = g_score
                    neighbor.parent = current_node
            else:
                neighbor.g = g_score
                neighbor.parent = current_node
                heapq.heappush(open_list, neighbor)

    return []

def get_neighbors(node, grid):
    x, y = node.x, node.y
    neighbors = []

    if x > 0 and grid[x - 1][y] == 0:  # 左方格子
        neighbors.append(Node(x - 1, y))
    if x < len(grid) - 1 and grid[x + 1][y] == 0:  # 右方格子
        neighbors.append(Node(x + 1, y))
    if y > 0 and grid[x][y - 1] == 0:  # 上方格子
        neighbors.append(Node(x, y - 1))
    if y < len(grid[0]) - 1 and grid[x][y + 1] == 0:  # 下方格子
        neighbors.append(Node(x, y + 1))

    return neighbors

def construct_path(node):
    path = []
    while node:
        path.append((node.x, node.y))
        node = node.parent
    return path[::-1]

# 示例使用
grid = [[0, 0, 0, 0],
        [0, 1, 1, 0],
        [0, 0, 0, 0],
        [0, 0, 0, 0]]

start_x, start_y = 0, 0
end_x, end_y = 3, 3

path = astar(start_x, start_y, end_x, end_y, grid)
print(path)

这是一个使用二维数组表示的简单网格地图，0表示可通行的格子，1表示障碍物。我们在示例中找到从(0, 0)起点到(3, 3)终点的最短路径，并打印出路径坐标。

### 回答3：
A*算法是一种常用于寻找最短路径的启发式搜索算法，我们可以用Python来编写一个简单的A*算法。

首先，我们需要定义一个表示节点的类，并为该类添加必要的属性和方法。每个节点需要有一个位置（x，y坐标），一个代价值（g值），一个启发值（h值）和一个父节点。我们可以通过计算代价值和启发值来计算A*算法中的f值。

接下来，我们需要定义一个A*算法函数，该函数接受起始节点和目标节点作为参数，并返回一条最短路径。

在算法函数内部，我们需要创建一个开放列表和一个关闭列表，以跟踪已经访问过的节点和待评估的节点。我们将起始节点添加到开放列表中，并设置其g值为0。

然后，我们进入一个循环，直到开放列表为空或者找到了目标节点。在每次循环迭代中，我们需要找到开放列表中具有最小f值的节点，并将其移除。然后，我们将其添加到关闭列表中并进行评估。

在评估节点的过程中，我们需要检查其相邻的节点，并计算到目标节点的代价值和启发值。如果相邻节点不在开放列表和关闭列表中，则将其添加到开放列表中，并将当前节点设置为其父节点。

最后，当循环结束时，如果找到了目标节点，我们可以回溯父节点并构建最短路径。如果没有找到目标节点，说明没有可行的路径。

通过以上步骤，我们可以实现一个简单的A*算法，并用Python语言编写。当然，这只是一个简单的示例，实际的A*算法可能还涉及更复杂的实现。