print ad
# {'Descriptif': 'Abcde', 'Code': 'AAA', 'Montant': 1234.5599999999999}
car je trouve cela très lisible, notamment par l'absence de caractères
parasites (guillemets, apostrophes, accolades, etc.)
Malheureusement, ça ne passe, dès qu'il y a des caractères non "Ascii de
base" ; par exemple, des accents. Ainsi, utiliser un "E" accent aigu pour
l'année, donne :
J'ai cherché en utilisant l'encodage HTML (et en modifiant la fonction),
mais ça ne passe pas (et la lisibilité, et surtout la facilité d'écriture),
en prend un coup :
Idem en utilisant un encodage "à la LaTex" (\'e), ou l'unicode-HTML
(é)
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si
quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de
construire des dictionnaires, mais qui accepte les accents (et,
éventuellement, d'autres caractères particuliers, tel l'espace).
Heu... Ca t'apporte quoi de plus que de créer directement le dict, exactement ?
ad = dict( Code = 'AAA', Descriptif = 'Abcde', Montant = 1234.56, Mois = 3, Annee = 2007 )
Malheureusement, ça ne passe, dès qu'il y a des caractères non "Ascii de base" ;
Bin non. Tu ne peut pas utiliser des caractères "exotiques" dans un identifiant. Point. C'est dans la doc, Michel.
J'ai cherché en utilisant l'encodage HTML
Quelle drôle d'idée...
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de construire des dictionnaires, mais qui accepte les accents (et, éventuellement, d'autres caractères particuliers, tel l'espace).
ad = { 'Année' : 2007, }
Bonjour !
J'aime beaucoup construire des dictionnaires de cette façon :
Heu... Ca t'apporte quoi de plus que de créer directement le dict,
exactement ?
ad = dict(
Code = 'AAA',
Descriptif = 'Abcde',
Montant = 1234.56,
Mois = 3,
Annee = 2007
)
Malheureusement, ça ne passe, dès qu'il y a des caractères non "Ascii de
base" ;
Bin non. Tu ne peut pas utiliser des caractères "exotiques" dans un
identifiant. Point. C'est dans la doc, Michel.
J'ai cherché en utilisant l'encodage HTML
Quelle drôle d'idée...
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si
quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de
construire des dictionnaires, mais qui accepte les accents (et,
éventuellement, d'autres caractères particuliers, tel l'espace).
Heu... Ca t'apporte quoi de plus que de créer directement le dict, exactement ?
ad = dict( Code = 'AAA', Descriptif = 'Abcde', Montant = 1234.56, Mois = 3, Annee = 2007 )
Malheureusement, ça ne passe, dès qu'il y a des caractères non "Ascii de base" ;
Bin non. Tu ne peut pas utiliser des caractères "exotiques" dans un identifiant. Point. C'est dans la doc, Michel.
J'ai cherché en utilisant l'encodage HTML
Quelle drôle d'idée...
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de construire des dictionnaires, mais qui accepte les accents (et, éventuellement, d'autres caractères particuliers, tel l'espace).
ad = { 'Année' : 2007, }
Michel Claveau
Bonsoir !
Ca t'apporte quoi de plus que de créer directement le dict ? ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte, on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la syntaxe.
-- @-salutations
Michel Claveau
Bonsoir !
Ca t'apporte quoi de plus que de créer directement le dict ?
ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre :
tc.Code = "ABCD"
tc.Libellé = "Item d'article complet"
tc.Montant = 1234.56
tc.Tva = tc.Montant*19.60/100
tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins
égale.
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte,
on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la
syntaxe.
Ca t'apporte quoi de plus que de créer directement le dict ? ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte, on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la syntaxe.
-- @-salutations
Michel Claveau
Pierre Maurette
[...]
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de construire des dictionnaires, mais qui accepte les accents (et, éventuellement, d'autres caractères particuliers, tel l'espace).
Je débute en python, j'ai bricolé un truc certainement codé avec les pieds. En effet, je ne connais pas le dixième des modules et fonctions de haut niveau disponibles. On peut simplifier en se passant de getDicos(), et en réservant un fichier aux données. Dans cette version, on les place dans le fichier lui-même ce qui oblige à faire une copie temporaire. Il faut adapter la ligne 2 à son environnement. Testé sous Linux - Ubuntu - en console et sous Eclipse/Pydev avec utf-8, et tel quel sous Windows XP dans la console d'Eclipse.
#!/usr/bin/python # -*- coding: iso-8859-1 -*-
""" *data = datafortest1 Code = "AAAM" Moi = Pierre Maurette Descriptif = 'Abécd' ## commentaire Montant = 1234.56 ##commentaire Mois = 3 Année = 2007 fin data """
""" *data = dataaccentuées
Kode = "PETRUS" Lui = Léonard de Vinci Ça va bien = 'Abèàcd' Montant = 1234.54 Mois = 3 Année = 2007
fin data """
import sys, os, shutil from tempfile import gettempdir
def getDicos(max): """Retourne un dictionnaire dont les keys sont les noms des dictionnaires, et les values les lignes de début et de fin à utiliser avec getDico() 'max' limite le nombre de lignes scannées Ó partir du début Mettre -1 ou une valeur démesurée convient le plus souvent""" shutil.copy(__file__, gettempdir()) file = open(os.path.join(gettempdir(), os.path.basename(__file__)),'rb') lines = file.readlines()[:max] dicos = {} linenumber = 0 diconame = None for line in lines: linenumber += 1 line = line.replace(' ','') if not diconame: if line[:8] == '"""*data': diconame = line.split('=')[1].rstrip('rn') dicos[diconame] = [linenumber] else: if line[:10] == 'findata"""': dicos[diconame].append(linenumber - 1) diconame = None file.close() return dicos
def getDico(b, e): """Retourne un dictionnaire à partir de la lecture des lignes b + 1 et e """ shutil.copy(__file__, gettempdir()) file = open(os.path.join(gettempdir(), os.path.basename(__file__)),'rb') lines = file.readlines()[b:e] dico = {} for line in lines: record = (line.split('#')[0]).split('=') if len(record)==2: cle = record[0].strip() val = record[1].strip(''"nr ') try: dico[cle] = int(val) except: try: dico[cle] = float(val) except: dico[cle] = val file.close() return dico
def test(): print 'Bonne année' dicos = getDicos(1000) for diconame in dicos: print 'n', diconame, ' -> ' dico = getDico(dicos[diconame][0], dicos[diconame][1]) for key in dico: print 't', key, ' -> ', dico[key] print 'Année : ', dico['Année'] sys.exit(0)
if __name__ == '__main__': test()
-- Pierre Maurette
[...]
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si
quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de
construire des dictionnaires, mais qui accepte les accents (et,
éventuellement, d'autres caractères particuliers, tel l'espace).
Je débute en python, j'ai bricolé un truc certainement codé avec les
pieds. En effet, je ne connais pas le dixième des modules et fonctions
de haut niveau disponibles.
On peut simplifier en se passant de getDicos(), et en réservant un
fichier aux données. Dans cette version, on les place dans le fichier
lui-même ce qui oblige à faire une copie temporaire.
Il faut adapter la ligne 2 à son environnement. Testé sous Linux -
Ubuntu - en console et sous Eclipse/Pydev avec utf-8, et tel quel sous
Windows XP dans la console d'Eclipse.
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
""" *data = datafortest1
Code = "AAAM"
Moi = Pierre Maurette
Descriptif = 'Abécd'
## commentaire
Montant = 1234.56 ##commentaire
Mois = 3
Année = 2007
fin data """
""" *data = dataaccentuées
Kode = "PETRUS"
Lui = Léonard de Vinci
Ça va bien = 'Abèàcd'
Montant = 1234.54
Mois = 3
Année = 2007
fin data """
import sys, os, shutil
from tempfile import gettempdir
def getDicos(max):
"""Retourne un dictionnaire dont les keys sont les noms des
dictionnaires,
et les values les lignes de début et de fin à utiliser avec
getDico()
'max' limite le nombre de lignes scannées Ó partir du début
Mettre -1 ou une valeur démesurée convient le plus souvent"""
shutil.copy(__file__, gettempdir())
file = open(os.path.join(gettempdir(),
os.path.basename(__file__)),'rb')
lines = file.readlines()[:max]
dicos = {}
linenumber = 0
diconame = None
for line in lines:
linenumber += 1
line = line.replace(' ','')
if not diconame:
if line[:8] == '"""*data':
diconame = line.split('=')[1].rstrip('rn')
dicos[diconame] = [linenumber]
else:
if line[:10] == 'findata"""':
dicos[diconame].append(linenumber - 1)
diconame = None
file.close()
return dicos
def getDico(b, e):
"""Retourne un dictionnaire à partir de la lecture des lignes b + 1
et e """
shutil.copy(__file__, gettempdir())
file = open(os.path.join(gettempdir(),
os.path.basename(__file__)),'rb')
lines = file.readlines()[b:e]
dico = {}
for line in lines:
record = (line.split('#')[0]).split('=')
if len(record)==2:
cle = record[0].strip()
val = record[1].strip(''"nr ')
try:
dico[cle] = int(val)
except:
try:
dico[cle] = float(val)
except:
dico[cle] = val
file.close()
return dico
def test():
print 'Bonne année'
dicos = getDicos(1000)
for diconame in dicos:
print 'n', diconame, ' -> '
dico = getDico(dicos[diconame][0], dicos[diconame][1])
for key in dico:
print 't', key, ' -> ', dico[key]
print 'Année : ', dico['Année']
sys.exit(0)
Avant de me lancer dans un pseudo-encodage maison, j'aimerais savoir si quelqu'un connaîtrait-il un moyen tout-prêt, aussi lisible/facile, de construire des dictionnaires, mais qui accepte les accents (et, éventuellement, d'autres caractères particuliers, tel l'espace).
Je débute en python, j'ai bricolé un truc certainement codé avec les pieds. En effet, je ne connais pas le dixième des modules et fonctions de haut niveau disponibles. On peut simplifier en se passant de getDicos(), et en réservant un fichier aux données. Dans cette version, on les place dans le fichier lui-même ce qui oblige à faire une copie temporaire. Il faut adapter la ligne 2 à son environnement. Testé sous Linux - Ubuntu - en console et sous Eclipse/Pydev avec utf-8, et tel quel sous Windows XP dans la console d'Eclipse.
#!/usr/bin/python # -*- coding: iso-8859-1 -*-
""" *data = datafortest1 Code = "AAAM" Moi = Pierre Maurette Descriptif = 'Abécd' ## commentaire Montant = 1234.56 ##commentaire Mois = 3 Année = 2007 fin data """
""" *data = dataaccentuées
Kode = "PETRUS" Lui = Léonard de Vinci Ça va bien = 'Abèàcd' Montant = 1234.54 Mois = 3 Année = 2007
fin data """
import sys, os, shutil from tempfile import gettempdir
def getDicos(max): """Retourne un dictionnaire dont les keys sont les noms des dictionnaires, et les values les lignes de début et de fin à utiliser avec getDico() 'max' limite le nombre de lignes scannées Ó partir du début Mettre -1 ou une valeur démesurée convient le plus souvent""" shutil.copy(__file__, gettempdir()) file = open(os.path.join(gettempdir(), os.path.basename(__file__)),'rb') lines = file.readlines()[:max] dicos = {} linenumber = 0 diconame = None for line in lines: linenumber += 1 line = line.replace(' ','') if not diconame: if line[:8] == '"""*data': diconame = line.split('=')[1].rstrip('rn') dicos[diconame] = [linenumber] else: if line[:10] == 'findata"""': dicos[diconame].append(linenumber - 1) diconame = None file.close() return dicos
def getDico(b, e): """Retourne un dictionnaire à partir de la lecture des lignes b + 1 et e """ shutil.copy(__file__, gettempdir()) file = open(os.path.join(gettempdir(), os.path.basename(__file__)),'rb') lines = file.readlines()[b:e] dico = {} for line in lines: record = (line.split('#')[0]).split('=') if len(record)==2: cle = record[0].strip() val = record[1].strip(''"nr ') try: dico[cle] = int(val) except: try: dico[cle] = float(val) except: dico[cle] = val file.close() return dico
def test(): print 'Bonne année' dicos = getDicos(1000) for diconame in dicos: print 'n', diconame, ' -> ' dico = getDico(dicos[diconame][0], dicos[diconame][1]) for key in dico: print 't', key, ' -> ', dico[key] print 'Année : ', dico['Année'] sys.exit(0)
if __name__ == '__main__': test()
-- Pierre Maurette
William Dode
On 04-03-2007, Michel Claveau wrote:
Bonsoir !
Ca t'apporte quoi de plus que de créer directement le dict ? ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Et puisque tu as tc.libellé, alors en quoi ça gène que les propriétées n'aient pas d'accent vu qu'elles ne seront jamais vues par l'utilisateur ?
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte, on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la syntaxe.
Essaye de voir les choses du bon côté, ça ne l'alourdit pas, ça l'allège même :
J'ai également un orm qui fait un mapping automatique avec la base de donnée, et parfois je me retrouve avec un champ avec accent, dans ce cas je fait (exceptionellement) :
-- William Dodé - http://flibuste.net Développeur informatique indépendant
On 04-03-2007, Michel Claveau wrote:
Bonsoir !
Ca t'apporte quoi de plus que de créer directement le dict ?
ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre :
tc.Code = "ABCD"
tc.Libellé = "Item d'article complet"
tc.Montant = 1234.56
tc.Tva = tc.Montant*19.60/100
tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins
égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées
pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour
de bon...
Et puisque tu as tc.libellé, alors en quoi ça gène que les propriétées
n'aient pas d'accent vu qu'elles ne seront jamais vues par l'utilisateur
?
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte,
on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la
syntaxe.
Essaye de voir les choses du bon côté, ça ne l'alourdit pas, ça l'allège
même :
J'ai également un orm qui fait un mapping automatique avec la base de
donnée, et parfois je me retrouve avec un champ avec accent, dans ce cas
je fait (exceptionellement) :
Ca t'apporte quoi de plus que de créer directement le dict ? ne peut pas utiliser des caractères "exotiques" dans un identifiant
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Et puisque tu as tc.libellé, alors en quoi ça gène que les propriétées n'aient pas d'accent vu qu'elles ne seront jamais vues par l'utilisateur ?
Comme on ne peut pas utiliser d'accents dans (le nom d')une propriéte, on est obligé d'utiliser un dictionnaire. Du coup, ça alourdit la syntaxe.
Essaye de voir les choses du bon côté, ça ne l'alourdit pas, ça l'allège même :
J'ai également un orm qui fait un mapping automatique avec la base de donnée, et parfois je me retrouve avec un champ avec accent, dans ce cas je fait (exceptionellement) :
-- William Dodé - http://flibuste.net Développeur informatique indépendant
Alex Marandon
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre :
tc.Code = "ABCD"
tc.Libellé = "Item d'article complet"
tc.Montant = 1234.56
tc.Tva = tc.Montant*19.60/100
tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins
égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées
pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour
de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa
langue pour nommer des identifieurs.
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
Michel Claveau
'soir !
si on pouvait définir des atributs en Unicode (par exemple), il n'y aurait plus aucun problème d'échange des sources.
Par contre, on pourrait aller plus loin. Par exemple, lire le code de droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon (comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour échanger des sources avec des développeurs du Laos utilisant l'écriture Tham (écriture non linéaire, oubliée par Unicode).
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours. Même les vendredis...
-- @-salutations
Michel Claveau
'soir !
si on pouvait définir des atributs en Unicode (par exemple), il n'y
aurait plus aucun problème d'échange des sources.
Par contre, on pourrait aller plus loin. Par exemple, lire le code de
droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le
chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon
(comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme
Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page
sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour
échanger des sources avec des développeurs du Laos utilisant l'écriture
Tham (écriture non linéaire, oubliée par Unicode).
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours.
Même les vendredis...
si on pouvait définir des atributs en Unicode (par exemple), il n'y aurait plus aucun problème d'échange des sources.
Par contre, on pourrait aller plus loin. Par exemple, lire le code de droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon (comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour échanger des sources avec des développeurs du Laos utilisant l'écriture Tham (écriture non linéaire, oubliée par Unicode).
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours. Même les vendredis...
-- @-salutations
Michel Claveau
Bruno Desthuilliers
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec des italiens, des russes et des japonais...
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre :
tc.Code = "ABCD"
tc.Libellé = "Item d'article complet"
tc.Montant = 1234.56
tc.Tva = tc.Montant*19.60/100
tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins
égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées
pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour
de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa
langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec
des italiens, des russes et des japonais...
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec des italiens, des russes et des japonais...
Méta-MCI
Re !
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol
Tu n'as pas de chance ; car je discute assez souvent d'Object-PAL avec des correspondants hispaniques (Espagne et Argentine) ; et même en espagnol, avec un allemand (l'espagnol est notre PPDC linguistique).
Bon, c'est vrai que, avec d'autres langues étrangères (anglais, klingon, parisien), je suis beaucoup moins à l'aise...
Bonne nuit
Michel Claveau
Re !
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol
Tu n'as pas de chance ; car je discute assez souvent d'Object-PAL avec des
correspondants hispaniques (Espagne et Argentine) ; et même en espagnol,
avec un allemand (l'espagnol est notre PPDC linguistique).
Bon, c'est vrai que, avec d'autres langues étrangères (anglais, klingon,
parisien), je suis beaucoup moins à l'aise...
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol
Tu n'as pas de chance ; car je discute assez souvent d'Object-PAL avec des correspondants hispaniques (Espagne et Argentine) ; et même en espagnol, avec un allemand (l'espagnol est notre PPDC linguistique).
Bon, c'est vrai que, avec d'autres langues étrangères (anglais, klingon, parisien), je suis beaucoup moins à l'aise...
Bonne nuit
Michel Claveau
Bruno Desthuilliers
'soir !
si on pouvait définir des atributs en Unicode (par exemple), il n'y aurait plus aucun problème d'échange des sources.
Ah tiens ?
Par contre, on pourrait aller plus loin. Par exemple, lire le code de droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon (comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour échanger des sources avec des développeurs du Laos utilisant l'écriture Tham (écriture non linéaire, oubliée par Unicode).
Bin oui...
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours. Même les vendredis...
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol ou en italien ?
'soir !
si on pouvait définir des atributs en Unicode (par exemple), il n'y
aurait plus aucun problème d'échange des sources.
Ah tiens ?
Par contre, on pourrait aller plus loin. Par exemple, lire le code de
droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le
chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon
(comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme
Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page
sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour
échanger des sources avec des développeurs du Laos utilisant l'écriture
Tham (écriture non linéaire, oubliée par Unicode).
Bin oui...
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours. Même
les vendredis...
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol ou
en italien ?
si on pouvait définir des atributs en Unicode (par exemple), il n'y aurait plus aucun problème d'échange des sources.
Ah tiens ?
Par contre, on pourrait aller plus loin. Par exemple, lire le code de droite à gauche, (comme l'hébreu ou l'arabe), de haut en bas (comme le chinois), variable (comme les hiéroglyphes égyptiens), boustrophédon (comme certaine runes),
(au passage, il existe déjà des langages multidirectionnel, comme Befunge, voir http://fr.wikipedia.org/wiki/Befunge, ou une vieille page sur un de mes sites).
Mais, même avec Unicode, il restera des problèmes. Par exemple, pour échanger des sources avec des développeurs du Laos utilisant l'écriture Tham (écriture non linéaire, oubliée par Unicode).
Bin oui...
Toutefois, il faut relativiser : ça ne m'arrive pas tout les jours. Même les vendredis...
Tu a déjà essayer de lire du code source ne serait-ce qu'en espagnol ou en italien ?
Alex Marandon
Bruno Desthuilliers wrote:
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec des italiens, des russes et des japonais...
Tout a fait, si le francais n'est pas leur langue maternelle, ils risquent d'etre deroutes par l'absence d'accents. Pour nous c'est moins un probleme.
Bruno Desthuilliers wrote:
William Dode wrote:
En fait, dans Paradox, on utilise des instructions du genre :
tc.Code = "ABCD"
tc.Libellé = "Item d'article complet"
tc.Montant = 1234.56
tc.Tva = tc.Montant*19.60/100
tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins
égale.
Heureusement que ce n'est pas possible sinon, imagine les
difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la
lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa
langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec
des italiens, des russes et des japonais...
Tout a fait, si le francais n'est pas leur langue maternelle, ils
risquent d'etre deroutes par l'absence d'accents. Pour nous c'est moins
un probleme.
En fait, dans Paradox, on utilise des instructions du genre : tc.Code = "ABCD" tc.Libellé = "Item d'article complet" tc.Montant = 1234.56 tc.Tva = tc.Montant*19.60/100 tc.Année = 2007
Et, j'aurais aimé, sous Python, retrouver une lisibilité au moins égale.
Heureusement que ce n'est pas possible sinon, imagine les difficultées pour s'échanger des codes d'un pays à l'autre ! Adieu la lisibilité pour de bon...
Pourtant je trouve ca plutot légitime de vouloir utiliser des mots de sa langue pour nommer des identifieurs.
Oui. Et puis c'est tellement plus partique pour partager du code avec des italiens, des russes et des japonais...
Tout a fait, si le francais n'est pas leur langue maternelle, ils risquent d'etre deroutes par l'absence d'accents. Pour nous c'est moins un probleme.
