Focus sur "Python Tutorial 3rd Edition", [Python Tutorial] sur le Web (https://docs.python.org/ja/3.5) J'ai également regardé /tutorial/index.html) et l'ai exécuté. Il m'a fallu beaucoup de temps pour prendre cette note. L'environnement d'exécution est principalement constitué de commandes dans CentOS7. Enfin, je l'ai essayé sur Jupyer Notebook, mais c'était plus facile pour moi personnellement.
Python est un langage d'interprétation
(Dans le shell) Démarrer l'interpréteur python3.5 * 3,5 points varient en fonction de l'environnement \ >>> quit () Quitte l'interpréteur
commande python -c [argument] ...
Accessible en exécutant "import sys" sys.argv
Invite principale (>>>) Invite secondaire (...)
Par défaut, le code source Python est traité comme encodé en UTF-8.
| Ne peut pas être changé | Peut être changé | Répétable | séquence | cartographie | Les données | |
|---|---|---|---|---|---|---|
| bool | ◎ | True,False | ||||
| int | ◎ | entier | ||||
| float | ◎ | Nombre à virgule flottante | ||||
| complex | ◎ | Nombre complexe | ||||
| str | ◎ | ◎ | ◎ | Chaîne | ||
| list | ◎ | ◎ | ◎ | |||
| tuple | ◎ | ◎ | ◎ | |||
| range | ◎ | ◎ | ◎ | |||
| dict | ◎ | ◎ | ◎ | |||
| set | ◎ | ◎ | ||||
| bytes | ◎ | ◎ | ◎ | binaire | ||
| bytearray | ◎ | ◎ | ◎ | |||
| file object | ◎ | ◎ |
L'opérateur + - * /% () est comme l'image d'autres langues
opérateur.
>>> 17 / 3; #division(En python2"//"Même résultat que
>>> 17 // 3; # ***Division arrondie***
>>> 5 *** 2; #5 au carré
>>> 0%3 #0/Reste de 3 → 0
3*3.72/1.5
En mode interactif, la dernière expression affichée est "_」(souligner)Est attribué à.
>>> price = 100.5
>>> tax = 10.5
>>> price * tax
>>> price + _ #En mode interactif, la dernière expression affichée est la variable "_Remplacer dans
>>> _ = 10000 #La substitution est possible, mais elle doit être traitée en lecture seule
Erreur lors de l'utilisation sans affectation à la variable
>>> 'doesn\'t' #échapper
>>> "doesn't" #Mettre entre guillemets
>>> s = 'First\nSecond'
>>> print(s)
>>> print(r'C:\some\name') #chaîne brute
Autre(Non listé).
>>> a = 'Py'
>>> b = 'thon'
>>> c = 'Jython'
>>> a = b = c #Affectation multiple
>>> a #La dernière variable s'applique à tout
'Jython'
>>> b
'Jython'
>>> c
'Jython'
Les guillemets triples (guillemets doubles ou simples) peuvent gérer les sauts de ligne tels quels.
>>> '''aaa #Exemple
... bbb
... ccc
... '''
'aaa\nbbb\nccc\n'
>>> print("""\ #Plusieurs lignes 1
... Usage: ls
... -r
... -h
... """)
>>> print('''\ #Plusieurs lignes 2
... Usage: ls
... -r
... -h
... ''')
La combinaison de chaînes de caractères utilise essentiellement +. (Les espaces sont possibles, mais les erreurs autres que les variables et les chaînes)
Concaténation de chaînes.
>>> word = 'python'
>>> word2 = 'ium'
>>> 3 * 'un' + 'ium' #répétition
'unununium'
>>> 'Py' + 'thon' #Le personnage est +,Tout espace peut être combiné
'Python'
>>> 'Py' 'thon'
'Python'
>>> word 'ium' #Les variables et les caractères ne peuvent pas être combinés avec des espaces
File "<stdin>", line 1
word 'ium'
^
SyntaxError: invalid syntax
>>> word word2 #Les espaces ne permettent pas la combinaison de variables
File "<stdin>", line 1
word word2
^
SyntaxError: invalid syntax
>>> word + word2 #Utilisez + pour combiner des variables et des variables et des caractères
'pythonium'
Manipulation de chaîne variable(Spécification d'index).
>>> word = 'python'
>>> word[2] #***0 est le premier caractère***
't'
>>> word[-2] #***-1 est le dernier caractère***
'o'
Trancher trancher > String [Index de début: Index de fin: Nombre d'étapes]
L'index est entre les lettres(between)L'extrémité gauche du premier caractère est 0.
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
Manipulation de chaîne variable(Tranchage(Coupé)La désignation).
>>> word = 'python'
>>> word[0:2] #Inclut le premier caractère mais n'inclut pas le dernier caractère
'py'
>>> word[2:5] #Inclut le premier caractère mais n'inclut pas le dernier caractère
'tho'
>>> word[:2] #début:0 lorsqu'il est omis
'py'
>>> word[-2:] #Fin:Si omis, la taille de la chaîne de caractères(Jusqu'au dernier personnage)
'on'
>>> word[:-2] #début:0 lorsqu'il est omis
'pyth'
>>> word[0:10:2] #Précisez le nombre d'étapes * Bien qu'elles ne soient pas mentionnées dans le livre, des questions seront posées lors de l'examen simulé
'pto'
>>> word[:2] + word[2:] #Équivalent à une chaîne
'python'
Manipulation de chaîne variable(Désignation hors de portée).
>>> word[42] #La spécification d'index est NG
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> word[4:42] #La spécification de tranchage est OK
'on'
Manipulation de chaîne variable(Changer de chaîne).
>>> word[0] = 'J' #La chaîne de caractères Python ne peut pas être modifiée = corps immuable(immutable)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> 'J' + word[1:] #Besoin de générer une nouvelle chaîne
'Jython'
Manipulation de chaîne variable(Longueur de chaine).
>>> word = 'dive\ninto\ncode\t'
>>> print(len(word))
15 #Les caractères de contrôle sont comptés comme un caractère
>>> d = 'xxxxDIVExxxxDIVExxxxDIVE'
>>> print(d.replace('DIVE', 'CODE', 1))
xxxxCODExxxxDIVExxxxDIVE #Remplacez uniquement la première valeur
>>> d
'xxxxDIVExxxxDIVExxxxDIVE' #Aucune modification de la chaîne d'origine
liste.
>>> squares = [1,4,9,16,25]
>>> squares
[1, 4, 9, 16, 25]
>>> squares[0]
1
>>> squares[2]
9
>>> squares[-1]
25
>>> squares[-3:]
[9, 16, 25]
>>> squares[:]
[1, 4, 9, 16, 25]
>>> squares[::]
[1, 4, 9, 16, 25]
>>> squares[:::]
File "<stdin>", line 1
squares[:::]
^
SyntaxError: invalid syntax
Concaténation de liste.
>>> squares + [ 100, 1001 ]
[1, 4, 9, 16, 25, 100, 1001]
>>> squares2 = [ 8001, 8002 ]
>>> squares + squares2
[1, 4, 9, 16, 25, 8001, 8002] #Les valeurs de la liste ne changent pas
La liste peut être modifiée(mutable).
>>> squares[1] = 40000
>>> squares
[1, 40000, 9, 16, 25]
>>> squares.append(216) # append()Méthode
>>> squares.append(7**3)
>>> squares
[1, 40000, 9, 16, 25, 216, 343] #Ajouter à la fin de la liste
>>> letters = ['a','b','c','d','e','f','g'] #La substitution au tranchage est également possible
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C','D','E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> letters[:] = []
>>> letters
[]
for i in range(s): print(i)
range (10) # 1 et 3 arguments peuvent être omis si étape par étape à partir de 0 range (5, 10) # 3ème argument peut être omis si étape par étape plage (0, 10, 3) # 0 à 10 en 3 étapes
>>> print(range(10)) # (Mise en garde)Le numéro de série de la valeur n'est pas affiché
range(0, 10)
-Comme avec le langage C, l'instruction break et l'instruction continue quittent chacune la boucle et sautent le reste de la boucle pour passer à l'itération suivante. -La clause else dans la boucle ressemble plus à celle de l'instruction try qu'à celle de l'instruction if. L'instruction tyr est exécutée lorsqu'aucune exception ne se produit et la boucle est exécutée lorsque *** break ne se produit pas ***.
·ne fais rien. Il est utilisé lorsqu'une erreur syntaxique se produit.
Lorsque vous faites la plus petite classe.
>>> class MyEmptyClass:
... pass
Lorsque vous n'écrivez pas de code spécifique dans la fonction ou l'instruction conditionnelle lors de l'écriture d'un nouveau code.
>>> def initlog(*args):
... pass
4.7.1. Valeur d'argument par défaut Le format le plus pratique consiste à spécifier une valeur par défaut pour un ou plusieurs arguments.
def ask_default (a, b, c = 100): # 100 est mis à c lorsque le 3ème argument est omis
Accumuler les arguments passés à la fonction lors des appels de fonction suivants.
>>> def f(a, L=[]):
... L.append(a)
... return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
4.7.2. Arguments de mots clés La fonction peut également se présenter sous la forme "mot-clé = valeur". Lors de l'appel d'une fonction, l'argument positionnel doit venir en premier et l'argument mot-clé doit venir après.
>>> def fugafuga(title,content = 'default_content', number = 4):
... print(title, end=' ')
... print(content, end=' ')
... print(number)
...
...
>>> fugafuga(title = 'title_default', content = 'None', number = 5)
title_default None 5
>>> fugafuga(title = 'title_default', number = 5) #Les arguments de mot-clé peuvent être omis (les arguments du milieu peuvent être omis)
title_default default_content 5
>>> fugafuga(1000) #Les arguments positionnels sont également possibles (les arguments du milieu ne peuvent pas être omis)
1000 default_content 4
4.7.3. Liste d'arguments facultatifs L'option la moins utilisée est de spécifier que la fonction peut être appelée avec n'importe quel nombre d'arguments.
>>> def write_multiple_items(file, separator, *args):
... file.write(separator.join(args))
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'
>>> def dive_into_code(teacher, *mentor):
... print(teacher)
... print(mentor)
...
>>> dive_into_code('Noro', 'Nakao', 'Miyaoka')
Noro #Emplacement du 1er argument
('Nakao', 'Miyaoka') #Après le deuxième argument
4.7.4. Déballage de la liste d'arguments
4.7.5. Type Lambda
4.7.6. Déballage de la liste d'arguments Chaîne de documentation
Python a PEP 8 comme guide de style que la plupart des projets suivent.
Les points suivants -Utilisez 4 blancs pour l'indentation et n'utilisez pas de tabulations. Les quatre espaces sont exactement à mi-chemin entre les petits retraits (qui peuvent être profondément imbriqués) et les grands retraits (faciles à lire). Les onglets sont source de confusion et doivent être éliminés. -Enveloppez les lignes de sorte que la largeur du code source ne dépasse pas 79 caractères. Cela aidera les utilisateurs avec des écrans plus petits et permettra même d'aligner les codes sur des écrans plus grands. -Utilisez des lignes vierges pour séparer les grands blocs de code dans une fonction, une classe ou une fonction. ・ Si possible, écrivez des commentaires indépendamment sur la ligne. -Utilisez docstring. • Insérez des espaces avant et après l'opérateur et après la virgule, et aucun espace immédiatement à l'intérieur des parenthèses: a = f (1, 2) + g (3, 4). -Donner des noms cohérents aux classes et aux fonctions. Par convention, CamelCase est utilisé pour les noms de classe et lower_case_with_underscores est utilisé pour les noms de fonctions et de méthodes. Utilisez toujours self comme nom du premier argument de la méthode. -N'utilisez pas d'encodages bizarres dans le code que vous avez l'intention d'utiliser dans un environnement international. Dans tous les cas, l'UTF-8 par défaut de Python ou l'ASCII brut fonctionne le mieux. -De même, les caractères non ASCII ne doivent pas être utilisés dans les identifiants si la moindre autre personne parlant la langue peut lire ou maintenir le code.
Méthode de liste append(x) extend(L) insert(i,x) remove(x) pop ([i]) Supprime l'élément à la position spécifiée dans la liste de la liste et renvoie cet élément. S'il est omis, l'élément à la fin de la liste est ciblé. Équivalent à clear () del a [:] index(x) countx(x) list.sort(key=None,reverse=False) list.reverse() list.copy () Renvoie une copie superficielle de la liste. Équivaut à un [:]. list.count (x) Nombre de x dans la liste
>>> key = ['001','002','003','002','005','006','003','009']
>>> print(key.count('001'),key.count('002'),key.count('003'))
1 2 2
>>> key.reverse()
>>> key
['009', '003', '006', '005', '002', '003', '002', '001']
>>> key.sort()
>>> key
['001', '002', '002', '003', '003', '005', '006', '009']
>>> key.append('010')
>>> key
['001', '002', '002', '003', '003', '005', '006', '009', '010']
>>> key.insert(2,'020')
>>> key
['001', '002', '020', '002', '003', '003', '005', '006', '009', '010']
>>> key.extend(key)
>>> key
['001', '002', '020', '002', '003', '003', '005', '006', '009', '010', '001', '002', '020', '002', '003', '003', '005', '006', '009', '010']:
Méthode du type de liste(pop et ajouter)Peut utiliser la liste comme une pile.
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack.pop()
6
>>> stack
[3, 4, 5]
Il est possible d'utiliser une liste comme file d'attente, mais la méthode list n'est pas efficace. Il est plus rapide d'ajouter ou de passer à la fin de la liste, L'insertion et le passage en haut de la liste sont lents. (Parce qu'il est nécessaire de décaler les autres éléments un par un). Utilisez collections.deque.
>>> 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'])
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> squares = list(map(lambda x: x**2, range(10))) #Comme ci-dessus
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> squares = [x**2 for x in range(10)] #Comme ci-dessus:Inclusion de liste
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [(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)]
>>> #Équivalent à ce qui précède
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y)) #Si l'expression est un taple, le tapple doit avoir un crochet circulaire:Avoir besoin
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> [[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]]
>>> vec = [-4, -2, 0, 2, 4]
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> [(x, x**2) for x in range(6)] #Générer une liste de taples binaires
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> [x, x**2 for x in range(6)] #Erreur si le taple n'est pas entre parenthèses
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> vec = [[1,2,3], [4,5,6], [7,8,9]] #Liste lissée (une dimension): utilisez deux pour
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
Permuter les lignes et les colonnes dans la matrice.
>>> matrix = [ # matrix = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],]
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)] #Notation d'inclusion
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
#Équivalent à
>>> 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]]
#Équivalent à ce qui suit
>>> 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]]
En pratique, il est préférable d'utiliser la fonction intégrée zip () que d'utiliser des expressions de flux complexes. fonction zip (): une fonction qui combine des éléments de plusieurs objets itérables (listes, taples, etc.)
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
Référence: confirmation supplémentaire.
>>> [row[i] for row in matrix3] #
[4, 8, 12]
>>> [i for row in matrix3] #
[3, 3, 3]
>>> matrix3
[[1, 2, 3, 4, 99], [5, 6, 7, 8, 91], [9, 10, 11, 12, 92, 93]]
>>> [[row[i] for row in matrix3] for i in range(5)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12], [99, 91, 92]]
>>> [[row[i] for row in matrix3] for i in range(6)]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 1, in <listcomp>
File "<stdin>", line 1, in <listcomp>
IndexError: list index out of range
pour a, b, c dans zip (A, B, C) # Itérer plusieurs séquences
Référence: zip().
>>> names = ['Alice', 'Bob', 'Charlie']
>>> ages = [24, 50, 18]
>>> for name, age in zip(names, ages):
... print(name, age)
...
Alice 24
Bob 50
Charlie 18
>>> 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[:] #Supprimer toutes les valeurs
>>> a
[]
>>> del a #Supprimer toute la variable
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
-Type de données de séquence: - liste, tuple, plage, etc. ・ Tuple Vous n'êtes pas obligé de le mettre entre parenthèses lors de l'écriture d'un taple Vous aurez peut-être besoin de parenthèses (si le tapple faisait partie d'une expression plus grande) Vous ne pouvez pas remplacer les éléments du taple. Immuable. Le tuple peut contenir des types mutables tels que des listes. Les éléments sont souvent accessibles par des opérations de décompression ou des index (ou des attributs dans le cas des objets nommés)
Taple.
>>> t = 12345, 54332, 'hello!'
>>> t
(12345, 54332, 'hello!')
>>> t[0]
12345
>>> u = t, (1, 2, 3, 4, 5)
>>> u #Les taples peuvent être imbriqués
((12345, 54332, 'hello!'), (1, 2, 3, 4, 5))
>>> t[0] = 88888 #Taple ne peut pas être changé
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Emballer / déballer.
>>> t = 12345, 54321, 'hello!' #Pack Taple(tuple packing)
>>> x, y, z = t #Déballage de séquence(sequence unpacking)
>>> x
12345
>>> y
54321
>>> z
'hello!'
Méthode Taple.
>>> key0 = ('001','002','003','002','005','006','003','009')
>>> key0.count('002')
2
>>> key0.append('099') #La méthode de changement n'est pas possible
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
Une collection d'éléments non ordonnés sans éléments qui se chevauchent
L'utilisation de base consiste à déterminer l'existence et à éliminer les entrées en double Prend en charge les opérations mathématiques telles que la somme (union), le produit (intersection), la différence (différence) et la différence symétrique (différence symétrique)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)
{'banana', 'apple', 'orange', 'pear'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'c', 'd', 'a', 'b', 'r'} # 'abracadabra'Éléments en double supprimés de'abrcd'
(Référence 2.7)set(['a', 'r', 'b', 'c', 'd'])
>>> a - b #Ensemble de différences(Idem pour la méthode de différence)
{'d', 'r', 'b'}
>>> a | b #Ensemble de somme(Idem pour la méthode d'union)
{'c', 'z', 'm', 'l', 'd', 'a', 'b', 'r'}
>>> a & b #Ensemble de produits(Idem pour la méthode d'intersection): Caractères qui existent à nouveau dans a et b
{'c', 'a'}
>>> a ^ b #Ensemble de somme logique exclusif(symmetric_Idem pour la méthode de différence): Caractères rares dans a ou b
{'d', 'z', 'm', 'r', 'b', 'l'}
Prise en charge de l'inclusion d'ensemble.
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
(Hors de portée) Ajouter un élément pour définir myset.add (x) Supprimer des éléments de l'ensemble myset.remove (x) Créer un type d'ensemble à partir d'un type de liste
>>> mylist = [2, 1, 3, 1]
>>> myset = set(mylist)
>>> print(myset)
{1, 2, 3}
Un ensemble non ordonné de clés (uniques) et de valeurs
Valeur clé Seul un type immuable peut être saisi Un taple peut être une clé s'il ne contient que des chaînes, des nombres ou d'autres taples. Vous ne pouvez pas lister. )
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape'] #Effacer(Erreur si non présente)
>>> tel
{'jack': 4098, 'guido': 4127} # 'sape'A été supprimé
>>> tel['irv'] = 4127 # 'irv'Ajouter
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127} # 'irv'Position: 3 séries(3.6.8)Aboutir à.
(référence) {'jack': 4098, 'irv': 4127, 'guido': 4127} # 'irv'Position: livre,Cliquez ici pour le Web. 2 système(2.7.5)Si vous le faites, le résultat sera ici. * Vous n'avez pas à vous inquiéter car il n'y a pas de commande.
>>> tel['irv'] = 9999 #Modifier la valeur
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 9999}
>>> list(tel.keys())
['jack', 'guido', 'irv']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel #Contrôle d'existence
True
>>> 'jack' not in tel
False
dict()Le constructeur génère un dictionnaire à partir d'une liste contenant un tuple de paires clé / valeur.
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098} #3 séries(3.6.8)L'exécution entraîne
(référence){'sape': 4139, 'jack': 4098, 'guido': 4127} #2 système(2.7.5)L'exécution entraîne
Si la clé est une chaîne simple, définissez-la à l'aide d'arguments de mot-clé et générez un dictionnaire.
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098} #3 séries(3.6.8)L'exécution entraîne
(référence){'sape': 4139, 'jack': 4098, 'guido': 4127} #2 système(2.7.5)L'exécution entraîne
Générer un dictionnaire à partir de n'importe quelle paire clé / valeur à l'aide d'expressions d'inclusion de dictionnaire.
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>>dic = {'Noro': 1, 'Nakao': 2, 'Miyaoka': 3}
>>>dic['Miyaoka'] += 1
>>>print(dic)
{'Noro': 1, 'Nakao': 2, 'Miyaoka': 4} #1 ajout! !!
Méthode du dictionnaire update() copy() items() values() del clear()
Lors de la lecture en boucle d'un dictionnaire, les éléments()Vous pouvez utiliser la méthode pour récupérer 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
Énumérer lors du bouclage sur une séquence()Les fonctions peuvent être utilisées pour récupérer des index d'éléments et des éléments en même temps.
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
(0, 'tic') #Index d'élément, valeur
(1, 'tac')
(2, 'toe')
Fonction zip pour boucler deux ou plusieurs types de séquence en même temps()Utilisez pour combiner chaque élément.
>>> 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.
Spécifiez la plage de la séquence dans le sens avant, puis la fonction inversée()Appel.>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1
Boucle la séquence dans l'ordre trié: trié()Utilisez une fonction. (Renvoie un nouveau tableau trié sans changer le tableau d'origine).
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
Dans certains cas, il est plus facile et plus sûr de créer une nouvelle liste que de modifier la 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]
Pour la condition utilisée dans les instructions while et if, il existe d'autres opérateurs ainsi que des comparaisons de valeurs. -Opérateurs de comparaison dans et pas dans: si une certaine valeur existe (ou n'existe pas) dans une certaine séquence * Déjà mentionné -Operators est et n'est pas: si les deux objets sont réellement le même objet Uniquement significatif pour les objets mutables comme les listes
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'
-Notez qu'en Python, contrairement au langage C, l'affectation ne peut pas être effectuée à l'intérieur d'une expression. C: if(a=1)==1
-Les objets de séquence peuvent être comparés à des objets qui ont le même type de séquence. -Dans le module, le nom du module (de la chaîne de caractères) peut être obtenu avec la variable globale name. (Méthode de comparaison) ★★ ・ Comparer dans l'ordre lexical -Si les résultats de comparaison de tous les éléments des deux séquences sont égaux, les séquences sont considérées comme égales. -Si une séquence est une séquence partielle correspondant au début de l'autre, la séquence la plus courte est considérée comme la séquence la plus petite.
>>> (1, 2, 3) < (1, 2, 4)
True
>>> [1, 2, 3] < [1, 2, 4]
True
>>> (1, 2, 3, 4) < (1, 2, 4)
True
>>> (1, 2) < (1, 2, -1)
True
>>> 'ABC' < 'C' < 'Pascal' < 'Python' #Ordre du dictionnaire
True
>>> (1, 2, 3) == (1.0, 2.0, 3.0) #0 et 0.0 est équivalent
True
>>> (1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
True
(Mémo) Comparaison de caractères: J'ai fait un peu de recherche car le standard était inconnu dans l'ordre du dictionnaire, mais je n'ai pas compris tout de suite, donc j'ai seulement examiné le mouvement. Au moins, cela semble être dans l'ordre du code asscii.
>>> 'C' < 'c' # 'C':0x43、'c'：0x63
True
>>> 'c' < 'C'
False
>>> 'c' < 'c'
False
>>> 'C' < 'C'
False
>>> '(' < ')' # '(':0x28、')'：0x29
True
>>> ')' < '('
False
-La comparaison entre des objets de types différents est possible tant que ces objets fournissent des méthodes de comparaison appropriées. L'interpréteur lève une exception TypeError s'il ne fournit pas une méthode de comparaison appropriée (Référence: série Python2) Même s'il n'y a relativement aucune erreur, ce sera toujours False et aucune erreur ne se produira.
TypeError pour comparer des chaînes et des nombres, des listes et des taples.
>>> 'ab' < 3 #Chaînes et nombres.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> (1,3,5) < [1,3,6] #Liste et taple.
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'tuple' and 'list'
-En Python, il existe un moyen d'écrire la définition dans un fichier et de l'utiliser dans un script ou sur une instance interactive de l'interpréteur, et ce fichier est appelé un module. -La définition d'un module peut être importée dans d'autres modules ou module principal.
>>> import fibo
>>> fibo.fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Un module est un fichier contenant des définitions et des déclarations Python. Le nom du fichier est "nom du module + .py" ・ Si vous souhaitez utiliser la fonction fréquemment, vous pouvez l'affecter à une variable locale.
>>> import fibo
>>> fib = fibo.fib #Peut être affecté à une variable locale(Définition de module omise)
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Un module peut contenir une instruction exécutable en plus de la définition de la fonction. (Pour initialiser le module) Ces instructions exécutables ne sont exécutées que lorsque le nom du module est trouvé pour la première fois dans l'instruction d'importation. -Chaque module a sa propre table de symboles privée, et les fonctions définies dans le module utilisent cette table comme table de symboles globale. -Les variables globales peuvent être utilisées dans les modules. -Un module peut également importer d'autres modules. -Toutes les instructions d'importation sont placées au début du module, mais c'est habituel et non obligatoire. -Le nom du module importé est placé dans la table des symboles globale du module d'importation. -La déclaration d'importation a également une variante qui importe le nom dans un module directement dans la table des symboles du module exécutant l'importation.
*** importer
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Il existe également une variante qui importe tous les noms définis dans le module.
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
-Utilisation de la fonction importlib.reload () (imp.reload () de 3.4 à 3.3) Pour des raisons d'efficacité, chaque module n'est importé qu'une seule fois par session de l'interpréteur. Rechargez si vous souhaitez réparer le module et testez-le immédiatement.
-Lorsque le script est exécuté avec "python fibo.py
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
Ordre lors de l'importation d'un module nommé spam
Mettez en cache chaque module compilé en tant que fichier "module.version.pyc" dans le répertoire "pycache" pour accélérer le chargement du module
# ll -R
drwxr-xr-x 2 racine racine 33 1 janvier 08:31 __pycache__
-rw-r--r--1 racine racine 376 1 janvier 08:48 fibo.py
./__pycache__:
-rw-r--r--1 racine racine 503 1er janvier 08:31 fibo.cpython-36.pyc
Python compare la date et l'heure de la modification de la source avec la version compilée et vérifie automatiquement si la version compilée est obsolète et n'a pas besoin d'être recompilée. -Les modules compilés sont indépendants de la plate-forme, de sorte que la même bibliothèque peut être partagée entre des systèmes avec des architectures différentes. ・ Deux cas où le cache n'est pas vérifié
Recompilez toujours lorsque le module est chargé directement depuis la ligne de commande Sans module source
module winreg fourni uniquement sur les systèmes Windows Variables sys.ps1 et sys.ps2 Définir les chaînes de caractères à afficher sur les invites principales et secondaires
sys.path est défini sur le chemin par défaut obtenu à partir de la variable d'environnement PYTHONPATH, ou sur la valeur par défaut intégrée si PYTHONPATH n'est pas défini..
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
Vous pouvez voir le nom défini par le module. Renvoie une liste triée de chaînes.
>>> import fibo, sys
>>> dir(fibo)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__',(réduction)
Sans arguments, dir()Énumère les noms actuellement définis.
>>> a = [1, 2, 3, 4, 5]
>>> fib = fibo.fib
>>> dir() #Aucun argument
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'fib', 'fibo', 'sys']
La liste des fonctions intégrées et des noms de variables utilise les fonctions intégrées du module standard * Non répertorié par dir ()
>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError',(réduction)
Comment créer un module Python en utilisant "nom de module délimité par des points"
-Nom du module A.B → Représente le sous-module B du package A · Les auteurs de packages multi-modules n'ont plus à se soucier des noms de modules de chacun -Le fichier init.py est nécessaire pour que Python traite un répertoire comme un répertoire contenant des packages. -Dans le cas le plus simple, init.py peut être juste un fichier vide, mais init.py peut exécuter le code d'initialisation pour le package ou définir les variables all.
Importer des modules individuels à partir du package(cas 1).
>>> import sound.effects.echo
>>> sound.effects.echo.echofilter(input, output, delay=0.7, atten=4) #Doit être référencé par son nom complet
Importer des modules individuels à partir du package(Cas 2).
>>> from sound.effects import echo
>>> echo.echofilter(input, output, delay=0.7, atten=4) #Disponible sans nom de package
Importer des modules individuels à partir du package(Cas 3).
from sound.effects.echo import echofilter
echofilter(input, output, delay=0.7, atten=4) #Méthode disponible directement
-Lors de l'utilisation de la syntaxe "à partir de l'élément d'importation du package" l'élément peut être un sous-module (ou sous-package) du package package Autres noms définis dans le package, tels que fonctions, classes, variables, etc. L'instruction d'importation vérifie d'abord si l'élément est défini dans le package. S'il n'est pas défini, il tentera de charger le module, en supposant que l'élément est le nom du module. Si aucun module n'est trouvé, une ImportError est levée
-Lors de l'utilisation de la syntaxe de "import item.subitem.subsubitem" Chaque élément, à l'exception du dernier sous-sous-élément, doit être un package
Demandez à l'auteur du package de fournir explicitement l'index du package
「from sound.effects import * 」
Prend en charge path comme attribut spécial L'attribut path précède l'exécution du code dans init.py du package. Initialisé pour être une liste contenant les noms de répertoire contenant init.py
-Comment sortir la valeur:
Déclaration d'expression fonction print () Méthode write () de l'objet fichier
-Le fichier représentant la sortie standard peut être référencé dans sys.stdout. ・ Comment formater la sortie
Utilisez des opérations de découpage et de concaténation de chaînes pour effectuer tout le traitement des chaînes Utilisez la méthode str.format Utilisez la classe Template du module string Comment convertir une valeur en chaîne: transmettez la valeur à la fonction repr () ou str ().
-La fonction str () sert à renvoyer une représentation lisible par l'homme de la valeur. La fonction repr () est destinée à renvoyer une représentation lisible par un interprète (ou SyntaxError s'il n'y a pas de syntaxe équivalente). Pour les objets qui n'ont pas de représentation spécifique adaptée à la lecture humaine, str () renvoie la même valeur que repr ().
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> repr(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> str(s)
'The value of x is 32.5, and y is 40000...'
>>> repr(s)
"'The value of x is 32.5, and y is 40000...'"
>>> hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> str((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
>>> repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Ecrire une table carrée et cubique de deux manières.
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
Méthode str.rjust (width [, fillchar]) ・ ・ ・ Renvoie une chaîne de caractères justifiée à droite avec la longueur de width. Lorsque fillchar est spécifié, il est rempli avec les caractères spécifiés. Méthode str.ljust (width [, fillchar]) ・ ・ ・ Renvoie une chaîne de caractères justifiée à gauche avec la longueur de width. Lorsque fillchar est spécifié, il est rempli avec les caractères spécifiés. Si vous souhaitez tronquer des caractères, utilisez des tranches et utilisez x.ljust (n) [: n]. Round () pour arrondir. Méthode str.center (width [, fillchar]) ・ ・ ・ Renvoie une chaîne de caractères centrée avec la longueur de width. Lorsque fillchar est spécifié, il est rempli avec les caractères spécifiés. Méthode str.zfill (): remplit à zéro le côté gauche de la chaîne de caractères numériques
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
méthode str.format ()
Les parenthèses et les caractères qu'elles contiennent(C'est ce qu'on appelle un champ de format).
>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"
Le nombre entre parenthèses est str.format()Peut être utilisé pour représenter la position de l'objet passé à la méthode.
>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
str.format()Si un argument de mot-clé est passé à la méthode, sa valeur est référencée par le nom de l'argument de mot-clé.
>>> print('This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.
Vous pouvez également combiner des arguments ordinaux et des mots-clés.
>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',other='Georg'))
The story of Bill, Manfred, and Georg.
'!a'(ascii()Adapter)Ou'!s'(str()Adapter)Ou'!r'(repr()Adapter)Peut être converti avant le formatage de la valeur à l'aide de.
>>> contents = 'eels'
>>> print('My hovercraft is full of {}.'.format(contents))
My hovercraft is full of eels.
>>> print('My hovercraft is full of {!r}.'.format(contents))
My hovercraft is full of 'eels'.
Contrôle du formatage des valeurs par les spécificateurs de format.
>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.
'Spécifiez la largeur de caractère minimale du champ en ajoutant un entier après.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print('{0:10} ==> {1:10d}'.format(name, phone))
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678
Passez le dictionnaire comme argument et mettez des crochets'[]'Vous pouvez vous référer à la clé du dictionnaire en utilisant.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
table**] Comment passer comme argument de mot-clé en utilisant la notation.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Formatage de chaîne à l'aide de l'opérateur%
>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.
Deuxième argument de open: * Identique à fopen en langage C
| mode | mouvement | S'il y a un fichier | Si le fichier n'existe pas |
|---|---|---|---|
| r (Par défaut) | Lecture seulement | Pas de changement | Erreur |
| w | Écriture seule | Définir la taille sur 0 (écraser) | Créer un nouveau |
| a | Uniquement pour l'écriture supplémentaire | Ajouter à la fin du fichier | Créer un nouveau |
| r+ | Lire et écrire | Pas de changement | Erreur |
| w+ | Ecrire et lire | Définir la taille sur 0 (écraser) | Créer un nouveau |
| a+ | Lecture et écriture supplémentaire | Ajouter à la fin du fichier | Créer un nouveau |
Mode texte et mode binaire ・ Mode texte (par défaut) Convertir le code de saut de ligne Traiter le code de saut de ligne comme EOF (fin de fichier) ・ Mode binaire (b) ・ ・ ・ Spécifiez ici les données binaires telles que JPG et EXE. Ne pas convertir le code de saut de ligne Ne pas traiter le code de saut de ligne comme EOF (fin de fichier) Méthode de spécification: combiner avec le mode ci-dessus et régler sur «rb» et «r + b». (B peut être devant ou derrière, mais b est derrière)
Fichier ouvert.
f = open('workfile','wb')
lire et lire en ligne
f.read(size)Lire.
f = open('workfile','w')
>>> f.read()
'123\n456\n'
f.read(size)Lire par taille.
>>> f.read(5)
'123\n4' #Renvoie une chaîne d'octets spécifiés
>>> f.read(5)
'56\n' #Si les octets spécifiés ne sont pas atteints, seule la chaîne de caractères existante est renvoyée.
>>> f.read(5)
'' #Si tu atteins la fin''rends le
Lire avec readline.
>>> f.readline()
'123\n' #Renvoie ligne par ligne
>>> f.readline()
'456\n'
>>> f.readline()
'' #Si tu atteins la fin''rends le
Pour lire plusieurs lignes d'un fichier, écrivez une boucle sur l'objet fichier.
>>> f = open('workfile','r+')
>>> for line in f:
... print(line, end='')
...
123
456
Vous pouvez également utiliser list (f) ou f.readlines () si vous souhaitez lire chaque ligne du fichier au format liste
Écriture de fichier.
>>> f = open('workfile','r+')
>>> f.write('This is a test\n') #Écriture de fichier
15 #Le nombre de caractères écrits est renvoyé
>>> f.close()
>>> f = open('workfile','r+') #Vérifiez ci-dessous
>>> f.read()
'This is a test\n'
>>> f.close()
D'autres types d'objets doivent être convertis avant l'écriture Soit une chaîne (mode texte), soit un objet octets (mode binaire)
>>> f = open('workfile','r+')
>>> value = ('the answer', 42)
>>> s = str(value) #Chaîne
>>> value
('the answer', 42)
>>> s
"('the answer', 42)"
>>> f.write(s)
18
>>> f.close()
f.tell () ・ ・ ・ Renvoie un entier indiquant la position actuelle dans le fichier f.seek (décalage, point de départ) ・ ・ ・ Lorsque vous souhaitez changer la position actuelle Point de départ: début du fichier "0" (par défaut), position actuelle "1", fin du fichier "2"
Erreur de lecture sans ouvrir le fichier * Le Web est décrit dans la lecture et l'écriture de fichiers.
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.
Utilisez le mot-clé avec lorsque vous traitez des objets fichier. Lorsque vous quittez une série d'enquêtes, le dossier est fermé correctement et toutes les exceptions se produisent au milieu. Beaucoup plus court que le bloc d'action d'essai du parti.
Fichier ouvert / lu * Le Web est décrit dans la lecture / l'écriture de fichiers.
>>> with open('workfile') as f:
... read_data = f.read()
...
>>> f.closed
True
Les objets fichier ont également des méthodes telles que isatty () et truncate (), mais elles sont rarement utilisées
Les chaînes de caractères peuvent être lues et écrites librement dans des fichiers, mais les valeurs numériques nécessitent un petit effort. La méthode read () ne renvoie qu'une chaîne, vous devez donc passer par une fonction telle que int (). Lorsqu'il s'agit de données complexes, il est compliqué de le faire manuellement.
Python facilite le travail avec JSON
>>> import json
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'
>>> import json
>>> x = {'name':'yamada','data':[2,3,4]}
>>> print(json.dumps(x))
{"name": "yamada", "data": [2, 3, 4]}
dump ・ ・ ・ Sérialiser simplement l'objet dans un fichier texte charger ・ ・ ・ Désérialiser
(Voir) module pickle Un protocole qui vous permet de sérialiser n'importe quel objet Python complexe, par opposition à JSON. Cependant, il est unique à Python et ne peut pas être utilisé pour communiquer avec des applications écrites dans d'autres langages. De plus, il n'est pas sécurisé par défaut.
Le contenu d'affichage du message d'erreur lorsqu'une exception se produit dans la fonction est important
Se produit car il ne suit pas les règles définies par Python. Erreur d'interprétation (d'analyse) de la syntaxe Affichage: SyntaxError
Même si l'expression de champ est syntaxiquement correcte, une erreur se produit lors de son exécution. Affichage: ZeroDivisionError, NameError, TypeError, etc. Il existe une liste d'exceptions intégrées dans Exceptions intégrées
♯ ## Gestion des exceptions Comportement de l'instruction try
Spécifiez des gestionnaires pour diverses exceptions en fournissant plusieurs clauses except dans une instruction try
... except (RuntimeError, TypeError, NameError):
Les variables peuvent être spécifiées après le nom de l'exception dans la clause except La variable est liée à une instance d'exception et instance.args contient les arguments permettant de créer l'instance d'exception. Str () est défini dans l'instance d'exception et l'argument peut être imprimé directement sans faire référence à .args.
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
... print(type(inst))
... print(inst.args)
... print(inst.args)
... x, y = inst.args
... print('x =', x)
... print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs
Le gestionnaire d'exceptions gère également les exceptions qui se produisent dans une fonction appelée (même indirectement) à partir de la clause try. (Pas seulement des exceptions qui se produisent directement dans la clause try)
clause else (clause else) ・ ・ ・ La clause else est exécutée lorsqu'aucune exception n'est levée dans la clause try. L'instruction try… except peut éventuellement avoir une clause else S'il y a une clause else, elle doit être placée après toutes les clauses except
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
Vous pouvez utiliser l'instruction rise pour lever certaines exceptions
Vous pouvez inclure vos propres exceptions dans votre programme en créant une nouvelle classe d'exceptions. Vous pouvez définir tout ce qu'une classe normale peut faire, mais n'autorisez généralement le gestionnaire qu'à récupérer des informations sur l'erreur lorsqu'une exception se produit.
class Error(Exception):
pass
class InputError(Error):
def __init__(self, expression, message): #Primordial
self.expression = expression
self.message = message
La clause finally est toujours exécutée avant de quitter l'instruction try, indépendamment du fait qu'une exception se soit produite.
Le problème ci-dessous est que le fichier est laissé ouvert
for line in open("myfile.txt"):
print(line, end="")
L'instruction with garantit que les objets tels que les fichiers sont toujours nettoyés immédiatement et correctement.
with open("myfile.txt") as f:
for line in f:
print(line, end="")
Les objets ont une individualité et le même objet peut se voir attribuer plusieurs noms (à partir de plusieurs portées). (Dans d'autres langues, cela s'appelle l'aliasing)
Un espace de noms est un mappage d'un nom à un objet. Une étendue est une plage de texte de programme accessible directement depuis un espace de noms.
(La forme la plus simple)
class ClassName:
<Phrase 1>
.
.
.
Les objets de classe prennent en charge deux types d'opérations: la référence d'attribut et l'instanciation.
Référence d'attribut Instanciation
>>> class Complex:
... def __init__(self, realpart, imagpart):
... self.r = realpart
... self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)
Les objets Instance ne prennent en charge que les opérations de référence d'attribut. Deux types de noms d'attributs, attributs de données et méthodes, sont valides
Les attributs de données correspondent aux "variables d'instance" Smalltalk et aux "membres de données" C ++ Une méthode est une fonction qui "appartient" à un objet.
· Les variables d'instance concernent les données uniques de chaque instance · Les variables de classe concernent les attributs et méthodes partagés par toutes les instances de cette classe
-Les attributs de données écrasent les attributs de méthode avec le même nom → Utilisez des règles qui minimisent la possibilité de collision Commencez le nom de la méthode par une lettre supérieure, préfixez le nom de l'attribut de données avec une courte chaîne unique (ou juste un soulignement), utilisez un verbe pour la méthode, utilisez un nom pour l'attribut de données, etc. Le premier argument de la méthode s'appelle self, mais cette dénomination n'est qu'une convention
class DerivedClassName(BaseClassName):
<Phrase 1>
.
.
.
class DerivedClassName(Base1,Base2,Base3):
Si l'attribut dans DerivedClassName n'existe pas, il sera d'abord recherché à partir de Base1, puis récursivement à partir de la classe de base de Base1, et s'il n'est toujours pas trouvé, il sera recherché à partir de Base2.
Mais en réalité, c'est un peu plus compliqué que ça L'ordre de résolution des méthodes est modifié dynamiquement en raison de l'appel collaboratif à super (). Connue sous le nom de méthode call-next dans d'autres langues avec héritage multiple, elle est plus puissante que le super appel dans les langues avec un seul héritage.
Il n'y a pas de variables d'instance "privées" en Python. Cependant, il est habituel de traiter les noms commençant par un trait de soulignement (par exemple _spam) comme privés.
-Les types de données qui regroupent des éléments de données nommés, tels que «record» de Pascal et «struct» en langage C, sont implémentés en utilisant la définition de la classe shell.
Vous pouvez utiliser l'instruction for pour parcourir la plupart des objets conteneurs.
>>> for element in [1, 2, 3]:
... print(element)
...
1
2
3
>>> for element in (1, 2, 3):
... print(element)
...
1
2
3
>>> for key in {'one':1, 'two':2}:
... print(key)
...
one
two
>>> for char in "123":
... print(char)
...
1
2
3
>>> for line in open("workfile"):
... print(line, end='')
...
0123456789abcdef2)>>>
Dans les coulisses, l'instruction for appelle la fonction iter () sur l'objet conteneur.
-La fonction retourne un objet itérateur qui définit la méthode next () qui accède aux éléments du conteneur un par un. -S'il n'y a plus d'éléments, la méthode next () lève une exception StopIteration et la boucle for se termine à la réception de la notification.
Vous pouvez également appeler la méthode next () directement en utilisant la fonction intégrée next ().
>>> s = 'abc'
>>> it = iter(s)
>>> it
<str_iterator object at 0x7fc6cf183eb8>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration #Lancer une exception StopIteration
Il est facile d'ajouter un comportement itératif à votre classe si vous observez les mécanismes derrière le protocole d'itérateur.
Définissez une méthode iter () qui renvoie un objet avec une méthode next (). Si la classe définit la méthode next (), la méthode iter () peut également simplement renvoyer self.
>>> class Reverse:
... """Iterator for looping over a sequence backwards."""
... def __init__(self, data):
... self.data = data
... self.index = len(data)
... def __iter__(self):
... return self
... def __next__(self):
... if self.index == 0:
... raise StopIteration
... self.index = self.index - 1
... return self.data[self.index]
...
>>> rev = Reverse('123')
>>> iter(rev)
<__main__.Reverse object at 0x7fc6cf18ec88>
>>> for char in rev:
... print(char)
...
3
2
1
-Generator est un outil concis et puissant pour créer des itérateurs. -Utiliser la déclaration de rendement lors du retour de certaines données -À chaque fois que next () est appelé sur le générateur, le générateur reprend le traitement précédemment interrompu (enregistrement de l'état).
>>> def reverse(data):
... for index in range(len(data)-1, -1, -1):
... yield data[index]
...
>>> for char in reverse('golf'):
... print(char)
...
f
l
o
g
Pour un générateur simple, il existe un moyen simple de le coder à l'aide d'une expression. Une expression avec une syntaxe similaire à l'inclusion de liste, mais avec des parenthèses au lieu de crochets.
>>> sum(i*i for i in range(10))
285
module os ・ ・ ・ lié au système d'exploitation
>>> import os
>>> os.getcwd()
'/root/sample/test'
>>> os.chdir('/root')
>>> os.system('mkdir today')
0
Utilisez le format import os au lieu de from os import *
>>> import os
>>> dir(os)
>>> help(os)
module shutil: une interface de haut niveau plus simple à utiliser pour la gestion quotidienne des fichiers et des répertoires.
>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
'archive.db'
>>> shutil.move('/build/executables', 'installdir')
'installdir'
module glob ・ ・ ・ Obtenez le nom du chemin du fichier qui correspond au modèle spécifié dans l'argument
>>> import glob
>>> glob.glob('*.py')
>>> glob.glob('*') #Sortie de tous les noms de fichiers dans le répertoire
>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']
Le module sys a également des attributs pour stdin, stdout et stderr
Le module re fournit des expressions régulières pour un traitement plus avancé des chaînes
Le module math fournit un moyen d'accéder aux fonctions de la bibliothèque en langage C pour l'arithmétique en virgule flottante
>>> import math
>>> math.cos(math.pi / 4)
0.7071067811865476
>>> math.log(1024, 2) # log(x[, base]):X(Avec e en bas)Logarithmique naturelle
10.0
>>> math.sqrt(2) #Obtenir la racine carrée
1.4142135623730951
Le module aléatoire fournit un outil de sélection d'éléments basé sur des nombres aléatoires
>>> import random
>>> random.choice(['apple','pear','banana'])
'pear'
>>> random.sample(range(100), 10)
[6, 49, 57, 72, 31, 25, 35, 90, 30, 76]
>>> random.random()
0.7892340475238878
>>> random.randrange(6)
5
Le module statistique calcule les caractéristiques statistiques de base des données numériques (moyenne, médiane, variance, etc.)
SciPy Project fournit de nombreux modules pour le traitement numérique
Les deux modules les plus simples sont urllib.request pour récupérer les données d'une URL et smtplib pour envoyer un email.
Le module datetime fournit des classes pour manipuler les dates et les heures de manière simple et complexe.
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2020, 1, 3)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'01-03-20. 03 Jan 2020 is a Friday on the 03 day of January.'
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
20244
Modules: zlib, gzip, bz2, lzma, zipfile, tarfile
>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979
module timeit
>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.025199586991220713
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.022948098019696772
Le module doctest fournit des outils pour rechercher des modules et évaluer des tests intégrés dans la docstring du programme.
batterie incluse: Une bibliothèque et un environnement intégré pouvant être utilisés immédiatement par le programmeur sont préparés à l'avance. modules xmlrpc.client et xmlrpc.server package de courrier électronique package json module sqlite3 gettext, locale, package de codecs
-Reprlib module: limite la longueur de sortie, peut être modifié, mais la valeur par défaut est de 6 éléments
reprlib.repr et repr.
>>> reprlib.repr('1111122222333334444455555666667777788888')
"'111112222233...6667777788888'" #Omis en chemin
>>> repr('1111122222333334444455555666667777788888')
"'1111122222333334444455555666667777788888'" #(Comparaison)résultat de repr
reprlib.repr et repr:Combiné avec set set.
>>> reprlib.repr(set('1111122222333334444455555666667777788888'))
"{'1', '2', '3', '4', '5', '6', ...}" #Rendez-le unique en utilisant l'ensemble de jeu et omettez le dos
>>> repr(set('1111122222333334444455555666667777788888'))
"{'5', '3', '8', '2', '6', '1', '4', '7'}" #(Comparaison)résultat de repr
>>> reprlib.repr({'d', 'e', 't', 'c', 'n', 'o', 'v', 'i'})
"{'c', 'd', 'e', 'i', 'n', 'o', ...}"
-Module d'impression -Module Textwrap: ajuste le texte composé de paragraphes afin qu'il s'adapte exactement à la largeur d'écran spécifiée. ・ Module local
Le module string contient la classe Template, qui est flexible et a une syntaxe simple que les utilisateurs finaux peuvent facilement modifier.
>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'
La méthode substitute () lève une KeyError s'il n'y a pas d'équivalent d'espace réservé dans le dictionnaire ou l'argument de mot-clé.
module struct ・ ・ ・ Fournit des fonctions telles que pack () et unpack () qui exploitent des formats d'enregistrement binaire de différentes longueurs.
>>> import struct
>>> kind, value = struct.unpack("BxH", data)
>>> data
b'd\x00\xb0\x04'
Le thread est une technique permettant de fractionner plusieurs tâches qui ne sont pas par ordre de dépendance. Le problème le plus difficile dans la création d'une application multi-thread est la coordination entre les threads qui partagent des données et des ressources.
Le module de journalisation fournit un système de journalisation flexible avec de nombreuses fonctions.
>>> import logging
>>> logging.debug('Debugging information')
>>> logging.info('Informational message')
>>> logging.warning('Warning:config file %s not found', 'server.conf')
WARNING:root:Warning:config file server.conf not found
>>> logging.error('Error occurred')
ERROR:root:Error occurred
>>> logging.critical('Critical error -- shutting down')
CRITICAL:root:Critical error -- shutting down
Par défaut, la sortie info () et debug () est supprimée et la sortie est envoyée aux erreurs standard
Python gère automatiquement la mémoire (la plupart des objets sont gérés par le comptage de références et le garbage collection supprime les références circulaires). La mémoire est libérée peu de temps après la disparition de la dernière référence à l'objet.
Le module decimal fournit des types de données Decimal qui prennent en charge les opérations arithmétiques de fraction flottante décimale.
Étant donné que la classe Decimal peut représenter des valeurs exactes, elle permet également le calcul des restes et des tests d'égalité qui ne peuvent pas être calculés comme prévu avec des nombres binaires à virgule flottante. module décimal ・ ・ ・ Calcul arithmétique avec la précision requise
pyvenv tutorial-env Créez le répertoire tutorial-env s'il n'existe pas et créez un sous-répertoire à l'intérieur qui contient l'interpréteur Python, les bibliothèques standard et d'autres fichiers associés.
pip search astronomy pip install novas pip install requests==2.6.0 pip install --upgrade requests pip show requests pip list pip freeze > requirements.txt pip install -r requirements.txt pip uninstall request
Apprendre après avoir appris le tutoriel et divers liens
-La complétion des variables et des noms de modules est automatiquement activée au démarrage de l'interpréteur, et la fonction de complétion peut être appelée avec la touche [Tab]. · Par défaut, enregistrez l'historique dans un fichier nommé .python_history dans votre répertoire utilisateur
IPython bpython
Les nombres à virgule flottante sont représentés dans le matériel informatique sous forme de fractions (binaires) avec une base de 2.
L'erreur de représentation est liée au fait que certaines fractions décimales (en fait la plupart) ne peuvent pas être représentées sous forme de fractions binaires (base 2).
>>> from decimal import Decimal
>>> from fractions import Fraction
>>> Fraction.from_float(0.1)
Fraction(3602879701896397, 36028797018963968)
>>> (0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)
>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> format(Decimal.from_float(0.1), '.17')
'0.10000000000000001'
Recommended Posts