瀏覽代碼

integrate two fragments

master
Dimitri Merejkowsky 5 年之前
父節點
當前提交
9cf509ded8
共有 1 個檔案被更改,包括 175 行新增1 行删除
  1. +175
    -1
      sessions/python-05.md

+ 175
- 1
sessions/python-05.md 查看文件

@@ -334,4 +334,178 @@ def main():

#

\center \huge Compléments
\center \huge Compléments - tris


# sort() - ordre naturel

```python
>>> nombres = [2, 3, 1, 5]
>>> nombres.sort()
>>> nombres
[1, 2, 3, 5]
```

Notez que la liste est modifiée *sur place*.

# sort() - ordre alphabétique

```python
>>> mots = ["abeille", "faucon", "chat"]
>>> mots.sort()
>>> mots
['abeille', 'chat', 'faucon']
```

# sort() - ordre lexicographique

Pour chaque "liste-élément" on compare le premier élément.
S'il y a égalité, on regarde le deuxième élément, etc:

```python
>>> composite = [["chat", 1], ["abeille", 2], ["chat", 3]]
>>> composite.sort()
>>> composite
[['abeille', 2], ['chat', 1], ['chat', 3]]
```

L'ordre alphabétique est l'ordre lexicographique pour les chaînes de caractères :)

# Attention!

Tous les éléments de la liste doivent être comparables deux à deux:

\vfill

```python
>>> mauvaise_liste = ["un", 2]
>>> mauvaise_liste.sort()
TypeError
```


# Comparer autrement

Exemple: trier les mots par leur taille avec l'argument `key`

\vfill

```python
def taille(mot):
return len(mot)

mots = ["chat", "abeille", "faucon"]
mots.sort(key=taille)
>>> mots
["chat", "faucon", "abeille"]
```

# Lambda

Sert définir une fonction sans utiliser `def`

```python
>>> retourne_42 = lambda: 42 # pas d'argument
>>> retourne_42()
42
>>> ajoute_deux = lambda x: x + 2 # un seul argument
>>> ajoute_deux(3)
5
>>> multiplie = lambda x, y: x* y # deux arguments
>>> multiplie(2, 3)
6
```
Note: le corps de la fonction doit tenir en une seule ligne

# Utilisation avec sort

```python
>>> mots = ["chat", "abeille", "faucon"]
>>> mots.sort(key=lambda x: len(x))
>>> mots
["chat", "faucon", "abeille"]
```


# sorted()

```python
b = a.copy()
b.sort()

# or
b = sorted(a)
```


\center \huge Compléments - fichiers


# Rappel: lire

```python
file = open("toto.txt", "r") # 'r' comme 'read'
contenu = file.read()
file.close()
```

Note: le fichier `toto.txt` doit exister!

# Écrire

On peut écrire tout le contenu d'un coup:

```python
contenu = "du texte à sauvegarder"
file = open("article.txt", "w") # 'w' comme 'write'
file.write(contenu)
file.close()
```


* Le fichier `article.txt` sera écrasé s'il existe déjà.
* N'oubliez surtout pas d'appeler `close()`

# Que faire en cas d'erreur ?

```python
file = open("article.txt", "w") # 'w' comme 'write'
# ... beacoup de code ici
# ... < une erreur
file.close()
```

S'il y a une erreur entre `open()` et `close()`, le fichier ne sera pas fermé!


# Le mot-clé with

```python
with open("toto.txt", "w") as file:
file.write("du texte")
```

Quand on sort du bloc `with` on a la garantie que `file.close()` sera appelé,
*même* si on sort du bloc à cause d'une erreur.

# Convention

Il n'y a maintenant plus aucune raison d'appeler `.close()` "à la main",
donc ne le faites pas ...

# Lire et écrire des lignes

Très courant:

```python
with open("toto.txt", "r") as file:
lignes = file.readlines()

# faire quelque chose avec la liste de lignes

with open("toto.txt", "w") as file:
file.writelines(lignes)
```

Pensez à fermer le premier fichier avant d'ouvrir le second.
(ça marche même s'ils ont le même nom)