Algoritmos Esenciales en Python: Procesamiento de Texto y Manipulación de Listas

Clasificado en Informática

Escrito el en español con un tamaño de 7,43 KB

Este documento presenta una colección de funciones Python fundamentales para el procesamiento de texto y la manipulación de listas. Cada sección detalla la implementación de un algoritmo específico, ideal para estudiantes y desarrolladores que buscan comprender o reutilizar estas lógicas básicas.

Funciones de Procesamiento de Texto en Python

Contar Palabras en una Cadena

Esta función calcula el número total de palabras presentes en un texto dado. Define una palabra como una secuencia de letras, ignorando espacios y otros caracteres no alfabéticos.

def contarPalabras(texto):
    i=0
    contador=0
    while i<len(texto):
        while i<len(texto) and not esLetra(texto[i]):
            i+=1
        z=1
        while i<len(texto) and esLetra(texto[i]):
            if z==1:
                contador+=1
                z=0
            i+=1
    return contador

Buscar Existencia de Palabra en Texto

Esta función determina si una palabra específica se encuentra dentro de un texto más largo. Recorre el texto identificando palabras y comparándolas con la palabra buscada.

def buscar(t,p):
    i=0
    bandera=False
    while i<len(t):
        while i<len(t) and not es_letra(t[i]):
            i+=1
        hay_pal=False
        pal=""
        while i<len(t) and es_letra(t[i]):
            pal+=t[i]
            hay_pal=True
            i+=1
        if hay_pal:
            if comparar(pal,p):
                bandera=True

    return bandera

Encontrar la Palabra Más Larga

Esta función identifica y retorna la palabra de mayor longitud dentro de un texto. Itera a través del texto, extrayendo cada palabra y comparando su longitud con la palabra más larga encontrada hasta el momento.

def palabraMayor(texto):
    i=0
    palabra=''
    mayor=''
    while i<len(texto):
        while i<len(texto) and not esLetra(texto[i]):
            i+=1
        while i<len(texto) and esLetra(texto[i]):
            palabra+=texto[i]
            i+=1
        if len(palabra)>=len(mayor):
            mayor=palabra
        palabra=''
    return mayor

Encontrar la Palabra Más Corta

Similar a la función anterior, esta función busca y devuelve la palabra de menor longitud en un texto. Maneja el caso inicial para asegurar que la primera palabra válida se establezca como la más corta.

def palabraMenor(texto):
    i=0
    palabra=''
    z=0
    while i<len(texto):
        while i<len(texto) and not esLetra(texto[i]):
            i+=1
        while i<len(texto) and esLetra(texto[i]):
            palabra+=texto[i]
            i+=1
        if z==0:
            menor=palabra
            z=1
        if i<len(texto) and len(palabra)<=len(menor):
            menor=palabra
        palabra=''
    return menor

Contar Ocurrencias de Subcadena en Texto Largo

Esta implementación de la función buscar cuenta cuántas veces aparece una subcadena (texto corto) dentro de una cadena más grande (texto largo). Utiliza un enfoque de ventana deslizante para comparar segmentos del texto.

def buscar(tl,tc):
    longtl=len(tl)
    longtc=len(tc)
    i=0
    cont=0
    while i<=longtl-longtc:
        if tl[i:i+longtc]==tc:
            cont+=1
        i+=1
    return cont

Comparar Palabras (Verificar Anagramas)

Esta función compara dos palabras para determinar si son "equivalentes" en términos de sus caracteres, es decir, si son anagramas. Verifica que tengan la misma longitud y que cada carácter aparezca el mismo número de veces en ambas palabras.

def comparar(p1,p2):
    if len(p1)!=len(p2):
        res= False
    else:
        band=True
        for l in p1:
            cont1=0
            cont2=0
            for l1 in p1:
                if l==l1:
                    cont1+=1
            for l2 in p2:
                if l==l2:
                    cont2+=1
            if cont1!=cont2:
                band=False
        res=band
    return res

Capitalizar la Primera Letra de Cada Palabra

Esta función transforma un texto para que la primera letra de cada palabra esté en mayúscula, mientras que el resto de las letras permanecen en su estado original. Requiere una función auxiliar letraMayuscula no incluida en este fragmento.

def textoMayuscula(texto):
    i=0
    x=''
    z=0
    while i<len(texto):
        while i<len(texto) and not esLetra(texto[i]):
            x+=texto[i]
            i+=1
        z=1
        while i<len(texto) and esLetra(texto[i]):
            if z==1:
                x+=letraMayuscula(texto[i])
                z=0
            else:
                x+=texto[i]
            i+=1
    return x

Práctica 6: Funciones de Manipulación de Listas en Python

Cargar Lista de Números Enteros

Esta función permite al usuario ingresar números enteros para construir una lista. La carga finaliza cuando se introduce un 0, y se valida que los números ingresados no sean negativos.

def cargar(lst):
    lst=[]
    x=int(input("Ingrese numero, finalice con 0:\n"))
    while x<0:
        x=int(input("ERROR. Ingrese numero: "))
    while x!=0:
        lst.append(i)
        x=int(input())
        while x<0:
            x=int(input("ERROR. Ingrese numero: "))

Modificar Elementos de Lista dentro de un Rango

Esta función itera sobre una lista y, para cada elemento que no se encuentre dentro de un rango especificado [a, b], lo reemplaza con un número entero aleatorio dentro de ese mismo rango. Requiere la importación del módulo random.

def cambialista(lst,a,b):
    i=0
    while i<len(lst):
        if lst[i]>=a and lst[i]<=b:
            i+=1
        else:
            lst[i]=(random.randint(a,b))
            i+=1
    return lst

Ordenar Lista (Algoritmo de Burbuja)

Implementación del algoritmo de ordenamiento de burbuja para organizar los elementos de una lista en orden ascendente. Realiza múltiples pasadas, comparando y swappeando elementos adyacentes.

def ordenarLista(lst):
    for pasada in range(len(lst)-1):
        for i in range (len(lst)-1):
            if lst[i]>lst[i+1]:
                aux=lst[i]
                lst[i]=lst[i+1]
                lst[i+1]=aux

Insertar Número en Lista Ordenada

Esta función inserta un número dado en una lista que se asume ya está ordenada, manteniendo el orden. Encuentra la posición correcta para el nuevo elemento y lo inserta.

def inserOrd(lst,num):
    primero=1
    for i in range(len(lst)):
        if lst[i]>=num and primero:
            lst.insert(i,num)
            primero=0
    if primero:
        lst.insert(len(lst),num)

Encontrar Valor Mínimo en Lista

Esta función recorre una lista de números para encontrar y retornar el valor más pequeño presente en ella. Asume que la lista no está vacía.

def minVal(l):
    menor=l[0]
    for num in l:
        if num<menor:
            menor=num
    return menor

Estas funciones representan ejemplos prácticos de algoritmos básicos en Python, útiles para el manejo de cadenas de texto y estructuras de datos tipo lista. Son un excelente punto de partida para entender la lógica de programación y la manipulación de datos.

Entradas relacionadas: