Python lower() – Cómo poner en minúsculas una cadena Python usando el equivalente de la función tolower

Estimated read time 13 min read

Una cadena es un tipo de datos formado por caracteres entrecomillados. Estos caracteres pueden ser letras, símbolos o números.

En Python, hay diferentes formas de trabajar con cadenas. Estos métodos son funciones incorporadas que cambian los resultados de la cadena.

Por ejemplo, si quiero imprimir mi nombre con su primera letra en mayúscula, utilizo el método .title() para poner la primera letra en mayúscula.

En este artículo, aprenderemos a convertir letras mayúsculas en minúsculas sin utilizar el método incorporado.

Cómo convertir una cadena a minúsculas usando .lower()

Las cadenas pueden estar formadas por diferentes caracteres – uno de esos caracteres son las letras del alfabeto. El alfabeto inglés se puede escribir en mayúsculas o minúsculas. Al cambiar una cadena a minúsculas, sólo se aplica a las letras.

En Python, hay un método incorporado que puede cambiar una cadena que está en mayúsculas a minúsculas. También se aplica a las cadenas que tienen letras tanto en mayúsculas como en minúsculas. El método «.lower() » cambia las cadenas a minúsculas.

name = "BOB STONE"
print(name.lower()) # >> bob stone
name1 = "Ruby Roundhouse"
print(name1.lower()) # >> ruby roundhouse
name2 = "joHN Wick"
print(name2.lower()) # >> john wick
name3 = "charlieNew"
print(name3.lower()) # >> charlienew

Podemos ver en el bloque de código anterior que las variables que almacenan cada cadena tienen letras mayúsculas. Luego con el método .lower() convierte esas letras a minúsculas.

Otras formas de convertir una cadena de Python a minúsculas

Aparte del método incorporado «.lower()», hay diferentes maneras de convertir letras mayúsculas a minúsculas en Python. En este artículo, veremos dos formas diferentes.

Hay dos formas de acceder a las letras:

  • copiándolos manualmente en una lista o
  • haciendo uso del estándar Unicode

Cómo acceder a las letras de una lista

La idea es recorrer una lista de letras y sustituir las mayúsculas de una cadena por minúsculas.

Primero, crea una variable que almacene una entrada que acepte una cadena con letras mayúsculas.

A continuación, crea otra variable que almacene una lista de letras mayúsculas y minúsculas.

Por último, crea una variable final que almacene una cadena vacía, que es donde se almacenarán las letras minúsculas.

word = str(input("Enter a word: ” ))

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

lowercase_letters = ''

En la lista anterior, vemos que tiene letras minúsculas y mayúsculas. Hay 26 letras en el alfabeto inglés, pero el índice en una lista empieza por 0, por lo que el recuento del alfabeto es 51 (tanto para las mayúsculas como para las minúsculas).

También podemos ver que las minúsculas se escriben primero (lado izquierdo) y las mayúsculas después (lado derecho). Los índices de las minúsculas van de 0 a 25, mientras que los de las mayúsculas van de 26 a 51.

A continuación, recorremos cada carácter de la cadena.

for char in word:

es el nuevo nombre de la variable que almacena todos los caracteres de la variable .

Hay dos casos de cadenas que vamos a convertir. El primer caso son las cadenas con sólo letras mayúsculas y el segundo son las cadenas con símbolos especiales, números, algunas minúsculas y algunas mayúsculas.

CASO I: cadenas sólo con mayúsculas

Para convertir las letras mayúsculas en minúsculas, tenemos que encontrar el índice de cada letra almacenada por la variable de la lista. Para encontrar un índice utilizamos el método «.index()»:

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
word = str(input("Enter a word: " ))
for char in word:
    print(alphabet.index(char))

# Results
# Enter a word: GIRL
# 32
# 34
# 43
# 37

In the above code, the indexes of the letters in the <word> «GIRL» are printed.

In the list, the lowercase letters have indexes from 0-25 and uppercase letters have indexes from 26 – 51. When setting the condition («if» statement) we start checking if the index of the letter is greater than ’25’ because the first uppercase index starts from ’26’ .

To get the corresponding lowercase letters, we substract 26 from each uppercase index. When we get the indexes of the lowercase numbers, we use indexing (variable_name[index_number]) to find the corresponding letters. The lowercase letters are now added to the variable name <lower_case_letters> that stores an empty string.

We return the variable <lowercase_letters> by printing it outside the loop.

for char in word:
      if alphabet.index(char) > 25:
          lowercase_letters += alphabet[alphabet.index(char)-26]
  print(lowercase_letters)

Este es el aspecto del código cuando lo juntamos todo:

def change_to_lowercase(word):
    
  alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
  lowercase_letters = ''
  
  for char in word:
      if alphabet.index(char) > 25:
          lowercase_letters += alphabet[alphabet.index(char)-26]
      
  return lowercase_letters

word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: FERE
# fere
# Enter a word: PYTHONISFUN
# pythonisfun

CASO II: cadenas con símbolos especiales, números, letras minúsculas junto a letras mayúsculas.

Antes de convertir las letras mayúsculas en minúsculas, debemos comprobar algunas condiciones. Las condiciones comprobarán si cada carácter de la palabra:

  • no es una letra
  • tiene letras mayúsculas y minúsculas en la palabra. Si algunas letras de la palabra son minúsculas, no se modificarán.

Tras estas comprobaciones, asume que el resto de caracteres son letras mayúsculas.

Para comprobar si un carácter no es una letra, utilizamos la palabra clave «not in». Para comprobar si un carácter es minúscula, buscamos el índice y lo comparamos con el último recuento de las letras minúsculas de la lista.

De nuevo, las letras minúsculas tienen índices de 0-25, y el índice de la última letra minúscula es 25. Estos caracteres se añaden a la variable de nombre que almacena una cadena vacía.

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char

En el bloque de código anterior, utilizamos el método .index() para encontrar la posición de las letras en el alfabeto.

Para los caracteres restantes que asumimos son letras mayúsculas, en la lista de letras, los índices de esas letras son de 26 – 51. Para encontrar sus correspondientes índices de letras minúsculas, restamos por 26, y usamos el método .index() para encontrar la letra.

Indexación = nombre_variable[número_índice]. Añadimos el resultado final a la variable que almacena la cadena vacía.

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char
    else:
        lowercase_letters += alphabet[alphabet.index(char)-26]

Luego imprimimos minúsculas_letras fuera del bucle:

for char in word:
    if char not in alphabet or alphabet.index(char)<=25:
        lowercase_letters += char
    else:
        lowercase_letters += alphabet[alphabet.index(char)-26]
print(lowercase_letters)

Este es el aspecto del código cuando lo juntamos todo:

def change_to_lowercase(word):
    
  alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
  lowercase_letters = ''
  
  for char in word:
      if char not in alphabet or alphabet.index(char)<=25:
          lowercase_letters += char
      else:
          lowercase_letters += alphabet[alphabet.index(char)-26]
  return lowercase_letters

word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: 2022BlackADAM&&
# 2022blackadam&&
# Enter a word: Weasle2@3568QQQAJHGB
# weasle2@3568qqqajhgb

Cómo acceder a las letras utilizando el estándar Unicode

Unicode significa estándar universal de codificación de caracteres. Según unicode.org,

«El estándar Unicode proporciona un número único para cada carácter, independientemente de la plataforma, el dispositivo, la aplicación o el idioma».

En términos sencillos, todas las letras de diferentes idiomas tienen un número único que representa cada carácter presente en Unicode.

Utilizamos dos métodos cuando trabajamos con Unicode en Python: ord() y chr().

  • ord(): esta función acepta caracteres (letras en cualquier idioma) y devuelve el número único según el estándar Unicode.
  • chr(): esta función acepta números enteros y devuelve el carácter equivalente según el estándar Unicode.

Antes de entrar de lleno en la explicación del código, he aquí una tabla que contiene todos los números únicos del alfabeto inglés, tanto en minúsculas como en mayúsculas.

Ahora que estamos familiarizados con lo que es Unicode y cómo acceder a los valores en Python, vamos a sumergirnos.

Primero, crea una variable que almacene una entrada que acepte una cadena con letras mayúsculas.

Luego, crea la variable final que almacena una cadena vacía, que es donde se almacenarán las letras minúsculas.

word = str(input("Enter a word: ” ))
lowercase_letters = ''

A continuación, recorremos en bucle cada carácter de la cadena.

for char in word:

es el nuevo nombre de la variable que almacena todos los caracteres de la variable .

CASO I: cadenas que sólo contienen letras mayúsculas.

Antes de convertir las letras mayúsculas a minúsculas, tenemos que comprobar si cada carácter de la palabra está en mayúscula.

Según la tabla Unicode, la letra mayúscula A tiene el número «65», y la letra mayúscula Z tiene el número «90». Comprobamos si cada carácter de tiene números entre 65 y 90. Si es así, son letras mayúsculas.

print((ord('A')))
# RESULT
# 65
print((ord('Z')))
# RESULT
# 90
print((ord('F')))
# RESULT
# 70

La función ord() devuelve el número único de cada letra en mayúscula.

Para convertir las letras mayúsculas en minúsculas, sumamos la diferencia entre ambos casos, «32», a cada número de las mayúsculas para obtener las minúsculas.

Por ejemplo:

number_for_A = ord('A')
number_for_a = ord('a')
difference_a = number_for_a - number_for_A
print("Differences in letters" , difference_a)
print("The unique number for A", number_for_A)
print("The unique number for a", number_for_a)

 # Results
# The unique number for A 65
# The unique number for a 97
# Differences in letters 32

number_for_F = ord('F')
number_for_f = ord('f')
difference_f = number_for_f - number_for_F
print("The unique number for F", number_for_F)
print("The unique number for f", number_for_f)
print("Differences in letters" , difference_f)
# Results
# The unique number for F 70
# The unique number for f 102
# Differences in letters 32

En el código anterior, ‘a’ es 97 en la tabla unicode y ‘A’ es 65. La diferencia entre ambos es de 32. Si queremos obtener el valor de «a» en la tabla, sumamos 32 al valor de A «65» y obtenemos «97».

Así que para convertir a minúsculas, tenemos que añadir 32 a cada uno de los números de las letras mayúsculas para obtener sus correspondientes letras minúsculas.

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
    print(char)
# Results
# Enter a word: REAL
# 114
# 101
# 97
# 108

En el código anterior, recorremos la variable para acceder a cada carácter.

A continuación, comprobamos si cada carácter de la variable tiene un número único entre 65 y 90. Si es así, está formado por letras mayúsculas. Si es así, se trata de letras mayúsculas.

Para obtener las letras minúsculas correspondientes, sumamos 32. El resultado anterior imprime los números únicos de las letras minúsculas.

Podemos emparejar los números con sus letras utilizando la función chr().

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
        to_letters = chr(char)
    print(to_letters) 
    
    
# Result
# Enter a word: REAL
# r
# e
# a
# l

Ahora vemos que las letras devueltas están en minúsculas. Para obtener las letras en una línea, la añadimos a la variable que almacena la cadena vacía y devolvemos la variable.

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char) + 32
        to_letters = chr(char)
        lowercase_letters += to_letters
print(lowercase_letters)
# Result
# Enter a word: FERE
# fere

Esto es lo que parece cuando lo juntamos todo:

def change_to_lowercase(word):
    lowercase_letters = ''
    for char in word:
        if ord(char) >= 65 and ord(char) <= 90:
            char = ord(char)+32
            to_letters = chr(char)
            lowercase_letters += to_letters
    return lowercase_letters
word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Results
# Enter a word: HARDWORKPAYS
# hardworkpays
# Enter a word: PYTHONISFUN
# pythonisfun

CASO II: cadenas con símbolos especiales, números, minúsculas junto a mayúsculas.

Para las cadenas que tienen letras que no son letras y algunas letras minúsculas, añadimos una sentencia ‘else’ para devolver los valores tal y como aparecen en la cadena. Las letras mayúsculas se convierten a minúsculas:

word = str(input("Enter a word: " ))
lowercase_letters = ''
for char in word:
    if ord(char) >= 65 and ord(char) <= 90:
        char = ord(char)+32
        to_letters = chr(char)
        lowercase_letters += to_letters
    else:
        lowercase_letters += char
print(lowercase_letters)

# Result
# Enter a word: @#&YEAERS09=
# @#&yeaers09=

Esto es lo que parece cuando lo juntamos todo:

def change_to_lowercase(word):
    lowercase_letters = ''
    for char in word:
        if ord(char) >= 65 and ord(char) <= 90:
            char = ord(char)+32
            to_letters = chr(char)
            lowercase_letters += to_letters
        else:
            lowercase_letters += char
    return lowercase_letters
word = str(input("Enter a word: " ))
print(change_to_lowercase(word=word))

# Enter a word: YOUGOT#$^
# yougot#$
# Enter a word: BuLLettrAIn@2022
# bullettrain@2022


Sé que el segundo método requiere mucho tiempo, pero también te da el resultado, igual que el primero.

Resumen

En este artículo, has aprendido cómo convertir caracteres y cadenas de un caso a otro. También hemos echado un vistazo a la tabla ASCII.

El segundo método es más eficiente y sencillo una vez que sabes cómo utilizar las dos funciones importantes. Los índices de las letras están incorporados en Python, así que no hay necesidad de memorizarlos.

También le puede gustar

Más del autor

+ There are no comments

Add yours