Ajout TP 7 et avancement sur Echecs avant POO
Before Width: | Height: | Size: 4.3 KiB After Width: | Height: | Size: 4.3 KiB |
Before Width: | Height: | Size: 3.2 KiB After Width: | Height: | Size: 3.2 KiB |
Before Width: | Height: | Size: 6.9 KiB After Width: | Height: | Size: 6.9 KiB |
Before Width: | Height: | Size: 4.8 KiB After Width: | Height: | Size: 4.8 KiB |
Before Width: | Height: | Size: 3 KiB After Width: | Height: | Size: 3 KiB |
Before Width: | Height: | Size: 2.3 KiB After Width: | Height: | Size: 2.3 KiB |
|
@ -1,3 +1,5 @@
|
||||||
|
# pylint: disable=W0603
|
||||||
|
|
||||||
# INFOS
|
# INFOS
|
||||||
|
|
||||||
# Pièces :
|
# Pièces :
|
||||||
|
@ -32,7 +34,7 @@ from random import randint
|
||||||
CASES_COTE = 8
|
CASES_COTE = 8
|
||||||
|
|
||||||
j_grille = None
|
j_grille = None
|
||||||
auxBlancs = None
|
j_joueur = True
|
||||||
|
|
||||||
def j_eNoir(xD, yD): # TODO Peut être considérablement amélioré
|
def j_eNoir(xD, yD): # TODO Peut être considérablement amélioré
|
||||||
i = 1
|
i = 1
|
||||||
|
@ -48,21 +50,23 @@ def j_cGrille():
|
||||||
for x in range(CASES_COTE):
|
for x in range(CASES_COTE):
|
||||||
colonne = []
|
colonne = []
|
||||||
for y in range(CASES_COTE):
|
for y in range(CASES_COTE):
|
||||||
if j_eNoir(x, y):
|
colonne.append(0)
|
||||||
colonne.append(0)
|
|
||||||
else:
|
|
||||||
colonne.append(-1)
|
|
||||||
j_grille.append(colonne)
|
j_grille.append(colonne)
|
||||||
|
|
||||||
def j_remplirGrille():
|
def j_remplirGrille():
|
||||||
global j_grille
|
global j_grille
|
||||||
j_grille[2][2] = 5
|
speciales = [2, 3, 4, 6, 5, 4, 3, 2]
|
||||||
|
for i in range(0, 8):
|
||||||
|
j_grille[i][0] = speciales[i] + 10
|
||||||
|
j_grille[i][1] = 11
|
||||||
|
j_grille[i][6] = 1
|
||||||
|
j_grille[i][7] = speciales[i]
|
||||||
|
|
||||||
def j_nvPartie():
|
def j_nvPartie():
|
||||||
j_cGrille()
|
j_cGrille()
|
||||||
j_remplirGrille()
|
j_remplirGrille()
|
||||||
global auxBlancs
|
global j_joueur
|
||||||
auxBlancs = True
|
j_joueur = True
|
||||||
|
|
||||||
def j_cPion(x, y, piece):
|
def j_cPion(x, y, piece):
|
||||||
"""
|
"""
|
||||||
|
@ -70,30 +74,62 @@ def j_cPion(x, y, piece):
|
||||||
j_grille[x][y] = piece
|
j_grille[x][y] = piece
|
||||||
return True
|
return True
|
||||||
|
|
||||||
|
def j_mvtPossible(x1, y1, x2, y2):
|
||||||
|
pion = j_grille[x1][y1]
|
||||||
|
if (pion >= 10 and j_joueur == False) or (pion < 10 and j_joueur == True):
|
||||||
|
if pion > 0 and j_grille[x2][y2] <= 0:
|
||||||
|
tPion = pion%10
|
||||||
|
if tPion == 1:
|
||||||
|
if x1 == x2:
|
||||||
|
if j_joueur:
|
||||||
|
if y2 == y1-1:
|
||||||
|
return True
|
||||||
|
else:
|
||||||
|
return -4
|
||||||
|
else:
|
||||||
|
if y2 == y1+1:
|
||||||
|
return True
|
||||||
|
else:
|
||||||
|
return -4
|
||||||
|
else:
|
||||||
|
return -4
|
||||||
|
elif tPion == 6:
|
||||||
|
if x2 <= x1+1 and x2 >= x1-1 and y2 <= y1+1 and y2 >= y1-1 \
|
||||||
|
and (x1 != x2 or y1 != y2):
|
||||||
|
return True
|
||||||
|
else:
|
||||||
|
return -4
|
||||||
|
else:
|
||||||
|
return -3
|
||||||
|
|
||||||
|
return True
|
||||||
|
else:
|
||||||
|
return -2
|
||||||
|
else:
|
||||||
|
return -1
|
||||||
|
|
||||||
def j_dPion(x1, y1, x2, y2):
|
def j_dPion(x1, y1, x2, y2):
|
||||||
# TODO Vérification du mouvement possible
|
test = j_mvtPossible(x1, y1, x2, y2)
|
||||||
assert(j_grille[x1][y1] > 0), "ERR1"
|
if test == True:
|
||||||
assert(j_grille[x2][y2] != 0), "ERR2"
|
global j_joueur, j_grille
|
||||||
j_grille[x2][y2] = j_grille[x1][y1]
|
j_grille[x2][y2] = j_grille[x1][y1]
|
||||||
return True
|
j_grille[x1][y1] = 0
|
||||||
|
# j_joueur = not j_joueur # DEBUG
|
||||||
# def poserPion(x, y):
|
return True
|
||||||
# global auxBlancs
|
else:
|
||||||
# if j_grille[x][y] == 0:
|
return test
|
||||||
# j_grille[x][y] = 1
|
|
||||||
# pion(x, y, auxBlancs)
|
|
||||||
# auxBlancs = not auxBlancs
|
|
||||||
# elif j_grille[x][y] == -1:
|
|
||||||
# statut('On joue sur les cases noires !')
|
|
||||||
# else:
|
|
||||||
# statut('Il y a déjà quelque chose ici.')
|
|
||||||
|
|
||||||
|
|
||||||
# GUI
|
# GUI
|
||||||
DECX = 0
|
DECX = 0
|
||||||
DECY = 0
|
DECY = 0
|
||||||
COTE_CASE = 50
|
COTE_CASE = 50
|
||||||
MARGE_PIONS = 5
|
MARGE_PIONS = 5
|
||||||
|
TEMPS_ANIM = 200
|
||||||
|
INTER_ANIM = 10
|
||||||
|
|
||||||
|
g_imagesOriginales = []
|
||||||
|
g_imagesRedim = []
|
||||||
|
|
||||||
|
|
||||||
g_grilleDamier = None
|
g_grilleDamier = None
|
||||||
g_grillePions = None
|
g_grillePions = None
|
||||||
|
@ -102,6 +138,14 @@ fen = None
|
||||||
can = None
|
can = None
|
||||||
chaine = None
|
chaine = None
|
||||||
|
|
||||||
|
# Animation
|
||||||
|
g_x1 = None
|
||||||
|
g_y1 = None
|
||||||
|
g_x2 = None
|
||||||
|
g_y2 = None
|
||||||
|
g_pion = None
|
||||||
|
g_anim = None
|
||||||
|
|
||||||
def g_fen():
|
def g_fen():
|
||||||
global fen, can, chaine
|
global fen, can, chaine
|
||||||
fen = Tk()
|
fen = Tk()
|
||||||
|
@ -119,14 +163,49 @@ def g_fen():
|
||||||
|
|
||||||
def g_statut(texte, delai=0):
|
def g_statut(texte, delai=0):
|
||||||
chaine.config(text=texte)
|
chaine.config(text=texte)
|
||||||
print(texte)
|
# TODO Timeout effacer si parametre / Liste
|
||||||
# TODO Timeout effacer si parametre
|
|
||||||
|
def g_importerImages():
|
||||||
|
global g_imagesOriginales
|
||||||
|
for piece in range(0, 21):
|
||||||
|
nom = 'sprites/'
|
||||||
|
if piece%10 == 1:
|
||||||
|
nom += 'pion'
|
||||||
|
elif piece%10 == 2:
|
||||||
|
nom += 'tour'
|
||||||
|
elif piece%10 == 3:
|
||||||
|
nom += 'cavalier'
|
||||||
|
elif piece%10 == 4:
|
||||||
|
nom += 'fou'
|
||||||
|
elif piece%10 == 5:
|
||||||
|
nom += 'dame'
|
||||||
|
elif piece%10 == 6:
|
||||||
|
nom += 'roi'
|
||||||
|
else:
|
||||||
|
g_imagesOriginales.append('')
|
||||||
|
continue
|
||||||
|
if piece < 10:
|
||||||
|
nom += 'B'
|
||||||
|
else:
|
||||||
|
nom += 'N'
|
||||||
|
nom += '.gif'
|
||||||
|
g_imagesOriginales.append(PhotoImage(file=nom))
|
||||||
|
|
||||||
|
def g_redimImages():
|
||||||
|
global g_imagesRedim
|
||||||
|
sample = int(504/(COTE_CASE-MARGE_PIONS))
|
||||||
|
for piece in range(0, 21):
|
||||||
|
if g_imagesOriginales[piece] != '':
|
||||||
|
g_imagesRedim.append(g_imagesOriginales[piece].subsample(sample))
|
||||||
|
else:
|
||||||
|
g_imagesRedim.append('')
|
||||||
|
|
||||||
|
|
||||||
def g_cCase(x, y):
|
def g_cCase(x, y):
|
||||||
if j_eNoir(x, y):
|
if j_eNoir(x, y):
|
||||||
couleur = 'black'
|
couleur = '#D18B47'
|
||||||
else:
|
else:
|
||||||
couleur = 'white'
|
couleur = '#FFCE9E'
|
||||||
return can.create_rectangle(x*COTE_CASE, y*COTE_CASE, \
|
return can.create_rectangle(x*COTE_CASE, y*COTE_CASE, \
|
||||||
(x+1)*COTE_CASE, (y+1)*COTE_CASE, fill=couleur)
|
(x+1)*COTE_CASE, (y+1)*COTE_CASE, fill=couleur)
|
||||||
|
|
||||||
|
@ -143,32 +222,39 @@ def g_cPion(x, y, piece):
|
||||||
global g_grillePions
|
global g_grillePions
|
||||||
global g_photos
|
global g_photos
|
||||||
if piece > 0:
|
if piece > 0:
|
||||||
nom = 'sprites/'
|
g_grillePions[x][y] = can.create_image((x+.5)*COTE_CASE, \
|
||||||
if piece%10 == 5:
|
(y+.5)*COTE_CASE, image=g_imagesRedim[piece])
|
||||||
nom += 'reine'
|
|
||||||
else:
|
|
||||||
nom += 'pion'
|
|
||||||
if piece < 10:
|
|
||||||
nom += 'B'
|
|
||||||
else:
|
|
||||||
nom += 'N'
|
|
||||||
nom += '.gif'
|
|
||||||
g_photos.append(PhotoImage(file=nom))
|
|
||||||
sample = int(504/(COTE_CASE-MARGE_PIONS))
|
|
||||||
g_photos[-1] = g_photos[-1].subsample(sample)
|
|
||||||
g_grillePions[x][y] = can.create_image((x+.5)*COTE_CASE, (y+.5)*COTE_CASE, image=g_photos[-1])
|
|
||||||
# g_grillePions[x][y] = can.create_oval(x*COTE_CASE+MARGE_PIONS, y*COTE_CASE+MARGE_PIONS, \
|
|
||||||
# (x+1)*COTE_CASE-MARGE_PIONS, (y+1)*COTE_CASE-MARGE_PIONS, \
|
|
||||||
# outline='gray', width=2, fill='white' if piece < 10 else 'black')
|
|
||||||
else:
|
else:
|
||||||
g_grillePions[x][y] = False
|
g_grillePions[x][y] = False
|
||||||
|
|
||||||
|
def g_dPionFinal():
|
||||||
|
can.coords(g_pion, g_x2, g_y2)
|
||||||
|
|
||||||
|
def g_dPionAnim():
|
||||||
|
global g_pion, g_anim
|
||||||
|
x = g_x1 + (g_x2-g_x1) * (g_anim/TEMPS_ANIM)
|
||||||
|
y = g_y1 + (g_y2-g_y1) * (g_anim/TEMPS_ANIM)
|
||||||
|
can.coords(g_pion, x, y)
|
||||||
|
g_anim += INTER_ANIM
|
||||||
|
if g_anim < TEMPS_ANIM:
|
||||||
|
fen.after(INTER_ANIM, g_dPionAnim)
|
||||||
|
else:
|
||||||
|
g_dPionFinal()
|
||||||
|
|
||||||
def g_dPion(x1, y1, x2, y2):
|
def g_dPion(x1, y1, x2, y2):
|
||||||
global g_grillePions
|
# TODO Bloquer l'entrée pendant l'anim
|
||||||
pion = g_grillePions[x1][y1]
|
global g_grillePions, g_x1, g_y1, g_x2, g_y2, g_pion, g_anim
|
||||||
can.coords(pion, x2*COTE_CASE+MARGE_PIONS, y2*COTE_CASE+MARGE_PIONS, (x2+1)*COTE_CASE-MARGE_PIONS, (y2+1)*COTE_CASE-MARGE_PIONS)
|
g_x1 = (x1+.5)*COTE_CASE
|
||||||
|
g_y1 = (y1+.5)*COTE_CASE
|
||||||
|
g_x2 = (x2+.5)*COTE_CASE
|
||||||
|
g_y2 = (y2+.5)*COTE_CASE
|
||||||
|
g_pion = g_grillePions[x1][y1]
|
||||||
|
g_anim = 0
|
||||||
|
# can.coords(g_grillePions[x1][y1], (x2+.5)*COTE_CASE, (y2+.5)*COTE_CASE)
|
||||||
|
g_grillePions[x2][y2] = g_grillePions[x1][y1]
|
||||||
g_grillePions[x1][y1] = False
|
g_grillePions[x1][y1] = False
|
||||||
g_grillePions[x2][y2] = pion
|
g_dPionAnim()
|
||||||
|
# g_dPionFinal()
|
||||||
|
|
||||||
def g_cGrille():
|
def g_cGrille():
|
||||||
global g_grillePions
|
global g_grillePions
|
||||||
|
@ -185,8 +271,32 @@ def g_remplirGrille(j_grilleF):
|
||||||
for y in range(0, CASES_COTE):
|
for y in range(0, CASES_COTE):
|
||||||
g_cPion(x, y, j_grilleF[x][y])
|
g_cPion(x, y, j_grilleF[x][y])
|
||||||
|
|
||||||
|
def g_init():
|
||||||
|
g_fen()
|
||||||
|
g_importerImages()
|
||||||
|
g_redimImages()
|
||||||
|
|
||||||
# Frontend
|
# Frontend
|
||||||
|
|
||||||
|
f_origine = True
|
||||||
|
f_x1 = -1
|
||||||
|
f_y1 = -1
|
||||||
|
f_x2 = -1
|
||||||
|
f_y2 = -1
|
||||||
|
|
||||||
|
def f_statutPrendre():
|
||||||
|
if j_joueur:
|
||||||
|
joueur = 'blancs'
|
||||||
|
else:
|
||||||
|
joueur = 'noirs'
|
||||||
|
g_statut('Prendre (' + joueur + ')')
|
||||||
|
|
||||||
|
def f_init():
|
||||||
|
g_init()
|
||||||
|
f_nvPartie()
|
||||||
|
f_statutPrendre()
|
||||||
|
|
||||||
|
|
||||||
def f_cPion(x, y, piece):
|
def f_cPion(x, y, piece):
|
||||||
if j_cPion(x, y, piece):
|
if j_cPion(x, y, piece):
|
||||||
g_cPion(x, y, piece)
|
g_cPion(x, y, piece)
|
||||||
|
@ -198,10 +308,12 @@ def f_cPionAlea():
|
||||||
g_cPion(randint(1, CASES_COTE), randint(1, CASES_COTE), 1)
|
g_cPion(randint(1, CASES_COTE), randint(1, CASES_COTE), 1)
|
||||||
|
|
||||||
def f_dPion(x1, y1, x2, y2):
|
def f_dPion(x1, y1, x2, y2):
|
||||||
if j_dPion(x1, y1, x2, y2):
|
test = j_dPion(x1, y1, x2, y2)
|
||||||
|
if test == True:
|
||||||
g_dPion(x1, y1, x2, y2)
|
g_dPion(x1, y1, x2, y2)
|
||||||
return True
|
return True
|
||||||
else:
|
else:
|
||||||
|
g_statut('Impossible ! ('+str(test)+')') # TODO Messages corrects
|
||||||
return False
|
return False
|
||||||
|
|
||||||
def f_nvPartie():
|
def f_nvPartie():
|
||||||
|
@ -210,13 +322,24 @@ def f_nvPartie():
|
||||||
g_cGrille()
|
g_cGrille()
|
||||||
g_remplirGrille(j_grille)
|
g_remplirGrille(j_grille)
|
||||||
|
|
||||||
|
def f_dClic(x, y):
|
||||||
|
global f_origine, f_x1, f_y1, f_x2, f_y2
|
||||||
|
if f_origine:
|
||||||
|
f_x1, f_y1 = x, y
|
||||||
|
# TODO Colorer case
|
||||||
|
g_statut('Poser')
|
||||||
|
else:
|
||||||
|
f_x2, f_y2 = x, y
|
||||||
|
f_dPion(f_x1, f_y1, f_x2, f_y2)
|
||||||
|
f_statutPrendre()
|
||||||
|
f_origine = not f_origine
|
||||||
|
|
||||||
|
|
||||||
def f_clic(event):
|
def f_clic(event):
|
||||||
x = event.x//COTE_CASE
|
x = event.x//COTE_CASE
|
||||||
y = event.y//COTE_CASE
|
y = event.y//COTE_CASE
|
||||||
f_cPion(x, y, 1)
|
f_dClic(x, y)
|
||||||
|
|
||||||
|
|
||||||
# MAIN
|
|
||||||
|
|
||||||
g_fen()
|
f_init()
|
||||||
f_nvPartie()
|
|
||||||
|
|
396
S1/TP 7/chaines.py
Normal file
|
@ -0,0 +1,396 @@
|
||||||
|
# VAN DEN BERGE Manon - PeiP 12 - 2014/2015
|
||||||
|
# PREUD'HOMME BONTOUX Geoffrey - PeiP 12 - 2014/2015
|
||||||
|
# TP n°7 donné le 7/11/2014 - Exercices sur les chaînes de caractère
|
||||||
|
# http://www.fil.univ-lille1.fr/~wegrzyno/portail/Info/Doc/HTML/seq4_chaines_caracteres.html#exercices
|
||||||
|
|
||||||
|
import doctest
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice 30 lignes vides
|
||||||
|
|
||||||
|
# Comment en utilisant print une seule fois peut-on imprimer 30 lignes
|
||||||
|
# vides ? (boucles pour et tant que interdites)
|
||||||
|
|
||||||
|
# En utilisant l'opérateur de répétition
|
||||||
|
|
||||||
|
# print("\n"*30, end='')
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Impression verticale
|
||||||
|
|
||||||
|
# Réalisez une fonction imprimer_vertical qui imprime un à un les
|
||||||
|
# caractères de la chaîne qu’on lui donne en paramètre les uns au dessus
|
||||||
|
# des autres.
|
||||||
|
|
||||||
|
def imprimer_vertical(chaine):
|
||||||
|
"""
|
||||||
|
Imprime un à un les caractères de la chaîne donnée en paramètre les uns au
|
||||||
|
dessus des autres.
|
||||||
|
str → ∅
|
||||||
|
CU : chaine du type str
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
for i in chaine:
|
||||||
|
print(i)
|
||||||
|
|
||||||
|
# >>> imprimer_vertical('Timoleon')
|
||||||
|
# T
|
||||||
|
# i
|
||||||
|
# m
|
||||||
|
# o
|
||||||
|
# l
|
||||||
|
# e
|
||||||
|
# o
|
||||||
|
# n
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Impression à l’envers
|
||||||
|
|
||||||
|
# Réalisez d’au moins deux façons différentes une fonction imprimer_envers
|
||||||
|
# qui imprime la chaîne qu’on lui donne en paramètre en inversant l’ordre
|
||||||
|
# des caractères.
|
||||||
|
|
||||||
|
# Avertissement Utilisez le paramètre optionnel end de la fonction print pour
|
||||||
|
# éviter les passages à la ligne non désirés.
|
||||||
|
|
||||||
|
def imprimer_envers1(chaine):
|
||||||
|
"""
|
||||||
|
Imprime la chaîne donnée en paramètre en inversant l’ordre des caractères.
|
||||||
|
str → ∅
|
||||||
|
CU : chaine du type str
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
affichage = ''
|
||||||
|
for i in chaine:
|
||||||
|
affichage = i + affichage
|
||||||
|
print(affichage)
|
||||||
|
|
||||||
|
# >>> imprimer_envers1('Timoleon')
|
||||||
|
# noelomiT
|
||||||
|
# >>> imprimer_envers1('')
|
||||||
|
#
|
||||||
|
|
||||||
|
def imprimer_envers2(chaine):
|
||||||
|
"""
|
||||||
|
Imprime la chaîne donnée en paramètre en inversant l’ordre des caractères.
|
||||||
|
str → ∅
|
||||||
|
CU : chaine du type str
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
affichage = ''
|
||||||
|
if len(chaine) > 0:
|
||||||
|
for i in range(-1, -len(chaine)-1, -1):
|
||||||
|
print(i, chaine[i])
|
||||||
|
affichage += chaine[i]
|
||||||
|
print(affichage)
|
||||||
|
|
||||||
|
# >>> imprimer_envers2('Timoleon')
|
||||||
|
# noelomiT
|
||||||
|
# >>> imprimer_envers2('')
|
||||||
|
#
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Miroir
|
||||||
|
|
||||||
|
# Réalisez une fonction miroir qui renvoie une chaîne contenant les
|
||||||
|
# caractères de la chaîne qu’on lui donne en paramètre dans l’ordre
|
||||||
|
# inverse.
|
||||||
|
|
||||||
|
def miroir(chaine):
|
||||||
|
"""
|
||||||
|
Renvoie une chaîne contenant les caractères de la chaîne donnés en paramètre
|
||||||
|
dans l’ordre inverse.
|
||||||
|
str → str
|
||||||
|
CU : chaine du type str
|
||||||
|
|
||||||
|
>>> miroir ('Timoleon')
|
||||||
|
'noelomiT'
|
||||||
|
>>> miroir ('')
|
||||||
|
''
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
retour = ''
|
||||||
|
if len(chaine) > 0:
|
||||||
|
for i in range(-1, -len(chaine)-1, -1):
|
||||||
|
retour += chaine[i]
|
||||||
|
return retour
|
||||||
|
|
||||||
|
# Exercice Palindrome
|
||||||
|
|
||||||
|
# Un palindrome est un mot qui se lit de la même façon de gauche à droite
|
||||||
|
# et de droite à gauche. Par exemple, ICI, ELLE et RADAR sont des
|
||||||
|
# palindromes.
|
||||||
|
|
||||||
|
# Par extension, une chaîne de caractères est dite palindromique si la
|
||||||
|
# liste de ses caractères parcourus de gauche à droite est la même que
|
||||||
|
# celle de ses caractères parcourus de droite à gauche. Par exemple, la
|
||||||
|
# chaîne 'A, 1 b+b 1 ,A' est palindromique
|
||||||
|
|
||||||
|
# Le but est de réaliser un prédicat est_palindromique qui renvoie
|
||||||
|
|
||||||
|
# True si la chaîne passée en paramètre est palindromique
|
||||||
|
# False dans le cas contraire.
|
||||||
|
# >>> est_palindromique ('Timoleon')
|
||||||
|
# False
|
||||||
|
# >>> est_palindromique ('RADAR')
|
||||||
|
# True
|
||||||
|
# >>> est_palindromique ('A, 1 b+b 1 ,A')
|
||||||
|
# True
|
||||||
|
|
||||||
|
# Réalisez ce prédicat en utilisant la fonction miroir de l’exercice précédent.
|
||||||
|
|
||||||
|
def est_palindromique1(chaine):
|
||||||
|
"""
|
||||||
|
Indique si la chaîne passée en paramètre est palindromique
|
||||||
|
str → bool
|
||||||
|
CU : mot est du type str
|
||||||
|
|
||||||
|
>>> est_palindromique1('Timoleon')
|
||||||
|
False
|
||||||
|
>>> est_palindromique1('A, 1 b+b 1 ,A')
|
||||||
|
True
|
||||||
|
>>> est_palindromique1('')
|
||||||
|
True
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
return chaine == miroir(chaine)
|
||||||
|
|
||||||
|
# Réalisez une autre version sans utiliser la fonction miroir.
|
||||||
|
|
||||||
|
def est_palindromique2(chaine):
|
||||||
|
"""
|
||||||
|
Indique si la chaîne passée en paramètre est palindromique
|
||||||
|
str → bool
|
||||||
|
CU : mot est du type str
|
||||||
|
|
||||||
|
>>> est_palindromique1('Timoleon')
|
||||||
|
False
|
||||||
|
>>> est_palindromique1('A, 1 b+b 1 ,A')
|
||||||
|
True
|
||||||
|
>>> est_palindromique1('')
|
||||||
|
True
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
longueur = len(chaine) # On crée une variable pour éviter
|
||||||
|
# de trop appeler len()
|
||||||
|
if longueur > 0:
|
||||||
|
for i in range(longueur):
|
||||||
|
if chaine[longueur-i-1] != chaine[i]:
|
||||||
|
return False
|
||||||
|
return True
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Longueur d’une chaîne
|
||||||
|
|
||||||
|
# La fonction len renvoie la longueur de la chaîne de caractères qu’on lui
|
||||||
|
# passe en paramètre.
|
||||||
|
|
||||||
|
# Sans utiliser cette fonction, réalisez une fonction qui fait exactement
|
||||||
|
# la même chose.
|
||||||
|
|
||||||
|
def my_len(chaine):
|
||||||
|
"""
|
||||||
|
Renvoie la longueur de la chaîne de caractères passée en paramètre.
|
||||||
|
str → int
|
||||||
|
CU : chaine est du type str
|
||||||
|
|
||||||
|
>>> my_len ('')
|
||||||
|
0
|
||||||
|
>>> my_len ('abcd')
|
||||||
|
4
|
||||||
|
>>> my_len ('esope reste ici et se repose')
|
||||||
|
28
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
a = 0
|
||||||
|
for i in chaine[:]:
|
||||||
|
a += 1
|
||||||
|
return a
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Suppression d’un caractère
|
||||||
|
|
||||||
|
# Réalisez une fonction qui renvoie une chaîne obtenue en supprimant le
|
||||||
|
# caractère d’indice i d’une chaîne s, l’indice et la chaîne s étant
|
||||||
|
# passés en paramètres.
|
||||||
|
|
||||||
|
def sauf(s, i):
|
||||||
|
"""
|
||||||
|
Renvoie une chaîne obtenue en supprimant le caractère d’indice
|
||||||
|
i d’une chaîne s, l’indice et la chaîne s étant passés en paramètres.
|
||||||
|
(str, int) → str
|
||||||
|
CU : s du type str et 0 ≤ i < len(s)
|
||||||
|
|
||||||
|
>>> sauf('Timoleon', 3)
|
||||||
|
'Timleon'
|
||||||
|
"""
|
||||||
|
assert(type(s) is str), "s doit être du type str"
|
||||||
|
assert(i >= 0 and i < len(s)), "i doit être dans l'intervalle [0, len(s)["
|
||||||
|
|
||||||
|
return s[:i] + s[i + 1:]
|
||||||
|
|
||||||
|
# Vous pourrez supposer que l’indice est un entier positif ou nul.
|
||||||
|
|
||||||
|
# >>> s = 'Timoleon'
|
||||||
|
# >>> for i in range(len(s)):
|
||||||
|
# ... print(sauf(s, i))
|
||||||
|
# ...
|
||||||
|
# imoleon
|
||||||
|
# Tmoleon
|
||||||
|
# Tioleon
|
||||||
|
# Timleon
|
||||||
|
# Timoeon
|
||||||
|
# Timolon
|
||||||
|
# Timolen
|
||||||
|
# Timoleo
|
||||||
|
|
||||||
|
|
||||||
|
# Que renvoie votre fonction si l’indice passé en paramètre est négatif ?
|
||||||
|
|
||||||
|
# En premier test, la fonction déclenche une erreur d'assertion.
|
||||||
|
# En enlevant les assertions, l'instruction sauf(s, -i) (pour i positif)
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Nombre d’occurrences
|
||||||
|
|
||||||
|
# Réalisez une fonction qui renvoie le nombre d’occurrences d’un caractère
|
||||||
|
# dans une chaîne, le caractère et la chaîne étant passés en paramètre.
|
||||||
|
|
||||||
|
def nbre_occurrences(caractere, chaine):
|
||||||
|
"""
|
||||||
|
Renvoie le nombre d’occurrences d’un caractère dans une chaîne, le caractère
|
||||||
|
et la chaîne étant passés en paramètre.
|
||||||
|
(str, str) → int
|
||||||
|
CU : caractere de type str de taille 1 et chaine de type str
|
||||||
|
|
||||||
|
>>> nbre_occurrences ('o', 'Timoleon')
|
||||||
|
2
|
||||||
|
>>> nbre_occurrences ('y', 'Timoleon')
|
||||||
|
0
|
||||||
|
>>> nbre_occurrences (' ', 'esope reste ici et se repose')
|
||||||
|
5
|
||||||
|
"""
|
||||||
|
assert(type(caractere) is str and len(caractere) == 1), \
|
||||||
|
"caractere doit être du type str et de taille 1"
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
nombre = 0
|
||||||
|
for i in chaine:
|
||||||
|
if i == caractere:
|
||||||
|
nombre += 1
|
||||||
|
return nombre
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Suppression des occurences d’un caractère
|
||||||
|
|
||||||
|
# Réalisez une fonction qui renvoie une chaîne obtenue en supprimant
|
||||||
|
# toutes les occurrences d’un caractère dans une chaîne, ce caractère et
|
||||||
|
# cette chaîne étant passés en paramètres.
|
||||||
|
|
||||||
|
def supprime_car(caractere, chaine):
|
||||||
|
"""
|
||||||
|
Renvoie une chaîne obtenue en supprimant toutes les occurrences d’un
|
||||||
|
caractère dans une chaîne, ce caractère et cette chaîne étant passés en
|
||||||
|
paramètres.
|
||||||
|
(str, str) → str
|
||||||
|
CU : caractere de type str de taille 1 et chaine de type str
|
||||||
|
|
||||||
|
>>> supprime_car ('o', 'Timoleon')
|
||||||
|
'Timlen'
|
||||||
|
>>> supprime_car ('y', 'Timoleon')
|
||||||
|
'Timoleon'
|
||||||
|
"""
|
||||||
|
assert(type(caractere) is str and len(caractere) == 1), \
|
||||||
|
"caractere doit être du type str et de taille 1"
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
|
||||||
|
retour = ''
|
||||||
|
for i in chaine:
|
||||||
|
if i != caractere:
|
||||||
|
retour += i
|
||||||
|
return retour
|
||||||
|
|
||||||
|
|
||||||
|
# La phrase esope reste ici et se repose n’est pas un palindrome au sens
|
||||||
|
# donné dans l’exercice ci-dessus. Mais si on ne regarde que les lettres,
|
||||||
|
# c’est un palindrome.
|
||||||
|
|
||||||
|
# Comment vérifier ce point avec les fonctions supprime_car et
|
||||||
|
# est_palindromique ?
|
||||||
|
|
||||||
|
# On peut utiliser la composée des deux fonctions de la façon suivante
|
||||||
|
# (chaine étant la chaine dont on souhaite vérifier si elle est palindromique)
|
||||||
|
|
||||||
|
# est_palindromique(supprime_car(' ', chaine))
|
||||||
|
|
||||||
|
# On peut même enlever les points, les virgules et toute autre ponctuation
|
||||||
|
# génante
|
||||||
|
|
||||||
|
# est_palindromique(supprime_car(' ', supprime_car(',', supprime_car('.', \
|
||||||
|
# supprime_car('!', supprime_car('?', chaine))))))
|
||||||
|
|
||||||
|
# Cependant, créer une nouvelle fonction qui supprime tous les caractères d'une
|
||||||
|
# contenus dans une liste serait plus approprié dans ce cas.
|
||||||
|
|
||||||
|
|
||||||
|
# Exercice Remplacement d’un caractère
|
||||||
|
|
||||||
|
# Réalisez une fonction qui remplace le caractère d’un indice donné d’une
|
||||||
|
# chaîne de caractères par une autre chaîne de caractères.
|
||||||
|
|
||||||
|
def remplace_indice(chaine, indice, remplacement):
|
||||||
|
"""
|
||||||
|
Remplace le caractère d’un indice donné d’une chaîne de caractères par une
|
||||||
|
autre chaîne de caractères.
|
||||||
|
(str, int, str) → str
|
||||||
|
CU : chaine de type str et indice de type int et remplacement de type str
|
||||||
|
|
||||||
|
>>> remplace_indice ('Timileon',3,'o')
|
||||||
|
'Timoleon'
|
||||||
|
>>> remplace_indice ('Tixleon',2,'mo')
|
||||||
|
'Timoleon'
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
assert(type(indice) is int), "indice doit être du type int"
|
||||||
|
assert(type(remplacement) is str), "remplacement doit être du type str"
|
||||||
|
|
||||||
|
return chaine[:indice] + remplacement + chaine[indice + 1:]
|
||||||
|
|
||||||
|
# Réalisez une fonction qui remplace dans une chaîne donnée toutes les
|
||||||
|
# occurences d’un caracère donné par une autre chaîne de caractères.
|
||||||
|
|
||||||
|
def remplace_occurrences(chaine, caractere, remplacement):
|
||||||
|
"""
|
||||||
|
Remplace dans une chaîne donnée toutes les occurences d’un caracère donné
|
||||||
|
par une autre chaîne de caractères.
|
||||||
|
(str, str, str) → str
|
||||||
|
CU : chaine de type str et caractere du type str et de taille 1 et
|
||||||
|
remplacement de type str
|
||||||
|
|
||||||
|
>>> remplace_occurrences ('@ 3 est le neveu de @ 1er.','@','Napoléon')
|
||||||
|
'Napoléon 3 est le neveu de Napoléon 1er.'
|
||||||
|
"""
|
||||||
|
assert(type(chaine) is str), "chaine doit être du type str"
|
||||||
|
assert(type(caractere) is str and len(caractere) == 1), \
|
||||||
|
"caractere doit être du type str et de taille 1"
|
||||||
|
assert(type(remplacement) is str), "remplacement doit être du type str"
|
||||||
|
|
||||||
|
retour = ''
|
||||||
|
for i in chaine:
|
||||||
|
if i == caractere:
|
||||||
|
retour += remplacement
|
||||||
|
else:
|
||||||
|
retour += i
|
||||||
|
return retour
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def tester():
|
||||||
|
doctest.testmod(verbose=True)
|