Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
Ce dépôt est archivé. Vous pouvez voir les fichiers et le cloner, mais vous ne pouvez pas pousser ni ouvrir de ticket/demande d'ajout.

python-14.md 3.5 KiB

il y a 5 ans
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173
  1. % Programmation avec Python (chapitre 14)
  2. % Dimitri Merejkowsky
  3. \center \huge Parlons de binaire
  4. # Bits et octets
  5. * Un bit (*bit* en anglais) c'est la valeur 1 ou 0
  6. * Un octet (*byte* en anglais) c'est une suite de 8 bits
  7. # À retenir
  8. **Ces paquets de 8 ne veulent rien dire en eux-mêmes**.
  9. Ils n'ont de sens que dans le cadre d'une *convention*.
  10. Détaillons.
  11. # Bases
  12. On peut *interpréter* bits et octets comme des nombres
  13. ```
  14. 2: 01 5 101 1*4 + 0*2 + 1*1
  15. 10: 0..9 305 305 3*10 + 0*10 + 5*1
  16. 16: 0..9..F 3490 DA2 (d=13)*256 + (a=10)*16 + 2*1
  17. ```
  18. # Bases en Python
  19. ```python
  20. >>> 0b101
  21. 5
  22. >>> 0xda2
  23. 3490
  24. ```
  25. ```python
  26. >>> bin(5)
  27. "0b101"
  28. >>> hex(3490)
  29. "0xda2"
  30. ```
  31. # Manipuler des octets en Python
  32. Avec `bytearray` par exemple:
  33. ```python
  34. data = bytearray(
  35. [0b1100001,
  36. 0b1100010,
  37. 0b1100011,
  38. 0b1100100]
  39. )
  40. # equivalent:
  41. data = bytearray([97,98,99])
  42. # equivalent aussi:
  43. data = bytearray([0x61, 0x62, 0x63]
  44. ```
  45. # Texte
  46. On peut interpréter des octets comme du texte - c'est la table ASCII
  47. ![ascii table](img/ascii-table.png)
  48. # ASCII - remarques
  49. * C'est *vieux* - 1960
  50. * Le A est pour American
  51. * Ça sert à *envoyer* du texte sur des terminaux d'où les "caractères" non-imprimables dans la liste
  52. * Mais c'est une convention *très* utilisée
  53. # En ASCII
  54. C'est aussi la façon dont l'affiche python
  55. ```python
  56. >>> data = bytearray([97,98,99])
  57. >>> data
  58. bytearray(b"abc")
  59. ```
  60. # Types
  61. La variable `b"abc"` est une "chaîne de bits", de même que `"abc"` est une "chaîne de caractères".
  62. Python apelle ces types `bytes` et `str`:
  63. ```python
  64. >>> type("abc")
  65. str
  66. >>> type(b"abc")
  67. bytes
  68. ```
  69. Notez bien que ce qu'affiche Python n'est qu'une *interpétation* du tableau de bits.
  70. # bits versus bytearray
  71. De la même manière qu'on ne peut pas un caractère dans une string, on ne peut
  72. pas modifier un bit - ou un octet dans un `bytes`.
  73. ```python
  74. >>> a = "foo"
  75. >>> a[0] = "f"
  76. TypeError: 'str' object does not support item assignment
  77. >>> b = b"foo"
  78. >>> b[0] = 1
  79. TypeError: 'bytes' object does not support item assignment
  80. ```
  81. # bits versus bytearray (2)
  82. Par contre on peut modifier un bytearray
  83. ```python
  84. >>> b = bytearray(b"foo")
  85. >>> b[0] = 95
  86. >>> b
  87. bytearray("_oo")
  88. ```
  89. # Quand ce n'est pas imprimable
  90. Python affiche `\x` et le code hexa:
  91. ```python
  92. >>> data = bytearray([7, 69, 76, 70])
  93. >>> data
  94. bytearray(b'\x07ELF')
  95. ```
  96. # Plus loin que l'ASCII
  97. Pas de caractères accentuès dans ASCII. Du coup, on a d'autres *conventions* qu'on appelle "encodage".
  98. ```python
  99. # latin-1: utilisé sur certains vieux sites
  100. # - souvent européens
  101. >>> bytearray([0b11101001]).decode('latin-1')
  102. 'é'
  103. ```
  104. ```python
  105. # cp850: dans l'invite de commande Windows
  106. >>> bytearray([0b11101001]).decode('cp850')
  107. 'Ú'
  108. ```
  109. Mais ça, c'était avant. Avant UTF-8, un encodage qui a mis tout le monde d'accord.
  110. # UTF-8 en pratique
  111. * Compatible avec ASCII
  112. * Mais certains caractères sont représentés par 2 octets ou plus:
  113. ![utf8 exemple](img/utf8.png)
  114. # Conséquences
  115. * Peut représenter *tout* type de texte (latin, chinois, coréen, langues disparues, ....)
  116. * On ne peut pas accéder à la n-ème lettre directement dans une chaîne unicode, il faut parcourir lettre par lettre
  117. * Et toutes les séquences de bits ne sont pas forcément valides
  118. # Conclusions
  119. * On utilise souvent le binaire pour échanger entre Python et le monde extérieur
  120. * Python vous cache un peu ça en utilisant UTF-8 par défaut donc ça marche souvent
  121. * Le 'plain text' n'existe pas: tout texte a un *encodage*, et il vous faut connaître cet encodage
  122. * Si vous avez le choix, utilisez UTF-8