Il s'agit d'une tentative de lire la 3e édition du didacticiel Python et de noter ce que vous avez appris.
Et quand j'aurai fini de lire, j'aimerais passer cet examen À la fin, le test a commencé ...!
** Commençons! ** **
Examen de base pour la certification d'ingénieur Python 3
J'espère que ça continue, j'espère que ça continue
list.append(x)
--Ajouter un élément à la fin de la liste
--Equivalent à ʻa [len (a):] = [x] , ʻa + = [x]
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.append(333)
>>> a
[66.25, 333, 333, 1, 1234.5, 333]
list.extend(L) --Agrandir la liste en ajoutant tous les éléments de la liste donnée L à la fin de la liste
, ʻa + = L.>>> a = [66.25, 333, 333, 1, 1234.5]
>>> b = [1, 2, 3]
>>> a.extend(b)
>>> a
[66.25, 333, 333, 1, 1234.5, 1, 2, 3]
list.insert(i, x) --Insérer un élément à la position spécifiée --Le premier argument est l'index de l'élément
sera inséré au début de la liste --ʻA.insert (len (a), x) ʻest équivalent à ʻa.append (x) >>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.insert(2, -1)
>>> a
[66.25, 333, -1, 333, 1, 1234.5]
list.remove(x)
--Supprimer le premier élément avec la valeur x
--Si un tel élément n'existe pas, une erreur se produira.
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.remove(333)
>>> a
[66.25, 333, 1, 1234.5]
list.pop([i])
--Supprime l'élément à la position spécifiée de la liste et renvoie cet élément
--Si aucun index n'est spécifié, a.pop () renvoie le dernier élément de la liste et le supprime de la liste.
* Les crochets utilisés pour entourer l'index i dans cette signature de méthode (notation de définition) sont , Indique uniquement que l'argument est facultatif **, et un coin à cette position
Cela ne signifie pas que vous devez entrer des parenthèses. Ces notations sont souvent vues dans les références de bibliothèques.
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.pop()
1234.5
>>> a
[66.25, 333, 333, 1]
>>> a.pop(2)
333
>>> a
[66.25, 333, 1]
list.clear()
--Supprimer tous les éléments de la liste
--Equivalent à del a [:]
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.clear()
>>> a
[]
list.index(x) --Retourne l'index du premier élément avec une valeur de x --Si un tel élément n'existe pas, une erreur se produira.
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> a.index(1)
3
list.count(x) --Retourne le nombre de x dans la liste
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
list.sort(key=None, reverse=False) --Trier la liste sur place (= directement l'objet de la liste sans faire de copie) --Le tri peut être personnalisé avec des arguments
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
>>> a.sort(reverse=True)
>>> a
[1234.5, 333, 333, 66.25, 1, -1]
list.reverse()
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.reverse()
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
list.copy() --Renvoie une copie superficielle de la liste --Equivalent à ʻa [:] `
>>> a = [333, 1234.5, 1, 333, -1, 66.25]
>>> a.copy()
[333, 1234.5, 1, 333, -1, 66.25]
pour charger des éléments en haut de la pile --Utilisez pop ()` non indexé pour obtenir un élément du haut de la pile>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack
[3, 4, 5]
>>> stack.pop()
5
>>> stack
[3, 4]
--Dans la file d'attente, récupérez les éléments dans l'ordre dans lequel ils ont été placés
--`` appendetpop à la fin de la liste sont rapides, mais ʻinsert et pop au début de la liste sont lents
(cela nécessite que tous les autres éléments soient décalés de 1) Pour)
collections.deque pour implémenter les files d'attente **
--deque est conçu pour accélérer les ajouts d'éléments et apparaît au début et à la fin>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")
>>> queue.append("Graham")
>>> queue.popleft()
'Eric'
>>> queue.popleft()
'John'
>>> queue
deque(['Michael', 'Terry', 'Graham'])
Un programme qui génère une liste de carrés
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Un programme qui génère une liste de carrés (lors de l'utilisation de l'expression lamdba)
>>> squares = list(map(lambda x: x**2, range(10)))
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Un programme qui génère une liste de carrés (lors de l'utilisation de l'inclusion de liste)
>>> squares = [x**2 for x in range(10)]
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Une inclusion de liste consiste en une expression suivie d'une clause «for», suivie de zéro ou plus de clauses «for» ou de clauses «if», toutes placées entre parenthèses ([]).
Ce que vous obtenez est une nouvelle liste de valeurs qui évaluent la première expression dans le contexte des clauses for et if suivantes.
Par exemple, l'inclusion de liste suivante prend des éléments de deux listes et les rassemble dans un taple s'ils ne sont pas identiques.
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x !=y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Ceci est équivalent au programme suivant
>>> combs = []
>>> for x in [1,2,4]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (4, 3), (4, 1)]
Notez que les instructions for et if du programme ci-dessous sont dans le même ordre. Les crochets de cercle sont requis lorsque l'expression est tapul
>>> #Générer une nouvelle liste avec des valeurs doublées
>>> vec = [-4, -2, 0, 2, 4]
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> #Filtrer pour supprimer les nombres négatifs
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> #Appliquer la fonction à tous les éléments
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> #Appeler une méthode pour chaque élément
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> #Taple binaire(Valeur numérique,Prix carré)Générer une liste de
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> #Une erreur se produira si le taple n'est pas entre parenthèses.
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> #Lisser (unidimensionnel) la liste en utilisant deux pour
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Les inclusions de liste peuvent contenir des expressions composées et des fonctions imbriquées
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
Une matrice 3x4 implémentée avec 3 listes de longueur 4
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
Permuter les lignes et les colonnes
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Le programme ci-dessus équivaut à
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Autrement dit, équivalent à
>>> transposed = []
>>> for i in range(4):
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
De manière réaliste, utilisez des fonctions intégrées pour les flux complexes
La fonction zip peut être utilisée dans ces situations
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
pop () en ce qu'elle ne renvoie pas de valeur>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
del peut également être utilisé pour supprimer une variable entière
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
--Taple se compose de valeurs séparées par des virgules
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> #Les taples peuvent être imbriqués
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> #Taple ne peut pas être changé
>>> t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Peut stocker des objets variables
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
Les taples de sortie sont toujours entre parenthèses, de sorte que les taples imbriqués sont également interprétés correctement. Il n'est pas possible d'affecter à un élément dans un tuple, mais il est possible de générer un tuple contenant des objets mutables tels que des listes.
Les taples ressemblent à des listes, mais ils sont utilisés dans différentes situations et ont des usages différents. Les taples sont ** immuables **, et il est habituel de créer une séquence d'éléments dissemblables et d'accéder à chaque élément par décompression ou par index (ou même un attribut dans le cas d'un nom mois taple).
Les listes sont ** mutables **, généralement constituées d'éléments similaires, et accessibles en itérant sur la liste.
Il y a un problème spécial à faire un tapple avec 0 ou 1 éléments (il est impossible de le distinguer des autres types car il n'y a pas de virgule de délimitation), donc la syntaxe a un échappement pour traiter ces derniers. Tout d'abord, un taple vide est fait en vidant une paire de parenthèses. Et un élément taple est fait en ajoutant une virgule après une valeur
>>> empty = ()
>>> singleton = 'hello',
>>> len(empty)
0
>>> singleton
('hello',)
La phrase suivante est un exemple d'emballage de tapple (emballage de taple) 12345, 54321, bonjour! Sont dans un même robinet
>>> t = 12345, 54321, 'hello!'
>>> t
(12345, 54321, 'hello!')
Le traitement suivant est appelé ** déballage de séquence **, et toute séquence peut venir universellement. Lors du déballage d'une séquence, vous avez besoin d'une liste de variables sur le côté gauche égale à la longueur de la séquence. Notez que l'affectation multiple est juste une combinaison de conditionnement de tapple et de déballage de séquence.
>>> t = 12345, 54321, 'hello!'
>>> x, y, z = t
>>> x
12345
>>> y
54321
>>> z
'hello!'
set () pour générer l'ensemble (toute l'entreprise générera un dictionnaire vide)>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
{'orange', 'pear', 'banana', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
Démontrer les opérations d'ensemble en prenant des caractères (uniques) sans chevauchement de deux mots
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> #Caractère unique d'un
>>> a
{'b', 'r', 'a', 'd', 'c'}
>>> #Caractères qui existent dans a mais pas dans b
>>> a - b
{'r', 'b', 'd'}
>>> #Caractères présents dans a ou b
>>> a | b
{'l', 'm', 'b', 'z', 'r', 'a', 'd', 'c'}
>>> #Caractères qui existent à la fois dans a et b
>>> a & b
{'a', 'c'}
>>> #Caractères inhabituels dans a ou b
>>> a ^ b
{'m', 'b', 'z', 'r', 'd', 'l'}
Les inclusions définies qui sont similaires aux inclusions de liste sont également prises en charge
>>> a = { x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
et ʻextend ().del.
--Si vous enregistrez à l'aide d'une clé déjà utilisée, la valeur précédente sera perdue.list (d.keys ()) retourne une liste non triée de toutes les clés de ce dictionnaire (si vous voulez trier, à la placetrié (d.keys ()) À
--Si vous voulez vérifier si une clé existe dans le dictionnaire, utilisez le mot-clé ʻin`.>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel.keys())
['jack', 'guido', 'irv']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
Le constructeur dict construit un dictionnaire à partir d'une séquence de tapples de paires" clé: valeur ".
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Les dictionnaires peuvent être générés à partir d'expressions arbitraires qui donnent des clés et des valeurs à l'aide d'inclusions de dictionnaire
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
Si la clé est une simple chaîne, il peut être plus facile de spécifier la paire avec l'argument mot-clé.
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
Lorsque vous bouclez un dictionnaire, vous pouvez utiliser la méthode ʻitems () `pour obtenir la clé et sa valeur correspondante en même temps.
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
Lors de la boucle d'une séquence, vous pouvez utiliser la fonction ʻenumerate () `pour obtenir l'index de position et la valeur correspondante en même temps.
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
Si vous voulez faire une boucle sur deux séquences en même temps, vous pouvez utiliser la fonction zip () pour jumeler les entrées des deux sociétés.
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
Pour boucler la séquence dans l'ordre inverse, spécifiez d'abord la séquence dans l'ordre avant, puis appelez la fonction reverse ().
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
Utilisez la fonction sorted () pour boucler la séquence dans l'ordre trié
Cette fonction ne touche pas la séquence d'origine et renvoie une liste nouvellement triée
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
Si vous souhaitez modifier une liste en boucle, il est plus facile et plus sûr de créer une nouvelle liste
>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
... if not math.isnan(value):
... filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]
--Tout opérateur peut être utilisé pour les conditions utilisées dans les instructions while et ʻif, pas seulement pour la comparaison. --Les opérateurs de comparaison ʻin et not in vérifient si une valeur existe dans la séquence
et ʻor sont souvent appelés ** opérateurs de court-circuit **. sont vrais mais que B est faux, ʻA et B et C n'évaluent pas l'expression CLa comparaison et d'autres résultats booléens peuvent être affectés à des variables
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
< ou > est également une opération légitime tant que ces objets ont la méthode de comparaison appropriée.--La copie peu profonde crée un nouvel objet composé, puis (autant que possible) insère une référence à l'objet trouvé dans l'objet d'origine. --Référence: bibliothèque standard Python 8.10. Copy - Copie superficielle et opérations de copie profonde
Recommended Posts