1
2
c:\python34\python.exe -m venv d:\pyenvqt4
c:\python34\python.exe -m venv d:\pyenvqt5

1
2
3
4
5
[Paths]
Prefix = ../Lib/site-packages/PyQt4
Binaries = .
Plugins = plugins
Translations = translations

1
2
3
4
5
# pour PyQt4:
d:\pyenvqt4\Scripts\pythonw.exe monprogramme.pyw

# pour PyQt5:
d:\pyenvqt5\Scripts\pythonw.exe monprogramme.pyw

1
2
3
4
5
# pour PyQt4:
d:\pyenvqt4\Scripts\pythonw.exe  d:\pyenvqt4\Lib\site-packages\PyQt4\examples\demos\qtdemo\qtdemo.pyw

# pour PyQt5:
d:\pyenvqt5\Scripts\pythonw.exe d:\pyenvqt5\Lib\site-packages\PyQt5\examples\qtdemo\qtdemo.pyw

1
2
3
4
5
6
def regexp(motif, item):
    """retourne True si le motif regex a été satisfait dans l'item
       False sinon
    """
    regex = re.compile(motif, re.I)  # re.I: ignore casse
    return regex.search(item) is not None

cnx.create_function("REGEXP", 2, regexp)

1
2
3
4
5
aaa bbb ccc(ddd)eee fff
aaa (bbb) ccc
(aaa)bbb ccc ddd
aaabbbcccddd(eee)
aaabbbcccddd

1
2
3
4
5
6
7
cur.execute("""
    SELECT mots
    FROM test
    WHERE mots REGEXP ?
    ORDER BY mots
    """, ('\(.*\)',))
liste = cur.fetchall()

1
2
3
4
(aaa)bbb ccc ddd
aaa (bbb) ccc
aaa bbb ccc(ddd)eee fff
aaabbbcccddd(eee)

1
2
3
4
5
6
7
8
9
10
def regextract(motif, item):
    """retourne la 1ère sous-chaine qui satisfait au motif regex donné
       si aucune sous-chaine n'est trouvée, renvoie None
    """
    regex = re.compile(motif, re.I)  # re.I: ignore la casse
    result = regex.findall(item)  # liste des sous-chaines trouvées
    if result != []:
        return result[0]  # on ne renvoie que la 1ère s'il y en a plusieurs
    else:
        return None

1
2
3
4
5
6
7
cur.execute("""
    SELECT regextract(?,mots) as parentheses
    FROM test
    WHERE mots REGEXP ?
    ORDER BY parentheses
    """, ('\(.*\)', '\(.*\)'))
liste = cur.fetchall()

1
2
3
4
(aaa)
(bbb)
(ddd)
(eee)

 '\((.*)\)'

1
2
3
4
CASE WHEN sousreq != ''
THEN sousreq
ELSE 'Non disponible'
END

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
class Varsql(object):
    """déclaration et utilisation de variables dans sqlite3
    """
 
    def __init__(self):
        """initialise le dictionnaire des variables
        """
        self.dicovar = {}
 
    def set_var(self, var, val):
        """cree la variable var et lui affecte la valeur val
        """
        self.dicovar[var] = val
        return val
 
    def get_var(self, var):
        """retourne la valeur val de la variable var si elle existe
           sinon, retourne None
        """
        if var in self.dicovar:
            return self.dicovar[var]
        else:
            return None
 
varsql = Varsql()  # instanciation de la classe

1
2
cnx.create_function("set_var", 2, varsql.set_var)
cnx.create_function("get_var", 1, varsql.get_var)

1
2
3
4
cur.execute("""
    SELECT set_var('x', mots), get_var('x')
    FROM test
    """)

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
27
28
import locale
 
class Compdicofr(object):
    """comparaison de 2 chaines selon le dictionnaire français"""
 
    def __init__(self):
        self.loc = locale.getlocale()  # stocke la locale courante
        self.espinsec = '\xA0'  # espace insécable
 
    def __call__(self, v1, v2):
 
        # on retire les tirets et les blancs insécables
        v1 = v1.replace('-', '')
        v1 = v1.replace(self.espinsec, '')
        v2 = v2.replace('-', '')
        v2 = v2.replace(self.espinsec, '')
 
        # on fait la comparaison selon la locale
        locale.setlocale(locale.LC_ALL, '')
        comp = locale.strcoll(v1, v2)
 
        # retour à la locale initiale
        locale.setlocale(locale.LC_ALL, self.loc)
 
        # on retourne le résultat de la comparaison
        return comp
 
compdicofr = Compdicofr()

1
2
3
4
5
6
xabc
abcç
abcé
Xabcù
Abcè
êqsdf

1
2
3
4
5
6
7
8
9
cur.execute("""
    SELECT *
    FROM test 
    ORDER BY mots
    """)
datas = cur.fetchall()
 
for data in datas:
    print data[0]

1
2
3
4
5
6
Abcè
Xabcù
abcç
abcé
xabc
êqsdf

1
2
3
4
5
6
7
8
9
10
11
cnx.create_collation("compdicofr", compdicofr)
 
cur.execute("""
    SELECT *
    FROM test 
    ORDER BY mots COLLATE compdicofr
    """)
datas = cur.fetchall()
 
for data in datas:
    print data[0]

1
2
3
4
5
6
abcç
abcé
Abcè
êqsdf
xabc
Xabcù

1
2
3
4
5
6
7
from difflib import SequenceMatcher
 
mots =["Durand", "Meyer", "Dupond", "Dopon", "DUPON", "Nguyen", "Toto"]
ratio = 0.8
resultat = [mot for mot in mots if SequenceMatcher(None, "Dupont", mot).ratio() >= ratio]
print(resultat)
['Dupond']

1
2
3
4
5
6
7
8
9
10
import unicodedata
 
def majuscsa(chaine):
    """Convertit la chaine (unicode), en majuscules non accentuées
    """
    # convertit en majuscule avec conservation des accents éventuels
    chaine = chaine.upper()
    # supprime les accents éventuels qui restent
    chnorm = unicodedata.normalize('NFKD', chaine)
    return "".join([car for car in chnorm if not unicodedata.combining(car)])

1
2
3
4
5
6
7
8
9
from difflib import SequenceMatcher
 
def simil(mot1, mot2, ratio, okmajusc=True):
    """compare les 2 mots, et retourne True si le tx de similitude >= ratio
       si okmajusc=True, la comparaison est faite en majuscule sans accent
    """
    if okmajusc:
        mot1, mot2 = majuscsa(mot1), majuscsa(mot2)
    return SequenceMatcher(None, mot1, mot2).ratio() >= ratio

1
2
3
4
5
# fonction 'simil' (similitude de 2 chaines)
cnx.create_function("simil", 3, simil)
 
# fonction 'majuscsa' (majuscule_sans_accent))
cnx.create_function("majuscsa", 1, majuscsa)

1
2
3
4
5
6
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
from configparser import ConfigParser
from collections import OrderedDict

1
2
3
4
5
6
7
8
9
10
11
12
13
def chargini(ficini, encodage="utf-8"):
    """charge le contenu du fichier ini 'ficini' avec l'encodage 'encodage'
       retourne le dictionnaire de dictionnaires ordonné, image des données
    """
    cfg = ConfigParser()
    with open(ficini, 'r', encoding=encodage) as fs:
        cfg.read_file(fs)
    dini = OrderedDict()
    for section in cfg.sections():
        dini[section] = OrderedDict()
        for option, valeur in cfg.items(section):
            dini[section][option] = valeur
    return dini

1
2
3
4
5
6
7
8
9
10
11
def sauvini(dini, ficini, encodage="utf-8"):
    """sauve le dictionnaire de dictionnaires 'dini' dans le fichier ini
       'ficini' avec l'encodage 'encodage'
    """
    cfg = ConfigParser()
    for section in dini:
        cfg.add_section(section)
        for option, valeur in dini[section].items():
            cfg.set(section, option, valeur)
    with open(ficini, 'w', encoding=encodage) as fd:
        cfg.write(fd)

1
2
3
4
5
6
from bibini import chargini, sauvini
...
dico = chargini("config.ini")
...
sauvini(dico, "config.ini")
...