Aprendiendo Python mediante pequeñas pruebas

Cuadno empieces con python ya no volveras a los otros xD

Me gusta la idea, si tengo tiempo esta semana (malditos exámenes xD) me lo miraré.

#6 te doy algun consejillo que espero que no te lo tomes como ninguna crítica:

La función "esPerfecto" que devuelva 1 o 0 es grave xD, mejor return True o return False (ojo con las mayus).

De esa forma todo linea que tienes como:

if (esPerfecto(i+1)==1): 

Es sustituida simplemente por:

if (esPerfecto(i+1)): 

Otro cosa, en esta linea:

res = res + [i +1]

cambiala por :

res.append( i+1 )

ó

res.extend( i+1 )

Según lo que quieras hacer. Este punto es muy importante para la eficiencia.

También aclararte que print en python se suele usar simplemente con (sin paréntesis) :

print "hola mundo"

Como sabes mete automáticamente \n al final, si no lo quieres pon:

print "hola mundo",

Por otro lado la llamada al main(), mejor haz esto:

if __name__ == '__main__':
	main()

De esa forma si ese modulo lo quieres usar desde un "import" de otro modulo, no te ejecuta el main, pero para un ejemplo pequeño, no esta mal.

Por último, yo evitaría cualquier llamada recursiva y la sustituiría por un while con condición de salida.

Eso respecto a estilo de programación, en cuanto al algoritmo parece que esta bien, pero no lo he probado

Enga un saludo

Joder no me imaginé que fuera tan parecido a C con toques de Pascal

#10: Sí, eso mola un huevo. Aunque al no estar acostumbrado a veces no sabes por qué te da fallo. Aunque por mucho que digan a nivel de sintaxis yo prefiero Java xD

EDIT: A ver si se anima más gente, que esto puede llegar a ser interesante.

Bueno, me alegra ver que ya se ha animado gente a poner códigos y comentar los de otros A ver si esto sigue un poco adelante, que a penas se habla de este lenguaje en MV...

Mi código para la prueba 1:

# -*- coding: utf-8 -*-

# Obtenemos el valor introducido
valor = raw_input("Introduzca un valor entero mayor o igual que 6: ")

# Lo transformarmos en un entero
valor = int(valor)

# Comprobamos que el valor introducido es válido
if valor < 6:
	print "ERROR: El valor introducido tiene que ser superior o igual a 6."
	exit()

# Para cada numero entre 6 (el menor numero perfecto) y el valor introducido
for posiblePerfecto in range(6, valor + 1):
	# Inicializamos la suma de sus divisores a cero
	suma = 0
	
# Buscamos sus divisores. Cuando lleguemos a la mitad del número candidato,
# dejamos de buscar, puesto que ya no puede tener más candidatos
for i in range(1, (posiblePerfecto / 2) + 1):
	# Si el numero que estamos evaluando es uno de sus divisores
	if posiblePerfecto % i == 0:
		# Lo añadimos a la suma
		suma += i

# Si la suma de sus divisores es igual al propio número, se trata de un número
# perfecto, y lo notificamos por pantalla
if suma == posiblePerfecto:
	print posiblePerfecto,

A parte de esto, pues os pongo varias dudas que se me han ido ocurriendo:

• ¿Cómo hago para que si en vez de meter un entero se mete un carácter, string, flotante, etc. la función "int" no me dé error?

• ¿Cómo puedo hacer para que en la función range me llegue hasta el número que introduzco en el segundo parámetro y no hasta el anterior? ¿Siempre hay que sumarle 1 o hay una solución más elegante?

También sobre el código de #6, una pregunta: ¿para qué usas en la función getPerfectos la variable inc?

Y también comentar que he estado pensando que quizá en vez de poner cada semana una entrega, lo ideal sería ir poniendo una lista de pruebas y que la gente haga la que le interese cuando quiera, sin límites de nada, ¿no? ¿Qué os parece? Se aceptan sugerencias sobre pruebas xD De momento he añadido una segunda prueba, a ver si alguien más propone alguna prueba para hacer.

Un saludo!

#13 mirate esto, debes capturar la excepcion, que en este caso es ValueError, además he aprovechado para explicar lo útil que son los valores por defecto.

Para capturar cualquier tipo de excepcion:

try:
... codigo ...
except:
... tratamiento excepcion ...

Una excepcion muy típica, es el CTRL + C

try:
... codigo ...
except KeyboardInterrupt:
print "Abortado"

#!/usr/bin/python

def pedirEntero( pregunta="Introduce un entero" , mensajeERROR="ERROR. No has introducido un entero" ):
	insistir = True
	while insistir:
		try:
			numero = int(raw_input ("%s : " % pregunta))
			insistir = False
		except ValueError:
			print mensajeERROR
	return numero
	
print "Has introducido el num = %d" % pedirEntero()
print "Has introducido el num = %d" % pedirEntero("OTRO PLZ")
print "Has introducido el num = %d" % pedirEntero("OTRO PLZ PLZ" , "K COJONES PONES")

TIOBE es una empresa de de Ingeniería del software, tienen un ranking muy interesante, para tratar de calcular el mejor lenguaje:

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

"The popular search engines Google, MSN, Yahoo!, and YouTube are used to calculate the ratings. Observe that the TIOBE index is not about the best programming language or the language in which most lines of code have been written."

Esta basado en buscadores

En el 2007 python fue top 1, ahora mismo esta 6

scheme k es ? xDD he leido k es funcional ... en mi uni solo damos camel, es mejor ? k diferencia hay ?

Bueno, en todo caso... ahí va mi solución al primero de los retos en Scheme...
Me encantan estos retos :-)

Lo he resuelto utilizando dos algoritmos.
El primero de ellos es un cálculo simple, parecido a los que se pusieron en Python
y al método de la Wikipedia que calcula cada divisor para los números, pero es sencillo.

;; Devuelve cierto o falso según un número es perfecto.
(define (perfect? num)
  (let ((count 0))
    (begin
      (for-each
        (lambda (n)
          (if (zero? (remainder num n))
          (set! count (+ count n)))) (cdr (iota num)))
      (if (= num count) #t #f))))

;; Lee un número N por teclado y filtra una lista construída 
;; con los números desde 1 hasta N según cada uno es perfecto o no.
(display (filter perfect? (cdr (iota (1+ (read))))))

Si al programa le pasamos un 500, mostrará:
(6 28 496)

El problema de este procedimiento es que es sumamente lento.
Si probais a pasarle 10000000 (10 millones), os llevará la vida hacer
el cálculo. (es también un problema en las soluciones con Python)

Leyendo por ahí (en la Wikipedia inglesa) encontré otro método
utilizando números primos y una fórmula tal que:
Si (2^k − 1) es primo entonces 2^{k - 1} * (2^k - 1) es un número perfecto
hecha por Ibn al-Haytham y Euler.
(leer aquí: http://en.wikipedia.org/wiki/Perfect_number)

Así que hice otro programilla. :-)

;; Devuelve #t si un número es primo
;; y #f si no lo es. Sólo comprueba impares
;; y va desde k 3, hasta k * k > n.
(define (is-prime? n)
  (if (even? n) #f
  (let loop ((k 3))
    (if (> (* k k) n) #t
    (if (zero? (remainder n k)) #f
    (loop (+ k 2)))))))

;; Construye una lista de números perfectos
;; desde 0 hasta k. Utiliza la fórmula anterior
;; Optimiza terminando en cuanto un resultado
;; es mayor que el número pedido. 
(define (perfect-numbers k)
  (let loop ((num 0) (ls '(0)))
    (if (> (car ls) k) 
      (cddr (reverse (cdr ls)))
    (if (is-prime? (- (expt 2 num) 1))
      (loop (1+ num) (cons (* (expt 2 (- num 1)) (- (expt 2 num) 1)) ls))
      (loop (1+ num) ls)))))

;; Ya podemos rular el programa.
(display (perfect-numbers (read))

Ahora el programa sí es eficiente.
Si le pasamos 100000000 (100 millones) devuelve
instantáneamente:
(6 28 496 8128 33550336)

o con 100000000000 (100 mil millones)
(6 28 496 8128 33550336 8589869056)

Saludos!

Mi solución de la prueba 2: Solapamiento:

# -*- coding: utf-8 -*-

def solapamiento(t1, t2):
	solap = 0
	for i in range(min(len(t1), len(t2))):
		if t1[-i - 1:] == t2[:i + 1]:
			solap = i + 1
	
return solap

def solapamiento(t1, t2):
	solap = 0
	# Para todos los componentes de la tupla más pequeña
	for i in range(min(len(t1), len(t2)) + 1):
		# Si los últimos i+1 componentes de la primera tupla
		# coinciden con los primeros i+1 componentes de la última
		if t1[-i:] == t2[:i]:
			solap = i
	
return solap

a = ["a", "b", "c", "d", "e", "f", "g"]
b = ["e", "f", "g", "h", "i"]
c = (1, 2, 3, 4, 5)
d = (2, 3, 4, 5, 6)
e = [1, ["a", "b"], 2]
f = [["a", "b"], 2, 3, 4, 5, 6]

print solapamiento(a, b)
print solapamiento(b, a)
print solapamiento(c, d)
print solapamiento(d, c)
print solapamiento(e, f)

He dejado dos soluciones, las dos hacen lo mismo, pero la segunda es un poco más clara.

Con los ejemplos que he puesto, podéis ver como esta función es, además de simple, muy potente, porque también permite comparar con listas dentro de listas, tuplas dentro de listas, etc.

#15, gracias, no se me había ocurrido usar excepciones.

Soleil, está genial que las hagas en Scheme. Yo no lo conocía, y siempre está bien comparar la misma solución escrita en otros lenguajes. De todas formas, si comparo tu solución con la mía, creo que en python queda más claro y además no he tenido que crear ninguna función adicional para recorrer listas hacia atrás. Por curiosidad, si en scheme metes una lista dentro de otra, ¿sigue funcionando bien tu programa?

También me alegra que te haya gustado el ejercicio del solapamiento. Se trata de una práctica de Metodología de la Programación, de 1º de Ingeniería Informática. Hace ya 6 años tuve que hacerla en C++ y ahora al hacerla en Python me he alegrado un montón, porque lo que en C++ me ocupaba un buen puñado de líneas, en Python se soluciona en SEIS líneas...

La verdad es que me está gustando mucho este Python, a primera vista parece que al darte tantas funcionalidades y facilidades, te ahorra mucho tiempo, porque puedes ponerte a programar directamente sin tener que estar implementando por tu cuenta cosas triviales y repetitivas, no sé si me explico.

Ah, si se te ocurre algún ejercicio, por favor, postéalo. Ahora voy a pensar en algún ejercicio relacionado con clases, para practicar un poco con ellas. En cuanto se me ocurra algo lo pongo.

EDIT: Sobre el método de Euclides, también pensé en hacerlo así, pero me surgió una duda. Está claro que haciendo el método de Euclides va a salir un número perfecto, pero ¿todos los números perfectos se forman mediante el método de Euclides? Esto es importante, porque si la respuesta es no, entonces no valdría este método.

Ahí va un reto interesante : -)
http://projecteuler.net/index.php?section=problems&id=12

joe, no podiais haber escogido una fecha con mas examenes? aunq bueno a ver si me acuerdo de este thread dentro de un mes

Aquí está la mía para el primero. Tampoco me he calentado mucho la cabeza, que hace años que no toco python .

N = 0
while N < 6:
    N = input('Introduce un número mayor o igual que 6: ')

for n in range(6, N+1):
    suma = 1
    for i in range(2, n):
        if n % i == 0:
            suma = suma + i
    if suma == n:
        print str(n) + ' es un número perfecto'

Y aquí el segundo. Este ya está más bonito.

def solapamientoN(L, M, pos):
    for i in range(1, pos):
        if L[-i] != M[pos-i]:
            return False
    return True    

def solapamiento(L, M):
    ultimo = L[-1]
    pos = -1
    solape = -1

while True:
    try:
        pos = M.index(ultimo, pos + 1)
        if solapamientoN(L, M, pos + 1):
            solape = pos + 1
    except ValueError:
        break

return solape

def main():
    L = []
    M = []
    print 'Introduce la primera lista (control + c para acabar)'
    while True:
        try:
            e = input()
            L.append(e)
        except KeyboardInterrupt:
            break

print 'Introduce la segunda lista (control + c para acabar)'
while True:
    try:
        e = input()
        M.append(e)
    except KeyboardInterrupt:
        break

solape = solapamiento(L,M)
if solape == -1:
    print 'No hay solapamiento'
else:
    print 'Hay solapamiento de grado ' + str(solape)    

if __name__ == '__main__':
    main()

Ahora que estais empezando, es bueno que os acostumbreis a seguir las reglas de estilo que proponen los creadores de python, realmente tienen muy buenos consejos:

http://www.python.org/dev/peps/pep-0008/