J'étudie le python et le nombre de petites histoires a augmenté, je vais donc le résumer légèrement. Veuillez me pardonner, bien que certaines parties n'aient pas été étudiées en profondeur.
Liste des petites histoires
J'expliquerai dans l'ordre du haut de la liste.
L'identité signifie que les objets sont les mêmes et l'équivalence signifie que les valeurs sont les mêmes. L'identité est évaluée par «« est »», et l'équivalence est évaluée par «» = par la suite ». Maintenant, vérifions le résultat pour chaque type.
int
-5 à 256 entiers utilisent le même objet pour économiser la mémoire. Les autres entiers ne sont pas les mêmes même s'ils ont la même valeur.
a = 256
b = 256
a is b # True
c = 257
d = 257
c is d # False
e = -5
f = -5
e is f # True
g = -6
h = -6
g is h # False
float, long, complex
Cela se comporte différemment des entiers. Même si elles ont la même valeur, elles ne sont pas identiques car la mémoire stockée est différente.
a = 1.0
b = 1.0
a == b # True
a is b # False
a = 1L
a = 1L
a == b # True
a is b # False
a = 1 + 2j
b = 1 + 2j
a == b # True
a is b # False
bool
Il n'y a qu'un seul vrai / faux.
a = True
b = True
a is b # True
a = False
b = False
a is b # True
En passant, bool est une sous-classe de int, et False peut être traité comme` `` 0 et True comme `` 1.
isinstance(False, bool) # True
isinstance(False, int) # True
False == 0 # True
False is 0 # False
True == 1 # True
True is 1 # False
True + True # 2
result = -1
'OK' if result == 0 else 'NG' # 'NG'
('NG', 'OK')[result == 0] # 'NG'
result = 0
('NG', 'OK')[result == 0] # 'OK'
string
Les chaînes de caractères qui ne contiennent pas de caractères spéciaux sont les mêmes car elles sont internées dans la liste de noms. Si des caractères spéciaux tels que des espaces et des opérateurs sont inclus, ils ne sont pas identiques même s'ils ont la même valeur. Cependant, s'il n'y a qu'un seul caractère spécial, ce sera le même.
a = 'foo'
b = 'foo'
a == b # True
a is b # True
a = 'f o o'
b = 'f o o'
a == b # True
a is b # False
a = 'x+y'
b = 'x+y'
a == b # True
a is b # False
a = '/'
b = '/'
a == b # True
a is b # True
De plus, il n'en sera pas de même dans les cas suivants.
a = 'f'
a += 'oo'
b = 'foo'
a == b # True
a is b # False
list, tuple, dictionary
Comme les chaînes, la liste, le tuple et le dictionnaire ne sont pas les mêmes même s'ils ont la même valeur.
a = [1, 2, 3]
b = [1, 2, 3]
a == b # True
a is b # False
a = (1, 2, 3)
b = (1, 2, 3)
a == b # True
a is b # False
a = {'x': 1, 'y': 2}
b = {'x': 1, 'y': 2}
a == b # True
a is b # False
set
set est un ensemble avec des valeurs uniques. La particularité est qu'il n'y a aucune garantie de commande. Même si set a la même valeur, ce n'est pas la même chose.
a = set([1, 3, 2])
b = set([1, 3, 2])
c = set([1, 2, 3, 2])
a == b # True
a is b # False
a == c # True ->Vrai car il ne conserve pas les informations de commande et uniquement des valeurs uniques
a is c # False
En guise de mise en garde, si vous copiez en utilisant , la modification d'un élément changera également l'autre élément.
a = [1, 2, 3]
b = a
a[0] = [0, 0] # a: [[0, 0], 2, 3], b: [[0, 0], 2, 3] -> a[0]Si vous changez b[0]Va aussi changer
Si vous copiez à l'aide de tranches, ce sera une copie complète et vous pouvez éviter le problème ci-dessus.
a = [1, 2, 3]
b = a[:]
a[0] = 0 # a: [0, 2, 3], b: [1, 2, 3] -> a[0]Seulement changer
b[1] = 0 # a: [0, 2, 3], b: [1, 0, 3] -> b[1]Seulement changer
À propos, les éléments de string et tuple ne peuvent pas être modifiés.
b = 'foo'
b[0] = 'h' # TypeError: 'str' object does not support item assignment
a = (1, 2, 3)
a[0] = 0 # TypeError: 'tuple' object does not support item assignment
En python, vous pouvez définir "une fonction qui prend une fonction comme argument".
def higher(func, x, y):
return func(x, y)
def add(a, b):
return a + b
def sub(a, b):
return a - b
print higher(add, 4, 3) # 7
print higher(sub, 4, 3) # 1
Au fait, l'utilisation de lambdavous évite d'avoir à définir des fonctions commeadd et `` `sub.
def higher(func, x, y):
return fun(x, y)
print higher(lambda a, b: a + b, 4, 3) # 7
print higher(lambda a, b: a - b, 4, 3) # 1
Définissez une fonction dans une fonction et définissez-la à renvoyer.
L'exécution de la fonction externe `f``` renverra _f``` dans f```. Le _f '' retourné est une fonction, vous pouvez donc passer plus de valeurs pour l'exécuter.
Par conséquent, la méthode d'exécution est la suivante: f (1) (2) ''.
def f(x):
def _f(y):
return x + y
return _f
print f(1) # <function _f at 0x10e45b140>
print f(1)(2) # 3
Comme les fonctions en python sont des objets, vous pouvez ajouter librement des propriétés. Je ne savais pas comment m'en servir. S'il vous plaît, faites-moi savoir.
def foo():
return '!!!'
foo.x = 1
foo.y = 2
foo.f = lambda x: x + 1
print foo() # !!!
print foo.x # 1
print foo.y # 2.000000
print foo.f(9) # 10
python n'a pas de mécanisme pour restreindre l'accès comme privé '' et protégé '' trouvé en C ++ et Java.
Par conséquent, les restrictions d'accès sont appliquées de manière pseudo en ajoutant un trait de soulignement au début du nom de variable ou du nom de méthode.
Dans le cas d'un trait de soulignement, il peut en fait être appelé, mais cela indique l'intention de l'implémenter en tant que méthode privée.
Dans le cas de deux barres inférieures, elle ne peut pas être appelée avec le nom de méthode défini et l'accès est restreint.
Strictement parlant, ce n'est pas que vous ne pouvez pas l'appeler, c'est juste que le nom de la méthode a été changé en _ (nom de la classe) __ (nom de la méthode) .
Par conséquent, il peut être appelé sous la forme de _ (nom de classe) __ (nom de méthode) .
class Foo(object):
def __init__(self, x):
self.x = x
def f(self, y):
return self.x + y
def _f(self, y):
return self.x + y + 1
def __f(self, y):
return self.x + y + 2
foo = Foo(1)
print foo.f(1) # 2
print foo._f(1) # 3
print foo.__f(1) # AttributeError: 'Foo' object has no attribute '__f'
print foo._Foo__f(1) # 4
Le calcul de int $ \ div $ int en python 2.x n'est pas "l'entier avec les fractions tronquées" mais "l'entier maximum qui ne dépasse pas le résultat de la division". C'est pourquoi c'est comme ça.
print 1 / 2 # 0
print -1 / 2 # -1
Au fait, en python 3.x, le calcul de int $ \ div $ int est une fraction.
Aussi, pour que python 3.x se comporte de la même manière que python 2.x, utilisez // '' ``.
//Est python 2.Il peut également être utilisé avec x.
#### **`Python3.x`**
```python
1 / 2 # 0.5
1 // 2 # 0
-1 / 2 # -0.5
-1 // 2 # -1
Tout le monde aime les engourdissements.
Si vous vérifiez le tableau à une dimension avec le nombre d'éléments $ n $ avec shape, ce sera `` `` (n,) `` `. Utilisez `` `` reshape pour transformer cela en un vecteur ligne (1, n) ou un vecteur colonne (n, 1) .
arr = numpy.arange(10) # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr.shape # (10, )
arr.reshape((1, -1))
# array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
arr.reshape((-1, 1))
# array([[0],
# [1],
# [2],
# [3],
# [4],
# [5],
# [6],
# [7],
# [8],
# [9]])
Il peut être retourné à l'aide de tranches. Les tranches sont gérées par (index de début): (index de fin): (intervalle). Les valeurs négatives se réfèrent à l'index de l'arrière.
[-1::-1]Vous pouvez découper de la fin au début avec.
Le premier `` -1 '' peut être omis.
```py
X = numpy.arange(9).reshape((3, 3))
# array([[0, 1, 2],
# [3, 4, 5],
# [6, 7, 8]])
X[::-1, :]
# array([[6, 7, 8],
# [3, 4, 5],
# [0, 1, 2]])
X[:, ::-1]
# array([[2, 1, 0],
# [5, 4, 3],
# [8, 7, 6]])
vectorize
Dans les fonctions universelles de numpy, quatre règles de fonctionnement entre les ndarrays, les fonctions triangulaires de chaque élément et les fonctions qui prennent des valeurs logarithmiques sont définies. Utilisez `` vectorize '' pour définir une fonction qui applique votre propre fonction à chaque élément. Par exemple, transmettez une fonction qui renvoie le reste lorsqu'il est divisé par 10 pour vectoriser et passez ndarray à cette fonction.
X = numpy.arange(25).reshape((5, 5))
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14],
# [15, 16, 17, 18, 19],
# [20, 21, 22, 23, 24]])
numpy.vectorize(lambda x: x % 10)(X)
# array([[0, 1, 2, 3, 4],
# [5, 6, 7, 8, 9],
# [0, 1, 2, 3, 4],
# [5, 6, 7, 8, 9],
# [0, 1, 2, 3, 4]])
J'ai essayé de résumer la petite histoire de python. S'il vous plaît laissez-moi savoir s'il y a d'autres choses comme ça. Si vous trouvez quelque chose, je l'ajouterai au besoin.
Corrigé en se référant aux commentaires de @ Tsutomu-KKE @ github, @shiracamus et @kochory. (04/06/2016)
Recommended Posts