Exercice 1.2 du Poly

  |   Source

a) Arithmétique de base

In [2]:
3 + 25 * 2
Out[2]:
53
  /      [code python]

Python respecte les ordres de priorité sur les opérations arithmétiques : inutile de de parenthéser en 3 + (25 * 2)

In [2]:
23/4
Out[2]:
5
  /      [code python]

La division entre entiers est par défaut la division euclidienne.

Rappel : pour la divison réelle, placer un point décimal sur l'un des deux entiers pour le déclarer comme un flottant :

In [3]:
23./4  ,   23/4.
Out[3]:
(5.75, 5.75)
  /      [code python]
In [4]:
23.//4 # Le quotient de la division euclidienne
Out[4]:
5.0
  /      [code python]
In [5]:
23 % 4
Out[5]:
3
  /      [code python]

On obtient le reste de la division euclidienne. En effet : $23 = 5 \times 4 + 3$

In [6]:
2**100
Out[6]:
1267650600228229401496703205376L
  /      [code python]

C'est $2^{100}$ : on obtient un nombre à 31 chiffres (j'ai compté !) qui se termine par un L : abréviation de large integer (grand entier).

Si on veut demander à Python le nombre de chiffres, on peut p.ex :

  1. Convertir ce nombre en chaîne de caractères avec str()
  2. Calculer la longueur de la chaîne avec len().

Ce qui donne :

In [7]:
len(str(2**100))
Out[7]:
31
  /      [code python]

Problème : m'affiche-t-il la valeur approchée ou la valeur exacte ?

Question subsidiaire : combien de chiffres y a-t-il dans l'écriture de $2^{100}$ ?

Réponse : Les nombres à $n$ chiffres sont les nombres $x$ vérifiant l'encadrement suivant : \[10^{n-1} \le x < 10^n. \]

Ainsi on cherche l'entier $n$ tel que : \[ 10^{n-1} \le 2^{100} < 10^n. \]

En passant aux $\log_{10}$ : \[n- 1 \le 100 \log_{10} (2) < n. \]

En ajoutant $1$ membre à membre : \[ n \le 100 \log_{10} (2) +1 < n+1. \]

Mais je ne sais pas combien vaut $100 \log_{10} (2)$. Il me faudrait une calculette. Attends ! J'ai Pyhton qui est fait pour ça. Demandons donc à Python combien vaut $ 100 \log_{10} (2)$ :

In [8]:
from math import log10
100*log10(2)
Out[8]:
30.10299956639812
  /      [code python]

Finalement, $n$ est l'entier tel que $n \le 31,1 < n+1$.

Conclusion : $2^{100}$ a 31 chiffres.

Remarque (exo de spé math) : Vérifier que $2^{100}$ se termine par un $6$.

Comme Python nous a dit : $2^{100}=$1 267 650 600 228 229 401 496 703 205 376, on peut penser qu'il nous donne la valeur exacte de $2^{100}$

b) Représentation des flottants

In [9]:
2.6-3.3*2.0
Out[9]:
-3.9999999999999996
  /      [code python]

On devrait trouver -4. Attention aux problèmes de représentation des flottants : dans la machine, les nombres ne sont pas codés en base 10, mais en base 2 (en binaire).

In [10]:
2.6-3.3*2.0 == -4.0 # je demande à Python si ces deux nombres sont égaux.
Out[10]:
False
  /      [code python]

Python considère ces deux flottants comme distincts !

c) Chaînes de caractères

In [11]:
"bon" + "jour"
Out[11]:
'bonjour'
  /      [code python]

Les chaînes de caractères sont délimitées par des guillemets. Le + n'est pas l'addition ici mais la concaténation de deux chaînes.

In [12]:
"J'en veux " + 3

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-12-e235c5b9395f> in <module>()
----> 1 "J'en veux " + 3

TypeError: cannot concatenate 'str' and 'int' objects
  /      [code python]

Problème de type : Le + coordonne obligatoirement deux objets de même type. Or ici le premier est une chaîne et le second un entier. Si on veut rectifier :

In [13]:
"J'en veux " + "3" # Correction
Out[13]:
"J'en veux 3"
  /      [code python]
In [14]:
"Dis \"bonjour\". "
Out[14]:
'Dis "bonjour". '
  /      [code python]

Rappel : le backslash a servi à échapper les guillemets de leur rôle de délimiteur de chaînes de caractères. Il peuvent ainsi jouer leur rôle naturel de guillemets.

In [15]:
"Ca marche " + pas

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-15-47735f0bb249> in <module>()
----> 1 "Ca marche " + pas

NameError: name 'pas' is not defined
  /      [code python]

ici, pas est compris comme le nom d'une variable (c'est un appel de variable). Or on n'a jamais créé de variable pas

In [16]:
 "Ca marche " + "pas" # Correction
Out[16]:
'Ca marche pas'
  /      [code python]
In [17]:
"ha " * 3      +       "!"
Out[17]:
'ha ha ha !'
  /      [code python]

Python concatène deux chaînes :

  1. la chaîne "!" et la chaîne "ha " * 3
  2. la chaîne "ha " * 3 est la chaîne "ha " concaténée 3 fois avec elle-même.
In [18]:
"dom" * "mage"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-18-46c2d62d86b8> in <module>()
----> 1 "dom" * "mage"

TypeError: can't multiply sequence by non-int of type 'str'
  /      [code python]

On ne peut pas multiplier deux chaînes de caractères : on sait seulement les concaténer par un + ou les répliquer par un * mais dans ce dernier cas, Python aurait dû trouver un entier au lieu de la chaîne de caractères "mage".

d) Expressions logiques

In [19]:
1 + 1 = 2

  File "<ipython-input-19-8b405997bb2f>", line 1
    1 + 1 = 2
SyntaxError: can't assign to operator
  /      [code python]

Le symbole = sert à assigner une valeur à une variable. En l'occurrence, c'est assigner la valeur 2 à une variable qu'on appelle : 1 + 1. Ce nom est interdit.

Rappel. Dans une initialisation/affectation de variables, le nom de la variable est toujours à gauche du =

In [20]:
1 + 1 == 2 # On demande à  Python si il est vrai que 1+1 = 2 (c'est un test logique et pas une affectation)
Out[20]:
True
  /      [code python]
In [21]:
2 + 2 == 4 # C'est encore un test logique. Le résultat d'un test logique est toujours : soit vrai soit faux
Out[21]:
True
  /      [code python]
In [22]:
2 + 2 <= 3
Out[22]:
False
  /      [code python]

La réponse est faux : on sait que c'est un test logique. Le symbole <= siginifie : $\le$

In [23]:
0 != 1 and 7 < 5
Out[23]:
False
  /      [code python]

Le symbole != signifie $\neq$. L'instruction teste si il est vrai que $0 \neq 1$ et $7<5$

In [24]:
0 == 1 or 7 >= 5 # le symbole >= signfie supérieur ou égal
Out[24]:
True
  /      [code python]
In [25]:
not (3.0 == 3)
Out[25]:
False
  /      [code python]

not signifie : la négation de ou le contraire de. D'après le principe logique du tiers exclu, une assertion et son contraire ne peuvent être simultanément vrai. Comme toute assertion ne peut être que vrai ou fausse, la négation d'une assertion vraie est obligatoirement fausse.

In [26]:
True or uohstuihsrt
Out[26]:
True
  /      [code python]

Le mot true n'est pas reconnu par Python. Comme un ou est vrai dès que l'une de ses options est vraie; Python (qui est paresseux) s'arrête de lire la suite puisqu'il a rencontré un vrai

In [27]:
uohstuihsrt or True

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-27-a777efddb92a> in <module>()
----> 1 uohstuihsrt or True

NameError: name 'uohstuihsrt' is not defined
  /      [code python]

En revanche,dans ce dernier cas, Python commence par analyser le premier terme uohstuihsrt. Cette fois, Python est coincé car une variable avec un tel nom (à coucher dehors d'ailleurs) n'a jamais été créé.

e) Conversion de types

In [28]:
int(14.3)
Out[28]:
14
  /      [code python]

C'est la troncature entière. À ne pas confondre avec la partie entière.

In [29]:
int(-14.3)
Out[29]:
-14
  /      [code python]
In [30]:
float(12)
Out[30]:
12.0
  /      [code python]

Convertit un entier en floattant (changement de type)

In [31]:
str(147)
Out[31]:
'147'
  /      [code python]

Convertit un entier en chaîne de caractères.

Comments powered by Disqus
Partager