Ejercicios Prácticos de Funciones en Python
Traducido por
ScribdTranslationsEjercicios Prácticos de Funciones en Python
Traducido por
ScribdTranslationsFunciones de Python - Ejercicios
Sra. S. Karthiga
función que toma una lista y devuelve un nuevo
lista con elementos únicos de la primera lista.
def lista_unica(l):
x = []
para a en l:
si a no está en x:
[Link](a)
devuelve x
imprimir(lista_unica([1,2,3,3,3,3,4,5]))
Salida
[1,2,3,4,5]
función para encontrar el máximo de tres
números.
def max_de_dos( x, y ):
si x > y:
retornar x
regresar y
def max_de_tres( x, y, z ):
devuelve max_de_dos( x, max_de_dos( y, z ) )
imprimir(max_de_tres(3, 6, -5))
Salida
6
función para sumar todos los números en un
lista.
def sumar(números):
total = 0
para x en números:
total += x
devolver total
imprimir(sum((8, 2, 3, 0, 7)))
Salida
20
función para multiplicar todos los números
en una lista.
def multiplicar(números):
total = 1
para x en números:
total *= x
devolver total
imprimir(multiplicar((8, 2, 3, -1, 7)))
Salida
-336
programa para invertir una cadena.
def string_reverse(cadena1):
rstr1 = ''
índice = len(str1)
mientras el índice > 0:
rstr1 += str1[ índice - 1 ]
índice = índice - 1
devolver rstr1
imprimir(string_reverse('1234abcd'))
Salida
dcba4321
función para calcular el número de letras mayúsculas y minúsculas
letras minúsculas.
def prueba_de_cadena(s):
d={"UPPER_CASE":0, "LOWER_CASE":0}
para c en s:
si c.es_mayuscula():
Salida
d["UPPER_CASE"]+=1
elif [Link](): El rápido marrón
d["LOWER_CASE"]+=1 Zorro
Número de caracteres en mayúscula: 3
else:
Número de caracteres en minúsculas: 13
pasar
print("Cadena Original : ", s)
print("No. de caracteres en mayúsculas: ", d["UPPER_CASE"])
print("No. de caracteres en minúscula : ",
d["LOWER_CASE"])
El rápido zorro marrón
función para verificar si un número
está en un rango dado.
def probar_rango(n):
si n está en el rango(3,9):
print(" %s está en el rango" % str(n))
sino:
El número está fuera del rango dado.
prueba_rango(5)
Salida
5 está en el rango
función que verifica si el número es primo o no?
def prueba_primo(n):
si (n==1):
retornar Falso
elif (n==2):
returnTrue;
de lo contrario:
para x en rango(2,n):
si(n % x==0):
devolver Falso
returnTrue
imprimir(test_prime(9))
Salida
Falso
programa para detectar el número de
variables locales declaradas en una función.
def abc():
x=1
y=2
str1= "w3resource"
print("Ejercicios de Python")
print(abc.__code__.co_nlocals)
Salida
4
programa para imprimir los números pares
de una lista dada.
def es_numero_par(l):
enum = []
para n en l:
si n % 2 == 0:
[Link](n)
devolver enum
imprimir(es_numero_par([1, 2, 3, 4, 5, 6, 7, 8, 9]))
Salida
[2, 4, 6, 8]
¿Verificar número perfecto?
def numero_perfecto(n):
sum = 0
para x en rango(1, n):
si n % x == 0:
suma += x
return sum == n
print(numero_perfecto(6))
Salida
Verdadero
Búsqueda Lineal/Secuencial
La búsqueda secuencial (a menudo llamada búsqueda lineal) es
realizado inspeccionando cada artículo en una lista uno por uno
de un extremo a otro para encontrar una coincidencia para lo que tú
estoy buscando.
Un enfoque simple es realizar una búsqueda lineal, es decir,
Comienza desde el elemento más a la izquierda de la lista y uno por uno
compara x con cada elemento de la lista.
Si x coincide con un elemento, devolver verdadero.
Si x no coincide con ninguno de los elementos, devuelve Falso.
Búsqueda Lineal
Ej :-
def buscar(lista,n):
para i en rango(len(lista)):
si lista[i] == n:
Salida
returnTrue
devolver Falso Encontrado
list = [1, 2, 'sachin', 4,'Geeks', 6]
n = 'Geeks'
si buscar(lista, n):
Encontrado
else:
No encontrado
Búsqueda Binaria
Compara x con el elemento del medio.
Si x coincide con el elemento del medio, devolvemos
el índice medio.
Si x es mayor que el elemento medio, entonces
x solo puede estar en la mitad derecha de la subarray después del
elemento medio. Así que repetimos para la mitad derecha.
De lo contrario (x es más pequeño) recursar para la mitad izquierda.
def busquedaBinaria(arr, l, r, x):
si r >= l: arr = [ 2, 3, 4, 10, 40 ]
mid = l + (r - l)/2 x = 10
result = binarySearch(arr, 0, len(arr)-1, x)
si arr[mid] == x: si el resultado != -1:
devolver medio imprimir "El elemento está presente en el índice % d" %
result
elif arr[mid] > x:
otros:
devolver búsquedaBinaria(arr, l, El elemento no está presente en el array
med-1, x)
sino:
return binarySearch(arr,
medio + 1, r, x
Salida
de lo contrario:
retornar -1 El elemento está presente
en el índice 3
Ordenando lista de enteros en orden ascendente
numbers = [1, 3, 4, 2]
nú[Link]()
imprimir(números)
[1,2,3,4]
Ordenar lista de enteros en orden descendente
numbers = [1, 3, 4, 2]
[Link](reverse=True)
imprimir(números)
[4,3,2,1]
Ordenar aplanar lista de listas
test_list = [[3, 5], [7, 3, 9], [1, 12]]
print("La lista original : " + str(test_list))
res = sorted([j for i in test_list for j in i])
print("La lista ordenada y aplanada : " + str(res))
Salida
The original list : [[3, 5], [7, 3, 9], [1, 12]]
The sorted and flattened list : [1, 3, 3, 5, 7, 9, 12]
Ordena los valores de la primera lista utilizando la segunda lista
Input : list1 = ["a", "b", "c", "d", "e", "f", "g", "h",
"yo"
lista2 = [ 0, 1, 1, 0, 1, 2, 2, 0,
1]
Output :['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']
def ordenar_lista(lista1, lista2):
pares_comprimidos = zip(lista2, lista1)
z = [x para a, x en sorted(zipped_pairs)]
regresar z
x = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1]
imprimir(ordenar_lista(x, y))
x = ["g", "e", "e", "k", "s", "f", "o", "r", "g", "e", "e", "k"]
s
y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1]
print(sort_list(x, y))
de colecciones importación Contador
ini_list = [1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 5, 5, 5, 4, 4, 4, 4, 4, 4]
print("lista inicial", str(ini_list))
result = sorted(ini_list, key = ini_list.count, reverse =True)
print("lista final", str(result))
Salida
initial list [1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 5, 5, 5, 4, 4, 4, 4, 4, 4]
final list [4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 5, 5, 5, 1, 1]