Funciones matemáticas

import math

# constantes
print(math.pi)
print(math.e)
print(math.tau)
print(math.inf)

# Funciones trigonométricas
print(math.sin(math.pi)) # seno
print(math.cos(math.pi)) # coseno
print(math.hypot(3,4)) #hipotenusa

# Funciones exponenciales
print(math.pow(2,10)) # 2 elevado a 10
print(math.sqrt(65536)) # raiz cuadrada
print(math.isqrt(101)) # raiz cuadrada entera

# Funciones logarítmicas
print(math.log10(100)) # logaritmo en base 10
print(math.log2(1024)) # logaritmo en base 2
print(math.log(10)) # logaritmo en base natural (e)
print(math.log(10,3)) # logaritmo en cualquier base

# Funciones de redondeo y truncamiento
print(math.ceil(3.4)) # entero más alto: 4
print(math.ceil(-3.4)) # entero más alto: -3
print(math.floor(3.4)) # entero más bajo: 3
print(math.floor(-3.4)) # entero más bajo: -4
print(math.trunc(3.4)) # parte entera 3
print(math.trunc(-3.4)) # parte entera -3

# redondeo correcto

inicio=0.5
for i in range(6):
    print(inicio+i,round(inicio+i),math.trunc(inicio+i+.5),int((inicio+i+.5)))


# curiosas
print(math.factorial(8)) # 8!
print(math.gcd(4,10)) # máximo común divisor


Módulo random

import random

print(random.randint(1,100)) # Número aletorio entre 1 y 100

print(random.random()) # Númer aleatorio entre 0 y 1 (1 no incluído)
print(round(random.random()*100)+1) # Númer aleatorio entre 0 y 1 (1 no incluído)

#random.seed(50) # pongo una semilla porque son números pseudoaletorios
print(random.randint(1,100)) # Número aletorio entre 1 y 100

tiradas=[]
for i in range(20):
    tiradas.append(random.randint(1,6))
print(tiradas)

alumnos=["Pau","Sandra","Glen","Renata","Juan"]
print(random.choice(alumnos)) # Me devuelve un alumno al azar
print(random.sample(alumnos,2)) # me devuelve una muestra de dos alumnos al azar
random.shuffle(alumnos) # desordena la lista
print(alumnos)
# recorro la lista desordenada
for alumno in alumnos:
    print(alumno)

# me devuelve un número decimal entre 2.5 y 5.5 con distribución uniforme
# es decir, todos tienen la misma probabilidad de aparecer
print(random.uniform(2.5, 5.5))
# Esto con una gaussiana indicando mu y sigma
print(random.gauss(0, 3))

Soluciones ejercicios diccionario

votaciones = [
    {
        "votante": "Juan",
        "votos": [
            {"participante": "Ana", "puntos": 5},
            {"participante": "Pedro", "puntos": 3}
        ]
    },
    {
        "votante": "Marta",
        "votos": [
            {"participante": "Ana", "puntos": 4},
            {"participante": "Luis", "puntos": 2}
        ]
    },
    {
        "votante": "Pedro",
        "votos": [
            {"participante": "Ana", "puntos": 3},
            {"participante": "Luis", "puntos": 5}
        ]
    }
]


# crear una función que nos devuelva una lista de participantes ordenada de
# más votos a menos votos

# para cada participante el número de votos que tiene
# ¿Puedo imprimir cada participante con su voto?
# Lo tengo que guardar en alguna parte: en un diccionario
def listaVotosRedundante(votaciones):
    resultado = {}
    for votacion in votaciones:
        # print(votacion["votos"])
        for voto in votacion["votos"]:
            resultado[voto["participante"]] = 0

    print(resultado)
    for votacion in votaciones:
        # print(votacion["votos"])
        for voto in votacion["votos"]:
            resultado[voto["participante"]] += voto["puntos"]
    print(resultado)
    return sorted(resultado,key=resultado.get,reverse=True)


def listaVotos(votaciones):
    # Guardo los datos en un diccionario
    resultado = {}
    # recorro las votaciones
    for votacion in votaciones:
        # Dentro de las votaciones recorro los votos
        for voto in votacion["votos"]:
            # Si el participante ya lo tengo en el diccionario sumo los puntos
            if voto["participante"] in resultado:
                resultado[voto["participante"]] += voto["puntos"]
            else:
                # Si no está lo creo con los puntos de esta votación
                # No puedo sumar los puntos si no existe de antes
                resultado[voto["participante"]] = voto["puntos"]

    # Ordeno las claves del diccionario (que son los participantes) por su valor (que son los votos)
    return sorted(resultado, key=resultado.get, reverse=True)


print(listaVotos(votaciones))

# Crear una función que nos devuelva un diccionario con
# la clave el nombre del votante y el valor la media de sus votos
# recorrer todos los votantes

def mediaVotos(votaciones):
    votantes={}
    # al final de lo que ponga aquí en mi diccionario tendré
    # el nombre de los votantes y de momento ponemos 0
    for votacion in votaciones:
        suma=0
        # Sumo todos sus puntos
        for voto in votacion["votos"]:
            suma+=voto["puntos"]
            # la media es la suma divido entre el número de votos
        votantes[votacion["votante"]] = suma/len(votacion["votos"])
    return votantes

print(mediaVotos(votaciones))

Ejemplo Palindromo y test

System.out.println(palindromo("Arriba la birra"));
		System.out.println(palindromo("Arriba mi birra"));
		System.out.println(palindromo("Isaac no ronca asi"));
		System.out.println(palindromo("En un lugar de la mancha"));
		StringBuilder sbuilder = new StringBuilder();
		long inicio = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			sbuilder.append("Elefante");
		}
		long fin = System.currentTimeMillis();
		System.out.println("Tiempo del StringBuilder: " + (fin - inicio));
		String cadena = "";
		inicio = System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			cadena += "Elefante";
		}
		fin = System.currentTimeMillis();
		System.out.println("Tiempo del String: " + (fin - inicio));
	}

	// Esta función nos dice si una cadena es o no un palíndromo
	// Se lee igual de principio a final que a la inversa
	// Ejemplo: Arriba la birra
	static boolean palindromo(String cadena) {
		// Igual a si misma dada la vuelta
		// Creo el stringbuilder
		StringBuilder cadsb = new StringBuilder(cadena.toLowerCase().replace(" ", ""));
		// Creo otro igual
		StringBuilder cadsb2 = new StringBuilder(cadsb);
		// Le doy la vuelta
		cadsb2.reverse();
		// Y los comparo
		return cadsb.compareTo(cadsb2) == 0;
	}

Stringbuilder

StringBuilder cad = new StringBuilder("Hola que tal");
		System.out.println(cad);
		// cad="Yo muy bien"; Esto da un yo estoy
		cad.append(" yo estoy muy bien");
		System.out.println(cad);
		// Comparte métodos con String
		System.out.println(cad.length());
		System.out.println(cad.substring(5));
		System.out.println(cad.substring(5,8));
		
		// Pero permite modificar insertando
		cad.insert(0, "hey!");
		System.out.println(cad);
		// O añadiendo al final
		cad.append(" yo estoy muy bien");
		
		// O eliminar posiciones
		System.out.println(cad.delete(2, 5));

		// Podemos darle la vuelta a la cadena
		System.out.println(cad.reverse());
		System.out.println(cad.reverse());
		
		// COnvierto un stringbuilder a una cadena
		String cad2=cad.toString();
		
		String nombre="Juan";
		// Convierto una cadena a Stringbuilder
		StringBuilder nombreSB=new StringBuilder(nombre);
		System.out.println(nombre);
		System.out.println(nombreSB);
		// Puedo añadir String o Stringbuilder
		nombreSB.append(cad);
		System.out.println(nombreSB);

Funciones de cadena

String c = "hola";
		String d = "hola";
		String e = new String("HOLA");
		System.out.println(c == d); // NO COMPARA VALORES
		System.out.println(c == e); // COMPARA EL PUNTERO
		System.out.println(c.equals(e)); // Compara el valor
		System.out.println(c.equalsIgnoreCase(e)); // Compara el valor
		c += " que tal";
		System.out.println(c);
		String alumno1 = "Ana";
		String alumno2 = "Pep";
		if (alumno1.compareTo(alumno2) > 0) {
			System.out.println(alumno1 + " es mayor que " + alumno2);
		} else {
			System.out.println(alumno2 + " es mayor que " + alumno1);
		}
		// Longitud
		System.out.println(alumno1.length());
		// Conversión de mayúsculas
		System.out.println(alumno1.toLowerCase()); //ana
		System.out.println(alumno1.toUpperCase()); // ANA
		c = "En un lugar de la mancha";
		// Subcadenas
		System.out.println(c.substring(5)); // A partir de la posición 5 hasta el final  lugar de la mancha
		System.out.println(c.substring(5, 8)); // De la posición 5 hasta la 8  lu

		// Inicio y fin
		System.out.println(c.startsWith("En")); //true
		System.out.println(c.endsWith("cha"));//true

		// Acceder a las letras
		for (int i = 0; i < c.length(); i++) {
			System.out.println(c.charAt(i));
		}

		// Reemplazar cadenas
		System.out.println(c.replace("a", "@"));
		System.out.println(c.replace("la", "LA"));

		// Buscar cadenas
		System.out.println(c.indexOf("un")); // 3
		System.out.println(c.indexOf("pepe")); // -1

		// Buscar todas las apariciones
		int pos = c.indexOf("a");
		while (pos != -1) {
			System.out.println(pos);
			pos = c.indexOf("a", pos + 1);
		}
		
		// Saber si hay una subcadena
		System.out.println(c.contains("un")); // true
		System.out.println(c.contains("pepe")); //false
		
		// Eliminar espacios al principio y al final
		c="    hola que    tal    ";

		System.out.println("|"+c+"|");
		System.out.println("|"+c.trim()+"|");

Sobrecarga

public class Sobrecarga {

	public static void main(String[] args) {
		
		System.out.println(suma(2,3));
		System.out.println(suma(2.4,3.6));
		System.out.println(suma(2,3,4));
		System.out.println(.1 + .2);
		System.out.println(repetir("*",9));
		System.out.println(repetir("-",20));
		System.out.println(repetir("-"));
		System.out.println(repetir());
		System.out.println(repetir(20));
	}
	static int suma(int a, int b) {
		return a+b;
	}
	static double suma(double a, double b) {
		return a+b;
	}
	static int suma(int a,int b,int c) {
		return a+b+c;
	}
	static String repetir(String cadena, int veces) {
		String res="";
		for(int i=0;i<veces;i++) {
			res+=cadena;
		}
		return res;
	}
	static String repetir(String cadena) {
		return repetir(cadena,10);
	}
	static String repetir() {
		return repetir("*",10);
	}
	static String repetir(int veces) {
		return repetir("*",veces);
	}
}

Ejercicio Diccionarios

votaciones = [
    {
        "votante": "Juan",
        "votos": [
            {"participante": "Ana", "puntos": 5},
            {"participante": "Pedro", "puntos": 3}
        ]
    },
    {
        "votante": "Marta",
        "votos": [
            {"participante": "Ana", "puntos": 4},
            {"participante": "Luis", "puntos": 2}
        ]
    },
    {
        "votante": "Pedro",
        "votos": [
            {"participante": "Ana", "puntos": 3},
            {"participante": "Luis", "puntos": 5}
        ]
    }
]

# crear una función que nos devuelva una lista de participantes ordenada de más votos a menos votos
# Crear una función que nos devuelva un diccionario con la clave el nombre del votante y el valor la media de sus votos
participantes={}
for votacion in votaciones:
  #  print(votacion)
  #  print(votacion["votos"])
    for voto in votacion["votos"]:
      #  print(voto)
        if voto["participante"] in participantes:
            participantes[voto["participante"]]+=voto["puntos"]
        else:
            participantes[voto["participante"]]=voto["puntos"]
print(participantes)

Ejemplos funciones predefinidas

# matemáticos
print(abs(-5))  # Salida: 5
print(abs(3.14))  # Salida: 3.14

print(max(10, 20, 30))  # Salida: 30
print(max([1, 2, 3, 4]))  # Salida: 4

print(min(10, 20, 30))  # Salida: 10
print(min([1, 2, 3, 4]))  # Salida: 1

print(sum([1, 2, 3, 4]))  # Salida: 10
print(sum([10, 20, 30], 5))  # Salida: 65

print(round(3.14159, 2))  # Salida: 3.14
print(round(2,0))  # Salida: 3
print(round(2.5))  # Salida: 2
print(round(3.5))  # Salida: 4

# información
print(len("Python"))  # Salida: 6
print(len([1, 2, 3, 4]))  # Salida: 4

print(type(5))  # Salida: <class 'int'>
print(type("hello"))  # Salida: <class 'str'>
print(type((1,2,3)))  # Salida: <class 'tuple'>

# entrada / salida
print("Hello, World!")  # Salida: Hello, World!
print(42)  # Salida: 42

nombre = input("¿Cómo te llamas? ")  # Entrada del usuario
print("Hola, " + nombre)

# conversión

print(str(123))  # Salida: '123'
print(str(3.14))  # Salida: '3.14'

print(int('123'))  # Salida: 123
print(int(3.99))  # Salida: 3

print(float('3.14'))  # Salida: 3.14
print(float(10))  # Salida: 10.0

print(bool(1))  # Salida: True
print(bool(''))  # Salida: False

# conversiones de tipos de datos complejos

print(list("hello"))  # Salida: ['h', 'e', 'l', 'l', 'o']
print(list((1, 2, 3)))  # Salida: [1, 2, 3]
print(list( {"color": "rojo", "tamaño": "M", "cantidad": 10}))  # Salida: ['color', 'tamaño', 'cantidad']

print(tuple([1, 2, 3]))  # Salida: (1, 2, 3)
print(tuple("hello"))  # Salida: ('h', 'e', 'l', 'l', 'o')

print(set([1, 2, 3, 2]))  # Salida: {1, 2, 3}
print(set("hello"))  # Salida: {'h', 'e', 'l', 'o'}

# Tengo que poner los valores o una lista de tuplas
print(dict(a=1, b=2))  # Salida: {'a': 1, 'b': 2}
print(dict([('a', 1), ('b', 2)]))  # Salida: {'a': 1, 'b': 2}

# Creación de listas

print(list(range(5)))  # Salida: [0, 1, 2, 3, 4]
print(list(range(1, 10, 2)))  # Salida: [1, 3, 5, 7, 9]

print(list(zip([1, 2, 3], ['a', 'b', 'c'])))  # Salida: [(1, 'a'), (2, 'b'), (3, 'c')]
print(list(zip('abc', '123')))  # Salida: [('a', '1'), ('b', '2'), ('c', '3')]
print(dict(list(zip('abc', '123'))))  # Salida: {'a': '1', 'b': '2', 'c': '3'}

# ordenar

# Ordenar una lista de números en orden ascendente
print(sorted([3, 1, 4, 1, 5, 9]))  # Salida: [1, 1, 3, 4, 5, 9]

# Ordenar una lista de palabras en orden descendente
print(sorted(["banana", "apple", "cherry"], reverse=True))  # Salida: ['cherry', 'banana', 'apple']

# Invertir una lista de números
numbers = [3, 1, 4, 1, 5, 9]
print(list(reversed(numbers)))  # Salida: [9, 5, 1, 4, 1, 3]

# Invertir una cadena de texto
text = "hello"
print("".join(reversed(text)))  # Salida: 'olleh'

# Encontrar el mínimo en una lista de números
print(min([3, 1, 4, 1, 5, -9],key=abs))  # Salida: 1

def letrasUnicas(cadena):
    return len(set(list(cadena)))
# Encontrar el máximo en una lista de palabras según la longitud
words = ["banana", "apple", "cherry"]
print(min(words, key=letrasUnicas))  # Salida: 'banana'