introduction

Il s'agit d'une tentative de lire la 3e édition du didacticiel Python et de noter ce que vous avez appris.

Tutoriel Python 3e édition

Et quand j'aurai fini de lire, j'aimerais passer cet examen À la fin du test, le test commencera ...

Examen de base pour la certification d'ingénieur Python 3

J'espère que ça continue, j'espère que ça continue

Utilisez Python comme calculatrice

Valeur numérique

Type de numéro

Les entiers ont le type ʻint`
Les nombres avec des fractions ont un type float --Division renvoie toujours le type float

>>> 2 + 2
4
>>> 50 - 5 * 6
20
>>> (50 - 5 * 6) / 4
5.0
>>> 8 / 5
1.6
>>> 17 / 3
5.66666666666667

Quatre règles

--Utilisez l'opérateur // si vous souhaitez effectuer une dévaluation et une division pour obtenir une solution entière (si vous souhaitez supprimer le reste) --Utilisez l'opérateur % si vous ne voulez obtenir que le reste

>>> 17 // 3
5
>>> 17 % 5
2
>>> 5 * 3 + 2
17

La puissance peut être calculée en utilisant l'opérateur **.

>>> 5 ** 2
25
>>> 2 ** 7
128

--Si les types à opérer sont mélangés, l'entier est converti en nombre à virgule flottante.

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

variable

--Le nombre égal (=) est utilisé pour attribuer une valeur à une variable

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Une erreur se produit si vous essayez d'utiliser une variable sans «définir» (attribuer une valeur).

#Si vous essayez d'accéder à une variable non définie, vous obtiendrez une NameError car la variable n'est pas définie.
>>> n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

En mode interactif, la dernière valeur affichée est affectée à la variable " _ "(trait de soulignement).

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

Autres types numériques

Différents types numériques tels que Decimal et Fraction sont pris en charge.
Les nombres complexes sont également pris en charge, en utilisant le suffixe «j» ou «J» pour indiquer leur partie imaginaire (par exemple «3 + 5j»).

Chaîne

Guillemets

Vous pouvez utiliser des guillemets simples ('...') et des guillemets doubles ("...") pour les guillemets, les deux avec le même résultat.
Vous n'avez pas besoin d'échapper les guillemets doubles entre guillemets simples
(les guillemets simples doivent être échappés comme `` \ '')
Pas besoin d'échapper les guillemets simples entre guillemets doubles
Vous pouvez échapper les guillemets avec une barre oblique inverse (\) --Backslash est entré et affiché avec un symbole de cercle sur les claviers japonais et les polices japonaises

>>> 'spam eggs' #Simple citation
'spam eggs'
>>> 'doesn\'t' #Simple citation\S'échapper avec...
"doesn't"
>>> "doesn't" # ...Utilisez des guillemets doubles
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

--Dans l'interpréteur, la chaîne est placée entre guillemets et les caractères spéciaux sont sortis avec \.

Les guillemets dans l'affichage sont entre guillemets uniquement si la chaîne elle-même contient des guillemets simples et ne contient pas de guillemets doubles, sinon elle est simple.

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she said.
>>> s = 'First line.\nSecond line.'
>>> s # print()Si vous affichez sans\n est inclus dans la sortie
'First line.\nSecond line.'
>>> print(s) # print()Avec\Une pause se produit à n
First line.
Second line.

caractère brut

--Utilisez ** chaîne brute ** pour éviter que les caractères précédés d'un "" ne soient interprétés comme des caractères spéciaux

>>> print('C:\some\name') # \car n est un saut de ligne
C:\some
ame
>>> print(r'C:\some\name') #Notez le r avant le devis
C:\some\name

Triple devis

Vous pouvez également écrire une chaîne littérale sur plusieurs lignes --Utilisez des guillemets triples ("" "..." "" ou '' '...' '') --Mettre \ à la fin de la ligne pour éviter d'inclure automatiquement le caractère de fin de ligne dans la chaîne

#Si vous faites ce qui suit
print("""\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
""")

#Vous obtenez la sortie suivante (notez que le premier saut de ligne n'est pas inclus)
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to

Concaténation de chaînes

Les chaînes peuvent être concaténées avec l'opérateur + et répétées avec l'opérateur *

#Répétez un 3 fois et ajoutez ium à la fin
>>> 3 * 'un' + 'ium'
'unununium'

Les chaînes littérales énumérées (entre guillemets) sont automatiquement concaténées
Pratique lorsque vous souhaitez fractionner une longue chaîne de caractères --Valide uniquement entre les littéraux, non valide pour les variables et les expressions

>>> 'Py' 'thon'
'Python'
>>> text = ('Une longue chaîne de caractères entre parenthèses'
'Mettons-le et connectons-le.')
>>> text
'Mettons une longue chaîne de caractères entre parenthèses et connectons-la.'

--Utilisez + pour concaténer des variables et des littéraux, et concaténer des variables

>>> prefix = 'Py'
>>> prefix + 'thon'
'Python'

indice

Les chaînes de caractères peuvent être ** indexées ** (spécifiées par le numéro de série) --Le premier caractère est 0 ――Le caractère ici est une chaîne de caractères d'une longueur de 1.

>>> word = 'Python'
>>> word[0] #Caractère en position 0
'P'
>>> word[5] #Caractère en position 5
'n'

Des nombres négatifs peuvent être utilisés pour l'index, indiquant que le comptage à partir de la droite --- 0 est identique à 0, donc les index négatifs commencent à -1

>>> word = 'Python'
>>> word[-1] #Dernier caractère
'n'
>>> word[-2] #L'avant-dernier personnage
'o'
>>> word[-6]
'P'

Une erreur se produit si vous spécifiez un index trop volumineux.

>>> word[42] #le mot contient 6 caractères
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range

Tranchage

Bien que vous puissiez obtenir des caractères individuels à l'aide d'index, vous pouvez obtenir des sous-chaînes en découpant.

>>> word = 'Python'
>>> word[0:2] #Caractères de la position 0 à 2 (y compris 0) (non compris 2)
'Py'
>>> word[2:5] #Caractères de la position 2 à 5 (dont 2) (non compris 5)
'tho'

Notez que le point de départ est toujours inclus et le point final est toujours exclu --Cela garantit que s [: i] + s [i:] est toujours équivalent à s

>>> word = 'Python'
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

La valeur par défaut du premier caractère est 0
La valeur par défaut du deuxième caractère est la taille de la chaîne de caractères.

>>> word = 'Python'
>>> word[:2] #Caractères du premier caractère à la position 2 (non compris 2)
'Py'
>>> word[4:] #Caractères de la position 4 (dont 4) à la fin
'on'
>>> word[-2:] #position-Caractères de 2 (inclus) à la fin
'on'

Comment se souvenir du tranchage
** L'index est un nombre qui indique les caractères "entre" **
** L'extrémité gauche du premier caractère est 0 **
** L'index n est à droite du dernier caractère de la chaîne de n caractères **
** Le découpage de l'index i à j [i: j] se compose de tous les caractères entre la limite i et la limite j **
** Pour les index non négatifs, la longueur de découpage est la différence entre les deux index (la longueur du mot [1: 3] est de 2) **

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

Dans le découpage, même si vous spécifiez un index en dehors de la plage, il sera traité de la bonne manière.

>>> word = 'Python'
>>> word[4:42]
'on'
>>> word[42:]
''

Immuable

Comme les chaînes Python ne peuvent pas être modifiées, une erreur se produira si vous affectez la position d'index des chaînes.

>>> word = 'Python'
>>> word[0] = 'J'
...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
...
TypeError: 'str' object does not support item assignment

--Si vous avez besoin d'une chaîne différente, vous devez générer une nouvelle chaîne

>>> word = 'Python'
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

liste

Aperçu

--Python a plusieurs types de données complexes qui peuvent être utilisés pour regrouper d'autres types de valeurs.

Le plus polyvalent est la liste, qui met les valeurs séparées par des virgules (éléments) entre crochets.
Les listes peuvent contenir des éléments de types différents, mais ont généralement tous le même type

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Index et tranchage

--Comme les chaînes (comme tous les autres types de séquence), les listes peuvent utiliser des index et des tranches

>>> squares = [1, 4, 9, 16, 25]
>>> squares[0] #L'indexation renvoie l'élément
1
>>> squares[-1]
25
>>> squares[-3:] #Le découpage crée et renvoie une nouvelle liste
[9, 16, 25]

--Peut être affecté au tranchage

Vous pouvez modifier la longueur de la liste et effacer tout le contenu de la liste.

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> #Remplacer certaines valeurs
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> #Supprimer ces
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> #Effacez la liste. Remplacez tous les éléments par une liste vide
>>> letters[:] = []
>>> letters
[]

Les opérations de découpage renvoient toujours une nouvelle liste contenant les éléments demandés ――Le tranchage suivant est un mouvement pour faire une nouvelle copie peu profonde et la renvoyer

>>> squares = [1, 4, 9, 16, 25]
>>> squares[:]
[1, 4, 9, 16, 25]

Concaténation de liste

Les listes prennent également en charge les opérations telles que la concaténation

>>> squares = [1, 4, 9, 16, 25]
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Mutable

La chaîne était immuable, mais la liste est ** mutable **, c'est-à-dire que le contenu peut être échangé.

>>> cubes = [1, 8, 27, 65, 125] #Quelque chose ne va pas
>>> 4 ** 3 #4 à la 3ème puissance est 64. Pas 65!
64
>>> cubes[3] = 64 #Échangez les mauvaises valeurs
>>> cubes
[1, 8, 27, 64, 125]

Ajouter un item

Les éléments peuvent être ajoutés à la fin de la liste en utilisant la méthode ʻappend () `

>>> cubes = [1, 8, 27, 64, 125]
>>> cubes.append(216) #Ajout de 6 à la 3e puissance
>>> cubes.append(7 ** 3) #Ajout de 7 à la 3e puissance
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Liste imbriquée

Les listes peuvent être imbriquées

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

le terme

littéral

La valeur réelle d'une valeur numérique ou d'une chaîne de caractères, telle qu'une constante, est simplement décrite.

Type de séquence

--Composé de plusieurs éléments, avec les éléments disposés dans l'ordre (liste, etc.)

Copie superficielle

--Une copie du pointeur sans duplication de l'objet

[Tutoriel Python] Une introduction facile à Python