Discussion :

[Invité]

Bonjour,

Je fais du python depuis quelques mois et je me pose une question sur les listes. Dans des langages comme C++, en utilisant la classe vector par exemple, on spécifie le le type que le tableau ou la liste va contenir. Or là je veux créer une liste qui va contenir des objets d'une de mes classes. Cette liste est dans une classe qui va devoir afficher des infos sur les objets qu'elle contient. Avec un exemple on comprend mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
def Afficher_Items(self):
     for i in self.tab:
         i.Get_Name()

Ma question est simple, peut-on définir quel type d'objet une liste va contenir ? Car là j'utilise une méthode spécifique à la classe que ma liste contient. Ca marche comme ça mais je sais pas si c'est syntaxiquement correct.

[N.tox]

Python n'étant pas un langage typé, pas besoin de décclarer le type d'objet que ta liste va contenir...

Toutefois, si dans ton code un objet d'un autre type peut être inseré dans ta liste, un simple test pour s'ssurer le le type d'objet traité est le bon avant de faire appel à la methode spécifique au dit type d'objet suffit...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def Afficher_Items(self):
    for i in self.tab:
        if type(i) == MyClass :
            i.Get_Name()

PS: oublies pas les balises [code][/code]

[Invité]

D'accord, merci ! Désolé pour les balises !

[eyquem]

Il n’y a pas besoin de déclarer quel type de variables une liste va contenir car une liste peut contenir des objets de types divers et différents en même temps:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import re
pat = re.compile('[abcdefghijkl]+')
 
from itertools import groupby
y = groupby([1,3,53,7,5,6,4,3,2,4,3,1,5,4,3,6,7,5,4,6,7,8])
 
class A:
    def __init__(self,x,nom):
        self.name = nom
        self.X = x
 
a = A(1020,'johnny')
 
dico = dict(zip([12,34,76,'radar','glop'],['soleil',(908,9876,456),'arbre',33,True]))
 
 
li = []
li.append(3)
li.append((24,'feu'))
li.extend((['orange','pomme','raisin','marron'],y))
li.append(dico)
li.extend([pat,a,A])
 
 
for w in li:
    print type(w),repr(w)

<type 'int'> 3
<type 'tuple'> (24, 'feu')
<type 'list'> ['orange', 'pomme', 'raisin', 'marron']
<type 'itertools.groupby'> <itertools.groupby object at 0x010B4060>
<type 'dict'> {'glop': True, 76: 'arbre', 34: (908, 9876, 456), 12: 'soleil', 'radar': 33}
<type '_sre.SRE_Pattern'> <_sre.SRE_Pattern object at 0x00A572F0>
<type 'instance'> <__main__.A instance at 0x010B2288>
<type 'classobj'> <class __main__.A at 0x010B4090>

C’est parce que Python se dérouille tout seul en coulisses pour gérer les choses.


Et non pas parce qu’il ne serait pas typé.
Je ne crois d’ailleurs pas qu’il puisse exister un langage entièrement non typé.
Un langage est faiblement typé ou fortement typé. Mais pas du tout : est-ce possible ?


Python est à typage fort dynamique


Typage fort, cela veut dire que lorsque deux variables de types distincts sont confrontées pour une opération, Python n’accepte pas de faire n’importe quoi.
Essayer print ’toto’+5 conduit à une erreur alors que PHP afficherait 'toto5'.

Mais le typage n'est pas cadenassé: essayer print 12+ True conduit à 13
et faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
a = 100
x = (’merguez','chocolat’)[a==100]

donne la valeur 'chocolat' à x parce que a==100 vaut True et que True est assimilé à 1.



Typage dynamique cela veut dire que le type d'une variable peut changer.
y = 100 , y est de type entier
y = ’mama’ fait devenir y de type chaîne.

Ceci est dû au fait que les noms de variables ne sont en fait pas des noms de variables mais des noms de référence. Or les références peuvent être déplacées d’un objet à un autre comme qui rigole, ce n'est pas le type d'une variable qui change, c'est une référence qui passe d'un d'objet d'un type donné à un autre objet d'un autre type.



D’ailleurs, quand on fait du Python, avec toutes ses facilités, on développe comme qui rigole.

http://www.tbray.org/ongoing/When/20...FutureLanguage

[Invité]

Parfait, merci pour les explications, bonne soirée !

[kango]

bonjour,

c'est probablement du pinaillage mais je ne suis pas d'accord avec la définition que tu donnes du typage dynamique fort eyquem.

voici ma compréhension, bâtie de mes expériences et des différents articles/posts que j'ai pu lire ci et là.

le typage fort indique qu'une variable ne peut pas changer de type au cours de l'exécution:

écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
y = "toto"
y = 1

ne doit pas s'interpréter comme y a changé de type mais que y a été redéfini (c'est une autre variable quoi) l'emplacement mémoire est complètement différent (voir avec la fonction id pour s'en convaincre). il ne faut pas voir y comme une variable mais comme un nom. Ici, le même nom sert à définir 2 choses bien distinctes: des objets de type différents rangés en mémoire dans des espaces différents.

La distinction entre variable et nom est importante je trouve en python, par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
a = 1
b = a

une seule variable est représentée en mémoire: 1. Et deux noms différents y sont associés: a et b.

par contre en faisant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
b+=1
print a # retourne 1

le nom b désigne toujours un entier mais l'emplacement mémoire est différent, comme si une nouvelle variable avait été crée en mémoire (mais c'est toujours le même nom ), l'ancienne variable existe toujours, elle vaut un et le nom a lui est toujours associé.

la notion de dynamique pour moi est uniquement le fait qu'il n'est pas nécessaire de déclarer quel type d'objet va être désigné par un nom donné.

ça a l'air inutilement compliqué tout ça, voir inutile tout court () mais des fois on se pose des questions bien pénibles si on ne le sait pas, et on peut y passer beaucoup de temps