Python

June 14, 2017

• Lenguaje de programación interpretado

• Multiparadigma
• Programación orientada a objetos, programación funcional

Historia
Creador: Guido van Rossum

A partir del 2000:

• Python 2

• Python 3. Elimina opciones e.g. filter y otras cambian sus sintaxis.

Filosofı́a de Python
• Tomar ideas prestadas de otros lenguajes que tengan sentido

• ”Las cosas deben ser tan simples como sea posible, pero no más simples”
• Haz una cosa bien (UNIX)
• No preocuparse mucho sobre el performance, planear primero, después
optimizar

• No pelear con el entorno, seguir la corriente

• No buscar la perfección porque las cosas suficientemente buenas son las
funcionales
• (Corolario) Está bien tomar atajos a veces, especialmente si se puede hacer
bien luego
• El núcleo del lenguaje debe correr en cualquier plataforma

1
 • No molestar a los usuarios con detalles de los que la máquina se pueda
encargar
• Soportar y animar a que el código sea independiente de la plataforma sin
restringir la accesibilidad que se tenga en ella

• Los errores no deben ser fatales, no deben pasar inadvertidos ni deben

llevar al intérprete de Python a un comportamiento no definido

Zen de Python
• Bello es mejor que feo
• Explı́cito es mejor que implı́cito
• Simple es mejor que complejo
• Complejo es mejor que complicado

• Los errores nunca deberı́an dejarse pasar silenciosamente. A menos que

hayan sido silenciados explı́citamente.
• Ahora es mejor que nunca
• Aunque nunca es a menudo mejor que ya mismo

• Si la implementación es difı́cil es explicar, es una mala idea y viceversa

Editores de texto
• Gedit

• Kate

Terminal
• Console (konsole)
• Gnome-terminal

$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> import this

The Zen of Python, by Tim Peters

2
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!
>>> 1+1
2
>>> a=10
>>> b=-10
>>> a+b
0
>>> a=1.1
>>> b=2.2
>>> a+b
3.3000000000000003 #(ERROR DE PUNTO FLOTANTE)
>>> a=1j
>>> b=2+3j
>>> a+b
(2+4j)
>>> print("Hola Mundo!")
Hola Mundo!

Edición en Gedit
#!/usr/bin/python3
#La primera linea se llama shebang
print("Hola mundo!")

Para ejecutar el programa, ir a la Terminal, moverse al directorio donde se

guardó el programa fuente y escribir python3 *nombredelprograma*.py:

$ python3 pydia1.py

3
Hola mundo!

Regreso al editor de textos

#Para poder concatenar un número y una cadena, debo convertir el número a cadena con str()
mi_variable="Hola "+str(7)
print(mi_variable)
mi_var=nombre
print(mi_var)

Booleanos
• None
• False
• Cero

• Cualquier secuencia vacı́a

• Cualquier diccionario vacı́o

Operaciones booleanas
• not :: Negación del objeto evaluado
• and :: Evaluación Y
• or :: Evaluación Ó

>>> not None

True
>>> not []
True
>>> not ()
True
>>> not 1
False
>>> not "1"
False
>>> not ""
True
>>> not "."
False
>>> not ("a",1)
False

4
Comparaciones
>>> "abc"<"bcd"
True
>>> "abc"<"bcd"<"bce"
True
>>> "abc"<"cab"
True
>>> "abc"<"abb"
False
>>> 1<1
False
>>> 1==1
True
>>> a=1
>>> b=1
>>> a is b
True

Tipos numéricos
Operaciones
• x + y :: Suma
• x*y :: Multplicación
• x/y :: División (piso)
• x%y :: Residuo
• -x :: Negación
• abs(x) :: Valor absoluto
• int(x) Cast a entero
• float(x) :: Cast a float
• complex(re,im) ::

Funciones para cadenas

• str.capitalize() :: Transforma el primer caracter a mayúsculas dejando los
demás caracteres en minúsculas
• str.count(sub[, start[, end]]) :: Regresa el número de ocurrencias de la
subcadena sub en el rango [ start, end ]

5
 • str.endswith(suffix[,start[,end]]) :: Regresa verdadero si la cadena termina
con la subcadena suffix

a=[1,2,3]
>>> a
[1, 2, 3]
>>> b=[4,5]
>>> a+b
[1, 2, 3, 4, 5]
>>> a
[1, 2, 3]
>>> b
[4, 5]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5]
>>> a*=3
>>> a
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> a.count(5)
3
>>> a.index(3)
2
>>> c=a.insert(3,’a’)
>>> c
>>> a
[1, 2, 3, ’a’, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> a.pop()
5
>>> a
[1, 2, 3, ’a’, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4]
>>> a.pop([3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ’list’ object cannot be interpreted as an integer
>>> a.pop(3)
’a’
>>> a
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4]
>>> a.remove(1)
>>> a
[2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4]
>>> a.reverse()
>>> a
[4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2]
>>> d=[24,4,64,2,7,8]

6
>>> d.sort(reverse=True)
>>> d
[64, 24, 8, 7, 4, 2]
>>> tupla=(1,2,3)
>>> tupla.remove(0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: ’tuple’ object has no attribute ’remove’
>>> set([’a’,’b’,’c’])
{’a’, ’c’, ’b’}
>>> set([’a’,’b’,’c’,’c’])
{’a’, ’c’, ’b’}
>>> engineers=set([’Juan’,’Maria’,’Jonas’,’Andres’])
>>> programmers=set([’Jonas’,’Samuel’,’Susana’,’Andres’])
>>> managers=set([’Maria’,’Jonas’,’Susana’,’Pedro’])
>>> employees=engineers|programmers|managers
>>> employees
{’Juan’, ’Jonas’, ’Susana’, ’Andres’, ’Maria’, ’Samuel’, ’Pedro’}
>>> engineers&managers
{’Maria’, ’Jonas’}
>>> managers-engineers-programmers
{’Pedro’}
>>> engineers.add(’Marvin’)
>>> engineers
{’Maria’, ’Juan’, ’Andres’, ’Marvin’, ’Jonas’}
>>> employees.issuperset(engineers)
False
>>> employees.update(engineers)
>>> employees.issuperset(engineers)
True