C'est une continuation de Tips ① Je vais l'écrire brièvement, donc je pense qu'il y a beaucoup de choses qui ne sont pas strictes, mais s'il y a des erreurs, veuillez commenter ~
J'ai utilisé le type de liste plusieurs fois, vous le savez donc, mais c'est un tableau sans taille spécifiée. Puisqu'il s'agit d'un objet liste, il est possible d'écrire ʻa = list () en plus de ʻa = [].
Le type liste garantit l'ordre des éléments.
python:Python3.5.0
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a.append(0) #Ajouter l'élément 0 après
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a.insert(1,0) #Ajouter l'élément 0 au numéro d'index spécifié
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a[0] #Élément d'accès avec index 0
1
>>> a[2] #L'index accède au deuxième élément
2
>>> a[-1] #L'index accède au premier élément par l'arrière(Il n'y a pas de 0)
0
>>> a[2:5] #L'index accède aux 2e au 5e éléments
[2, 3, 4]
>>> a[2:-2] #L'index accède au deuxième élément du premier au deuxième
[2, 3, 4, 5, 6, 7, 8]
>>> a[2:-2:2] ##L'index accède au deuxième élément du premier au deuxième élément en deux étapes.
[2, 4, 6, 8]
>>> b = [1.1, 1.2, 1.3, 1.4, 1.5]
>>> a.extend(b) #Rejoindre des listes
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1.1, 1.2, 1.3, 1.4, 1.5]
>>> a.pop() #Extraire et supprimer le dernier élément de la liste
1.5
>>> a
[1, 0, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1.1, 1.2, 1.3, 1.4]
>>> sorted(a) #Trier(ordre croissant)
[0, 0, 1, 1.1, 1.2, 1.3, 1.4, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sorted(a, reverse=True) #Trier(Ordre décroissant)
[9, 8, 7, 6, 5, 4, 3, 2, 1.4, 1.3, 1.2, 1.1, 1, 0, 0]
>>> len(a) #Longueur de la liste
16
Je suis enfin là ... C'est unique à Python! !! L'exemple qui est sorti plus tôt dans l'instruction for
python:Python3.5.0
>>> for i in range(1,10):
... a.append(i)
...
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Cela peut être écrit sur une seule ligne.
python:Python3.5.0
>>> a = [i for i in range(1,10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
Cela peut être un peu désagréable à première vue, mais c'est assez pratique une fois que vous vous y êtes habitué. À propos, il semble que la vitesse d'exécution soit plus rapide que de la tourner avec une instruction for normale.
python:Python3.5.0
>>> a = [i for i in range(1,10) if i % 2 == 0]
>>> a
[2, 4, 6, 8]
>>> a = [i if i % 2 == 0 else i*i for i in range(1,10)]
>>> a
[1, 2, 9, 4, 25, 6, 49, 8, 81]
>>> a = [[j for j in range(i)] for i in range(1,10)]
>>> a
[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5, 6], [0, 1, 2, 3, 4, 5, 6, 7], [0, 1, 2, 3, 4, 5, 6, 7, 8]]
>>>
Il peut être obscurci autant que vous le souhaitez, donc modérément ...
Notez qu'en Python, les objets sont passés par référence. int / float / str / unicode (série 2.x) ressemble à passer par valeur, mais à passer par référence pour les objets immuables (ce n'est pas faux ...). Eh bien, ce que vous devez savoir, c'est que le type de liste est passé par référence (il en va de même pour le type de tapple, le type d'agrégat et le type de dictionnaire). Donc, si vous voulez le passer comme argument à une autre variable ou fonction, vous devez le copier explicitement.
python:Python3.5.0
>>> a = [i for i in range(10)]
>>> b = a
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.pop()
9
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> b #b est également parti! !!
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> c = list(a) #Ce sera une copie(Différentes instances sont générées)
>>> from copy import copy
>>> d = copy(c) #le module de copie peut également être utilisé
>>> a.pop()
8
>>> a
[0, 1, 2, 3, 4, 5, 6, 7]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7]
>>> c
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> d
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>>
Cependant, il convient de noter que «list (a)» et «copy (a)» sont des copies superficielles. Une copie superficielle signifie que les objets profonds tels que ceux avec des listes imbriquées dans la liste ne sont pas copiés, seuls les objets les moins profonds sont copiés et les objets plus profonds sont passés par référence (difficile à expliquer). Ce problème est résolu en utilisant le module de copie deepcopy.
python:Python3.5.0
>>> a = [[j for j in range(4)] for i in range(4)]
>>> a
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> from copy import copy
>>> b = copy(a) #Copie superficielle
>>> a[0].pop() #Pop de la liste des éléments
3
>>> a #Les éléments sautés disparaissent de la liste des éléments
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> b #Celui qui apparaît disparaît de la liste des éléments de liste copiés! !!
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> from copy import deepcopy
>>> c = deepcopy(a) #Copie profonde
>>> a[0].pop()
2
>>> a
[[0, 1], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> b
[[0, 1], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> c #Pas disparaître! !!
[[0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
>>> a is b #Les instances d'objet les moins profondes sont différentes
False
>>> a[0] is b[0] #Les objets stockés plus profondément que cela seront la même instance en passant par référence
True
>>> a[0] is c[0] #deepcopy ↓ Les objets sont également passés par valeur
False
>>>
Le type de tuple est représenté par tuple. Le type tapple est essentiellement un agencement d'éléments comme une liste, mais une fois qu'une valeur est stockée, cette valeur ne peut pas être modifiée.
python:Python3.5.0
>>> a = tuple() #Taple vide
>>> a = (1,2,3,4,5) #1~Tapez avec 5 dans l'ordre
>>> a[1] #L'index accède au premier élément
2
>>> a[1:3] #Accéder aux éléments dont l'index est du 1er au 3ème
(2, 3)
>>> a[0:5:2] #Accéder aux éléments avec les index 0 à 5 à l'étape 2
(1, 3, 5)
>>> a[0] = 1 #J'obtiens une erreur lorsque j'attribue
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a = (1,) #Générer du tapple
>>> a
(1,)
>>> a = (1) #,Sans ça, ce ne sera pas un tuple
>>> a
1
>>>
La seule mise en garde est qu'il ne devient pas un taple sans virgule.
Le type d'ensemble est représenté par ensemble. Le type collectif est une collection d'éléments comme le type liste, mais l'ordre n'est pas garanti car il n'autorise pas les éléments en double.
python:Python3.5.0
>>> a = set() #Ensemble vide
>>> a
set([])
>>> a = {i for i in range(10)} #Notation d'inclusion
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.add(10) #Ajouter 10
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a.add(10) #Ajouter 10(Ça ne change pas parce qu'il existe déjà)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> a.remove(10) #Supprimer 10
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.remove(10) #Supprimer 10(Ce sera une erreur car ce n'est pas dans l'élément)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10
>>> a.add(10)
>>> a.discard(10) #Supprimer 10
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.discard(10) #Supprimer 10(Sinon, ne rien faire)
>>> a
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = {1,2,3,4,5}
>>> b.issubset(a) #Si b est un sous-ensemble de a
True
>>> b.issuperset(a) #Si a est un sous-ensemble de b
False
>>> c = {2,4,6,8,10,12,14,16,18,20}
>>> a.union(c) #Somme ensemble de deux ensembles
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20])
>>> a.intersection(c) #Ensemble de produits de deux ensembles
set([8, 2, 4, 6])
>>> a.difference(c) #Élément de a et non élément de c(a-c)ensemble
set([0, 1, 3, 5, 7, 9])
>>> a.symmetric_difference(c) #Somme logique exclusive de deux ensembles
set([0, 1, 3, 5, 7, 9, 10, 12, 14, 16, 18, 20])
>>> a_copy = a.copy() #Copie de l'ensemble(Passer par valeur)
>>> a is a_copy #Différentes instances dues au passage par valeur
False
>>> a == a_copy #La valeur est la même
True
>>> a_copy.update(c) #Ajouter des éléments d'autres ensembles à l'ensemble cible
>>> a_copy
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20])
>>> a_copy.pop() #Extraire et supprimer n'importe quel élément
0
>>> a_copy.clear() #Supprimer tous les éléments
>>> a_copy
set([])
>>>
** ~~ @ zakuro9715 a souligné et ajouté et corrigé le hachage ~~ **
** Correction du hachage signalé sur Twitter **
Il est important que les éléments soient hachés et triés, comme c'est le cas si vous voulez éviter la duplication d'éléments comme une utilisation de l'ensemble (peut-être pour éliminer la duplication d'éléments, peut-être).
En effet, la table de hachage est utilisée lors de l'analyse des éléments, vous pouvez donc utiliser O (1) en moyenne *, mais sinon, ce sera O (N). En d'autres termes, cela fonctionne mieux lorsque vous faites quelque chose comme ʻa in b. Le type de liste nécessite N × len (b) scans si vous faites quelque chose comme ʻa in b dans N boucles car les éléments ne sont pas hachés.
D'autre part, le type d'agrégat (également la clé de type de dictionnaire) est haché, de sorte qu'une telle analyse n'est pas effectuée.
Par conséquent, si le nombre de boucles est grand et qu'il y a de nombreux éléments, il est recommandé de transtyper en un type collectif et de juger ensuite les conditions telles que «a dans b».
Le type de dictionnaire est représenté par dict. Dans le type de dictionnaire, il est stocké sous forme de paire clé / valeur.
** En réponse au point de @ zakuro9715, j'ai ajouté et corrigé les paramètres clés ** La clé (ou valeur) ~~ peut être définie sur n'importe quel objet. ~~ La clé peut être définie ** s'il s'agit d'un objet hachable **. (Par exemple, vous ne pouvez pas définir un dict qui a un dict comme clé) Tout objet peut être défini pour la valeur.
python:Python3.5.0
>>> a = dict() #Générer un type de dictionnaire vide
>>> a = {str(i)+u"Th": i*i for i in range(10)}
>>> a
{'Premier': 1, '0ème': 0, '7e': 49, '4e': 16, '8ème': 64, '6e': 36, '9ème': 81, 'Cinquième': 25, 'La deuxième': 4, 'Le troisième': 9}
>>> a["0ème"] #"0ème"Obtenez la valeur de la clé
0
>>> a["Cinquième"] #"Cinquième"Obtenez la valeur de la clé
25
>>> a["10e"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: '10e'
>>> a.get(u"10e") #"10e"Obtenez la valeur de la clé(Non mais renvoie None au lieu d'une erreur)
>>> a.get(u"10e", 100) #"10e"Obtenez la valeur de la clé. Sinon, la valeur définie dans le deuxième argument est renvoyée.
100
>>> a.get(u"9ème", "100") #"9ème"Obtenez la valeur de la clé. Sinon, la valeur définie dans le deuxième argument est renvoyée.
81
>>> a.keys() #Dictez la clé_Retour en tant qu'objet appelé clés (liste en 2 séries)
dict_keys(['4e', 'Le troisième', 'Cinquième', 'La deuxième', '8ème', '0ème', '9ème', 'Premier', '7e', '6e'])
>>> a.values() #Dictez la valeur_Retour en tant qu'objet appelé values (liste en 2 séries)
dict_values([16, 9, 25, 4, 64, 0, 81, 1, 49, 36])
>>> a.items() #Dictez la clé et la valeur taple_Retourner comme un objet appelé items (liste en 2 séries)
dict_items([('4e', 16), ('Le troisième', 9), ('Cinquième', 25), ('La deuxième', 4), ('8ème', 64), ('0ème', 0), ('9ème', 81), ('Premier', 1), ('7e', 49), ('6e', 36)])
>>> "Premier" in a #Vérifiez s'il y a une clé
True
>>> del a["0ème"] #Supprimer la valeur de la clé correspondante
>>> a.pop(u"Premier") #Obtenez la valeur de la clé correspondante et supprimez-la
1
>>> a.popitem() #Obtenez et supprimez n'importe quel élément
('4e', 16)
>>> a
{'Le troisième': 9, 'Cinquième': 25, 'La deuxième': 4, '8ème': 64, '9ème': 81, '7e': 49, '6e': 36}
>>> b = a #Passer par référence
>>> c = a.copy() #Passer par valeur
>>> a is b #Même instance
True
>>> a is c #Différentes instances
False
>>> a == c #La valeur est la même
True
>>> a.clear() #Tout supprimer
>>> a
{}
>>> b #Supprimé car il s'agit de la même instance
{}
>>> c #Cela ne change pas parce que c'est une instance différente
{'9ème': 81, 'Cinquième': 25, 'La deuxième': 4, '8ème': 64, 'Le troisième': 9, '7e': 49, '6e': 36}
>>>
>>> a = {str(i)+"Th": i*i for i in range(10)} #Notation d'inclusion de dictionnaire
>>> a_copy = a.copy()
>>> a_copy.update({"0ème": 10})
>>> a_copy["0ème"]
10
>>>
Il existe de nombreuses façons utiles de compter et d'itérer, en particulier dans les listes et les dictionnaires, alors en voici quelques-unes que vous pourriez utiliser avec votre propre jugement et vos propres préjugés.
python:Python3.5.0
>>> a = [i for i in range(1,6)]
>>> #Sortie avec numéro d'index
>>> for i, num in enumerate(a):
... print "{}Élément du deuxième index:{}".format(i, num)
...
0e élément d'index: 1
Premier élément d'index: 2
Deuxième élément d'index: 3
Troisième élément d'index: 4
Quatrième élément d'index: 5
>>> #Itite deux listes en même temps
>>> b = [str(i)+u"Deuxième index" for i in range(5)]
>>> for a_num, b_num in zip(a, b):
... print(b_num+u"："+str(a_num))
...
0ème indice: 1
1er indice: 2
Deuxième indice: 3
Troisième indice: 4
4ème indice: 5
>>> c = [[j**i for j in range(1,5)] for i in range(1,5)]
>>> c
[[1, 2, 3, 4], [1, 4, 9, 16], [1, 8, 27, 64], [1, 16, 81, 256]]
>>> #Peut également être utilisé pour la translocation
>>> c_t = [[i, j, k, l] for i, j, k, l in zip(*c)]
>>> c_t
[[1, 1, 1, 1], [2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256]]
>>>
>>> from itertools import product, permutations, combinations, combinations_with_replacement
>>> #Comportement lors de l'imbrication d'instructions(Vous pouvez spécifier la profondeur d'imbrication avec répétition)
>>> for pear in product(a, repeat=2):
... print(pear)
...
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(2, 5)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
(3, 5)
(4, 1)
(4, 2)
(4, 3)
(4, 4)
(4, 5)
(5, 1)
(5, 2)
(5, 3)
(5, 4)
(5, 5)
>>> #Ordre qui ne permet pas de couvrir
>>> for pear in permutations(a, 2):
... print(pear)
...
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 1)
(2, 3)
(2, 4)
(2, 5)
(3, 1)
(3, 2)
(3, 4)
(3, 5)
(4, 1)
(4, 2)
(4, 3)
(4, 5)
(5, 1)
(5, 2)
(5, 3)
>>> #Une combinaison qui ne permet pas de couvrir
>>> for pear in combinations(a, 2):
... print(pear)
...
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 3)
(2, 4)
(2, 5)
(3, 4)
(3, 5)
(4, 5)
>>> #Combinaison qui permet de couvrir
>>> for pear in combinations_with_replacement(a, 2):
... print(pear)
...
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(1, 5)
(2, 2)
(2, 3)
(2, 4)
(2, 5)
(3, 3)
(3, 4)
(3, 5)
(4, 4)
(4, 5)
(5, 5)
>>>
python:Python3.5.0
>>> from itertools import combinations
>>> from collections import defaultdict, Counter
>>>
>>> #Créer un dictionnaire avec des dictionnaires imbriqués
>>> a = {}
>>> for key, val in combinations([i for i in range(6)], 2):
... if key not in a:
... a[key] = {}
... a[key][val] = key*val
...
>>> a
{0: {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, 1: {2: 2, 3: 3, 4: 4, 5: 5}, 2: {3: 6, 4: 8, 5: 10}, 3: {4: 12, 5: 15}, 4: {5: 20}}
>>>
>>> a = defaultdict(dict)
>>> for key, val in combinations([i for i in range(6)], 2):
... a[key][val] = key*val
...
>>> a
defaultdict(<type 'dict'>, {0: {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}, 1: {2: 2, 3: 3, 4: 4, 5: 5}, 2: {3: 6, 4: 8, 5: 10}, 3: {4: 12, 5: 15}, 4: {5: 20}})
>>>
>>>
>>> #Lors du stockage du compte pour une certaine clé dans le dictionnaire
>>> a = {}
>>> for key, val in combinations([i for i in range(6)], 2):
... if key in a:
... a[key] += val
... else:
... a[key] = val
...
>>> a
{0: 15, 1: 14, 2: 12, 3: 9, 4: 5}
>>> a = Counter()
>>> for key, val in combinations([i for i in range(6)], 2):
... a[key] += val
>>> a
Counter({0: 15, 1: 14, 2: 12, 3: 9, 4: 5})
>>>
Si vous êtes intéressé par d'autres choses, veuillez consulter Référence.
Ensuite, comment écrire une fonction. Ici, comme moyen de base pour écrire une fonction, j'écrirai à propos de la définition de la fonction, écriture de l'instruction / de l'argument (réglage par défaut) / valeur de retour (retour, rendement).
python:Python3.5.0
>>> #La manière la plus élémentaire d'écrire
>>> def hello():
... print("Hello world!!")
...
>>> hello()
Hello world!!
>>>
>>> #Comment écrire quand il y a un argument
>>> def hello_name(name):
... print("Hello {}!!".format(name))
...
>>> hello_name("Guido")
Hello Guido!!
>>>
>>> #Comment écrire lorsque l'argument a une valeur par défaut
>>> def hello_name(name="world"):
... print("Hello {}!!".format(name))
...
>>> hello_name()
Hello world!!
>>> hello_name("Guido")
Hello Guido!!
>>>
>>> #Comment écrire quand il y a une valeur de retour
>>> def hello_return(name):
... return "Hello {}!!".format(name)
...
>>> result = hello_return("Guido")
>>> print(result)
Hello Guido!!
>>>
>>> #Valeur de retour(Type de générateur)Comment écrire quand il y a
>>> def hello_yield(name):
... for s in name:
... yield s
...
>>> generater = hello_yield("Hello Guido!!")
>>> generater.next()
'H'
>>> generater.next()
'e'
>>> generater.next()
'l'
>>> generater.next()
'l'
>>> generater.next()
'o'
>>> generater.next()
' '
>>> generater.next()
'G'
>>> generater.next()
'u'
>>> generater.next()
'i'
>>> generater.next()
'd'
>>> generater.next()
'o'
>>> generater.next()
'!'
>>> generater.next()
'!'
>>> generater.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
En tant que débutant, l'expression du générateur peut être difficile à comprendre, mais vous n'avez pas à réfléchir sérieusement, pensez simplement "rappelez-vous l'état précédent de l'appel et renvoyez l'état suivant avecnext ()" ". S'il n'y a pas d'état suivant, une exception de la classeStopIteration` sera lancée, il est donc préférable de la contrôler avec try / sauf lorsque vous l'utilisez réellement.
python:Python3.5.0
>>> generater = hello_yield("Hello Guido!!")
>>> while True:
... try:
... result = generater.next()
... print(result)
... except StopIteration:
... break
...
H
e
l
l
o
G
u
i
d
o
!
!
>>>
Tout d'abord, à propos de la manière de base d'écrire une classe, je vais l'écrire ici car c'est un peu différent entre 2 séries et 3 séries.
python:Python2.7.9
>>> class Hello(object):
... prefix = "Hello "
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>>
Il s'agit d'un style d'écriture à deux systèmes qui hérite de la classe de base ʻobject, qui est un nouveau style de classe. Assurez-vous d'écrire «self» dans le premier argument de la méthode d'instance «hello» comme un mot réservé. Il s'agit de se référer à vous-même (instance), ceci en PHP. En d'autres termes, écrire ʻInstance.method (val) est lu commeClass.method (self, val).
Il existe aussi un ancien style de classe, donc vous ne pouvez écrire que class Hello: sans écrire ʻobject. Cependant, le nouveau style et l'ancien style ont des spécifications différentes (priorité d'héritage / méthode de classe, méthode / propriété statique), donc le nouveau style de classe est recommandé. C'est aussi parce que nous avons apporté des améliorations sans casser les anciennes spécifications. Par contre, dans la 3e série, class Hello:` sera le nouveau style de classe de la 2e série.
L'opération ne change pas, mais je l'écrirai pour le moment.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>>
Strictement parlant, ce n'est pas un constructeur, mais Python a une méthode appelée __init__ qui est appelée lorsqu'une instance est créée, et vous pouvez écrire ici un traitement de type constructeur.
python:Python3.5.0
>>> class Hello:
... def __init__(self, prefix="Hello "):
... self.prefix = prefix
... def hello(self, name="world"):
... print(self.prefix+name+"!!")
...
>>> HelloInstance = Hello()
>>> HelloInstance.hello()
Hello world!!
>>> HelloInstance.hello("Guido")
Hello Guido!!
>>> HelloInstance = Hello("Hey ")
>>> HelloInstance.hello("Guido")
Hey Guido!!
>>>
Au fait, il existe une méthode appelée «new» qui est appelée avant «init».
Il renvoie sa propre instance, et «__init __» est exécuté lorsque sa propre instance est renvoyée.
Vous pouvez personnaliser __new__ pour renvoyer une instance autre que vous-même, mais il n'y a aucun avantage. .. ..
Eh bien, ce n'est pas complètement hors de question, et vous pouvez écrire des métaclasses, mais est-ce pour les débutants? Je me sens comme ça, alors je vais l'omettre.
(Des astuces pour sortir des débutants / Des astuces pour les utilisateurs intermédiaires seront écrites dans un autre article)
En Python, si vous définissez une méthode dans une classe, il s'agit d'une méthode d'instance sauf indication contraire. Comme mentionné précédemment, le premier argument d'une méthode d'instance est «self», qui pointe vers sa propre instance. Cependant, vous pouvez également écrire des méthodes de classe et des méthodes statiques. Les différences de fonctionnement ainsi que la façon d'écrire des méthodes d'instance, des méthodes de classe et des méthodes statiques sont indiquées ci-dessous, mais vous ne les comprendrez peut-être pas si vous ne comprenez pas l'orientation des objets en premier lieu.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def __init__(self, prefix=None):
... if prefix:
... self.prefix = prefix + " "
... def hello(self, name="world"):
... """
...Méthode d'instance: le premier argument est self
... """
... print(self.prefix+name+"!!")
... @classmethod
... def hello_cls(cls, name="world"):
... """
...Méthode de classe: le premier argument est cls
... """
... print(cls.prefix+name+"!!")
... @staticmethod
... def hello_stc(name="world"):
... """
...Méthode statique: le premier argument n'est pas un mot réservé
... """
... print(name+"!!")
... @classmethod
... def set_class_prefix(cls, prefix):
... cls.prefix = prefix + " "
...
>>> HelloInstance1 = Hello("Hey") #Préfixe d'instance(self.prefix)To Hey
>>> HelloInstance1.hello("Guido!!")
Hey Guido!!!!
>>> HelloInstance1.hello_cls("Guido!!") #Puisqu'il s'agit d'une méthode de classe, le préfixe d'accès est le préfixe de la classe
Hello Guido!!!!
>>>
>>> HelloInstance2 = Hello("Hi") #Préfixe d'instance(self.prefix)To Hey
>>> HelloInstance2.hello("Guido!!")
Hi Guido!!!!
>>> HelloInstance2.hello_cls("Guido!!")
Hello Guido!!!!
>>>
>>> HelloInstance2.set_class_prefix("I'm") #Réécrire les variables de classe de HelloInstance2
>>> HelloInstance2.hello("Guido!!") #Les variables d'instance ne réécrivent pas
Hi Guido!!!!
>>> HelloInstance2.hello_cls("Guido!!") #Les variables de classe sont réécrites
I'm Guido!!!!
>>> #Un autre exemple
>>> HelloInstance1.hello("Guido!!") #Les variables d'instance ne réécrivent pas
Hey Guido!!!!
>>> HelloInstance1.hello_cls("Guido!!") #Puisqu'il s'agit d'une variable de classe, elle sera réécrite! !!
I'm Guido!!!!
>>>
>>> Hello.hello_stc() #Les méthodes statiques peuvent être appelées depuis la classe
world!!
>>>
Le point à noter est que si vous réécrivez une variable de classe à partir d'une méthode de classe, la variable de classe d'une autre instance changera également (c'est une variable de classe, pas une variable d'instance, donc c'est assez naturel).
C'est __ (deux traits de soulignement) tels que __name__, __init__, __new__, __call__ que vous voyez souvent lorsque vous utilisez Python, mais il est utilisé pour des méthodes spéciales.
Voici quelques méthodes spéciales courantes:
| Méthode spéciale | une fonction | Exemple d'utilisation |
|---|---|---|
| __doc__ | Chaîne de document | Consultez la documentation sur l'objet. objet.__doc__ |
| __name__ | Nom du fichier importé ou fichier exécutable | Lors de l'exécution d'un fichier. si__name__ == '__main__' |
| __dict__ | Contient les attributs de l'objet | Obtenez des attributs d'objet à partir de chaînes de caractères, etc. |
| __init__ | Méthode appelée lors de la création d'une instance | X = Class() |
| __new__ | Classe d'usine lors de la création d'une nouvelle instance de Russ | Il est également possible de remplacer et de créer une méta-classe |
| __call__ | Méthode appelée lorsque la fonction est exécutée | X() |
| __del__ | Méthode appelée lors de la destruction d'un objet | del object |
| __add__ | Ajouter(+)La méthode appelée lors de l'utilisation de l'opérateur | Peut être remplacé et personnalisé |
| __iter__ | Méthode appelée pendant la boucle | pour boucle. Notation d'inclusion |
| __getattr__ | Accès aux attributs | X.attr |
| __setattr__ | Affectation à l'attribut | X.attr = x |
L'héritage multiple est possible en Python. Voici un exemple d'héritage multiple au cas où.
python:Python3.5.0
>>> class Hello:
... prefix = "Hello "
... def say(self, name):
... return self.prefix + name
...
>>>
>>> class Hey:
... prefix = "Hey "
... def say(self, name):
... return self.prefix + name + "!"
...
>>>
>>> class HowAreYou(Hello, Hey):
... def __init__(self, name, *args, **kargs):
... #Initialisation de la classe parente
... #Dans cet exemple à la classe parent__init__N'est pas défini donc rien n'est fait
... super(HowAreYou, self).__init__(*args, **kargs)
... self.name = name
... def output(self):
... greet = self.say(self.name)
... print(greet, "How are you?")
...
>>>
>>> X = HowAreYou("Guido")
>>> X.output()
('Hello Guido', 'How are you?')
>>>
Comme mentionné ci-dessus, c'est comme créer une classe en héritant de deux classes ou plus. Eh bien, si vous expliquez ici, vous devez expliquer à partir de l'orientation de l'objet. Je vais laisser cela à d'autres articles.
Cependant, ce qu'il faut noter ici, c'est le mouvement lorsque HowAreYou.output () est exécuté. Dans le cas d'héritage multiple, les attributs peuvent entrer en conflit les uns avec les autres.
Dans cet exemple également (intentionnellement), les attributs disent être en conflit les uns avec les autres.
En Python, il est décidé quelle classe parent est priorisée lors de l'héritage multiple.
Fondamentalement, ① a la priorité sur ② dans l'ordre de ① "de gauche à droite" ② "de bas en haut" (② a priorité sur ① dans l'ancienne classe de style).
Donc dans ce cas, HowAreYou.output () donne la priorité àHello.say (). De même, «self.prefix» est prioritaire sur «Hello.prefix».
Bien sûr, je pense qu'il y a des attributs pour lesquels je veux faire un héritage multiple mais je ne veux pas qu'ils se heurtent (même si je pense qu'il est préférable de concevoir de sorte que l'héritage multiple ne soit pas fait, bien sûr).
La fonction utilisée à ce moment-là est ** Nameman Gring **.
Plus précisément, faites précéder les deux noms d'attribut d'un trait de soulignement.
Ensuite, il sera automatiquement interprété comme _Class__attr.
python:Python3.5.0
>>> class Hello:
... __prefix = "Hello "
... def __say(self, name):
... return self.__prefix + name
...
>>> class Hey:
... __prefix = "Hey "
... def __say(self, name):
... return self.__prefix + name + "!"
...
>>> class HowAreYou(Hello, Hey):
... def __init__(self, name, *args, **kargs):
... #Initialisation de la classe parente
... #Dans cet exemple à la classe parent__init__N'est pas défini donc rien n'est fait
... super(HowAreYou, self).__init__(*args, **kargs)
... self.name = name
... def hello_output(self):
... greet = self._Hello__say(self.name) #Bonjour__Appel dire
... print(greet, "How are you?")
... def hey_output(self):
... greet = self._Hey__say(self.name) #Salut__Appel dire
... print(greet, "How are you?")
...
>>> X = HowAreYou("Guido")
>>> X.hello_output() #Utilisez Hello say
('Hello Guido', 'How are you?')
>>> X.hey_output() #Utilisez Hey say
('Hey Guido!', 'How are you?')
>>> dir(X) #Afficher les attributs X
['_Hello__prefix', '_Hello__say', '_Hey__prefix', '_Hey__say', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hello_output', 'hey_output', 'name']
>>>
Comme mentionné ci-dessus, ajoutez simplement deux traits de soulignement («__») et le nom de l'attribut est précédé du «nom de la classe». ** Je pensais l'avoir écrit, mais ce n'est peut-être pas quelque chose à enseigner aux débutants ʕº̫͡ºʔ **
Contrairement à Java, Python ne peut pas masquer les attributs.
Cependant, vous pouvez faire quelque chose comme ça en utilisant un trait de soulignement.
Comme mentionné précédemment, le changement de nom peut être utilisé pour empêcher les attributs du même nom de se heurter dans différentes classes.
Bien que ce ne soit pas l'utilisation d'origine, vous pouvez masquer (comme) les attributs que vous voulez vraiment masquer en utilisant cette fonction.
De plus, _x et __x ont des significations légèrement différentes (peuvent être utilisées correctement), je vais donc les expliquer.
python:Python3.5.0
>>> class Hello:
... def __init__(self):
... self._prefix = "Hello" #1 trait de soulignement
... self.__prefix = "Hey" #2 traits de soulignement
...
>>> HelloInstance = Hello()
>>> HelloInstance._prefix #Underscore Un attribut est accessible
'Hello'
>>> HelloInstance.__prefix #Underscore Les deux attributs ne sont pas accessibles car ils sont
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Hello' object has no attribute '__prefix'
>>> HelloInstance._Hello__prefix #Accessible selon le nom mangling
'Hey'
>>>
S'il n'y a qu'un seul trait de soulignement, il est accessible, c'est donc juste un préfixe pour indiquer une variable locale comme norme de codage. Cependant, dans le cas de deux traits de soulignement, le changement de nom attribue automatiquement un «nom de classe», vous ne pouvez donc pas y accéder avec le même nom. Il ne peut pas être complètement caché de cette manière, mais il peut être caché de manière pseudo.
Je l'ai écrit brièvement, mais je suis fatigué, alors je vais continuer avec ③
Cliquez ici pour obtenir des conseils ① Cliquez ici pour obtenir des conseils ③
Recommended Posts