miércoles, 29 de agosto de 2018

Generar y ordenar palabras en Python

Reto: Ordenar palabras

Crear una serie de 10 palabras donde sus letras se obtienen de forma aleatoria. Mostrar estas palabras y mostrar esas mismas palabras ordenadas alfabéticamente.



Método 1

Creamos la lista frase que contendrá diez palabras compuestas cada una de ellas por cuatro letras aleatorias. La variable L contienen todo el abecedario en forma de lista. El primer bucle for contiene diez ciclos para generar las diez palabras. En el segundo bucle for es donde generamos cada palabra recogida como string en la variable p. Para ello, se elige aleatoriamente cada letra de la lista L.
Una vez generada la palabra p está se añade a la lista L con append.


import random
frase=[]
L=list('abcdefghijklmnopqrstuvwxyz')
for i in range(0,11):
  p=''
  for j in range(4):
    p+=L[random.randint(0,25)]
  frase.append(''.join(p))
print(frase)
print(sorted(frase))


Método 2

Con este método vamos a crear palabras donde se alternen parejas de consonante y vocal. La variable n contiene el número de parejas elegidas. Si n es tres obtendremos palabras con seis letras. La variable c es un string que contiene las consonantes y la variable v es otra cadena con las vocales. Inicializamos la variable L como lista vacía. Nos metemos en un primer bucle for de diez ciclos para generar las diez palabras. El segundo bucle for añade aleatoriamente una letra consonante y luego una letra vocal para que formen parejas, y se repite n veces.

import random
n=3 # nº de parejas de letras consonante-vocal
c='bcdfghjklmnpqrstvwxyz'
v='aeiou'
L=[]
for i in range(10):
  palabra=''
  for j in range(n):
    palabra+=''.join(random.choice(c))
    palabra+=''.join(random.choice(v))
  L.append(palabra)
print(L)
print(sorted(L))

viernes, 24 de agosto de 2018

Alternos con excepciones

Reto: Alternos con excepciones

Imprimir diez números aleatorios sin repetición entre 100 y 130, excepto los números 110, 115, 120 y alternando par, impar, comenzando por par.




Método 1

Importamos randint de la librería random. Creamos la lista L inicialmente vacía. Nos metemos en un bucle while con 10 ciclos. Por cada vuelta generamos un número aleatorio par entre 100 y 130. Si el número generado no es 110, ni 115, ni 120, y no está en la lista L, para evitar repeticiones, entonces nos metemos en otro condicional if.
En el segundo condicional se analiza la condición de que el número aleatorio sea par y que el lugar (n) que toca sea par, para garantizar que se trata de la ubicación donde ha de ir un número par, entonces se añade a la lista con append. y el contador n se incrementa en 1. La otra condición del elif analiza si el número aleatorio en impar y toca que la ubicación donde tenga que ir sea también impar, entonces se añade con append y el contador n se incrementa en 1.
Finalmente se imprime la lista y luego se vuelve a imprimir ordenada con sort.

from random import randint
n=0
L=[]
while n<10:
  t=randint(100,131)
  if t not in (110,115,120) and t not in L:
    if t%2==0 and n%2==0: #par y toca par
      L.append(t)
      n+=1
    elif t%2!=0 and n%2!=0: #impar y toca impar
      L.append(t)
      n+=1
print(L)
L.sort()
print(L)


Método 2

Generamos la lista Lp que contendrá ordenados todos los números pares posibles, que son los comprendidos entre 100 y 130 salvo el 110 y el 120.
Generamos la lista Li que contendrá ordenados todos los números impares posibles, que son los comprendidos entre 100 y 130 salvo el 115.
Imprimimos las listas Lp y Li.
Con random.shuffle barajamos cada lista. Creamos la lista L, inicialmente vacía. Nos metemos en un bucle for de 5 ciclos. Aunque nos piden 10 números en este reto el bucle for es de 5 ciclos ya que en cada uno de ellos se genera una pareja de números, el primero par y el segundo impar. Para generar el número par se toma el primer par de la lista de pares Lp, que ya se desordenó anteriormente, y para generar el número impar se hace lo mismo con la lista de impares Li.
El resultado será una lista de números L que contiene 5 parejas de números par, impar, que comienzan por par y se van alternando.

import random
Lp=[i for i in range(100,131,2) if i not in (110,120)] #genera todos los pares posibles
Li=[i for i in range(101,131,2) if i!=115]             #genera todos los impares posibles
print(Lp)
print(Li)
random.shuffle(Lp) #baraja los pares
random.shuffle(Li) #baraja los impares
L=[]
for k in range(5): # son 5 parejas de par, impar.
  L.append(Lp[k])  # toma el pare de indice k
  L.append(Li[k])  # toma el impar de indice k
print(L)

domingo, 19 de agosto de 2018

Aleatorios con excepciones

Reto: Aleatorios con excepciones

Generar números aleatorios pares entre 100 y 130, salvo 110 y 120.

Veamos varios casos, que pueden ser:

  • con repetición
  • sin repetición




Método 1

Importamos la librería random. Creamos la lista L inicialmente vacía. Nos metemos en un bucle for con 16 ciclos. Por cada vuelta generamos un número aleatorio par entre 100 y 130. Si el número generado no es 110, ni 120, entonces se añade a la lista con append.
Finalmente se imprime la lista y luego se vuelve a imprimir ordenada con sorted.

import random
L = []
for i in range(16):
    x = random.randrange(100,131,2)
    if x not in (110,120):
        L.append(x)
print(L)
print(sorted(L))


Método 2

Este método realiza un tratamiento similar al anterior pero usa List Comprehensions para comprimir el código en una sola línea.

import random
L=[r for r in [random.randint(100,130) for s in range(30)] if r%2==0 and r not in (110,120)]
print(L)
print(sorted(L))


Método 3

En este caso no importamos la librería random completa, únicamente importamos el método randint que genera números aleatorios entre 50 y 65. Con un if eliminamos aquellos valores que sean 55 o 60. El valor de la variable i que supere el filtro se multiplica por 2 para obtener los pares entre 100 y 130, excluidos del tratamiento los valores 110 y 120.

from random import randint
L = [i*2 for i in [randint(50,65) for j in range(16)] if i not in (55,60)]
print(L)
print(sorted(L))


Método 4

Este método es similar al método anterior si bien no es necesario multiplicar i por dos ya que los valores generados exigimos que sean pares incluyéndolo como una condición adicional en el if.

import random
L = [i for i in [random.randint(100,130) for j in range(30)] if i not in (110,120) and i%2==0]
print(L)
print(sorted(L, reverse=True))


Método 5

Usamos rando.sample que nos permite elegir una muestra aleatoria entre los valores generados. En este caso los valores obtenidos serán sin repetición gracias a que este método está diseñado para elegir sin repetición de una secuencia de números.

import random
L=[i for i in random.sample(range(100,131,2),16) if i not in (110,120)]
print(L)
L.sort(reverse=True)
print(L)


Método 6

Usamos random.shuffle sobre la lista generada previamente. Este método devuelve una nueva lista mezclada, lo que permite obtener un resultado sin repetición.

import random
L=[i for i in range(100,131,2) if i!=110 and i!=120]
random.shuffle(L) #desordena la lista
print(L)
print(sorted(L))

sábado, 18 de agosto de 2018

Donut de colores

 Utilizando la librería matplotlib.pyplot hemos conseguido generar unos puntos de diferentes colores y que no se impriman cuando están dentro de un rango, en este caso hemos creado una forma redonda como si fuera un Donut, aunque se puede cambiar para que haga cualquier forma.

El codigo Python:
from math import sqrt  
import random  
import matplotlib.pyplot as plt  
n = 10000  
p=q=0  
plt.figure(figsize=(7,7))  
for i in range(n):  
  p = random.random() * 8 - 4  
  q = random.random() * 8 - 4  
  r = sqrt(p ** 2 + q ** 2)  
  if 2<r<4:  
    x,y=p,q  
    plt.plot(x,y,'o',markersize=1)  
plt.show()  

El resultado de ese codigo:

En el código utilizamos coordenadas cartesianas para saber en qué lugar van a estar los puntos, generamos aleatoriamente las variables x e y que pondrá los puntos aleatoriamente por toda la pantalla, no sin antes usando un if para filtrar los puntos que son impresos en la pantalla, aquí es donde podemos elegir la forma de la figura que se termine de imprimir en pantalla.

En nuestro caso esto es la parte que crea esa forma de donut.

p = random.random() * 8 - 4   
q = random.random() * 8 - 4   
r = sqrt(p ** 2 + q ** 2)   
if 2<r<4:   
  x,y=p,q   
  plt.plot(x,y,'o',markersize=1)   

Primero generamos p y q aleatoriamente con random.random(), como esto solo genera números entre uno y cero la multiplicarlo por ocho y restarle cuatro le damos los márgenes que queremos para las coordenadas cartesianas. Luego aplicamos el teorema de Pitágoras para saber a qué distancia está ese punto desde el centro del plano.

Esta imagen puede que ayude a entender lo que estamos intentando hacer:


Y luego usando un if, si ese punto está dentro de las coordenadas dos y cuatro entonces les paso los valores de p,q y x,y para añadirlo al plot y luego imprimirlo.

Nota: Si ejecutas este código en algunos editores de código como PyCharm, al importar la librería matplotlib no solo tendrás que importarla escribiéndola en el código si no que tendrás que importarla desde el propio editor. Aquí os enseñamos cómo hacerlo: https://www.youtube.com/watch?v=aROm4KYHXLI&feature=youtu.be

sábado, 4 de agosto de 2018

Generar números aleatorios sin repetición y ordenarlos en Python

Reto: Ordenar números

Imprimir una lista de 10 números aleatorios sin repetición que varíen en el rango 80 a 99. Volver a imprimir la lista pero ordenada.




Método 1

Definimos la función unico que tiene dos argumentos. La función, dado el número x y la lista L, detecta si x es único o esta repetido. Si el número x no está en la lista entonces retorna True, y si el número se encuentra ya en la lista entonces devuelve False.
El bucle while nos proporciona los 10 números aleatorios sin repetición que ha de llegar a tener la lista. En este caso el bucle ha de ser del tipo while, no valdría un for, ya que no conocemos el número de ciclos que serán necesarios, puesto que si no existen repeticiones serán 10 ciclos pero si las hay el número aumenta. Por cada repetición encontrada se ha de generar un nuevo x aleatorio. Los x únicos generados se anexionan a la lista con append.
Finalmente se imprime la lista L y se ordena con sort.




import random
def unico(x,L):
  esUnico=True
  for i in range(len(L)):
    if x==L[i]:
      esUnico=False
      break
  return esUnico
L=[]
j=0
while j<10:
  x=random.randint(80,99)
  if unico(x,L):
    L.append(x)
    j+=1
print(L)
L.sort()
print(L)


Método 2

Inicializamos la lista L con su primer valor, el de la posición cero. Esto se hace fuera del bucle while ya que el primer x estamos seguros de que no se repite respecto a los anteriores, ya que es el primero. Luego nos metemos en un bucle while que genera los demás x aleatorios que de momento son candidatos, hasta que no se compruebe que no están repetidos entre los elementos que ya se encuentran en la lista. Para conseguir establecer si el número candidato se ha de anexionar a la lista o no se hace usando un bucle for que contiene un condicional if. La clave está en el else que no pertenece al if sino al for.
Finalmente imprimimos la lista L y la ordenamos con sorted.

import random
L=[random.randint(80, 99)] #este es L[0]
i=1
while i<10:
  x=random.randint(80,99)
  for j in range(0, len(L)):
    if L[j]==x:
      break
  else:
    L.append(x)
    i+=1
print(L)
print(sorted(L))


Método 3

Esta es una variante del método anterior que mejora el código ya que usa en el if la instrucción in, o mejor dicho, not in, para detectar si el nuevo número aleatorio se encuentra entre los que ya se han añadido a la lista L.


import random
L=[random.randint(80, 99)] #este es L[0]
i=1
while i<10:
  x=random.randint(80,99)
  if x not in L:
    L.append(x)
    i+=1
print(L)
print(sorted(L))


Método 4

Importamos únicamente el método sample de la librería random que permite crear una lista eligiendo aleatoriamente 10 valores de un rango de números creado con range que varía entre 80 y 100 (excluido el 100).

Con sorted ordenamos la lista . Si deseamos que la ordenación sea inversa tendremos que indicarlo poniendo print(sorted(L,reverse=True)).

from random import sample
L=sample(range(80,100),10)
print(L)
print(sorted(L))


Método 5

Este método, al igual que el anterior, utiliza sample para elegir una muestra aleatoria entre los posibles valores que generamos utilizando List Comprehension.
Faltaría ordenar la lista, pero hemos preferido dejar el código así para que se vea que en dos líneas se puede llegar a obtener la lista de aleatorios sin repetición.


from random import sample
print(sample([x for x in range(80,100)],10))


Método 6

Creamos la lista L usando list y range. Esta lista contendrá todos los números enteros consecutivos entre 80 y 99. La instrucción random.shuffle(L) baraja aleatoriamente la lista L. Creamos la lista L10 que contendrá los 10 primeros elementos de la lista L. Imprimimos la lista L10. Ordenamos la lista L10 en sentido inverso usando sort. Si la queremos ordenar en sentido creciente simplemente dejaremos vacío lo que va entre sus paréntesis. Sería L10.sort().


import random
L=list(range(80,100))
random.shuffle(L) #baraja la lista
L10=L[:10] #crea otra lista con los 10 primeros elementos
print(L10)
L10.sort(reverse=True) #ordena la lista L10
print(L10)

viernes, 3 de agosto de 2018

Años bisiestos en Python

Reto: Bisiesto

Crear una función que dado un año diga si es bisiesto.



Podemos consultar la Wikipedia para saber qué años son bisiestos.
El calendario Juliano dio paso a calendario Gregoriano en 1582. Desde entonces se estableció la regla que nos dice cuando una año es bisiesto y por lo tanto tiene 366 días, en lugar de 365, ya que se añade un día más el 29 de febrero.

  • Un año es bisiesto si es múltiplo de 4, salvo que...
    • el año termine en 00, en cuyo caso, no será bisiesto, salvo que ...
      • el año sea múltiplo de 400, en cuyo caso, si será bisiesto.
Como podemos observar para que un año sea bisiesto existe una regla general (que sea múltiplo de 4) pero a esta regla general existe una excepción (que el año termine en 00, esto es, los finales de siglo) en cuyo caso el año no será bisiesto, y finalmente existe una excepción a la excepción anterior (que el año sea múltiplo de 400) en cuyo caso el año si será bisiesto.

Así por ejemplo, los años 2100, 2200, 2300 no serán bisiestos, pero el 2400 si lo será.


Método 1

Definimos una función que contiene un if con una condición lógica compleja que resume la regla que nos da el año bisiesto.




def bisiesto(x):
  if x%4==0 and (not(x%100==0) or x%400==0 ):
    texto='es bisiesto.'
  else:
    texto='es un año NO bisiesto.'
  return texto
x=int(input('Introduzca un año entre 1600 y 2500:'))
print(x,bisiesto(x))


Método 2

Generamos un año aleatorio y definimos una función que nos retornará True si se trata de una año bisiesto y nos retornará False si el año generado no es bisiesto. Con este método hemos optado por realizar varios if concatenados para resolver la lógica de los años bisiestos.

import random
random.seed()
x=random.randint(1600,2500)
def bisiesto(x):
  if x%4==0:
    if x%100==0:
      if x%400==0:
        return True
      else:
        return False
    else:
      return True
  else:
    return False
if bisiesto(x):
  print(x,'es un año bisiesto.')
elif not(bisiesto(x)):
  print(x,'no es un año bisiesto')

Nombrar elementos en CSS

En CSS si quieres afectar a algún elemento del HTML tienes varias opciones.

La mas obvia es referirse a los elementos por etiquetas, simplemente escribiendo la etiqueta como se haría en HTML sin el mayor y menor. Como esto:

 p {  
   background-color: red;  
 }  
Y el resultado seria algo a esto:

Pero si quisiéramos darle un color diferente a cada p le tendríamos que dar un nombre diferente a cada p, para ello en HTML habría que hacer algo así: 

 <p id='uno'>Y en este los dos</p>  
 <p id='dos'>estamos de colores distintos</p>  

Y para llamarlos en el CSS hay que poner un # delante del nombre y escribir los parámetros como haríamos normalmente, similar a esto:

 #uno {  
   background-color: red;  
 }  
 #dos {  
   background-color: blue;  
 }  

Y con esas dos cosas implementadas en tu código el resultado debería de ser este:
También se puede utilizar * para afectar a todos los elementos (esto también incluye el fondo).
Este seria un ejemplo:


 * {  
  margin:1;  
  padding:2;  
 }  

Series en Python

Reto: Series

Listar los números entre un valor inicial y uno final, con un cierto intervalo. Al final dar la suma de todos los valores listados.




Método 1

Establecemos tres valores concretos para las variables inicial, final e intervalo. Con el objeto de llegar a calcular la suma total creamos la variable total que inicializamos a cero. Nos metemos en un bucle for para recorrer con range todos los valores del rango usando el intervalo establecido. El objeto range nos permite recorrer un rango comenzando por el inicio, pero no llegando nunca al final exactamente. Observe que en la imagen no aparece listado el final que es 20.

La variable total actúa como acumulador sumando en cada vuelta del bucle el valor que tome la variable i en ese momento. Finalmente, y fuera del bucle imprimimos el valor de la variable total.



inicial=10
final=20
intervalo=2
total=0 #inicializamos la suma a cero
for i in range(inicial,final,intervalo):
  total+=i #la variable total actúa de acumulador
  print(i)
print('La suma es:',total)


Método 2

Generamos valores aleatorios para las variable inicial, final e intervalo. Imprimimos por pantalla los valores obtenidos. Creamos la variable i que luego usaremos en el bucle while y la inicializamos con el valor inicial. Creamos la lista L y la inicializamos como una lista vacía. La variable total inicialmente valdrá cero. Nos metemos en un bucle while que durará mientras la variable i sea menor que el valor final. Con append vamos añadiendo a la lista L los valores del intervalo dados por la variable i. Dentro del bucle while incrementamos el valor de la variable i con el importe del intervalo. Acumulamos los valores obtenidos en la variable total. Fuera del bucle imprimimos la lista L y mostramos el importe de la suma.



import random
random.seed() #barajamos la serie de números aleatorios
inicial=random.randint(100,130)
final=inicial+random.randint(10,20)
intervalo=random.randint(2,5)
print('inicial=',inicial)
print('final=',final)
print('intervalo=',intervalo)
i=inicial
L=[] #inicializamos L como una lista vacía
total=0 #inicializamos la suma a cero
while i<final:
  L.append(i) #añadimos el valor i a la lista L
  i+=intervalo #aumentamos el valor del contador
  total+=i
print(L) #imprimimos la lista
print('La suma es:',total)

Operaciones con números en Python

Reto: Operaciones con números

Dados dos números hacer con ellos las operaciones básicas.




Consulte la entrada titulada:



Método 1

Inicialmente hacemos que la variable x valga 15 y la variable y tome un valor de 3. Calculamos e imprimimos la suma, resta, multiplicación y división. Luego damos nuevos valores a x e y, en una sola línea de código. Calculamos la potencia x elevado a y. Damos a x el valor 11 y calculamos la división entera y el módulo.

x=15
y=3
print(x,'+',y,'=',x+y)
print(x,'-',y,'=',x-y)
print(x,'*',y,'=',x*y)
print(x,'/',y,'=',x/y)
x,y=2,3
print(x,'elevado a',y,'=',x**y)
x=11
print(x,'división entera entre',y,'=',x//y)
print(x,'módulo',y,'=',x%y)
#operadores lógicos
print(x,'es mayor que',y,x>y)
print(x,'es menor que',y,x<y)
print(y,'<',x,'<20',y<x<20)


Método 2

Generamos aleatoriamente los valores x e y. Calculamos al suma, resta, multiplicación y potencia. Para la división creamos una función con un control de excepciones para evitar la división por cero. Con try hacemos la división normal pero si detectamos que se puede llegar a producir un erro de ZeroDivisionError lo que hacemos con except es evitar ese error y en su lugar la función retorna un texto que informa del motivo de no haber realizado la división. Con ello evitamos que el programa lance un error que detenga la ejecución y confunda al usuario. También creamos una función para la división entera y otra para el cálculo del módulo con el control de excepciones correspondiente.


import random
x=random.randrange(1,10,2) #genera impares entre 1 y 9
y=random.randrange(3) #genera 0,1,2
print(x,'+',y,'=',x+y)
print(x,'-',y,'=',x-y)
print(x,'*',y,'=',x*y)
print(x,'elevado a',y,'=',x**y)
def div(x,y):
    try: return x/y
    except ZeroDivisionError: return 'error: denominador cero'
print(x,'/',y,'=',div(x,y))
def divent(x,y):
    try: return x//y
    except ZeroDivisionError: return 'error: denominador cero'
print(x,'división entera entre',y,'=',divent(x,y))
def modulo(x,y):
    try: return x%y
    except ZeroDivisionError: return 'error: denominador cero'
print(x,'módulo',y,'=',modulo(x,y))


Longitud de una cadena en Python

Reto: Longitud de una cadena

Crear una función que calcule la longitud de una cadena alfanumérica. Crear otra función que dada una cadena devuelva el primer caracter en mayúsculas y el resto en minúsculas. Pasar una palabra por ambas funciones y dar el resultado.




Método 1

Para calcular la longitud de una cadena lo mejor es usar len que se verá en el método 2, pero hemos querido usar aquí una forma alternativa de conseguirlo. De la misma manera para convertir una cadena en un nombre propio, existe capitalize que usaremos en el método 2, pero hemos querido ver cómo se puede conseguir sin usar esta función propia de Python. Primero usamos lower para pasar todo a minúsculas, y luego usamos upper aplicado al primer carácter para que esté mayúsculas.

def longitudCadena(x):
  contador=0
  for i in x:
    contador+=1
  return contador
def nombrePropio(x):
  y=x.lower()
  return y[0].upper()+y[1:]
x=input('Indique una palabra') or 'mADRId'
print(nombrePropio(x),'tiene',longitudCadena(x),'caracteres.')


Método 2

Usamos len para obtener la longitud del stringcapitalize para convertirlo en nombre propio. usaremos.

def longitudCadena(x):
  return len(x)
def nombrePropio(x):
  return x.capitalize()
x=input('Indique una palabra') or 'maDRid'
print(nombrePropio(x),'tiene',longitudCadena(x),'caracteres.') 

Capitalización compuesta en Python

Reto: Capitalización compuesta

Crear una aplicación que trabaje con la ley de capitalización compuesta.




Método 1

Preguntamos al usuario por el capital inicial, los años y el tipo de interés anual. Imprimimos el montante final alcanzado redondeado a dos decimales.

C=float(input('Introduzca el capital inicial') or 1000)
print('Capital inicial=',C)
n=float(input('Introduzca los años') or 3)
print('años=',n)
i=float(input('Introduzca el tipo de interés, por ejemplo 0.08 para 8%') or .08)
print('Tipo de interés anual=',i)
print('Capital final=',round(C*(1+i)**n,2))


Método 2

Generamos de forma aleatoria el capital inicial, el tiempo y el tanto de interés. Imprimimos el montante final que calcula una función.

import random
def montante(C,n,i):
  return C*(1+i)**n
C=random.randint(1000,9999)
print('Capital inicial=',C)
n=random.randint(1,10)
print('años=',n)
i=random.randint(2,20)/100
print('Tipo de interés anual=',i)
print('Capital final=',round(montante(C,n,i),2))