sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 2010
-
1 juil. 2008 à 23:29
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 2010
-
4 juil. 2008 à 18:17
Bonjour,
je me remets au python mais plus serieusement cette fois ci :p
alors j'ai plusieurs question sur des choses sur lesquels je trouve que peux d'infos:
1) sur les modules
Venant du java a la base j'aime les prog bien decoupe donc divise en module
je veux faire un module Server.py qui se trouve dans le repertoire com/daedric/net
donc pour l'importe si je ne me trompe pas c'est
from com.daedric.net import * ?
j'ai essaye from com.daedric.net.Server import * ca ne marche pas
comment dois je proceder ? (j'ai cherche plusieurs source mais 99% des sources sont avec un seul fichier)
2) private
en OO : private type var est bien equivalent a __var en python ?
3)static
class UneClasse:
count = 0
la j'ai fais une classe avec un champ count
pour avoir un acces purement static (meme reference pour toutes les instances de la classe)
je dois vraiment y acceder comme ceci :
self.__class__.count ?
dans ce cas que represente un self.count ?
j'ai fais des test et ca agis comme si c'etait deux variables differentes
4) variable de classe
j'ai ete choque quand j'ai vu que l'on pouvais faire ca :
class Server:
"Server pour le proxy"
#__port = 0
def __init__(self, port=8080):
self.__port = port
def startListening(self):
pass;
def __getitem__(self, var):
if var == "port":
return self.__port
def getPort(self):
return self.__port
vaut-il mieu mettre quand meme le __port ?
pour le moment c'est tout
J'ai bien sur fais des tests et des recherches mais rien de bien concluant
"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"
1/ Pour importer un module il y a deux façons que nous allons traiter par des exemples :
Sans un répertoire quelconque, créé deux fichiers Python appeler Programme.py et Module.py.
Dans Module.py, tape
a = 2
On va essayer de retrouver cette variable dans Programme.py : Tape dans ce dernier fichier
from Module import *
print a
=> Cela revient à importer tout le module, et on importe donc la variable a ! À l'exécution on obtient
>>> 2
La deuxième solution est la suivante ; Dans Programme.py, tape :
import Module
a = 3
print Module.a
print a
Ainsi il n'y a pas de confusion entre les deux variables a !
Maintenant pour l'importer depuis un sous répertoire : Crée un dossier mod . Dans ce dossier met le fichier Module.py et un nouveau fichier qui doit obligatoirement s'appeler __init__.py (attention il y a 2 "_" au début et à la fin). Dans ce nouveau fichier tape :
from Module import *
Dans Programme.py tape:
from mod import *
print a
Le résultat s'affiche correctement ! Je pense avoir fait le tour ce cette question :p
2/ J'ai rien compris désolé
3/ Pour affecter une variable à une classe il faut ..........., heu, ................, rien ne vaut un exemple
a = 3
class Test:
def __init__(self):
self.a = 2
exemple = Test()
print a
print exemple.a
Voila, c'est pas très compliqué !
L'exemple que tu avais fait était incorrect, il maque def __init__(self) et count dans ton programme es dite variable local, c'est à dire qu'elle n'est définit que dans la fonction __init__ (enfin, si elle avait été créé ...)
4/ Je ne comprend pas très bien la question ! Tu es choquer parce que on peut maitre des "_" devant les variable ? C'est possible, même si je ne l'encourage pas. Certaine personne l'utilise pour différence des variable global ou local ! Ici si tu met port tout seul cela fonctionnera quand même. self.port et port sont différent !
Voila, j'espère t'avoir été utile.
Bon courage et à la prochaine
sheorogath
Messages postés2448Date d'inscriptionsamedi 21 février 2004StatutModérateurDernière intervention29 janvier 201017 2 juil. 2008 à 11:58
1) je pense que tu as fait le tour de la question merci ;)
2) une variable privee est une variable a laquel on ne peut y acceder qu'a l'interieur de la classe meme
et j'ai cru comprendre que pour cela il fallais mettre les __ devant le nom de la variable ...
3) tu n'as pas bien compris ma question ^^ mais ce n'est pas grave c'est pas ce qui m'interresse le plus
4) non ce qui m'a choque c'est le fais de pas preciser les variables de classes ... et ca marche quand meme ...
merci pour tes reponses je vais de ce pas voir le lien que tu m'a passe
"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"
aera group
Messages postés382Date d'inscriptionmercredi 23 août 2006StatutMembreDernière intervention 8 novembre 201018 2 juil. 2008 à 14:50
Je pense que la 2ème et 4ème questions sont équivalente ! Pour déclarer une varible en Python quelque soit sont utilité, quelle soit global, local ou intégré dans une classe, la mêthode est toujours la même :
nom_de_la_variable = valeur
En fait, c'est un peu différent pour les variables intégré dans les classes !
Mais je pense qu'il faudrait que tu maitrise les variable global et général pour commencer ! Oublions les classes et travailons avec des fonctions simples pour commencer ! Un script python simple se compose d'un programme principale avec ou sans fonctions. Les fonctions sont toujours avant le programme principale ! Le programme principale est exécuter de haut en bas, étapes par étapes, parfois redirigé vers des fonctions ou des classes mais toujours exécuter de haut en bas. Ainsi, on une variable peut être redéfinit à des endroit différant et prendra des fonctions différente au cour du temps. Un exemple est sans doute plus claire que ce charbia !
deftest():
a = 2
# Début du programme principal
a = 1
test()
print a
Le résultat afficher est 1 ! C'est comme si la fonction test n'avait pas été exécuté ! En fait, elle est exécuter mais le a du programme principal (variable global) et le a de la fonction test (variable local) sont différante ! De même lorsque l'on utilise la variable a dans la fonction, c'est le a de la fonction qui est utilisé ! Exemple :
deftest():
a = 2
print a
# Début du programme principal
a = 1
test()
print a
Les résultats sont :
>>> 2
>>> 1
Maintenant on va faire en sorte que l'on obtient qu'une variable a, celle du programme principal. Pour cella on utilise la syntaxe suivante :
global nom_de_la_variable
Un exemple :
deftest():
global a
a = 2
print a
# Début du programme principal
a = 1
test()
print a
Voici le résultat :
>>> 2
>>> 2
Je pense avoir fait le tour des variable globales et locales !
Maintenant un exemple avec les classes ! Les classes regroupent des fonctions, ont à le même problème : les variables définit dans les fonctions sont locales de bases sauf si on utilise global ! De plus ces variables ne sont pas attaché à une classes, mais au scripte ! Exemple :
classPersonne:
def__init__(self,age):
global age_personne
age_personne = age
defaffiche_age(self):
global age_personne
print age_personne
Résultat, rien ne fonctionne ! On est incapable de retrouver l'age de Rémy et l'age de Noémie !
>>> 18
>>> 18
Il faut définir une variable qui est affecté à la classe Personne et qui est indépendant des appels de la classe ! Pour cella, on utilise self ! La syntaxe est la suivante : self.nom_de_la_variable
Exemple :
classPersonne:
def__init__(self,age):
self.age_personne = age
defaffiche_age(self):
print self.age_personne
N.B. : str permet de convertir un nombre en une chaine de carractère
Le résultat est Impécable :
>>> 17
>>> 18
>>> Rémy à 17 ans
>>> Noémie à 18 ans
On à même été plus loin : on a réussit à appeler la variable age_personne depuis l'appel de la classe par Remy.age_personne
! Python est vraiment puissant
Au passage si on avait utiliser self.age au lieu de self.age_personne, il n'y aurait pas eut de confusion avec l'argument age, ni avec une variable globale ou locale nommé age ! Elles sont toute différente !
______
Aéra