Python 如何使用for循环进行此操作？_Python

Python 如何使用for循环进行此操作？

python

Python 如何使用for循环进行此操作？,python,Python,正在尝试制作一个batteship游戏，并希望使代码更加流畅 #Board: A = ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"] B = ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"] C = ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"] D = ["D0", "D1",

正在尝试制作一个batteship游戏，并希望使代码更加流畅

#Board:
A = ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"]
B = ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"]
C = ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"]
D = ["D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"]
E = ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9"]
F = ["F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"]
G = ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9"]
H = ["H0", "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9"]
I = ["I0", "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8", "I9"]
J = ["J0", "J1", "J2", "J3", "J4", "J5", "J6", "J7", "J8", "J9"]
print("\n",A,"\n",B,"\n",C,"\n",D,"\n",E,"\n",F,"\n",G,"\n",H,"\n",I,"\n",J)

#Variables
A_set = set(A)
B_set = set(B)
C_set = set(C)
D_set = set(D)
E_set = set(E)
F_set = set(F)
G_set = set(G)
H_set = set(H)
I_set = set(I)
J_set = set(J)

当我检查放置的代码是否在电路板内时，我使用以下代码：

def user_ship1():
    global nr1_user_ship
    nr1_user_ship = []
    print("Hide a ship within the board.")
    user_ship1 = input("")

    user_ship1 = user_ship1.capitalize()

    battlefield_check = set(user_ship1.split())

    within_battlefield0 = battlefield_check.intersection(A_set)
    within_battlefield1 = battlefield_check.intersection(B_set)
    within_battlefield2 = battlefield_check.intersection(C_set)
    within_battlefield3 = battlefield_check.intersection(D_set)
    within_battlefield4 = battlefield_check.intersection(E_set)
    within_battlefield5 = battlefield_check.intersection(F_set)
    within_battlefield6 = battlefield_check.intersection(G_set)
    within_battlefield7 = battlefield_check.intersection(H_set)
    within_battlefield8 = battlefield_check.intersection(I_set)
    within_battlefield9 = battlefield_check.intersection(J_set)

    if((within_battlefield0 == set()) and (within_battlefield1 == set()) and (within_battlefield2 == set()) and (within_battlefield3 == set()) and (within_battlefield4 == set()) and (within_battlefield5 == set()) and (within_battlefield6 == set()) and (within_battlefield7 == set()) and (within_battlefield8 == set()) and (within_battlefield9 == set())):
        print("Ship needs to be within the board.")
        exit()
    else:
        print("Great! Place another ship.")
    nr1_user_ship.append(user_ship1)

那么，我如何在forloop中使用它，以及如何更改代码以避免使用“全局”变量，您可以将集合打包到一个列表中，然后利用内置函数来最小化您的

if

条件，并避免战场X中的10个

变量：
set=[A_集、B_集、C_集、D_集、E_集、F_集、G_集、H_集、I_集、J_集]
如果所有（len（战场检查交叉点））=0（对于集合中的s）：
打印（“船需要在板内。”）


实际上，您也可以通过简单地执行以下操作来避免10X_集
变量：
rows=[A，B，C，D，E，F，G，H，I，J]
sets=[为行中的行设置（行）]

然后，您可以通过执行以下操作，进一步消除行变量：
board={'A'：[“A0”、“A1”、“A2”、…、“A6”、“A7”、“A8”、“A9”]，
“B”：[…]，
...}

上述内容将更改为：
set=[为线路板中的行设置（行）。值（）

您也可以将线路板设置为列表列表，并对线路板中的行使用，
，但似乎您希望用字母索引这些行，因此我使用了dict。
您可以将集合打包到列表中，然后利用内置功能最小化您的if
情况，并避免在_battlefieldx

变量中出现10个

：
set=[A_集、B_集、C_集、D_集、E_集、F_集、G_集、H_集、I_集、J_集]
如果所有（len（战场检查交叉点））=0（对于集合中的s）：
打印（“船需要在板内。”）


实际上，您也可以通过简单地执行以下操作来避免10X_集
变量：
rows=[A，B，C，D，E，F，G，H，I，J]
sets=[为行中的行设置（行）]

然后，您可以通过执行以下操作，进一步消除行变量：
board={'A'：[“A0”、“A1”、“A2”、…、“A6”、“A7”、“A8”、“A9”]，
“B”：[…]，
...}

上述内容将更改为：
set=[为线路板中的行设置（行）。值（）

您也可以将电路板设置为列表列表，并对电路板中的行使用，
，但似乎您希望用字母索引这些行，因此我使用了dict。
您的代码包含大量样板代码，例如，具有重复逻辑的代码
想象一下，如果您想更改电路板的大小，那么您所生成的代码将花费太多时间
将代码替换为如下列表：
board = [["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"],
         ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"],
         ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"],
         ["D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"],
         ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9"],
         ["F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"],
         ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9"],
         ["H0", "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9"],
         ["I0", "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8", "I9"],
         ["J0", "J1", "J2", "J3", "J4", "J5", "J6", "J7", "J8", "J9"]]

print(board[0])
>>> ['A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9']
print(board[0][0])
>>> A0

这允许更紧凑的代码：
print(any('B4' in sublist for sublist in board))
>>> True
print(any('BB' in sublist for sublist in board))
>>> False

您的代码包含大量样板代码，例如具有重复逻辑的代码
想象一下，如果您想更改电路板的大小，那么您所生成的代码将花费太多时间
将代码替换为如下列表：
board = [["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"],
         ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"],
         ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"],
         ["D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"],
         ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9"],
         ["F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"],
         ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9"],
         ["H0", "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9"],
         ["I0", "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8", "I9"],
         ["J0", "J1", "J2", "J3", "J4", "J5", "J6", "J7", "J8", "J9"]]

print(board[0])
>>> ['A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9']
print(board[0][0])
>>> A0

这允许更紧凑的代码：
print(any('B4' in sublist for sublist in board))
>>> True
print(any('BB' in sublist for sublist in board))
>>> False

在重构代码并使其“更平滑”方面，我将首先切换到不同的数据结构，如列表或字典，而不是选择创建许多带有前缀的变量
例如，对于电路板，将电路板制作为2D阵列如何
board = [ ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"],
          ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"],
          ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"],
          ["D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"],
          ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9"],
          ["F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"],
          ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9"],
          ["H0", "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9"],
          ["I0", "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8", "I9"],
          ["J0", "J1", "J2", "J3", "J4", "J5", "J6", "J7", "J8", "J9"] ]

print "\n".join(board)

可以看出，每个董事会项目值都非常公式化：“[行字母][列编号0索引]”。那么，像这样循环遍历每个字母行和列并动态生成电路板怎么样
board = [[None] * 10] * 10
for letterIdx, letter in enumerate(list("ABCDEFGHIJ")):
    for columnNum in range(10):
        board[letterIdx][columnNum] = letter + str(columnNum)

重构此部分后，您可以自动为每个字母行生成集合，如下图所示：
boardSets = [None] * 10
for rowIdx, row in enumerate(board):
    boardSets[rowIdx] = set(row)

对于前缀为“in_battley”的变量，您也可以将所有这些变量都放在一个列表中
withinBattlefield = []
for rowSetIdx, rowSet in enumerate(boardSets):
    withinBattlefield[rowSetIdx] = battlefield_check.intersection(rowSet)

现在所有内容都在一个列表中，您可以简单地使用for循环和单个条件语句，而不是长if语句：
inBoard = true
for rowInBattlefield in withinBattlefield:
    if(rowInBattlefield == set()):
        inBoard = false

if(not inBoard):
    print("Ship needs to be within the board.")
    exit()
else:
    print("Great! Place another ship.")

这只是如何将代码重构为更干净的一个示例。当然，可以通过为字母、电路板大小添加变量，在函数中添加一些常用功能，等等，对其进行进一步重构，使其更清晰
我希望这能回答你的问题，并祝你在战舰项目上好运
 在重构代码并使其“更平滑”方面，我将首先切换到不同的数据结构，如列表或字典，而不是选择创建许多带有前缀的变量
例如，对于电路板，将电路板制作为2D阵列如何
board = [ ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9"],
          ["B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9"],
          ["C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9"],
          ["D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9"],
          ["E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9"],
          ["F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"],
          ["G0", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9"],
          ["H0", "H1", "H2", "H3", "H4", "H5", "H6", "H7", "H8", "H9"],
          ["I0", "I1", "I2", "I3", "I4", "I5", "I6", "I7", "I8", "I9"],
          ["J0", "J1", "J2", "J3", "J4", "J5", "J6", "J7", "J8", "J9"] ]

print "\n".join(board)

可以看出，每个董事会项目值都非常公式化：“[行字母][列编号0索引]”。那么，像这样循环遍历每个字母行和列并动态生成电路板怎么样
board = [[None] * 10] * 10
for letterIdx, letter in enumerate(list("ABCDEFGHIJ")):
    for columnNum in range(10):
        board[letterIdx][columnNum] = letter + str(columnNum)

重构此部分后，您可以自动为每个字母行生成集合，如下图所示：
boardSets = [None] * 10
for rowIdx, row in enumerate(board):
    boardSets[rowIdx] = set(row)

对于前缀为“in_battley”的变量，您也可以将所有这些变量都放在一个列表中
withinBattlefield = []
for rowSetIdx, rowSet in enumerate(boardSets):
    withinBattlefield[rowSetIdx] = battlefield_check.intersection(rowSet)

现在所有内容都在一个列表中，您可以简单地使用for循环和单个条件语句，而不是长if语句：
inBoard = true
for rowInBattlefield in withinBattlefield:
    if(rowInBattlefield == set()):
        inBoard = false

if(not inBoard):
    print("Ship needs to be within the board.")
    exit()
else:
    print("Great! Place another ship.")

这只是如何将代码重构为更干净的一个示例。当然，可以通过为字母、电路板大小添加变量，在函数中添加一些常用功能，等等，对其进行进一步重构，使其更清晰
我希望这能回答你的问题，并祝你在战舰项目上好运
 我建议使用pandas
，这将为您节省大量开发，并将帮助您制作此类数据。我建议使用pandas
，这将为您节省大量开发，我相信创建列表的一种更惯用的方法是使用append
方法，而不是初始化列表和设置索引。例如，这个l=[None]*10；对于枚举（板）中的i，x:l[i]=x
应该是：l=[]；对于板中的x:l.append（x）
或更好的方法，一个列表comp:l=