"I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus)."
import this
The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those!
Ingresar y descargar en https://www.python.org/
En Windows debemos agregar el Path de Python para poder ejecutarlo en otras carpetas, seteando la variable de entorno
C:\>set PATH=%PATH%;C:\Python27
C:\>set PYTHONPATH=%PYTHONPATH%;C:\Python27
Propiedades del sistema->Configuraciones avanzadas->Variables de entorno:
Cuando ejecutamos el comando python
en la terminal
$ python
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 12:39:47)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for
more information.
>>>
El intérprete nos muersta los símbolos >>>
llamados prompt
y nos indica que está listo para que escribamos a continuación una sentencia que será evaluada.
Python permite utilizar las operaciones +, -, *, ! y **
(suma, resta, multiplicación, división y
potenciación). La sintaxis es la convencional (valores intercalados con operaciones), y se puede
usar paréntesis para modificar el orden de asociación natural de las operaciones (potenciación,
producto/división, suma/resta).
>>> 2+3
5
>>> 5*7
35
>>> 2+3*7
23
>>> (2+3)*7
35
>>> 10/4
2
>>> 5**2
25
>>>max(1,6,2,3,6)
>>>6
def
Ejemplo:
def hola_mundo():
return "Hola mundo!"
Son palarbas reservadas por Python. No podemos usarlas para nombres de variables, funciones ni ningún otro identificador.
import keyword
print keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
Creamos el archivo miModulo.py y escribimos:
#!/usr/bin/env python
def hola_mundo():
print "Hola mundo!"
hola_mundo()
Hola mundo!
Se puede correr de dos maneras:
import miModulo
miModulo.hola_mundo()
python miModulo.py
def hola(alguien):
print "Hola " + alguien + "!"
hola("Mati")
Hola Mati!
Aunque el nombre debe ser claro como para darnos una idea de lo que hace una función, aveces no alcanza. Por lo que es recomendable siempre docuemntar las funciónes. Tanto como para ayudarlo al otro que la lee o a el nosotros del futuro.
"""
def hola(persona1, persona2):
""" Imprime por pantalla un saludo, dirigido a las personas que se indican por parámetro."""
print("Hola " + persona1 + " y " + persona2)
hola("Miguel", "Mati")
Hola Miguel y Mati
Cuando una función definida está correctamente documentada, es posible acceder a su documentación mediante la función help provista por Python
help(hola)
Help on function hola in module __main__: hola(persona1, persona2) Imprime por pantalla un saludo, dirigido a las personas que se indican por parámetro.
Luego de realizar dichas tareas necesitamos que las funciones devuelvan el resultado a quién llamó la función
return
.None
(es el Null
de Python)x = hola_mundo()
print x
Hola mundo! None
Se dividen en:
Podemos comprobar el tipo con la función type() de Python
n_entero = 5 #Esto es un entero (int)
type(n_entero)
int
n_flotante = 3.14 #Esto es un numero de coma flotante (float)
type(n_flotante)
float
n_complejo = 1 + 2j #Esto es un numero complejo
type(n_complejo)
complex
cadena = "Miguel" #Esto es una cadena
type(cadena)
str
int
float
Operador | Descripción | Ejemplo |
---|---|---|
+ | suma | r = 3 + 2 # r es 5 |
- | resta | r = 4 - 7 # r es -3 |
- | negación | r = -7 # r es -7 |
* | producto | r = 2 * 6 # r es 12 |
** | exponenciación | r = 2 ** 6 # r es 64 |
/ | división (Python 3) | r = 3 / 2 # r es 1.5 |
/ | división entera (Python 2) | r = 3 / 2 # r es 1 |
// | división entera | r = 3.5 // 2 # r es 1.0 |
% | modulo | r = 7 % 2 # r es 1 |
Por ahora sólo diremos que las cadenas no son más que texto encerrado entre comillas simples (‘cadena’) o dobles (“cadena”).
cadena1 = "cadena"
cadena2 = 'cadena'
Operador | Descripción | Ejemplo |
---|---|---|
and | ¿se cumple a y b? | r = True and False # r es False |
or | ¿se cumple a o b? | r = True or False # r es True |
not | No a | r = not True # r es False |
Expresión | Significado |
---|---|
a == b | a es igual a b |
a != b | a es distinto de b |
a<b | a es menor que b |
a <= b | a es menor o igual que b |
a>b | a es mayor que b |
a >= b | a es mayor o igual que b |
if <condición_1>:
<hacer algo_1 si se da la condición_1>
elif <condición_2>:
<hacer algo_2 si se da la condición_2>
...
elif <condición_n>:
<hacer algo_n si se da la condición_n>
else:
<hacer otra cosa si no dan las anteriores>
def positivo_o_no(x):
if x > 0:
print("Numero positivo")
elif x == 0:
print("Igual a 0")
else:
print("Numero negativo")
positivo_o_no(10)
positivo_o_no(-10)
positivo_o_no(0)
Numero positivo Numero negativo Igual a 0
def es_bisiesto(anio):
""" Devuelve True si el año es bisiesto, False en caso contrario. """
if (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0):
return True
return False
def es_bisiesto(anio):
""" Devuelve True si el año es bisiesto, False en caso contrario. """
return (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0)
def es_bisiesto(anio):
""" Devuelve True si el año es bisiesto, False en caso contrario. """
return (not anio % 4 and anio % 100) or (not anio % 400)
Ya vimos que la función print
nos permite mostrar información al usuario del programa. En algunos casos también necesitaremos que el usuario ingrese datos al programa.
La necesitaremos, por ejemplo, si queremos escribir en Python un programa que pida al usuario que escriba su nombre, y luego lo salude. Para esto usaremos la funcion raw_input
#hola.py
def hola(nombre):
return "Hola " + nombre + "!"
def saludar():
nombre = raw_input("Por favor ingrese su nombre: ")
saludo = hola(nombre)
print(saludo)
saludar()
Por favor ingrese su nombre: Miguel Hola Miguel!
for <variable> in <secuencia de valores>:
<cuerpo>
Por ejemplo: Supongamos que queremos calcular la suma de los primeros 5 números cuadrados.
def imprimir_cuadrados1():
suma = 0
suma = suma + 1*1
suma = suma + 2*2
suma = suma + 3*3
suma = suma + 4*4
suma = suma + 5*5
return suma
imprimir_cuadrados1()
55
def imprimir(n):
acum = 0
for x in range(n + 1):
acum += x*x
return acum
imprimir(5)
55
def es_primo(n):
""" Dado un número n, devuelve True si es primo, False si no"""
for i in range(2,n):
if n % i == 0:
return False
return True
es_primo(83)
True
def triangulares(n):
for i in range(1, n + 1):
acum = 0
for j in range(1, i + 1):
acum += j
print(i, " - ", acum)
triangulares(5)
(1, ' - ', 1) (2, ' - ', 3) (3, ' - ', 6) (4, ' - ', 10) (5, ' - ', 15)
#Correrlo en terminal texto_while.py
texto = raw_input("Ingrese un texto(hasta 140 caracteres):")
while len(texto) > 140 :
texto = raw_input("Ingrese un texto(hasta 140 caracteres):")
Ingrese un texto(hasta 140 caracteres):texto
#ej14.py
def promedio():
acumulador = 0
cantidadNotas = 0
nota = int(raw_input("Ingrese una nota (-1 para salir):"))
while nota != -1:
acumulador += nota
cantidadNotas += 1
nota = int(raw_input("Ingrese una nota (-1 para salir):"))
return float(acumulador) / cantidadNotas
promedio()
Ingrese una nota (-1 para salir):2 Ingrese una nota (-1 para salir):3 Ingrese una nota (-1 para salir):-1
2.5
Utilizando la función randrange
del módulo random
, escribir un programa que obtenga un número aleatorio secreto, y luego permita al usuario ingresar números y le indique sin son menores o mayores que el número a adivinar, hasta que el usuario ingrese el número correcto.
randrange(1,10)
Devuelve un numero entre [1,10)
import random #Importa el modulo, si queremos ejecutar una funcion -> modulo.funcion()
from random import randrange #Importa solo la función randrange del modulo random
from random import * #Importa todas las funciones definidas en el modulo random
help(randrange)
randrange(1,40)
Help on method randrange in module random: randrange(self, start, stop=None, step=1, _int=<type 'int'>, _maxwidth=9007199254740992L) method of random.Random instance Choose a random item from range(start, stop[, step]). This fixes the problem with randint() which includes the endpoint; in Python this is usually not what you want.
13
# ej15.py
import random
def adivinador():
n = random.randrange(10)
ingresado = int(raw_input("Ingrese un número:"))
while ingresado != n:
if ingresado < n:
ingresado = int(raw_input("El número ingresado es menor. " +
"Ingrese un número:"))
else:
ingresado = int(raw_input("El número ingresado es mayor. " +
"Ingrese un número:"))
print "Correcto! El numero es ", n
adivinador()
Ingrese un número:2 Correcto! El numero es 2
#parametros1.py
import sys
for arg in sys.argv:
print arg
#ej1.6.py
import sys
def es_bisiesto(anio):
""" Devuelve True si el anio es bisiesto, False en caso contrario. """
return (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0)
print(es_bisiesto(int(sys.argv[1])))
Son texto encerrado entre comillas dobles (“ “) o simples (‘ ‘)
""" """
triple = """primera línea
esto se vera en otra línea"""
print triple
primera línea esto se vera en otra línea
"Un divertido " + "programa " + "de " + "radio"
'Un divertido programa de radio'
3 * "programas "
'programas programas programas '
len("programas ")
10
palabra = "curso python"
for letra in palabra:
print letra
c u r s o p y t h o n
a = "Verónica"
print a
print a[1]
print a[-2]
Verónica e c
Las cadenas son inmutables!
a[1] = 'o'
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-38-a1f251c3625e> in <module>() ----> 1 a[1] = 'o' TypeError: 'str' object does not support item assignment
def alverre(cadena):
for i in range(len(cadena) - 1, -1, -1):
print(cadena[i])
alverre("hola")
a l o h
def alverre2(cadena):
for i in range(1, len(cadena) + 1):
print(cadena[-i])
alverre2("chau")
u a h c
a = "Veronica"
print a[0:2]
print a[-4:-2]
print a[0:80]
print a[:3]
print a[3:]
print a[::2]
a = a[::-1]
print a
Ve ni Veronica Ver onica Vrnc acinoreV
Escribir funciones que dada una cadena y un caracter, inserte el caracter entre cada letra de la cadena. Ej: ’separar’ y ’,’ debería devolver ’s,e,p,a,r,a,r’
def separar(cadena, separador):
resultado = ""
for letra in cadena:
resultado += letra + separador
return resultado[:-1]
separar("hola",",")
'h,o,l,a'
def separar(cadena, separador):
resultado = cadena[0]
for i in range(1,len(cadena)):
resultado += separador + cadena[i]
return resultado
separar("como",",")
'c,o,m,o'
def separar(cadena, separador):
return separador.join(cadena)
separar("andas",",")
'a,n,d,a,s'
def es_palindromo(cadena):
for i in range(len(cadena) / 2 + 1):
if cadena[i] != cadena[-(i + 1)]:
return False
return True
def es_palindromo(cadena):
return cadena == cadena[::-1]
py -m pdb script.py
break numero_de_linea
break nombre_funcion
Chequear:
Documentación Python 2.7
https://docs.python.org/2/
Zen de python
http://legacy.python.org/dev/peps/pep-0020/
Wikipedia
https://en.wikipedia.org/wiki/Python
Apuntes Teóricos - Algoritmos y Programación I - Cátedra Wachenchauzer - FIUBA
http://algoritmos7540-rw.tk/