que - python mayusculas y minusculas

Diccionario de mayúsculas y minúsculas

Question

Me gustaría que mi diccionario sea insensible a mayúsculas y minúsculas.

Tengo este código de ejemplo:

text = "practice changing the color"

words = {''color'': ''colour'',
        ''practice'': ''practise''}

def replace(words,text):

    keys = words.keys()

    for i in keys:
        text= text.replace(i ,words[i])
    return  text

text = replace(words,text)

print text

Salida = práctica cambiando el color

Me gustaría otra cadena, "practice changing the Color" , (donde el Color comienza con mayúscula) para dar el mismo resultado.

Creo que hay una forma general de convertir a minúsculas usando mydictionary[key.lower()] pero no estoy seguro de cómo integrar esto mejor en mi código existente. (Si este fuera un enfoque razonable y simple de todos modos).

Answer 1

¿Consideraría usar string.lower() en sus entradas y usar un diccionario en minúsculas? Es un poco una solución pirata, pero funciona

Answer 2

Acabo de configurar una función para manejar esto:

def setLCdict(d, k, v):
    k = k.lower()
    d[k] = v
    return d

myDict = {}

Así que en lugar de

myDict[''A''] = 1
myDict[''B''] = 2

Usted puede:

myDict = setLCdict(myDict, ''A'', 1)
myDict = setLCdict(myDict, ''B'', 2)

Luego puede escribir el valor en minúscula antes de buscarlo o escribir una función para hacerlo.

    def lookupLCdict(d, k):
        k = k.lower()
        return d[k]

    myVal = lookupLCdict(myDict, ''a'')

Probablemente no sea lo ideal si desea hacer esto a nivel mundial, pero funciona bien si solo es un subconjunto para el que desea utilizarlo.

Answer 3

En mi caso particular, necesitaba una búsqueda de mayúsculas y minúsculas, sin embargo, no quería modificar el caso original de la clave. Por ejemplo:

>>> d = {}
>>> d[''MyConfig''] = ''value''
>>> d[''myconfig''] = ''new_value''
>>> d
{''MyConfig'': ''new_value''}

Puede ver que el diccionario aún tiene la clave original, sin embargo, se puede acceder a mayúsculas y minúsculas. Aquí hay una solución simple:

class CaseInsensitiveKey(object):
    def __init__(self, key):
        self.key = key
    def __hash__(self):
        return hash(self.key.lower())
    def __eq__(self, other):
        return self.key.lower() == other.key.lower()
    def __str__(self):
        return self.key

Las modificaciones __hash__ y __eq__ son necesarias para obtener y configurar entradas en el diccionario. Esto es crear claves que se agrupan en la misma posición en el diccionario si son iguales a mayúsculas y minúsculas.

Ahora cree un diccionario personalizado que inicialice un CaseInsensitiveKey usando la clave provista:

class CaseInsensitiveDict(dict):
    def __setitem__(self, key, value):
        key = CaseInsensitiveKey(key)
        super(CaseInsensitiveDict, self).__setitem__(key, value)
    def __getitem__(self, key):
        key = CaseInsensitiveKey(key)
        return super(CaseInsensitiveDict, self).__getitem__(key)

o simplemente asegúrese de pasar siempre una instancia de CaseInsensitiveKey como clave cuando use el diccionario.

Answer 4

He modificado la solución simple pero buena con pleasemorebacon (¡gracias!), Haciéndola un poco más compacta, independiente y con actualizaciones menores para permitir la construcción desde {''a'':1, ''B'':2} y el protocolo __contains__ . Finalmente, dado que se espera que CaseInsensitiveDict.Key sea ​​una cadena (lo que puede ser sensible a mayúsculas y minúsculas), es una buena idea derivar la clase Key de la str , entonces es posible, por ejemplo, volcar CaseInsensitiveDict con json.dumps fuera de la caja.

# caseinsensitivedict.py
class CaseInsensitiveDict(dict):

    class Key(str):
        def __init__(self, key):
            str.__init__(key)
        def __hash__(self):
            return hash(self.lower())
        def __eq__(self, other):
            return self.lower() == other.lower()

    def __init__(self, data=None):
        super(CaseInsensitiveDict, self).__init__()
        if data is None:
            data = {}
        for key, val in data.items():
            self[key] = val
    def __contains__(self, key):
        key = self.Key(key)
        return super(CaseInsensitiveDict, self).__contains__(key)
    def __setitem__(self, key, value):
        key = self.Key(key)
        super(CaseInsensitiveDict, self).__setitem__(key, value)
    def __getitem__(self, key):
        key = self.Key(key)
        return super(CaseInsensitiveDict, self).__getitem__(key)

Aquí hay una secuencia de comandos de prueba básica para aquellos que les gusta revisar las cosas en acción:

# test_CaseInsensitiveDict.py
import json
import unittest
from caseinsensitivedict import *

class Key(unittest.TestCase):
    def setUp(self):
        self.Key = CaseInsensitiveDict.Key
        self.lower = self.Key(''a'')
        self.upper = self.Key(''A'')

    def test_eq(self):
        self.assertEqual(self.lower, self.upper)

    def test_hash(self):
        self.assertEqual(hash(self.lower), hash(self.upper))

    def test_str(self):
        self.assertEqual(str(self.lower), ''a'')
        self.assertEqual(str(self.upper), ''A'')

class Dict(unittest.TestCase):
    def setUp(self):
        self.Dict = CaseInsensitiveDict
        self.d1 = self.Dict()
        self.d2 = self.Dict()
        self.d1[''a''] = 1
        self.d1[''B''] = 2
        self.d2[''A''] = 1
        self.d2[''b''] = 2

    def test_contains(self):
        self.assertIn(''B'', self.d1)
        d = self.Dict({''a'':1, ''B'':2})
        self.assertIn(''b'', d)

    def test_init(self):
        d = self.Dict()
        self.assertFalse(d)
        d = self.Dict({''a'':1, ''B'':2})
        self.assertTrue(d)

    def test_items(self):
        self.assertDictEqual(self.d1, self.d2)
        self.assertEqual(
            [v for v in self.d1.items()],
            [v for v in self.d2.items()])

    def test_json_dumps(self):
        s = json.dumps(self.d1)
        self.assertIn(''a'', s)
        self.assertIn(''B'', s)

    def test_keys(self):
        self.assertEqual(self.d1.keys(), self.d2.keys())

    def test_values(self):
        self.assertEqual(
            [v for v in self.d1.values()],
            [v for v in self.d2.values()])

Answer 5

La respuesta actualmente aprobada no funciona en muchos casos, por lo que no se puede utilizar como un reemplazo de dict . Algunos puntos difíciles para obtener un reemplazo adecuado de dict :

• Sobrecargar todos los métodos que involucran claves.
• manejando adecuadamente las claves que no son de cadena
• Manejando adecuadamente el constructor de la clase.

Lo siguiente debería funcionar mucho mejor:

class CaseInsensitiveDict(dict):
    @classmethod
    def _k(cls, key):
        return key.lower() if isinstance(key, basestring) else key

    def __init__(self, *args, **kwargs):
        super(CaseInsensitiveDict, self).__init__(*args, **kwargs)
        self._convert_keys()
    def __getitem__(self, key):
        return super(CaseInsensitiveDict, self).__getitem__(self.__class__._k(key))
    def __setitem__(self, key, value):
        super(CaseInsensitiveDict, self).__setitem__(self.__class__._k(key), value)
    def __delitem__(self, key):
        return super(CaseInsensitiveDict, self).__delitem__(self.__class__._k(key))
    def __contains__(self, key):
        return super(CaseInsensitiveDict, self).__contains__(self.__class__._k(key))
    def has_key(self, key):
        return super(CaseInsensitiveDict, self).has_key(self.__class__._k(key))
    def pop(self, key, *args, **kwargs):
        return super(CaseInsensitiveDict, self).pop(self.__class__._k(key), *args, **kwargs)
    def get(self, key, *args, **kwargs):
        return super(CaseInsensitiveDict, self).get(self.__class__._k(key), *args, **kwargs)
    def setdefault(self, key, *args, **kwargs):
        return super(CaseInsensitiveDict, self).setdefault(self.__class__._k(key), *args, **kwargs)
    def update(self, E={}, **F):
        super(CaseInsensitiveDict, self).update(self.__class__(E))
        super(CaseInsensitiveDict, self).update(self.__class__(**F))
    def _convert_keys(self):
        for k in list(self.keys()):
            v = super(CaseInsensitiveDict, self).pop(k)
            self.__setitem__(k, v)

Answer 6

Si bien un diccionario que no distingue entre mayúsculas y minúsculas es una solución, y hay respuestas sobre cómo lograrlo, es posible que haya una forma más fácil en este caso. Una búsqueda de mayúsculas y minúsculas es suficiente:

import re

text = "Practice changing the Color"
words = {''color'': ''colour'', ''practice'': ''practise''}

def replace(words,text):
        keys = words.keys()
        for i in keys:
                exp = re.compile(i, re.I)
                text = re.sub(exp, words[i], text)
        return text

text = replace(words,text)
print text

Answer 7

Si te entiendo correctamente y quieres una forma de teclear diccionarios de una manera que no distinga mayúsculas y minúsculas, una forma sería subclasificar dict y sobrecargar el establecedor / captador:

class CaseInsensitiveDict(dict):
    def __setitem__(self, key, value):
        super(CaseInsensitiveDict, self).__setitem__(key.lower(), value)

    def __getitem__(self, key):
        return super(CaseInsensitiveDict, self).__getitem__(key.lower())

Answer 8

Solo para que conste. Encontré una impresionante mejora en las Requests :

https://github.com/kennethreitz/requests/blob/v1.2.3/requests/structures.py#L37