API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 15th, 2019
400
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.33 KB | None | 0 0
raw download clone embed print report
  1. {
  2. "cells": [
  3. {
  4. "cell_type": "markdown",
  5. "metadata": {},
  6. "source": [
  7. "%load_ext nb_black"
  8. ]
  9. },
  10. {
  11. "cell_type": "markdown",
  12. "metadata": {
  13. "editable": false
  14. },
  15. "source": [
  16. "# Types de variables\n",
  17. "\n",
  18. "Jusqu’alors, en mathématiques, tu n’as utilisé (sur ta calculatrice ou sur Algobox) que des\n",
  19. "variables de type « nombre ». Python distingue plusieurs types de variables, voici les\n",
  20. "principaux :\n",
  21. "## Le type *bool*\n",
  22. "Il sert à représenter les variables booléennes : une variable de type *bool* est une valeur\n",
  23. "logique et vaut *True* (vrai) ou *False* (faux).\n",
  24. "\n",
  25. "On peut d'abord *déclarer* la variable en donnant son type, à ce moment elle est initialisée avec une valeur par défaut."
  26. ]
  27. },
  28. {
  29. "cell_type": "code",
  30. "execution_count": null,
  31. "metadata": {
  32. "editable": false
  33. },
  34. "outputs": [],
  35. "source": [
  36. "a = bool() # déclare une variable de type bool\n",
  37. "print(a) # affiche la valeur par défaut de a"
  38. ]
  39. },
  40. {
  41. "cell_type": "markdown",
  42. "metadata": {
  43. "editable": false
  44. },
  45. "source": [
  46. "En général en Python, on déclare une variable en même temps qu'on lui affecte une valeur. Python détermine tout seul le type qui convient."
  47. ]
  48. },
  49. {
  50. "cell_type": "code",
  51. "execution_count": null,
  52. "metadata": {},
  53. "outputs": [],
  54. "source": [
  55. "b = True # on déclare b en même temps qu'on lui affecte une valeur\n",
  56. "print(b) # affiche la valeur de b"
  57. ]
  58. },
  59. {
  60. "cell_type": "markdown",
  61. "metadata": {},
  62. "source": [
  63. "<font color=red>À FAIRE :</font>\n",
  64. "\n",
  65. "Dans les 2 cellules suivantes, déclare une variable c de type *bool* qui vaut *True* et une variable d de type *bool* qui vaut *False*.\n",
  66. "\n",
  67. "Affiche les."
  68. ]
  69. },
  70. {
  71. "cell_type": "code",
  72. "execution_count": null,
  73. "metadata": {},
  74. "outputs": [],
  75. "source": []
  76. },
  77. {
  78. "cell_type": "code",
  79. "execution_count": null,
  80. "metadata": {},
  81. "outputs": [],
  82. "source": []
  83. },
  84. {
  85. "cell_type": "markdown",
  86. "metadata": {},
  87. "source": [
  88. "Les *bool* servent très souvent lorsqu’on veut tester si une condition est vraie ou non. (on\n",
  89. "y reviendra plus tard).\n",
  90. "\n",
  91. "Avec les *bool* , on dispose d’opérations logiques : *or* (ou), *and* (et) et *not* (non)."
  92. ]
  93. },
  94. {
  95. "cell_type": "code",
  96. "execution_count": null,
  97. "metadata": {},
  98. "outputs": [],
  99. "source": [
  100. "True and False"
  101. ]
  102. },
  103. {
  104. "cell_type": "code",
  105. "execution_count": null,
  106. "metadata": {},
  107. "outputs": [],
  108. "source": [
  109. "True or False"
  110. ]
  111. },
  112. {
  113. "cell_type": "code",
  114. "execution_count": null,
  115. "metadata": {},
  116. "outputs": [],
  117. "source": [
  118. "not a or b"
  119. ]
  120. },
  121. {
  122. "cell_type": "markdown",
  123. "metadata": {},
  124. "source": [
  125. "<font color=red>À FAIRE :</font>\n",
  126. "\n",
  127. "Evalue dans les 3 cellules suivantes ce que vaut *c or d*, *c and d*, *c and not d*."
  128. ]
  129. },
  130. {
  131. "cell_type": "code",
  132. "execution_count": null,
  133. "metadata": {},
  134. "outputs": [],
  135. "source": [
  136. "c or d"
  137. ]
  138. },
  139. {
  140. "cell_type": "code",
  141. "execution_count": null,
  142. "metadata": {},
  143. "outputs": [],
  144. "source": [
  145. "c and d"
  146. ]
  147. },
  148. {
  149. "cell_type": "code",
  150. "execution_count": null,
  151. "metadata": {},
  152. "outputs": [],
  153. "source": [
  154. "c and not d"
  155. ]
  156. },
  157. {
  158. "cell_type": "markdown",
  159. "metadata": {},
  160. "source": [
  161. "<font color=red>À FAIRE :</font>\n",
  162. "\n",
  163. "Evalue *not c and d* et ensuite *not(c and d)*.\n",
  164. "\n",
  165. "Que peux-tu en conclure ?"
  166. ]
  167. },
  168. {
  169. "cell_type": "code",
  170. "execution_count": null,
  171. "metadata": {},
  172. "outputs": [],
  173. "source": []
  174. },
  175. {
  176. "cell_type": "code",
  177. "execution_count": null,
  178. "metadata": {},
  179. "outputs": [],
  180. "source": []
  181. },
  182. {
  183. "cell_type": "raw",
  184. "metadata": {},
  185. "source": [
  186. "Conclusion:\n"
  187. ]
  188. },
  189. {
  190. "cell_type": "markdown",
  191. "metadata": {},
  192. "source": [
  193. "## Le type *int*\n",
  194. "\n",
  195. "Il sert à représenter les *entiers relatifs* (*integer* signifie « entier » en Anglais).\n",
  196. "\n",
  197. "Sur les *int* , on dispose des opérations + (addition), - (soustraction), * multiplication."
  198. ]
  199. },
  200. {
  201. "cell_type": "code",
  202. "execution_count": null,
  203. "metadata": {},
  204. "outputs": [],
  205. "source": [
  206. "a = int() # on peut déclarer la variable de type int sans l'initialiser\n",
  207. "print(a) # elle prend une valeur par défaut"
  208. ]
  209. },
  210. {
  211. "cell_type": "code",
  212. "execution_count": null,
  213. "metadata": {},
  214. "outputs": [],
  215. "source": [
  216. "b = 3 # déclare une variable b de type int qui vaut 3\n",
  217. "c = 2\n",
  218. "print(b + c) # évalue b+c puis affiche le résultat"
  219. ]
  220. },
  221. {
  222. "cell_type": "code",
  223. "execution_count": null,
  224. "metadata": {},
  225. "outputs": [],
  226. "source": [
  227. "d = 2 * b - c # évalue 2*b-c et puisque c'est un entier,\n",
  228. "# déclare d comme variable de type int\n",
  229. "# et lui affecte la valeur 2*b-c\n",
  230. "print(d)"
  231. ]
  232. },
  233. {
  234. "cell_type": "markdown",
  235. "metadata": {},
  236. "source": [
  237. "<font color=red>À FAIRE :</font>\n",
  238. "\n",
  239. "Déclare x qui vaut 2, y qui vaut -3 et z qui vaut 7, puis t qui vaut 2x+3y-6z et affiche sa valeur."
  240. ]
  241. },
  242. {
  243. "cell_type": "code",
  244. "execution_count": null,
  245. "metadata": {},
  246. "outputs": [],
  247. "source": []
  248. },
  249. {
  250. "cell_type": "markdown",
  251. "metadata": {},
  252. "source": [
  253. "On dispose également de deux opérations très pratiques : soient a et b deux *int* , et b non\n",
  254. "nul, alors on peut effectuer la *division euclidienne* de a par b .\n",
  255. "\n",
  256. "a//b est le quotient et a%b est le reste."
  257. ]
  258. },
  259. {
  260. "cell_type": "code",
  261. "execution_count": null,
  262. "metadata": {},
  263. "outputs": [],
  264. "source": [
  265. "print(64//10)"
  266. ]
  267. },
  268. {
  269. "cell_type": "code",
  270. "execution_count": null,
  271. "metadata": {},
  272. "outputs": [],
  273. "source": [
  274. "print(64%10)"
  275. ]
  276. },
  277. {
  278. "cell_type": "code",
  279. "execution_count": null,
  280. "metadata": {},
  281. "outputs": [],
  282. "source": [
  283. "print(23//7)"
  284. ]
  285. },
  286. {
  287. "cell_type": "code",
  288. "execution_count": null,
  289. "metadata": {},
  290. "outputs": [],
  291. "source": [
  292. "print(23%7)"
  293. ]
  294. },
  295. {
  296. "cell_type": "markdown",
  297. "metadata": {},
  298. "source": [
  299. "On dispose de l’opération d’*exponentiation* (opération puissance), notée ** .\n",
  300. "\n",
  301. "**Attention:** Cette opération peut produire un résultat non-entier, de type *float* (voir partie\n",
  302. "suivante)."
  303. ]
  304. },
  305. {
  306. "cell_type": "code",
  307. "execution_count": null,
  308. "metadata": {},
  309. "outputs": [],
  310. "source": [
  311. "print(2 ** 3)"
  312. ]
  313. },
  314. {
  315. "cell_type": "code",
  316. "execution_count": null,
  317. "metadata": {},
  318. "outputs": [],
  319. "source": [
  320. "print(10 ** 4)"
  321. ]
  322. },
  323. {
  324. "cell_type": "code",
  325. "execution_count": null,
  326. "metadata": {},
  327. "outputs": [],
  328. "source": [
  329. "print(2 **(-1)) # ici le résultat n'est pas un entier"
  330. ]
  331. },
  332. {
  333. "cell_type": "markdown",
  334. "metadata": {},
  335. "source": [
  336. "Pour finir, la division décimale peut être effectuée sur des entiers, mais elle renvoie un\n",
  337. "résultat de type *float*."
  338. ]
  339. },
  340. {
  341. "cell_type": "code",
  342. "execution_count": null,
  343. "metadata": {},
  344. "outputs": [],
  345. "source": [
  346. "print(4/2)"
  347. ]
  348. },
  349. {
  350. "cell_type": "code",
  351. "execution_count": null,
  352. "metadata": {},
  353. "outputs": [],
  354. "source": [
  355. "print(2/3)"
  356. ]
  357. },
  358. {
  359. "cell_type": "markdown",
  360. "metadata": {},
  361. "source": [
  362. "## Le type *float*\n",
  363. "\n",
  364. "Il sert à représenter les nombres à virgule flottante (*to float* : flotter en Anglais). Ce sont des nombres décimaux (pas tout à fait, on y reviendra plus tard).\n",
  365. "\n",
  366. "Python comprend et utilise la notation scientifique :\n",
  367. "2.35e6 vaut $2,35 \\times 10^6$ , c’est-à-dire 2 350 000."
  368. ]
  369. },
  370. {
  371. "cell_type": "code",
  372. "execution_count": null,
  373. "metadata": {},
  374. "outputs": [],
  375. "source": [
  376. "a = float() # un float est déclaré qui aura par défaut la valeur 0\n",
  377. "print(a)"
  378. ]
  379. },
  380. {
  381. "cell_type": "code",
  382. "execution_count": null,
  383. "metadata": {},
  384. "outputs": [],
  385. "source": [
  386. "b = 3/2 # Python évalue 3/2, voit que c'est un float, donc déclare b comme float valant... 3/2\n",
  387. "print(b)"
  388. ]
  389. },
  390. {
  391. "cell_type": "code",
  392. "execution_count": null,
  393. "metadata": {},
  394. "outputs": [],
  395. "source": [
  396. "c = 13.0 # si on écrit 13 tout court on aura un int\n",
  397. "print(c)"
  398. ]
  399. },
  400. {
  401. "cell_type": "code",
  402. "execution_count": null,
  403. "metadata": {},
  404. "outputs": [],
  405. "source": [
  406. "d = 1.2e-4 # idem mais avec une notation scientifique\n",
  407. "print(d)"
  408. ]
  409. },
  410. {
  411. "cell_type": "markdown",
  412. "metadata": {},
  413. "source": [
  414. "Pour les opérations plus compliquées (racine carrée, cosinus, logarithme etc) on fait appel au module *math* :"
  415. ]
  416. },
  417. {
  418. "cell_type": "code",
  419. "execution_count": null,
  420. "metadata": {},
  421. "outputs": [],
  422. "source": [
  423. "from math import sqrt # on importe la fonction sqrt depuis le module math\n",
  424. "# sqrt est la racine carrée (square root en Anglais)\n",
  425. "\n",
  426. "a = sqrt(65)\n",
  427. "print(a) # évidemment c'est une valeur qpprochée"
  428. ]
  429. },
  430. {
  431. "cell_type": "code",
  432. "execution_count": null,
  433. "metadata": {},
  434. "outputs": [],
  435. "source": [
  436. "print(pi) # Python ne connait pas pi"
  437. ]
  438. },
  439. {
  440. "cell_type": "code",
  441. "execution_count": null,
  442. "metadata": {},
  443. "outputs": [],
  444. "source": [
  445. "from math import pi # mais on peut le trouver dans le module math\n",
  446. "print(pi)"
  447. ]
  448. },
  449. {
  450. "cell_type": "code",
  451. "execution_count": null,
  452. "metadata": {},
  453. "outputs": [],
  454. "source": [
  455. "from math import * # permet d'importer TOUTES les fonctions du module math\n",
  456. "print(cos(pi/3))\n",
  457. "print(exp(log(2)))"
  458. ]
  459. },
  460. {
  461. "cell_type": "markdown",
  462. "metadata": {},
  463. "source": [
  464. "<font color=red>À FAIRE :</font>\n",
  465. "\n",
  466. "On veut calculer la norme du vecteur de l'espace de coordonnées $(11,16,8)$ :\n",
  467. "* déclarer 3 *float* x, y et z valant 11,16 et 8;\n",
  468. "* déclarer le *float* n tel que $$n=\\sqrt{x^2+y^2+z^2}$$ et afficher la valeur de n."
  469. ]
  470. },
  471. {
  472. "cell_type": "code",
  473. "execution_count": null,
  474. "metadata": {},
  475. "outputs": [],
  476. "source": []
  477. },
  478. {
  479. "cell_type": "markdown",
  480. "metadata": {},
  481. "source": [
  482. "# Le type *str*\n",
  483. "Il sert à représenter les chaînes de caractères ( *str* est l’abréviation de *string*, qui\n",
  484. "veut dire chaîne en anglais). des apostrophes, ou des guillemets)."
  485. ]
  486. },
  487. {
  488. "cell_type": "code",
  489. "execution_count": null,
  490. "metadata": {},
  491. "outputs": [],
  492. "source": [
  493. "a = str() # déclaration sans initialisation\n",
  494. "print(a) # a contient la chaîne vide"
  495. ]
  496. },
  497. {
  498. "cell_type": "code",
  499. "execution_count": null,
  500. "metadata": {},
  501. "outputs": [],
  502. "source": [
  503. "b = 'Bonjour'\n",
  504. "print(b)"
  505. ]
  506. },
  507. {
  508. "cell_type": "code",
  509. "execution_count": null,
  510. "metadata": {},
  511. "outputs": [],
  512. "source": [
  513. "b = 'J'aime Python' #déclenche une erreur"
  514. ]
  515. },
  516. {
  517. "cell_type": "code",
  518. "execution_count": null,
  519. "metadata": {},
  520. "outputs": [],
  521. "source": [
  522. "b=\"J'aime Python\" #est valide"
  523. ]
  524. },
  525. {
  526. "cell_type": "code",
  527. "execution_count": null,
  528. "metadata": {},
  529. "outputs": [],
  530. "source": [
  531. "b=\"\"\"J'aime qu'on m'appelle \"Le Roi du Python\".\"\"\" # dans les cas extrêmes\n",
  532. "print(b)"
  533. ]
  534. },
  535. {
  536. "cell_type": "markdown",
  537. "metadata": {},
  538. "source": [
  539. "On peut aussi utiliser le *symbole d'échappement* \\\\ (backslash en Anglais, accessible avec ALT GR+8) :"
  540. ]
  541. },
  542. {
  543. "cell_type": "code",
  544. "execution_count": null,
  545. "metadata": {},
  546. "outputs": [],
  547. "source": [
  548. "b='J\\'aime qu\\'on m\\'appelle \\\"Le Roi du Python\\\".'\n",
  549. "print(b)"
  550. ]
  551. },
  552. {
  553. "cell_type": "markdown",
  554. "metadata": {},
  555. "source": [
  556. "On peut additionner 2 variables de type *str* , on peut aussi multiplier une variable de type\n",
  557. "*str* par un *int*."
  558. ]
  559. },
  560. {
  561. "cell_type": "code",
  562. "execution_count": null,
  563. "metadata": {},
  564. "outputs": [],
  565. "source": [
  566. "a=\"to\"\n",
  567. "b=\"fu\"\n",
  568. "print(a+b)"
  569. ]
  570. },
  571. {
  572. "cell_type": "code",
  573. "execution_count": null,
  574. "metadata": {},
  575. "outputs": [],
  576. "source": [
  577. "print(b+a)"
  578. ]
  579. },
  580. {
  581. "cell_type": "code",
  582. "execution_count": null,
  583. "metadata": {},
  584. "outputs": [],
  585. "source": [
  586. "print(a*2+b*2)"
  587. ]
  588. },
  589. {
  590. "cell_type": "markdown",
  591. "metadata": {},
  592. "source": [
  593. "<font color=red>À FAIRE :</font>\n",
  594. "\n",
  595. "À l'aide des variables précédentes, comment afficher tototofutotofutotofufu de manière simple ?"
  596. ]
  597. },
  598. {
  599. "cell_type": "code",
  600. "execution_count": null,
  601. "metadata": {},
  602. "outputs": [],
  603. "source": []
  604. },
  605. {
  606. "cell_type": "markdown",
  607. "metadata": {},
  608. "source": [
  609. "On peut accèder à chaque caractère d'une variable de type *str*:"
  610. ]
  611. },
  612. {
  613. "cell_type": "code",
  614. "execution_count": null,
  615. "metadata": {},
  616. "outputs": [],
  617. "source": [
  618. "chaine = 'Bonjour!'\n",
  619. "print(chaine[0])\n",
  620. "print(chaine[5])"
  621. ]
  622. },
  623. {
  624. "cell_type": "markdown",
  625. "metadata": {},
  626. "source": [
  627. "Voici comment Python représente la chaîne précédente :\n",
  628. "\n",
  629. "|i |0|1|2|3|4|5|6|7|\n",
  630. "|------------|-|-|-|-|-|-|-|-|\n",
  631. "|chaine\\[i\\] |B|o|n|j|o|u|r|!|\n",
  632. "\n",
  633. "Les espaces comptent aussi pour un caractère.\n",
  634. "\n",
  635. "Il faut remarquer que **l'indexation commence à 0 et non à 1**.\n",
  636. "\n",
  637. "On a parfois besoin de connaître la longueur (*length* en Anglais) d'une chaîne :"
  638. ]
  639. },
  640. {
  641. "cell_type": "code",
  642. "execution_count": null,
  643. "metadata": {},
  644. "outputs": [],
  645. "source": [
  646. "ma_chaine=\"Salut ça va ?\"\n",
  647. "print(len(ma_chaine))"
  648. ]
  649. },
  650. {
  651. "cell_type": "markdown",
  652. "metadata": {},
  653. "source": [
  654. "Enfin on peut accéder directement au dernier (ou à l'avant dernier) caractère d'une variable de type *str* :"
  655. ]
  656. },
  657. {
  658. "cell_type": "code",
  659. "execution_count": null,
  660. "metadata": {},
  661. "outputs": [],
  662. "source": [
  663. "ma_chaine=\"M'enfin ?!\"\n",
  664. "print(ma_chaine[-1])\n",
  665. "print(ma_chaine[-2])"
  666. ]
  667. },
  668. {
  669. "cell_type": "markdown",
  670. "metadata": {},
  671. "source": [
  672. "Enfin on peut vouloir extraire une sous-chaîne d’une chaine : \n",
  673. ">chaine\\[p :q\\] renvoie la sous-chaine de caractère qui commence par chaine\\[p\\] et qui se termine par chaine\\[q-1\\] :"
  674. ]
  675. },
  676. {
  677. "cell_type": "code",
  678. "execution_count": null,
  679. "metadata": {},
  680. "outputs": [],
  681. "source": [
  682. "ma_chaine=\"Salut la compagnie !\"\n",
  683. "print(ma_chaine[1:4]) # affiche la chaine qui commence au caractère d'indice 1 jusqu'à celui d'indice 4 exclu, donc d'indice 3\n"
  684. ]
  685. },
  686. {
  687. "cell_type": "markdown",
  688. "metadata": {},
  689. "source": [
  690. "<font color=red>À FAIRE :</font>\n",
  691. "\n",
  692. "Inspire-toi de l'exemple précédent pour afficher \"RSTUV\"."
  693. ]
  694. },
  695. {
  696. "cell_type": "code",
  697. "execution_count": null,
  698. "metadata": {},
  699. "outputs": [],
  700. "source": [
  701. "ma_chaine=\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\" #à toi de jouer\n"
  702. ]
  703. },
  704. {
  705. "cell_type": "markdown",
  706. "metadata": {},
  707. "source": [
  708. "Deux derniers \"trucs\" : pour obtenir la chaîne qui commence au début, pas besoin de préciser le 0."
  709. ]
  710. },
  711. {
  712. "cell_type": "code",
  713. "execution_count": 4,
  714. "metadata": {},
  715. "outputs": [
  716. {
  717. "name": "stdout",
  718. "output_type": "stream",
  719. "text": [
  720. "Salu\n"
  721. ]
  722. }
  723. ],
  724. "source": [
  725. "ma_chaine=\"Salut à tous !\"\n",
  726. "print(ma_chaine[:4]) #affiche la chaine du caractère 0 au caractère 3\n",
  727. "# équivaut à ma_chaine[0:4]"
  728. ]
  729. },
  730. {
  731. "cell_type": "markdown",
  732. "metadata": {},
  733. "source": [
  734. "Encore mieux : pour obtenir une chaîne qui se termine à la fin de la chaîne de départ, pas besoin de préciser l'indice du caractère de fin."
  735. ]
  736. },
  737. {
  738. "cell_type": "code",
  739. "execution_count": 5,
  740. "metadata": {},
  741. "outputs": [
  742. {
  743. "name": "stdout",
  744. "output_type": "stream",
  745. "text": [
  746. "t à tous !\n"
  747. ]
  748. }
  749. ],
  750. "source": [
  751. "print(ma_chaine[4:]) #affiche la chaine qui commence au caractère d'indice 4.\n",
  752. "# équivaut à print(ma_chaine[4:len(ma_chaine)]) ... ouf, c'est plus rapide."
  753. ]
  754. },
  755. {
  756. "cell_type": "markdown",
  757. "metadata": {},
  758. "source": [
  759. "## Le type *list*\n",
  760. "Il représente des *listes ordonnées* dont les éléments sont indexés par 0, 1,2 etc.\n",
  761. "Si a est une variable de type *list*, on accède aux éléments de a avec a\\[0\\], a\\[1\\], comme avec les *str*.\n"
  762. ]
  763. },
  764. {
  765. "cell_type": "code",
  766. "execution_count": null,
  767. "metadata": {},
  768. "outputs": [],
  769. "source": [
  770. "ma_liste=list()\n",
  771. "print(ma_liste) # on va afficher une liste vide."
  772. ]
  773. },
  774. {
  775. "cell_type": "code",
  776. "execution_count": null,
  777. "metadata": {},
  778. "outputs": [],
  779. "source": [
  780. "print(ma_liste[0]) # va produire une erreur car IL N'Y A PAS d'élémént d'indice 0"
  781. ]
  782. },
  783. {
  784. "cell_type": "code",
  785. "execution_count": null,
  786. "metadata": {},
  787. "outputs": [],
  788. "source": [
  789. "ma_liste[0]=2 # pas possible de créer un élément à la volée non plus"
  790. ]
  791. },
  792. {
  793. "cell_type": "code",
  794. "execution_count": null,
  795. "metadata": {},
  796. "outputs": [],
  797. "source": [
  798. "ma_liste=[20,18,14,16] #voilà comment faire pour définir une liste, avec des crochets"
  799. ]
  800. },
  801. {
  802. "cell_type": "code",
  803. "execution_count": null,
  804. "metadata": {},
  805. "outputs": [],
  806. "source": [
  807. "print(ma_liste[0])"
  808. ]
  809. },
  810. {
  811. "cell_type": "markdown",
  812. "metadata": {},
  813. "source": [
  814. "On peut mettre ce que l'on veut dans une liste, y compris des éléments de types différents :"
  815. ]
  816. },
  817. {
  818. "cell_type": "code",
  819. "execution_count": null,
  820. "metadata": {},
  821. "outputs": [],
  822. "source": [
  823. "ma_liste=[20, 3/4, \"stylo\", True]"
  824. ]
  825. },
  826. {
  827. "cell_type": "code",
  828. "execution_count": null,
  829. "metadata": {},
  830. "outputs": [],
  831. "source": [
  832. "ma_liste=[[1, 2, 3], [11, 12, 13]] # une liste à 2 éléments, chacun étant une liste à 3 éléments !"
  833. ]
  834. },
  835. {
  836. "cell_type": "markdown",
  837. "metadata": {},
  838. "source": [
  839. "L'exemple précédent est très courant, il sert à représenter un \"tableau de nombres à deux dimensions\" (en mathématique cela correspond à une *matrice*) :\n",
  840. "\n",
  841. "$$\\left(\n",
  842. "\\begin{matrix} \n",
  843. "1 & 2 & 3\\\\\n",
  844. "11 & 12 &13\\\\ \n",
  845. "\\end{matrix}\\right)$$"
  846. ]
  847. },
  848. {
  849. "cell_type": "markdown",
  850. "metadata": {},
  851. "source": [
  852. "Tout comme avec les *str* on peut ajouter des listes et les multiplier par un *int*.\n",
  853. "\n",
  854. "On reviendra plus tard sur ce type très utile."
  855. ]
  856. },
  857. {
  858. "cell_type": "markdown",
  859. "metadata": {},
  860. "source": [
  861. "## Le type *dict*"
  862. ]
  863. },
  864. {
  865. "cell_type": "markdown",
  866. "metadata": {},
  867. "source": [
  868. "C'est l'abréviation de *dictionary* (dictionnaire en Français).\n",
  869. "\n",
  870. "Un *dict* est une correspondance *clé-valeur*. Les clés doivent cependant être uniques."
  871. ]
  872. },
  873. {
  874. "cell_type": "code",
  875. "execution_count": null,
  876. "metadata": {},
  877. "outputs": [],
  878. "source": [
  879. "nombre_de_pattes = {\"homme\":2,\"chien\":4,\"loup\":4,\"abeille\":6} # les accolades servent à définir des dict\n",
  880. "print(nombre_de_pattes[\"chien\"])"
  881. ]
  882. },
  883. {
  884. "cell_type": "markdown",
  885. "metadata": {},
  886. "source": [
  887. "Contrairement aux listes, on peut créer des couples *clé-valeur* à la volée :"
  888. ]
  889. },
  890. {
  891. "cell_type": "code",
  892. "execution_count": null,
  893. "metadata": {},
  894. "outputs": [],
  895. "source": [
  896. "nombre_de_pattes[\"araignée\"]=8"
  897. ]
  898. },
  899. {
  900. "cell_type": "markdown",
  901. "metadata": {},
  902. "source": [
  903. "Ce qu'il faut savoir pour l'instant c'est que la notion de dictionnaire est compliquée (enfin, surtout au début) mais très puissante.\n",
  904. "## La fonction *type* et les conversions de types\n",
  905. "Pour connaître (ou vérifier) le type d'une variable on peut utiliser la fonction *type* :"
  906. ]
  907. },
  908. {
  909. "cell_type": "code",
  910. "execution_count": null,
  911. "metadata": {},
  912. "outputs": [],
  913. "source": [
  914. "a = 2\n",
  915. "print(type(a))"
  916. ]
  917. },
  918. {
  919. "cell_type": "code",
  920. "execution_count": null,
  921. "metadata": {},
  922. "outputs": [],
  923. "source": [
  924. "b=\"salut\"\n",
  925. "print(type(b))"
  926. ]
  927. },
  928. {
  929. "cell_type": "code",
  930. "execution_count": null,
  931. "metadata": {},
  932. "outputs": [],
  933. "source": [
  934. "c=[2,3,4]\n",
  935. "print(type(c))"
  936. ]
  937. },
  938. {
  939. "cell_type": "markdown",
  940. "metadata": {},
  941. "source": [
  942. "On peut parfois convertir une variable en une variable d'un autre type. Cela s'appelle le *transtypage* :"
  943. ]
  944. },
  945. {
  946. "cell_type": "code",
  947. "execution_count": null,
  948. "metadata": {},
  949. "outputs": [],
  950. "source": [
  951. "a=2016\n",
  952. "print(type(a))"
  953. ]
  954. },
  955. {
  956. "cell_type": "code",
  957. "execution_count": null,
  958. "metadata": {},
  959. "outputs": [],
  960. "source": [
  961. "b = float(a) # convertit un int en float\n",
  962. "print(b)"
  963. ]
  964. },
  965. {
  966. "cell_type": "code",
  967. "execution_count": null,
  968. "metadata": {},
  969. "outputs": [],
  970. "source": [
  971. "c = str(a) # convertit un int en float\n",
  972. "d=\" Super année !\"\n",
  973. "print(c+d) "
  974. ]
  975. },
  976. {
  977. "cell_type": "markdown",
  978. "metadata": {},
  979. "source": [
  980. "Cela peut avoir un intérêt car (entre autres) on ne peut pas toujours ajouter deux variables si elles n'ont pas le même type."
  981. ]
  982. },
  983. {
  984. "cell_type": "markdown",
  985. "metadata": {},
  986. "source": [
  987. "<font color=red>À FAIRE :</font>\n",
  988. "\n",
  989. "Rectifie le code de la cellule suivante à l'aide de la fonction *type*."
  990. ]
  991. },
  992. {
  993. "cell_type": "code",
  994. "execution_count": null,
  995. "metadata": {},
  996. "outputs": [],
  997. "source": [
  998. "debut =\"Dans Stranger Things, la fille aux super-pouvoirs s'appelle : \"\n",
  999. "fin = 11\n",
  1000. "print(debut+fin)"
  1001. ]
  1002. },
  1003. {
  1004. "cell_type": "markdown",
  1005. "metadata": {},
  1006. "source": [
  1007. "## Exercices"
  1008. ]
  1009. },
  1010. {
  1011. "cell_type": "markdown",
  1012. "metadata": {},
  1013. "source": [
  1014. "### Ex1 : affectations\n",
  1015. "\n",
  1016. "Que fait le script suivant ? (ne pas chercher à l'exécuter)\n",
  1017. "\n",
  1018. "a = 1\n",
  1019. "\n",
  1020. "b = a + 1\n",
  1021. "\n",
  1022. "c = 2 * b − ( a + b − 4)\n",
  1023. "\n",
  1024. "print(b)\n",
  1025. "\n",
  1026. "print(c)"
  1027. ]
  1028. },
  1029. {
  1030. "cell_type": "raw",
  1031. "metadata": {},
  1032. "source": [
  1033. "Réponse :\n"
  1034. ]
  1035. },
  1036. {
  1037. "cell_type": "markdown",
  1038. "metadata": {},
  1039. "source": [
  1040. "Quels sont les types des variables a, b et c ?"
  1041. ]
  1042. },
  1043. {
  1044. "cell_type": "raw",
  1045. "metadata": {},
  1046. "source": [
  1047. "Réponse : \n"
  1048. ]
  1049. },
  1050. {
  1051. "cell_type": "markdown",
  1052. "metadata": {},
  1053. "source": [
  1054. "### Ex2 : définition d'un *float*\n",
  1055. "Donne 3 manières de définir un *float* valant 2."
  1056. ]
  1057. },
  1058. {
  1059. "cell_type": "code",
  1060. "execution_count": null,
  1061. "metadata": {},
  1062. "outputs": [],
  1063. "source": []
  1064. },
  1065. {
  1066. "cell_type": "code",
  1067. "execution_count": null,
  1068. "metadata": {},
  1069. "outputs": [],
  1070. "source": []
  1071. },
  1072. {
  1073. "cell_type": "code",
  1074. "execution_count": null,
  1075. "metadata": {},
  1076. "outputs": [],
  1077. "source": []
  1078. },
  1079. {
  1080. "cell_type": "markdown",
  1081. "metadata": {},
  1082. "source": []
  1083. },
  1084. {
  1085. "cell_type": "markdown",
  1086. "metadata": {},
  1087. "source": [
  1088. "### Ex3 : des histoires de *str*\n",
  1089. "\n",
  1090. "Qu'affiche le script suivant ?\n",
  1091. "\n",
  1092. "a='ko'\n",
  1093. "\n",
  1094. "b='ka'\n",
  1095. "\n",
  1096. "c= 'la'\n",
  1097. "\n",
  1098. "print(a+b+a+c)"
  1099. ]
  1100. },
  1101. {
  1102. "cell_type": "raw",
  1103. "metadata": {},
  1104. "source": [
  1105. "Réponse :"
  1106. ]
  1107. },
  1108. {
  1109. "cell_type": "markdown",
  1110. "metadata": {},
  1111. "source": [
  1112. "### Ex4 : encore une histoire de *str*\n",
  1113. "\n",
  1114. "Qu'affiche le script suivant ?\n",
  1115. "\n",
  1116. "a=\"pincemi pincemoi\"\n",
  1117. "\n",
  1118. "b=a\\[:8\\] + \"et \" + a\\[8:\\]\n",
  1119. "\n",
  1120. "print(b)"
  1121. ]
  1122. },
  1123. {
  1124. "cell_type": "raw",
  1125. "metadata": {},
  1126. "source": [
  1127. "Réponse :"
  1128. ]
  1129. }
  1130. ],
  1131. "metadata": {
  1132. "kernelspec": {
  1133. "display_name": "Python 3",
  1134. "language": "python",
  1135. "name": "python3"
  1136. },
  1137. "language_info": {
  1138. "codemirror_mode": {
  1139. "name": "ipython",
  1140. "version": 3
  1141. },
  1142. "file_extension": ".py",
  1143. "mimetype": "text/x-python",
  1144. "name": "python",
  1145. "nbconvert_exporter": "python",
  1146. "pygments_lexer": "ipython3",
  1147. "version": "3.7.3"
  1148. }
  1149. },
  1150. "nbformat": 4,
  1151. "nbformat_minor": 2
  1152. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!