Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Bonjour à tous,
Voici un code qui est censé classer par ordre alphabétique une liste de
noms qui peuvent contenir des accents :
#-----------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sqlite3
connection = sqlite3.connect("test.sq3")
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name ASC")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#-----------------------------------
J'obtiens en sortie ceci :
#-----------------------------------
Antoine
Edouard
Eliot
Fanny
Jean
Pierre
Stephanie # devrait être juste après "Stéphane"
Stéphane
Élie # devrait être juste avant "Eliot"
#-----------------------------------
Cela ne me convient pas car je voudrais que l'ordre alphabétique soit
respecté comme si les accents n'étaient pas présents.
Comment faire pour que ma requête sql renvoie le classement que je
souhaite ?
Merci d'avance pour votre aide.
Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Le 09/08/2010 12:12, Alain BARTHE a écrit :Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Merci, le mot "collate" dans ta requête SQL m'a mis sur une piste. En
effet, ici
http://docs.python.org/library/sqlite3.html#sqlite3.Connection.create_collation,
il est question de la méthode create_collation qui permet de définir son
propre classement avec une fonction. Du coup, j'ai fait une fonction qui
compare deux chaînes avec cmp(), mais avant les chaines sont (entre
autres) délestées de leurs accents. Je pense que ce que j'ai fait n'est
pas vraiment pas très propre, mais le code marche. Le voici :
#------------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sys
import re
import sqlite3
def delete_accents(word_unicode):
dict_accents = { u'a': [u'à', u'á', u'â', u'ã', u'ä', u'å'],
u'A': [u'À', u'Á', u'Â', u'Ã', u'Ä', u'Å'],
u'c': [u'ç'],
u'C': [u'Ç'],
u'e': [u'è', u'é', u'ê', u'ë'],
u'E': [u'È', u'É', u'Ê', u'Ë'],
u'i': [u'ì', u'í', u'î', u'ï'],
u'I': [u'Ì', u'Í', u'Î', u'Ï'],
u'n': [u'ñ'],
u'N': [u'Ñ'],
u'o': [u'ò', u'ó', u'ô', u'õ', u'ö', u'ø'],
u'O': [u'Ò', u'Ó', u'Ô', u'Õ', u'Ö', u'Ø'],
u'u': [u'ù', u'ú', u'û', u'ü'],
u'U': [u'Ù', u'Ú', u'Û', u'Ü'],
u'y': [u'ÿ'] }
for (char, accented_chars) in dict_accents.iteritems():
for accented_char in accented_chars:
word_unicode = word_unicode.replace(accented_char, char)
return word_unicode
def collate_without_accent(string1, string2):
default_encoding_str = sys.stdin.encoding
string1 = string1.decode(default_encoding_str)
string2 = string2.decode(default_encoding_str)
string1 = delete_accents(string1).lower()
string2 = delete_accents(string2).lower()
reg_exp = re.compile(r"[^a-z]")
string1 = reg_exp.sub("", string1)
string2 = reg_exp.sub("", string2)
return cmp(string1, string2)
connection = sqlite3.connect("test.sq3")
connection.create_collation("mycollation", collate_without_accent)
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name COLLATE mycollation")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#------------------------------------
Comme le soulignait Bruno, mon problème n'est pas vraiment un problème
Python, je vais tenter quelques recherches sur SQLite.
Le 09/08/2010 12:12, Alain BARTHE a écrit :
Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Merci, le mot "collate" dans ta requête SQL m'a mis sur une piste. En
effet, ici
http://docs.python.org/library/sqlite3.html#sqlite3.Connection.create_collation,
il est question de la méthode create_collation qui permet de définir son
propre classement avec une fonction. Du coup, j'ai fait une fonction qui
compare deux chaînes avec cmp(), mais avant les chaines sont (entre
autres) délestées de leurs accents. Je pense que ce que j'ai fait n'est
pas vraiment pas très propre, mais le code marche. Le voici :
#------------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sys
import re
import sqlite3
def delete_accents(word_unicode):
dict_accents = { u'a': [u'à', u'á', u'â', u'ã', u'ä', u'å'],
u'A': [u'À', u'Á', u'Â', u'Ã', u'Ä', u'Å'],
u'c': [u'ç'],
u'C': [u'Ç'],
u'e': [u'è', u'é', u'ê', u'ë'],
u'E': [u'È', u'É', u'Ê', u'Ë'],
u'i': [u'ì', u'í', u'î', u'ï'],
u'I': [u'Ì', u'Í', u'Î', u'Ï'],
u'n': [u'ñ'],
u'N': [u'Ñ'],
u'o': [u'ò', u'ó', u'ô', u'õ', u'ö', u'ø'],
u'O': [u'Ò', u'Ó', u'Ô', u'Õ', u'Ö', u'Ø'],
u'u': [u'ù', u'ú', u'û', u'ü'],
u'U': [u'Ù', u'Ú', u'Û', u'Ü'],
u'y': [u'ÿ'] }
for (char, accented_chars) in dict_accents.iteritems():
for accented_char in accented_chars:
word_unicode = word_unicode.replace(accented_char, char)
return word_unicode
def collate_without_accent(string1, string2):
default_encoding_str = sys.stdin.encoding
string1 = string1.decode(default_encoding_str)
string2 = string2.decode(default_encoding_str)
string1 = delete_accents(string1).lower()
string2 = delete_accents(string2).lower()
reg_exp = re.compile(r"[^a-z]")
string1 = reg_exp.sub("", string1)
string2 = reg_exp.sub("", string2)
return cmp(string1, string2)
connection = sqlite3.connect("test.sq3")
connection.create_collation("mycollation", collate_without_accent)
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name COLLATE mycollation")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#------------------------------------
Comme le soulignait Bruno, mon problème n'est pas vraiment un problème
Python, je vais tenter quelques recherches sur SQLite.
Le 09/08/2010 12:12, Alain BARTHE a écrit :Tu devrais regarder coté "encodage et interclassement".
Je ne connais pas sqlite, mais en MySQL c'est un problème classique :
ALTER TABLE ma-table SET encodage COLLATE interclassement;
Il est probable que les mêmes possibilités existent en sqlite.
Merci, le mot "collate" dans ta requête SQL m'a mis sur une piste. En
effet, ici
http://docs.python.org/library/sqlite3.html#sqlite3.Connection.create_collation,
il est question de la méthode create_collation qui permet de définir son
propre classement avec une fonction. Du coup, j'ai fait une fonction qui
compare deux chaînes avec cmp(), mais avant les chaines sont (entre
autres) délestées de leurs accents. Je pense que ce que j'ai fait n'est
pas vraiment pas très propre, mais le code marche. Le voici :
#------------------------------------
#! /usr/bin/python
# -*- coding:Utf-8 -*-
import sys
import re
import sqlite3
def delete_accents(word_unicode):
dict_accents = { u'a': [u'à', u'á', u'â', u'ã', u'ä', u'å'],
u'A': [u'À', u'Á', u'Â', u'Ã', u'Ä', u'Å'],
u'c': [u'ç'],
u'C': [u'Ç'],
u'e': [u'è', u'é', u'ê', u'ë'],
u'E': [u'È', u'É', u'Ê', u'Ë'],
u'i': [u'ì', u'í', u'î', u'ï'],
u'I': [u'Ì', u'Í', u'Î', u'Ï'],
u'n': [u'ñ'],
u'N': [u'Ñ'],
u'o': [u'ò', u'ó', u'ô', u'õ', u'ö', u'ø'],
u'O': [u'Ò', u'Ó', u'Ô', u'Õ', u'Ö', u'Ø'],
u'u': [u'ù', u'ú', u'û', u'ü'],
u'U': [u'Ù', u'Ú', u'Û', u'Ü'],
u'y': [u'ÿ'] }
for (char, accented_chars) in dict_accents.iteritems():
for accented_char in accented_chars:
word_unicode = word_unicode.replace(accented_char, char)
return word_unicode
def collate_without_accent(string1, string2):
default_encoding_str = sys.stdin.encoding
string1 = string1.decode(default_encoding_str)
string2 = string2.decode(default_encoding_str)
string1 = delete_accents(string1).lower()
string2 = delete_accents(string2).lower()
reg_exp = re.compile(r"[^a-z]")
string1 = reg_exp.sub("", string1)
string2 = reg_exp.sub("", string2)
return cmp(string1, string2)
connection = sqlite3.connect("test.sq3")
connection.create_collation("mycollation", collate_without_accent)
cursor = connection.cursor()
cursor.execute("CREATE TABLE test (name TEXT)")
connection.commit()
my_list = [(u"Jean",),
(u"Stéphane",),
(u"Pierre",),
(u"Antoine",),
(u"Fanny",),
(u"Élie",),
(u"Eliot",),
(u"Edouard",),
(u"Stephanie",)]
for t in my_list:
cursor.execute("INSERT INTO test (name) VALUES (?)", t)
connection.commit()
cursor.execute("SELECT * FROM test ORDER BY name COLLATE mycollation")
for row in cursor:
name = row[0]
print name
cursor.close()
connection.close()
#------------------------------------
Comme le soulignait Bruno, mon problème n'est pas vraiment un problème
Python, je vais tenter quelques recherches sur SQLite.
Je pense qu'il doit y avoir plus simple :
- il doit être possible de prendre en compte automatiquement les accents
(e = é = ê = è parexemple), en fonction de la langue également, en
fournissant les bons paramètres à la table, ou à la base de données
elle-même
Je pense qu'il doit y avoir plus simple :
- il doit être possible de prendre en compte automatiquement les accents
(e = é = ê = è parexemple), en fonction de la langue également, en
fournissant les bons paramètres à la table, ou à la base de données
elle-même
Je pense qu'il doit y avoir plus simple :
- il doit être possible de prendre en compte automatiquement les accents
(e = é = ê = è parexemple), en fonction de la langue également, en
fournissant les bons paramètres à la table, ou à la base de données
elle-même
Je viens de faire quelques recherches et j'ai l'impression que ce n'est
pas possible hélas.
Je viens de faire quelques recherches et j'ai l'impression que ce n'est
pas possible hélas.
Je viens de faire quelques recherches et j'ai l'impression que ce n'est
pas possible hélas.
J'ai cru comprendre que ce n'était volontairement pas possible
nativement. La solution repose sur ICU: [couic]
J'ai cru comprendre que ce n'était volontairement pas possible
nativement. La solution repose sur ICU: [couic]
J'ai cru comprendre que ce n'était volontairement pas possible
nativement. La solution repose sur ICU: [couic]
Je crois que je vais rester sur mon petit code avec
".create_collation()". En effet, comme je le disais dans un message
précédent, ce script est une bidouille perso sur une toute petite table,
pas de souci de performances donc.
Je crois que je vais rester sur mon petit code avec
".create_collation()". En effet, comme je le disais dans un message
précédent, ce script est une bidouille perso sur une toute petite table,
pas de souci de performances donc.
Je crois que je vais rester sur mon petit code avec
".create_collation()". En effet, comme je le disais dans un message
précédent, ce script est une bidouille perso sur une toute petite table,
pas de souci de performances donc.
Ah bon. Mais comment ferais-tu cela ? Car personnellement, dans mon
script (du message du 9 août à 13h40), j'ai fait ceci :
Ah bon. Mais comment ferais-tu cela ? Car personnellement, dans mon
script (du message du 9 août à 13h40), j'ai fait ceci :
Ah bon. Mais comment ferais-tu cela ? Car personnellement, dans mon
script (du message du 9 août à 13h40), j'ai fait ceci :