---
# System prepended metadata

title: CHAP 2 TP 2

---

# CHAP 2 TP 2

Écrire une fonction inverse_dictionnaire qui prend en paramètre un dictionnaire et inverse ses clés et ses valeurs. Appliquer ce dictionnaire à l’exercice des capitales.

## version 1 :
```python = 
def inverse_dictionnaire(dico):
    resultat = {}
    for i in dico:
        resultat[dico[i]] = i 
    return resultat
```
## version 2 : 
```python = 
def inverse_dictionnaire2(dico):
    resultat = dict() 
    for cle,val in dico.items(): 
        resultat[val]=cle 
    return resultat
```
## version 3 :
```python = 
def inverse_dictionnaire3(dico):
    return {val:cle for cle,val in dico.items() }
```
On définit une carte comme un tuple (valeur, couleur). valeur prend pour valeur un entier entre 2 et 14, où 11 représente le Valet et l’14 l’As. couleur est un chaîne de caractères parmi “Pique“, “Coeur“, “Carreau“, “Trèfle“.

Écrire une fonction carte_valide qui prend un tuple en paramètre et retourne un booléen qui indique s’il représente une carte valide.
Écrire une fonction nom_carte qui prend un tuple représentant une carte en paramètre et retourne une chaîne de caractère avec le nom de la carte. Par exemple : “As de trèfle“ ou “7 de Pique“.
Écrire un programme qui crée un tableau contenant toutes les cartes d’un jeu de 52 cartes.
À l’aide de la fonction random() de la bibliothèque random tirer une carte au hasard dans le tableau et afficher son nom.

``` python =
def carte_valide(carte):
    couleurs = ["Pique", "Coeur","Carreau", "Trèfle"]
    if type(carte[0]) == int and type(carte[1]) == str:
        if carte[0] > 1 and carte[0] < 15 and carte[1] in couleurs:
            return True
        else : 
            return False 
    else : 
        return False
print(carte_valide((5,"Pique")))
print(carte_valide((1, "Toto")))
print(carte_valide(("Titi", "Toto")))
``` 

# version 1
``` python =
def nom_carte(carte):
    valeurs = {14 : "AS", 2 : "2", 3 : "3",
        4 : "4", 5 : "5", 6: "6", 7 : "7",
        9 : "9", 10 : "10", 11 : "Valet",
        8 : "8", 12 : "Dame", 13 : "Roi"
    }
    return valeurs[carte[0]] +" de "+ carte[1]
def nom_carte2(carte):
    valeurs = {14 : "AS",  11 : "Valet", 
    12 : "Dame", 13 : "Roi"
    }
    if carte[0] >= 2 and carte[0]<= 10:
        return str(carte[0]) +" de "+ carte[1]
    else : 
        return valeurs[carte[0]] +" de "+ carte[1]    ```
# test 
``` python =<
print(nom_carte((14,"Pique")))
print(nom_carte2((14,"Pique")))
```
``` python =
def tirage_aleatoire():
    jeu = jeux_cartes()
    index_carte = randint(1,52)
    return jeu[index_carte]
print(tirage_aleatoire())

def jeux_cartes():
    couleurs = ["Pique", "Coeur","Carreau", "Trèfle"]
    liste_cartes = []
    for i in couleurs:
        for j in range(2,15):
            liste_cartes.append(nom_carte((j,i)))
            # autre possibilité : 
            # liste_cartes += [nom_carte((j,i)]
            
    return liste_cartes
print(jeux_cartes())
```




# programme principal : 
## test fonction inverse_dictionnaire
```python = 
capitales = {"France": "Paris", "Italie": "Rome"}
```
### version 1 
```python = 
print(inverse_dictionnaire(capitales))
```
### version 2 
```python = 
print(inverse_dictionnaire2(capitales))
```
### version 3 
```python = 
print(inverse_dictionnaire3(capitales))
```


