J'en suis accro plusieurs fois, alors je vais l'étudier et l'apprendre en le gravant dans ma tête
tree a été exécutée.__init __. Py est appelé un package.__init __. Py car il ne recherche pas de modules de manière récursive dans un simple répertoire.sys.path est une liste de chaînes de chemins absolus, qui peuvent être confirmés par des méthodes telles que ʻimport sys; print sys.path`.
$ tree --charset=C
.
`-- greeting.py
greeting.py
def daytime():
print 'hey'
REPL
>>> import greeting
>>> greeting.daytime() #Appel
hey
REPL
>>> import greeting
>>> print type(greeting) #Le message d'accueil importé semble être un objet appelé module
<type 'module'>
>>> print dir(greeting) #Vous pouvez voir qu'il a un attribut de jour (partiellement omis)
['__builtins__', ..., 'daytime']
>>> greeting.daytime() #Lors de l'appel
hey
>>> print type(greeting.daytime) #Ce que j'ai appelé semble être un objet appelé fonction
<type 'function'>
REPL
>>> from greeting import daytime
>>> daytime() #Appel
hey
Comprenons ce qu'était ʻimport using from`
REPL
>>> from greeting import daytime
>>> print type(daytime) #Le jour importé de cette façon semble être un objet appelé fonction
<type 'function'>
>>> print dir(daytime) #Il n'y a pas d'attributs définis par moi-même (certains sont omis)
['__call__', ..., 'func_name']
>>> daytime() #Lors de l'appel
hey
>>> print type(daytime) #Ce que vous avez appelé est le même que ce que vous avez importé
<type 'function'>
En regardant ces deux exemples, on peut voir que les deux suivants se réfèrent à la même chose.
Daytime dans l'exemple en utilisant deREPL
>>> import greeting
>>> print type(greeting.daytime)
<type 'function'>
>>> from greeting import daytime
>>> print type(daytime)
<type 'function'>
Les deux sont des objets fonction, vous pouvez donc les appeler avec des parenthèses.
REPL
>>> import greeting
>>> greeting.daytime()
hey
>>> from greeting import daytime
>>> daytime()
hey
Maintenant que vous connaissez les objets module et function, essayez d'importer un autre package
$ tree --charset=C
.
`-- subdir
`-- greeting.py
REPL
>>> import subdir
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named subdir
Comme mentionné au début, subdir ne sera pas reconnu comme un paquet sauf si vous mettez __init __. Py.
$ touch subdir/__init__.py
encore une fois
REPL
>>> import subdir
>>> print dir(subdir) #Mais il n'y a pas d'attribut de salutation
['__builtins__', ..., '__path__']
Apparemment, même si vous importez le package, tous les fichiers inclus ne peuvent pas être utilisés sans autorisation. Si vous souhaitez importer un message d'accueil, vous devez importer ** sous-répertoire d'accueil **
REPL
>>> import subdir.greeting
>>> subdir.greeting.daytime()
hey
C'était une introduction un peu longue, mais je n'ai fait que ʻimport subdir.greeting` Maintenant je veux comprendre ça
REPL
>>> import subdir.greeting
>>> print type(subdir.greeting) #Après tout, importé est un objet module
<type 'module'>
>>> print dir(subdir.greeting) #A un attribut de jour
['__builtins__', ..., 'daytime']
>>> subdir.greeting.daytime() #Donc tu peux l'appeler comme ça
hey
>>> print type(subdir.greeting.daytime) #Et ce que j'ai appelé est un objet de fonction
<type 'function'>
Considérant que j'ai pu écrire «import salut» comme «depuis le jour importation de salutation»,
Il semble bon de penser à écrire un objet module à partir de
Vous pouvez donc écrire ce qui suit
REPL
>>> from subdir import greeting #Ecrire le module dans la pièce
>>> greeting.daytime() #Peut être appelé comme ça
hey
De plus, from peut être écrit en concaténant "module" selon la structure hiérarchique.
REPL
>>> from subdir.greeting import daytime #Écrire en concaténant le module à partir de la pièce
>>> daytime() #Peut être appelé comme ça
hey
J'ai l'impression de pouvoir le comprendre d'une manière ou d'une autre, mais je veux aussi comprendre cet exemple.
REPL
>>> from subdir import greeting
>>> print type(greeting) #Celui importé est un objet module
<type 'module'>
>>> print dir(greeting) #Parce qu'il a un attribut de jour
['__builtins__', ..., 'daytime']
>>> greeting.daytime() #Peut être appelé comme ça
hey
>>> print type(greeting.daytime) #Ce que j'ai appelé est un objet de fonction
<type 'function'>
REPL
>>> from subdir.greeting import daytime
>>> print type(daytime) #C'est l'objet fonction qui a été importé
<type 'function'>
>>> daytime() #Peut être appelé comme ça
hey
>>> print type(daytime) #Ce que vous avez appelé est le même que ce que vous avez importé
<type 'function'>
J'ai essayé environ 5 exemples jusqu'à présent, mais tous les objets exécutés sont des objets fonction.
ʻSi l'élément importé est module, l'attribut fonction` qu'il a
Si ce que vous importez est «fonction», vous pouvez appeler cet objet «fonction».
Ainsi, les trois exemples ci-dessous indiquent tous la même chose
REPL
>>> import subdir.greeting
>>> print type(subdir.greeting.daytime)
<type 'function'>
>>> from subdir import greeting
>>> print type(greeting.daytime)
<type 'function'>
>>> from subdir.greeting import daytime
>>> print type(daytime)
<type 'function'>
Les exemples jusqu'à présent sont des méthodes, mais je veux aussi comprendre ce qui se passe avec les classes
$ tree --charset=C
.
`-- person.py
person.py
class Person():
def daytime(self):
print 'hey'
REPL
>>> import person
>>> person.Person().daytime()
hey
C'était facile si je pouvais comprendre jusqu'ici
REPL
>>> import person
>>> print type(person) #Objet de module familier
<type 'module'>
>>> print dir(person) #A l'attribut Personne
['Person', ..., '__package__']
>>> print type(person.Person) #Contrairement à la méthode, il semble que ce soit un objet appelé classobj
<type 'classobj'>
>>> print dir(person.Person) #A un attribut de jour
['__doc__', ..., 'daytime']
>>> person.Person().daytime() #Puisqu'il s'agit d'une classe, elle est appelée après l'avoir instanciée.
hey
>>> print type(person.Person.daytime) #Contrairement à la fonction, elle semble être appelée méthode d'instance (la méthode statique est omise car il s'agit d'une histoire de classe)
<type 'instancemethod'>
REPL
>>> from person import Person
>>> Person().daytime()
hey
Je pense qu'il y a de nombreux cas où le nom de fichier et le nom de classe sont les mêmes C'est pourquoi l'instruction d'importation «from xxx Import Xxx» apparaît fréquemment.
Je pense que je le comprends déjà, mais pour le moment
REPL
>>> from person import Person
>>> print type(Person) #Après tout, c'est un objet classobj
<type 'classobj'>
>>> print type(Person.daytime) #Parce que l'attribut de jour dont il dispose est une méthode d'instance
<type 'instancemethod'>
>>> Person().daytime() #Peut être appelé comme ça
hey
Il semble qu'il n'y ait pas de grande différence si vous comprenez le cas des classes et le cas des méthodes
Il semble que vous n'ayez qu'à gérer classobj au lieu de function
REPL
>>> import greeting #Importer le nom du fichier
>>> print type(greeting) #Celui importé est le module
<type 'module'>
>>> print type(greeting.daytime) #La méthode qui peut réellement être utilisée est la fonction
<type 'function'>
REPL
>>> import person #Importer le nom du fichier
>>> print type(person) #Celui importé est le module
<type 'module'>
>>> print type(person.Person) #La classe qui peut réellement être utilisée est classobj
<type 'classobj'>
REPL
>>> import greeting.daytime
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named daytime #Puisque la journée est une fonction, pas un module, c'est certainement un module Non
>>> import person.Person
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named Person #Puisque Person est aussi classobj, pas module, ce n'est certainement pas un module
From None Il y a deux principaux points d'importation!
modulefunction ou classobj lors de l'utilisationREPL
>>> from greeting import daytime #Fonction d'importation
>>> from person import Person #Importer classobj
>>> from subdir import greeting #Module d'importation
>>> from subdir.greeting import daytime #Fonction d'importation
REPL
>>> import subdir.greeting #Si seulement importer.Peut être utilisé
>>> from subdir import greeting.daytime #S'il y en a de, importez.Ne peut pas être utilisé
File "<stdin>", line 1
from subdir import greeting.daytime
À partir de maintenant, il y a une forte possibilité que la vérification soit insuffisante ou que le Python-ness soit insuffisant.
J'écris très bien python, mais je suis autodidacte et je ne l'ai pas utilisé au travail, donc je ne comprends pas les conventions. Y a-t-il quelque chose comme ce qui suit comme matériel de jugement? Je pense qu'il devrait être unifié au moins pour chaque projet, mais je ne sais pas trop quoi faire ...
REPL
>>> import math
>>> print math.sin(0)
0.0
>>> print math.cos(0)
1.0
REPL
>>> from math import sin,cos
>>> print sin(0)
0.0
>>> print cos(0)
1.0
REPL
>>> from os.path import join
>>> from random import shuffle
>>> join('root', 'sub') #Quelle méthode de module est join? Système de liste? Système de passe?
>>> shuffle(range(100))
>>> abspath('current') #abspath ne peut pas être utilisé sauf s'il est ajouté à l'importation
from xxx import *
greeting.py
def morning():
print 'hello'
def daytime():
print 'hey'
def evening():
print 'good night'
Vous pouvez lire toutes les fonctions en procédant comme suit
REPL
>>> from greeting import *
>>> print dir()
['__builtins__', ..., 'daytime', 'evening', 'morning']
Cependant, en raison de la modification du côté du module, hello a également été importé avant que je le sache.
La variable locale hello a été écrasée, ce qui a causé un bogue même si elle n'a pas été corrigée ...
Je pense qu'il vaut mieux éviter from xxx import * pour que cela ne se produise pas
Au fait, vous ne pouvez pas le faire sans utiliser de
Si vous comprenez que seul module peut être importé, je pense que vous pouvez faire une erreur.
REPL
>>> import daytimeing.*
File "<stdin>", line 1
import daytimeing.*
^
SyntaxError: invalid syntax
$ tree --charset=C #REPL commence ici
.
`-- lib
|-- __init__.py
|-- commons.py <-.
`-- util |
|-- __init__.py |
`-- listutils.py --'
lib/commons.py
def commons():
print 'commons'
lib/util/listutils.py
from .. import commons
def listutils():
commons.commons()
print 'list utils'
REPL
>>> import lib.util.listutils
>>> lib.util.listutils.listutils()
commons
list utils
En écrivant .. in from, vous pouvez écrire le chemin relatif vers le haut de ce module.
** Cependant, il ne peut pas être spécifié au-dessus du chemin exécuté ** Vérifiez avec l'exemple suivant
$ tree --charset=C ..
..
|-- __init__.py
|-- lib.py <---.
`-- main ----' #REPL commence ici
Python:../lib.py
def lib():
print 'lib'
REPL
>>> from .. import lib
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Attempted relative import in non-package
Il semble que from .. import xxx ne puisse pas être fait s'il est au-dessus du chemin d'exécution.
Strictement parlant, je pense que ce n'est pas bon au-dessus de sys.path
Donc si vous voulez vraiment l'importer, ajoutez simplement sys.path
REPL
>>> import sys
>>> sys.path.append('..') # sys.ajouter un chemin
>>> from .. import lib # from ..Cela ne signifie pas que vous pourrez le faire
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Attempted relative import in non-package
>>> import lib #Vous pourrez importer la lib
>>> lib.lib()
lib
Rechercher des packages sous sys.path (ou quelque chose) Je pense que ça va si tu comprends ça
Cependant, si vous ajoutez sys.path et importez de force d'autres modules
Il peut être difficile pour l'importateur de comprendre
Surtout, je pense que la structure du paquet est étrange, donc je pense fermement que cela ne devrait pas être fait personnellement
Le nombre de lignes est devenu énorme! J'ai trouvé un espace pendant des jours et je l'ai écrit de différentes manières, donc je sens qu'il n'y a pas de sentiment général d'unité, mais c'est bien.
Je pense que c'était très bon de comprendre en vérifiant type () et dir ()
Vous ne devriez plus être accro à ʻimport` ...!
Je ne sais pas ce qui se passe lorsque j'utilise PyCharm Mais je veux essayer un jour
Recommended Posts