È "Un tipo definito dal programmatore." una giusta definizione di "classe" in Python?

Question

È "Un tipo definito dal programmatore." una giusta definizione di "classe" in Python?

#1 da (4 voti)
#2 da (3 voti)

2

In Think Python 2e "class" è definito come " Un tipo definito dal programmatore. Una definizione di classe crea un nuovo oggetto di classe. "

Ma non è un tipo incorporato considerato una classe troppo?

Usando Python 3.4.0 , il seguente codice:

class File:
    """Represents a computer file."""
    ...

print(type(str))
print(type(File))
print(type("Mahmud"))
print(type(File()))

ha il seguente output:

<class 'type'>
<class 'type'>
<class 'str'>
<class '__main__.File'>

. Quindi qui possiamo notare che le istanze di entrambe il tipo incorporato str e il tipo definito dal programmatore File appartengono a <class 'str'> e <class '__main__.File'> , rispettivamente, quindi entrambi str e File sono considerati classi , come ho capito. Quindi, la definizione è giusta? Se è così, come è giusto e cosa fraintendere o non sapere?

object-oriented python class terminology python-3.x

posta Mahmud Muhammad Naguib 06.07.2017 - 00:58

fonte

2 risposte

4

In Python 2, noterai che i tipi built-in sono a volte distinti dai tipi definiti dall'utente (classi):

>>> type(str)
<type 'type'>
>>> type("Mahmud")
<type 'str'>
>>> str
<type 'str'>

>>> class OldStyleClass:
...    pass
...
>>> type(OldStyleClass)
<type 'classobj'>
>>> type(OldStyleClass())
<type 'instance'>
>>> OldStyleClass
<class ...OldStyleClass at 0x...>

>>> class NewStyleClass(object):
...    pass
...
>>> type(NewStyleClass)
<type 'type'>
>>> type(NewStyleClass())
<class 'NewStyleClass'>
>>> NewStyleClass
<class 'NewStyleClass'>

Quindi abbiamo tre casi distinti:

tipi predefiniti come str
classi di vecchio stile
nuove classi di stile che ereditano da object .

           type(X)            X                   type(X())
           -----------------  ------------------  -----------------
builtin    <type 'type'>      <type 'X'>          <type 'X'>
old style  <type 'classobj'>  <class X at 0x...>  <type 'instance'>
new style  <type 'type'>      <class 'X'>         <class 'X'>

Le differenze tra questi casi sono sottili e sono diventate meno importanti nel tempo. Nelle precedenti versioni di Python, la rappresentazione interna influiva sulle capacità di riflessione. Un residuo di questi problemi in Python 2.7 è che type(X()) == X è falso quando X è una classe vecchio stile!

Quindi per Python 2.x ci sono alcune differenze tra i tipi built-in e le classi definite dall'utente, anche se tutti possono essere usati come classi (istanziati, ereditati da, ...). Considero la dichiarazione dell'autore corretta, anche se leggermente fuorviante. Sarebbe più corretto dire:

The class keyword allows programmers to define additional classes.

o

Each value has a class or type which contains available methods. You can add your own classes with the class keyword.

(Naturalmente, una definizione class non è l'unico modo per definire una nuova classe. Mi viene in mente il costruttore di type(…) , così come le estensioni C.)

In Python 3, questi tre casi sono stati combinati e non vi è alcuna differenza visibile tra le classi built-in e quelle definite dall'utente.

risposta data 06.07.2017 - 11:18

fonte

Leggi altre domande sui tag object-oriented python class terminology python-3.x

Best practice per la diffusione di varie opzioni nel codice dell'applicazione Devo fare test unitari per la stessa applicazione mirata su due diverse versioni di .NET?

score 3 · Accepted Answer

But isn't a built-in type considered a class too?

Sì, lo è. L'autore dell'articolo a cui ti sei collegato è un po ' corretto, ma la sua definizione è carente. Una definizione più completa di una classe in Python è: qualsiasi tipo definito se creato dall'utente o incorporato . Una classe è essenzialmente un progetto per la creazione di un oggetto, indipendentemente dal fatto che il "progetto" sia definito a livello di C, come con i builtin, o a livello di Python come con i tipi definiti dall'utente.

Tuttavia, normalmente quando si pensa a una classe in Python, si sta pensando in modo specifico alle classi definite dall'utente. Ma come ho chiarito sopra, non è necessariamente il modo corretto di pensare alle lezioni. Quindi, anche se la definizione potrebbe non essere completamente errata , non è nemmeno corretta.