Bonjour ,je souhaite transformer cet affichage en boucle

1. Un

Un = font.render("1", True, (10, 1, 200))
screen.blit(Un, (69,5))

1. Deux

Deux = font.render("2", True, (10,1,200))
screen.blit(Deux, (120,5))

1. Trois

Trois = font.render("3", True, (10,1,200))
screen.blit(Trois, (165,5))

1. Quatre

Quatre = font.render("4", True, (10,1,200))
screen.blit(Quatre, (215,5))

1. Cinq

Cinq = font.render("5", True, (10,1,200))
screen.blit(Cinq, (265,5))

1. Six

Six = font.render("6", True, (10,1,200))
screen.blit(Six, (315,5))

1. Sept

Sept = font.render("7", True, (10,1,200))
screen.blit(Sept, (365,5))

1. Huit

Huit = font.render("8", True, (10,1,200))
screen.blit(Huit, (415,5))

1. Neuf

Neuf = font.render("9", True, (10,1,200))
screen.blit(Neuf, (465,5))

1. Dix

Dix = font.render("10", True, (10,1,200))
screen.blit(Dix, (515,5))

#LETTRES VERTICALES

1. A

A = font.render("A", True, (10,1,200))
screen.blit(A, (15,55))

1. B

B = font.render("B", True, (10,1,200))
screen.blit(B, (15,105))

1. C

C = font.render("C", True, (10,1,200))
screen.blit(C, (15,155))

1. D

D = font.render("D", True, (10,1,200))
screen.blit(D, (15,205))

1. E

E = font.render("E", True, (10,1,200))
screen.blit(E, (15,255))

1. F

F = font.render("F", True, (10,1,200))
screen.blit(F, (15,305))

1. G

G = font.render("G", True, (10,1,200))
screen.blit(G, (15,355))

1. H

H = font.render("H", True, (10,1,200))
screen.blit(H, (15,405))

1. I

I = font.render("I", True, (10,1,200))
screen.blit(I, (15,455))

1. J

J = font.render("J", True, (10,1,200))
screen.blit(J, (15,505))

Pour un projet de bataille navale

Pouvez vous m'aidez ?

Nombre : déja y'a un gros probleme de coordonnées on va dire que une case prend 50px donc :
for i in range(1, 10):
txt = font.render(str(i), True, (10, 1, 200))
screen.blit(txt, (i * 50, 5))

owned by tab

et pour l'autre pareil tu fait un truc du genre :

for i, l in enumerate(list("ABCDEFGHIJ")):
txt = font.render(l, True, (10, 1, 200))
screen.blit(txt, (15, (i+1)*50))

Salut, tu peut appeler font.render indépendamment de blit(), qui ne fait que placer la surface générée par render() sur ta surface principale.
Tu perdras de la performance à générer les mêmes surfaces à chaque frame, alors que tu peut les générer une seule fois au démarrage du programme et ensuite les placer rapidement avec blit() autant de fois que tu veux dans ta boucle principale.

Tu peut également calculer les dimensions de chaque case avec font.size(txt) avant la boucle principale pour les aligner à des endroits précis