Un mémorandum pour moi. J'ai lu le ** premier python ** d'O'REILLY et j'ai énuméré ce que je pensais être "utilisable".
Par exemple, soyez prudent lorsque vous utilisez la liste suivante.
[Pas bien]list_use.py
L = [1, 2, 3] #Génération de liste
M = L #Copie de liste
M[0] = 5 #Changer le 0e élément de M
print M
>>> [5, 2, 3] #Ça va, ça a changé.
print L
>>> [5, 2, 3] #Hmm! ?? Je ne voulais pas changer la liste des L ...
En python, lors de l'attribution d'une valeur à une variable (par exemple, x = 1), deux boîtes, une boîte appelée variable et un objet appelé valeur, sont créées. Les variables stockent les informations de référence sur les objets et les affectations entre les variables (telles que y = x) copient les informations de référence.
Par conséquent, si la variable L a l'information de référence de l'objet [1, 2, 3] et que c'est M = L, l'information de référence de l'objet [1, 2, 3] sera stockée dans la variable M. Devenir. Par conséquent, changer M [0] = 5 est un acte de modification de l'objet auquel L se réfère également, donc même si vous avez l'intention de ne changer que M, vous changerez également L. Ceci est une mise en garde uniquement pour les objets variables. C'est la classe de dictionnaire de liste qui présente une variabilité, alors faites également attention à celles-ci. Si vous le faites, créez un nouvel objet comme suit.
[OK]list_use.py
L = [1, 2, 3] #Génération de liste
M = L[:] #Copiez tous les éléments de la liste
M[0] = 5 #Changer le 0e élément de M
print M
>>> [5, 2, 3]
print L
>>> [1, 2, 3] #L n'est pas affecté par le changement!
dict_test.py
D1 = {'spam':2, 'ham':1, 'eggs':3}
print D1.keys()
>>> ['eggs', 'ham', 'spam']
# D1.keys()Obtenir une liste des clés du dictionnaire
#Utile lors du traitement du dictionnaire dans l'ordre des clés
L = D1.keys()
L.sort()
for x in L:
print x, D1[x]
>>> eggs 3
>>> ham 1
>>> spam 2
dict_marge.py
D1 = {'spam':2, 'ham':1, 'eggs':3}
D2 = {'milk':4, 'ham': 4}
D1.update(D2)
print D1
>>> {'eggs': 3, 'milk': 4, 'ham': 4, 'spam': 2}
#De nouveaux éléments uniquement dans D2 sont ajoutés, les éléments dans D1 et D2 sont mis à jour
create_dict.py
keys = ['spam', 'eggs', 'toast']
vals = [1, 3, 5]
D3 = dict(zip(keys, vals))
print D3
>>> {'toast': 5, 'eggs': 3, 'spam': 1}
use_pickle.py
#Économisez avec cornichon
D = {'a':1, 'b':2}
import pickle
F = open('dump.pkl', 'w')
pickle.dump(D, F) #Sérialiser avec cornichon
F.close()
#Charger à partir de cornichon
F = open('dump.pkl', 'r')
E = pickle.load(F) #Désérialiser avec cornichon
print E
>>> {'a':1, 'b':2}
Comment écrire comme si l'exécution de l'instruction dans le dictionnaire. Par exemple, les contrôles suivants vérifient la présence d'éléments dans le dictionnaire de branche.
dict_if.py
branch = {'spam': 2, 'ham': 3, 'eggs': 1}
print branch.get('spam', 'nothing!')
>>> 2
print branch.get('bacon', 'nothing!')
>>> nothing!
Vous pouvez utiliser else dans les instructions while et for. else ne sera pas exécuté s'il éclate pendant la boucle, mais il sera exécuté si la boucle est terminée jusqu'à la fin. Par exemple, exemple d'utilisation pour le jugement de nombre premier suivant
while_else.py
y = 13
x = y /2
while x > 1:
if y % x == 0:
print y, 'has factor', x
break
x = x -1
else:
print y, 'is prime'
#Rompre s'il existe un nombre divisible supérieur à 1. Sinon, le nombre premier et la sortie dans else.
Si vous définissez un argument de fonction avec \ * ou \ * \ *, l'argument peut être reçu sous forme de type tapple ou dictionnaire. Utile lorsque vous n'êtes pas sûr du nombre de variables disponibles lors de l'appel d'une fonction.
args_test.py
#La valeur de l'argument devient un taple.
def f1(*args):
print args
f1()
>>> ()
#Un taple vide est émis.
f1(1)
>>> (1, )
#Un seul taple est émis.
f1(1, 2, 3, 4)
>>> (1, 2, 3, 4)
# 1, 2, 3,4 taples sont sortis
def f2(**args):
print args
f2()
>>> {}
#Un dictionnaire vide est sorti
f2(a = 1, b = 2)
>>> {'a': 1, 'b': 2}
# {'a': 1, 'b': 2}Le dictionnaire est sorti
Le nom est un mot utilisé dans LISP et semble être dérivé de λ. Comme def, il est utilisé pour définir une fonction.
lambda_test.py
L = [(lambda x : x ** 2), (lambda x : x ** 3), (lambda x : x ** 4)]
for f in L:
print f(2)
>>> 4
>>> 8
>>> 16
Si vous utilisez def, cela devient le suivant et est redondant. De plus, il n'est pas possible de saisir l'opération sans vérifier le contenu en sautant sur chaque fonction.
def_use.py
def f1(x): retrun x ** 2
def f2(x): retrun x ** 3
def f3(x): retrun x ** 4
L = [f1(2), f2(2), f3(2)]
for f in L:
print f
>>> 4
>>> 8
>>> 16
lambda est efficace lorsqu'il est utilisé lors de l'utilisation d'une fonction simple. De plus, la formule étant à proximité immédiate, la visibilité est bonne. Il est souvent utilisé dans la source de tensorflow, il semble donc qu'il n'y ait aucune perte à retenir. Mais je ne peux pas le comprendre. .. Revoyons cela plusieurs fois.
Utilisé lorsque vous souhaitez appliquer la même fonction à une séquence telle qu'une liste [chaîne de caractères (caractère par caractère), dictionnaire, etc.].
map_use.py
def inc(x): return x + 10
L = [11, 12, 13, 14, 15]
print map(inc, L)
>>> [21, 22, 23, 24, 25]
Peut également être utilisé en combinaison avec lambda.
map_lambda.py
L = [1, 2, 3, 4]
print map((lambda x: x + 3), L)
>>> [4, 5, 6, 7]
Comme map, vous pouvez appliquer une fonction à certaines valeurs et recevoir le résultat sous forme de liste.
list_loop1.py
#Boucle simple
print [x ** 2 for x in range(5)]
>>> [0, 1, 4, 9, 16]
La même chose peut être faite avec map, mais la notation d'inclusion de liste de base est plus simple à écrire.
list_loop2.py
#Vous pouvez également exprimer des doubles boucles
print [x + y for x in 'spam' for y in 'SPAM']
>>> ['sS', 'sP', 'sA', 'sM', 'pS', 'pP', 'pA', 'pM', .. , 'mA', 'mM']
list_loop3.py
#Vous pouvez également le combiner avec if
print [(x, y) for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 == 1]
>>> [(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
list_loop4.py
#Aussi bon pour manipuler la matrice
M = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
N = [[2, 2, 2],
[3, 3, 3],
[4, 4, 4]]
#Sortez la deuxième ligne de M
print [row[1] for row in M]
>>> [2, 5, 8]
#Multipliez chaque élément
print [[M[row][col] * N[row][col] for col in range(3)] for row in range(3)]
>>> [[2, 4, 6], [12, 15, 18], [28, 32, 36]]
Bien qu'il soit dans une fonction, le résultat peut être exécuté à tout moment sans renvoyer le résultat d'un seul coup. Il n'y a pas de retour et le rendement est décrit.
genesquare.py
#Créer un générateur
def gensquares(N):
for i in range(N):
yield i ** 2
#Exécution à l'aide d'un itérateur
x = gensquares(5) #Attribuer le générateur à x
print x.next()
>>> 0
print x.next()
>>> 1
print x.next()
>>> 4
print x.next()
>>> 9
print x.next()
>>> 16
print x.next()
>>> error ...
Recherchez dans le répertoire de sys.path (import sys; print sys.path).
sys.path comprend les quatre éléments suivants.
① Répertoire de travail du programme d'exécution ② Répertoire défini dans la variable d'environnement PYTHONPATH ③ Répertoire des modules de bibliothèque standard (groupe de bibliothèques [sys, math, etc.] emballé depuis le début) ④ Le répertoire décrit dans le fichier .pth (il semble être myconfig.pth, mais je ne l'ai pas trouvé dans mon environnement ...)
Par exemple, dans le cas des mathématiques, ③ est dans le chemin obtenu par le fichier math .__ suivant__. Ce sera l'un des chemins de bibliothèque standard.
>>> import math; dir(math)
['__doc__', '__file__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>> math.__file__
'/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload/math.so'
Inversement, si vous mv ce math.so depuis le répertoire de la bibliothèque standard, vous ne pourrez pas utiliser math.
MacBook-Pro:hoge$ sudo mv /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/lib-dynload/math.so ./
cd ..
MacBook-Pro:work fuga$ python
Python 2.7.10 (default, Jul 14 2015, 19:46:27)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import math
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named math
Si vous avez déjà .pyc, ne prenez pas la peine de le coder en octets. Cependant, si l'horodatage du fichier .py à importer est plus grand que le .pyc, codez-le. (Parce que .pyc semble être vieux) Cependant, lorsqu'il s'agit de créer .pyc en tant que fichier, ce n'est pas le cas. Il suffit de le coder en octet pour l'utiliser dans le module d'exécution actuel. Il ne produit pas de .pyc.
Génération d'objets de haut en bas.
La cible d'importation est module_test.py et le côté importation est module_use.py.
module_test.py
def printer(x):
print x
module_use.py
#import lit tout le module
import module_test
module_test.pirinter('spam')
>>> spam
#à partir de xxx import yyy lit la variable yyy de xxx
from module_test import printer
printer('spam')
>>> spam
Recommended Posts