Μπορεί κάποιος να εξηγήσει __all__ στην Python;

ψήφοι
608

Έχω χρησιμοποιήσει Python όλο και περισσότερο, και εξακολουθώ να βλέπω τη μεταβλητή __all__σύνολο σε διαφορετικά __init__.pyαρχεία. Μπορεί κάποιος να εξηγήσει τι κάνει αυτό;

Δημοσιεύθηκε 04/09/2008 στις 20:28
πηγή χρήστη
Σε άλλες γλώσσες...                            


11 απαντήσεις

ψήφοι
305

Είναι μια λίστα των δημόσιων αντικείμενα αυτής της ενότητας, όπως ερμηνεύεται από import *. Αυτό παρακάμπτει την προεπιλογή των κρύβει ό, τι αρχίζει με ένα χαρακτήρα υπογράμμισης.

Απαντήθηκε 04/09/2008 στις 20:30
πηγή χρήστη

ψήφοι
48

Από την (ανεπίσημη) Python Wiki αναφοράς :

Οι δημόσιες ονόματα που ορίζεται από μια ενότητα που καθορίζεται από τον έλεγχο ονομάτων του module για μια μεταβλητή με το όνομα __all__? εάν έχει οριστεί, θα πρέπει να είναι μια σειρά από χορδές που είναι τα ονόματα που ορίζονται ή εισάγονται από την εν λόγω μονάδα. Τα ονόματα που δίνονται σε __all__όλα θεωρούνται δημόσια και απαιτείται να υπάρχει. Αν __all__δεν ορίζεται, το σύνολο των δημόσιων ονόματα περιλαμβάνει όλα τα ονόματα που βρέθηκαν στο χώρο ονομάτων του module που δεν ξεκινούν με ένα χαρακτήρα υπογράμμισης ( «_»). __all__θα πρέπει να περιλαμβάνει το σύνολο του δημόσιου API. Σκοπός της είναι να αποφευχθούν τα στοιχεία τυχαία εξαγωγής που δεν αποτελούν μέρος του ΑΡΙ (όπως ενότητες βιβλιοθήκη η οποία εισήχθησαν και χρησιμοποιήθηκαν εντός της μονάδας).

Απαντήθηκε 04/09/2008 στις 20:31
πηγή χρήστη

ψήφοι
659

Συνδέεται με, αλλά δεν αναφέρονται ρητά εδώ, είναι ακριβώς πότε __all__χρησιμοποιείται. Πρόκειται για μια λίστα συμβολοσειρών που καθορίζει ποια σύμβολα σε μια ενότητα θα εξαχθούν όταν from <module> import *χρησιμοποιείται στη μονάδα.

Για παράδειγμα, ο παρακάτω κώδικας σε ένα foo.pyσαφώς εξάγει τα σύμβολα barκαι baz:

__all__ = ['bar', 'baz']

waz = 5
bar = 10
def baz(): return 'baz'

Αυτά τα σύμβολα μπορούν στη συνέχεια να εισαχθούν, όπως αυτό:

from foo import *

print bar
print baz

# The following will trigger an exception, as "waz" is not exported by the module
print waz

Αν το __all__παραπάνω είναι σε σχόλια, αυτός ο κώδικας στη συνέχεια θα εκτελέσει την ολοκλήρωση, ως η προεπιλεγμένη συμπεριφορά του import *είναι να εισάγει όλα τα σύμβολα που δεν ξεκινούν με έναν χαρακτήρα υπογράμμισης, από το συγκεκριμένο χώρο ονομάτων.

Παραπομπή: https://docs.python.org/3.5/tutorial/modules.html#importing-from-a-package

ΣΗΜΕΙΩΣΗ: __all__ επηρεάζει το from <module> import *μόνο συμπεριφορά. Τα μέλη που δεν αναφέρονται στην __all__εξακολουθούν να είναι προσβάσιμα από το εξωτερικό της μονάδας και μπορούν να εισαχθούν με from <module> import <member>.

Απαντήθηκε 15/09/2008 στις 14:49
πηγή χρήστη

ψήφοι
83

Αλλάζει, επίσης, τι pydoc θα δείξει:

module1.py

a = "A"
b = "B"
c = "C"

module2.py

__all__ = ['a', 'b']

a = "A"
b = "B"
c = "C"

$ Pydoc Module1

Βοήθεια για την ενότητα Module1:

ΟΝΟΜΑ
    Module1

ΑΡΧΕΙΟ
    module1.py

DATA 
    α = 'Α'
     b = 'Β'
     c = 'C'

$ Pydoc Module2

Βοήθεια για την ενότητα Module2:

ΟΝΟΜΑ
    Module2

ΑΡΧΕΙΟ
    module2.py

DATA 
    __all__ = [ 'a', 'b']
     α = 'Α'
     b = 'Β'

Δηλώνω __all__σε όλες τις ενότητες μου, καθώς και υπογράμμισης εσωτερικές λεπτομέρειες, αυτά βοηθούν πραγματικά όταν χρησιμοποιούν τα πράγματα δεν έχετε χρησιμοποιήσει ποτέ πριν σε ζωντανή συνεδρίες διερμηνέα.

Απαντήθηκε 15/05/2010 στις 02:22
πηγή χρήστη

ψήφοι
130

Είμαι απλά προσθέτοντας αυτό για να είμαι ακριβής:

Όλες οι άλλες απαντήσεις αναφέρονται σε ενότητες . Το αρχικό ερώτημα αναφέρεται ρητά __all__στην __init__.pyαρχείων, έτσι αυτό είναι για python πακέτα .

Σε γενικές γραμμές, __all__έρχεται μόνο στο παιχνίδι όταν η from xxx import *παραλλαγή του importχρησιμοποιείται δήλωση. Αυτό ισχύει για τα πακέτα καθώς και σε ενότητες.

Η συμπεριφορά των μονάδων εξηγείται στις άλλες απαντήσεις. Η ακριβής συμπεριφορά πακέτα περιγράφεται εδώ με λεπτομέρεια.

Με λίγα λόγια, __all__σε επίπεδο πακέτου κάνει περίπου το ίδιο πράγμα όπως και για ενότητες, εκτός του ότι ασχολείται με μονάδες εντός της συσκευασίας (σε αντίθεση με τον καθορισμό ονόματα στο εσωτερικό της μονάδας ). Έτσι __all__καθορίζει όλες τις ενότητες που πρέπει να φορτώνονται και να εισαχθεί στην τρέχουσα namespace όταν μας χρήση from package import *.

Η μεγάλη διαφορά είναι, ότι όταν παραλείπουν τη δήλωση __all__σε ένα πακέτο της __init__.py, η δήλωση from package import *δεν θα εισάγει τίποτα (με εξαιρέσεις περιγράφεται στην τεκμηρίωση, βλέπε παραπάνω σύνδεσμο).

Από την άλλη πλευρά, αν παραλείψετε __all__σε μια ενότητα, η «πρωταγωνίστησε εισαγωγή» θα εισάγει όλα τα ονόματα (δεν αρχίζει με μια κάτω παύλα) που ορίζεται στην ενότητα.

Απαντήθηκε 16/05/2013 στις 18:01
πηγή χρήστη

ψήφοι
97

Εξηγήστε __all__ στην Python;

Εξακολουθώ να βλέπω τη μεταβλητή __all__σύνολο σε διαφορετικά __init__.pyαρχεία.

Τι κάνει αυτό;

Τι __all__να κάνω;

Δηλώνει τα σημασιολογικά «δημόσια» ονόματα από μια μονάδα. Αν υπάρχει ένα όνομα το __all__, οι χρήστες αναμένεται να το χρησιμοποιήσει, και μπορούν να έχουν την προσδοκία ότι δεν θα αλλάξει.

Επίσης, θα πρέπει προγραμματικές επηρεάζει:

import *

__all__σε μια λειτουργική μονάδα, π.χ. module.py:

__all__ = ['foo', 'Bar']

σημαίνει ότι όταν import *από τη μονάδα, μόνο αυτά τα ονόματα στην __all__εισάγονται:

from module import *               # imports foo and Bar

εργαλεία τεκμηρίωσης

Τεκμηρίωση και κωδικός αυτόματη συμπλήρωση εργαλεία μπορούν (στην πραγματικότητα, πρέπει) να επιθεωρούν και το __all__να καθορίσει ποια ονόματα να εμφανίζονται ως διαθέσιμες από μια μονάδα.

__init__.py κάνει έναν κατάλογο ένα πακέτο Python

Από τα έγγραφα :

Τα __init__.pyαρχεία που απαιτούνται για να κάνουν Python θεραπεία τους καταλόγους και περιέχει πακέτα? Αυτό γίνεται για να αποφευχθεί καταλόγους με ένα κοινό όνομα, όπως εγχόρδων, από την ακούσια κρύβεται έγκυρες ενότητες που εμφανίζονται αργότερα στην πορεία αναζήτησης της μονάδας.

Στην απλούστερη περίπτωση, __init__.pyμπορεί απλά να είναι ένα κενό αρχείο, αλλά μπορεί επίσης να εκτελέσει κώδικα προετοιμασίας για το πακέτο ή να ορίσετε τη __all__μεταβλητή.

Έτσι, το __init__.pyνα κηρύξει την __all__για ένα πακέτο .

Η διαχείριση ενός API:

Ένα πακέτο τυπικά αποτελείται από δομοστοιχεία που μπορούν να εισάγουν το ένα το άλλο, αλλά ότι οι αναγκαστικά δεμένα μαζί με ένα __init__.pyαρχείο. Αυτό το αρχείο είναι αυτό που κάνει ο κατάλογος ένα πραγματικό πακέτο Python. Για παράδειγμα, ας υποθέσουμε ότι έχετε τα εξής:

 package/
   |-__init__.py # makes directory a Python package
   |-module_1.py
   |-module_2.py

στο __init__.pyγράφετε:

from module_1 import *
from module_2 import *

και module_1θα πρέπει:

__all__ = ['foo',]

και module_2θα πρέπει:

__all__ = ['Bar',]

Και τώρα που έχουν παρουσιάσει μια πλήρη api ότι κάποιος άλλος μπορεί να χρησιμοποιήσει όταν εισάγει το πακέτο σας, όπως έτσι:

import package
package.foo()
package.Bar()

Και δεν θα έχουν όλα τα άλλα ονόματα που χρησιμοποιούνται κατά τη δημιουργία μονάδων σας γεμίζετε το packageχώρο ονομάτων.

__all__ σε __init__.py

Μετά την περισσότερη δουλειά, ίσως έχετε αποφασίσει ότι οι μονάδες είναι πολύ μεγάλο και πρέπει να χωρίσουν. Έτσι, μπορείτε να κάνετε τα εξής:

 package/
   |-__init__.py
   |-module_1/
   |  |-__init__.py
   |  |-foo_implementation.py
   |-module_2/
      |-__init__.py
      |-Bar_implementation.py

Και σε κάθε __init__.pyδηλώνετε μια __all__, π.χ. module_1:

from foo_implementation import *
__all__ = ['foo']

Και module_2 είναι __init__.py:

from Bar_implementation import *
__all__ = ['Bar']

Και μπορείτε εύκολα να προσθέσετε τα πράγματα για να σας API που μπορείτε να διαχειριστείτε σε επίπεδο υποπακέτο αντί του επιπέδου ενότητας του υποπακέτο του. Αν θέλετε να προσθέσετε ένα νέο όνομα για το API, μπορείτε απλά να ενημερώσετε το __init__.py, π.χ. module_2:

from Bar_implementation import *
from Baz_implementation import *
__all__ = ['Bar', 'Baz']

Και αν δεν είστε έτοιμοι να δημοσιεύσει Bazστο κορυφαίο επίπεδο API, σε κορυφαίο επίπεδο σας __init__.pyθα μπορούσατε να έχετε:

from module_1 import *       # also constrained by __all__'s
from module_2 import *       # in the __init__.py's
__all__ = ['foo', 'Bar']     # further constraining the names advertised

και αν οι χρήστες σας έχουν επίγνωση της διαθεσιμότητας Baz, μπορούν να το χρησιμοποιήσουν:

import package
package.Baz()

αλλά αν δεν το γνωρίζουν, άλλα εργαλεία (όπως pydoc ) δεν θα τους ενημερώσει.

Μπορείτε αργότερα να αλλάξετε ότι όταν Bazείναι έτοιμο για prime time:

from module_1 import *
from module_2 import *
__all__ = ['foo', 'Bar', 'Baz']

Πρόθεμα _σε σχέση με __all__:

Από προεπιλογή, η Python θα εξάγει όλα τα ονόματα που δεν ξεκινούν με ένα _. Σίγουρα θα μπορούσε να βασιστεί σε αυτό το μηχανισμό. Μερικά πακέτα στην πρότυπη βιβλιοθήκη Python, στην πραγματικότητα, δεν βασίζονται σε αυτό, αλλά για να γίνει αυτό, Alias εισαγωγές τους, για παράδειγμα, σε ctypes/__init__.py:

import os as _os, sys as _sys

Χρησιμοποιώντας τη _σύμβαση μπορεί να είναι πιο κομψό, διότι καταργεί την απόλυση της ονοματοδοσίας τα ονόματα και πάλι. Αλλά προσθέτει την απόλυση των εισαγωγών (αν έχετε πολλά από αυτά) και είναι εύκολο να ξεχάσετε να κάνετε αυτό με συνέπεια - και το τελευταίο πράγμα που θέλετε είναι να πρέπει να υποστηρίξει επ 'αόριστον κάτι που προορίζεται να είναι μόνο μια λεπτομέρεια εφαρμογής, απλά επειδή έχετε ξεχάσει το πρόσημο μια _κατά ονομασία μιας λειτουργίας.

Εγώ προσωπικά γράψετε ένα __all__νωρίς στην εξέλιξή μου κύκλου ζωής για τις ενότητες έτσι ώστε οι άλλοι που θα μπορούσε να χρησιμοποιήσει τον κωδικό μου ξέρουν τι πρέπει να χρησιμοποιήσουν και να μην χρησιμοποιούν.

Τα περισσότερα πακέτα στην πρότυπη βιβλιοθήκη χρησιμοποιούν επίσης __all__.

Όταν αποφεύγοντας __all__νόημα

Είναι λογικό να διατηρηθεί η _σύμβαση πρόθεμα αντί του __all__όταν:

  • Είσαι ακόμα σε λειτουργία στις αρχές ανάπτυξης και δεν έχουν οι χρήστες, και συνεχώς μικροαλλαγές API σας.
  • Ίσως έχετε χρήστες, αλλά έχετε unittests που καλύπτουν το API, και είστε ακόμα ενεργά προσθήκη στο API και μικροαλλαγές στην ανάπτυξη.

μια exportδιακοσμητής

Το μειονέκτημα της χρήσης __all__είναι ότι θα πρέπει να γράψετε τα ονόματα των λειτουργιών και των τάξεων που εξάγονται δύο φορές - και οι πληροφορίες διατηρούνται χωριστά από τους ορισμούς. Θα μπορούσε να χρησιμοποιήσει ένα διακοσμητή για να λύσει αυτό το πρόβλημα.

Πήρα την ιδέα για μια τέτοια διακοσμητής εξαγωγή από την ομιλία του David Beazley για τη συσκευασία. Αυτή η εφαρμογή φαίνεται να λειτουργεί καλά σε παραδοσιακό εισαγωγέα CPython του. Εάν έχετε ένα ειδικό γάντζο εισαγωγή ή σύστημα, δεν το εγγυάται, αλλά αν την εγκρίνει, είναι αρκετά τετριμμένο να κάνει πίσω - θα πρέπει απλά να προσθέσετε μη αυτόματα τα ονόματα πίσω στο__all__

Έτσι, για παράδειγμα, μια βιβλιοθήκη βοηθητικό πρόγραμμα, που θα καθορίσει την διακοσμητής:

import sys

def export(fn):
    mod = sys.modules[fn.__module__]
    if hasattr(mod, '__all__'):
        mod.__all__.append(fn.__name__)
    else:
        mod.__all__ = [fn.__name__]
    return fn

και, στη συνέχεια, όπου θα ορίσετε μία __all__, μπορείτε να το κάνετε αυτό:

$ cat > main.py
from lib import export
__all__ = [] # optional - we create a list if __all__ is not there.

@export
def foo(): pass

@export
def bar():
    'bar'

def main():
    print('main')

if __name__ == '__main__':
    main()

Και αυτό λειτουργεί μια χαρά αν λειτουργεί ως κύρια ή εισάγονται από άλλη λειτουργία.

$ cat > run.py
import main
main.main()

$ python run.py
main

Και API τροφοδότηση με import *θα λειτουργήσει επίσης:

$ cat > run.py
from main import *
foo()
bar()
main() # expected to error here, not exported

$ python run.py
Traceback (most recent call last):
  File "run.py", line 4, in <module>
    main() # expected to error here, not exported
NameError: name 'main' is not defined
Απαντήθηκε 29/02/2016 στις 19:58
πηγή χρήστη

ψήφοι
17

__all__προσαρμόζει τον αστερίσκο στοfrom <module> import *

__all__προσαρμόζει τον αστερίσκο στοfrom <package> import *


Μια μονάδα είναι ένα .pyαρχείο προορίζεται να εισαχθεί.

Ένα πακέτο είναι ένας κατάλογος με ένα __init__.pyαρχείο. Ένα πακέτο περιέχει συνήθως ενότητες.

""" cheese.py """

__all__ = ['swiss', 'cheddar']

swiss = 4.99
cheddar = 3.99
gouda = 10.99

__all__αφήνει τους ανθρώπους γνωρίζουν τα «δημόσια» χαρακτηριστικά της μονάδας . [ @AaronHall ] Επίσης, pydoc τα αναγνωρίζει. [ @Longpoke ]

από την μονάδα εισαγωγής *

Δείτε πώς swissκαι cheddarέρχονται σε τοπικό namespace, αλλά δεν είναι gouda:

>>> from cheese import *
>>> swiss, cheddar
(4.99, 3.99)
>>> gouda
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'gouda' is not defined

Χωρίς __all__, κάθε σύμβολο (που δεν ξεκινά με μια κάτω παύλα) θα ήταν διαθέσιμες.


Οι εισαγωγές χωρίς *δεν επηρεάζονται από__all__


εισαγωγής ενότητα

>>> import cheese
>>> cheese.swiss, cheese.cheddar, cheese.gouda
(4.99, 3.99, 10.99)

από την μονάδα εισαγωγής ονόματα

>>> from cheese import swiss, cheddar, gouda
>>> swiss, cheddar, gouda
(4.99, 3.99, 10.99)

εισαγωγής μονάδα ως localName

>>> import cheese as ch
>>> ch.swiss, ch.cheddar, ch.gouda
(4.99, 3.99, 10.99)

Στο __init__.pyαρχείο του πακέτου __all__ είναι μια λίστα των χορδών με τα ονόματα των δημόσιων μονάδων ή άλλα αντικείμενα. Αυτά τα χαρακτηριστικά είναι διαθέσιμα για τις εισαγωγές μπαλαντέρ. Όπως με τις ενότητες, __all__προσαρμόζει το *όταν μπαλαντέρ-εισαγωγή από τη συσκευασία. [ @MartinStettner ]

Εδώ είναι ένα απόσπασμα από το Connector Python MySQL __init__.py :

__all__ = [
    'MySQLConnection', 'Connect', 'custom_error_exception',

    # Some useful constants
    'FieldType', 'FieldFlag', 'ClientFlag', 'CharacterSet', 'RefreshOption',
    'HAVE_CEXT',

    # Error handling
    'Error', 'Warning',

    ...etc...

    ]

Μπαλαντέρ εισαγωγές ... θα πρέπει να αποφεύγεται, καθώς [συγχέουν] αναγνωστών και πολλά αυτοματοποιημένα εργαλεία.

[ PEP 8 , @ToolmakerSteve]

Απαντήθηκε 20/03/2016 στις 18:20
πηγή χρήστη

ψήφοι
7

__all__χρησιμοποιείται για την τεκμηρίωση της δημόσιας API μιας μονάδας Python. Αν και είναι προαιρετική, __all__θα πρέπει να χρησιμοποιούνται.

Εδώ είναι το σχετικό απόσπασμα από τη γλώσσα Python αναφοράς :

Οι δημόσιες ονόματα που ορίζεται από μια ενότητα που καθορίζεται από τον έλεγχο ονομάτων του module για μια μεταβλητή με το όνομα __all__? εάν έχει οριστεί, θα πρέπει να είναι μια σειρά από χορδές που είναι τα ονόματα που ορίζονται ή εισάγονται από την εν λόγω μονάδα. Τα ονόματα που δίνονται σε __all__όλα θεωρούνται δημόσια και απαιτείται να υπάρχει. Αν __all__δεν ορίζεται, το σύνολο των δημόσιων ονόματα περιλαμβάνει όλα τα ονόματα που βρέθηκαν στο χώρο ονομάτων του module που δεν ξεκινούν με ένα χαρακτήρα υπογράμμισης ( «_»). __all__θα πρέπει να περιλαμβάνει το σύνολο του δημόσιου API. Σκοπός της είναι να αποφευχθούν τα στοιχεία τυχαία εξαγωγής που δεν αποτελούν μέρος του ΑΡΙ (όπως ενότητες βιβλιοθήκη η οποία εισήχθησαν και χρησιμοποιήθηκαν εντός της μονάδας).

PEP 8 χρησιμοποιεί παρόμοια διατύπωση, αν και καθιστά επίσης σαφές ότι τα εισαγόμενα ονόματα δεν αποτελούν μέρος του δημόσιου API, όταν __all__απουσιάζει:

Για την καλύτερη ενδοσκόπηση υποστήριξη, ενότητες θα πρέπει να δηλώσουν ρητά τα ονόματα στα δημόσια API τους, χρησιμοποιώντας το __all__χαρακτηριστικό. Ρύθμιση __all__σε μια κενή λίστα δείχνει ότι η μονάδα δεν έχει καμία δημόσια API.

[...]

Τα εισαγόμενα ονόματα πρέπει πάντα να θεωρείται ως λεπτομέρεια εφαρμογής. Άλλες ενότητες δεν πρέπει να βασίζονται σε έμμεση πρόσβαση σε αυτά τα εισαγόμενα ονόματα, εκτός αν αποτελούν σαφώς τεκμηριωμένη μέρος του API του περιέχει μονάδα, όπως είναι os.pathή ενός πακέτου __init__μονάδα που εκθέτει λειτουργικότητα από υποενότητες.

Επιπλέον, όπως επισημαίνεται σε άλλες απαντήσεις, __all__χρησιμοποιείται για να επιτρέψει μπαλαντέρ εισαγωγής για τα πακέτα :

Η δήλωση εισαγωγής χρησιμοποιεί την ακόλουθη σύμβαση: αν ένα πακέτο του __init__.pyκώδικα ορίζει έναν κατάλογο που ονομάζεται __all__, θα θεωρείται ότι είναι η λίστα με τα ονόματα ενότητα που πρέπει να εισαχθεί όταν from package import *συναντάται.

Απαντήθηκε 26/04/2016 στις 00:39
πηγή χρήστη

ψήφοι
1

Σύντομη απάντηση

__all__επηρεάζει from <module> import *καταστάσεις.

Long απάντηση

Σκεφτείτε το εξής παράδειγμα:

foo
├── bar.py
└── __init__.py

Σε foo/__init__.py:

  • (Σιωπηρή) Αν δεν ορίσετε __all__, τότε from foo import *θα ορίζεται μόνο τα ονόματα των εισαγωγών σε foo/__init__.py.

  • (Explicit) Αν ορίσουμε __all__ = [], τότε from foo import *θα εισάγει τίποτα.

  • (Explicit) Αν ορίσουμε __all__ = [ <name1>, ... ], τότε from foo import *θα εισαγάγει μόνο τα ονόματα.

Να σημειωθεί ότι στην σιωπηρή υπόθεση, python δεν θα εισάγει τα ονόματα που αρχίζουν με _. Ωστόσο, μπορείτε να επιβάλετε την εισαγωγή αυτών των ονομάτων που χρησιμοποιούν __all__.

Μπορείτε να δείτε το έγγραφο Python εδώ .

Απαντήθηκε 03/04/2018 στις 00:19
πηγή χρήστη

ψήφοι
1

Εκτός από τις υπάρχουσες απαντήσεις, __all__δεν πρέπει να είναι μια λίστα. Σύμφωνα με την τεκμηρίωση σχετικά με την importκατάσταση , εάν έχει οριστεί, __all__πρέπει να είναι μια σειρά από χορδές που είναι τα ονόματα που ορίζονται ή εισάγονται από τη μονάδα. Έτσι, μπορείτε επίσης να χρησιμοποιήσετε μια πλειάδα για να σώσει κάποια κύκλους μνήμη και CPU. Απλά μην ξεχάσετε κόμμα σε περίπτωση που η μονάδα καθορίζει ένα ενιαίο δημόσιο όνομα:

__all__ = ('some_name',)

Απαντήθηκε 09/01/2019 στις 12:48
πηγή χρήστη

ψήφοι
0

Αυτό ορίζεται με σαφήνεια στο PEP8 εδώ :

Παγκόσμια ονόματα των μεταβλητών

(Ας ελπίσουμε ότι αυτές οι μεταβλητές προορίζονται για χρήση εντός μόνο μία μονάδα.) Οι συμβάσεις που είναι περίπου το ίδιο με εκείνες για τις λειτουργίες.

Ενότητες που έχουν σχεδιαστεί για χρήση με from M import *θα πρέπει να χρησιμοποιούν το __all__μηχανισμό για την πρόληψη globals εξαγωγή, ή να χρησιμοποιήσετε την παλαιότερη σύμβαση πρόθεμα όπως globals με ένα χαρακτήρα υπογράμμισης (που μπορεί να θέλετε να κάνετε για να δείξει αυτά τα globals είναι «ενότητα μη-δημόσιες»).

PEP8 προβλέπει συμβάσεις που κωδικοποιεί για τον κώδικα Python που περιλαμβάνει την πρότυπη βιβλιοθήκη στην κύρια διανομή Python. Τα περισσότερα μπορείτε να ακολουθήσετε αυτό, θα είναι πιο κοντά στην προέλευση.

Απαντήθηκε 17/06/2019 στις 19:55
πηγή χρήστη

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more