Introducción a la programación en Python
clase 1

Introducción a Python

  • Python es un lenguaje de programación de propósito general muy poderoso y flexible, a la vez que sencillo y fácil de aprender.
  • Es un lenguaje de alto nivel, que permite procesar fácilmente todo tipo de estructuras de datos, tanto numéricos como de texto.
  • Python es software libre, y está implementado en todas las plataformas y sistemas operativos habituales.

características

  • es un lenguaje interpretado, no compilado
  • es un lenguaje multiparadigma, que permite tanto programación orientada a objetos como programación estructurada
  • en Python, el formato del código (p. ej., la indentación) es estructural

instalación de Python

sitio oficial: https://www.python.org/

instaladores

última versión de Python2: 2.7.8 https://www.python.org/download/releases/2.7.8/
última versión de Python3: 3.4.1 https://www.python.org/download/releases/3.4.1/

documentación

https://www.python.org/doc/

  • Tutorial de Python, de Guido van Rossum y Fred L. Drake, Jr.

versión original en inglés: HTML
traducción al argentino: HTML - PDF

entorno de desarrollo

Utilizaremos Idle, un entorno de desarrollo sencillo incluido en la distribución de Python.

Tipos en Python (I)

números

enteros (precisión ilimitada)

In [1]:
5
Out[1]:
5
In [2]:
-728
Out[2]:
-728
In [3]:
2387672347650910239486849367819823783745
Out[3]:
2387672347650910239486849367819823783745

coma flotante

In [4]:
2.238476
Out[4]:
2.238476
In [5]:
3.14e-10
Out[5]:
3.14e-10
In [6]:
1.
Out[6]:
1.0
In [7]:
.1
Out[7]:
0.1

cadenas de caracteres (strings)

In [8]:
'las cadenas de caracteres se pueden definir con comillas simples...'
Out[8]:
'las cadenas de caracteres se pueden definir con comillas simples...'
In [9]:
"...o con comillas dobles"
Out[9]:
'...o con comillas dobles'
In [10]:
'''con tres comillas (simples o dobles)
se pueden definir cadenas de varios renglones'''
Out[10]:
'con tres comillas (simples o dobles)\nse pueden definir cadenas de varios renglones'
In [11]:
'500'
Out[11]:
'500'
In [12]:
"las cadenas puede tener caracteres extendidos: ñáöłê @€£ 漢字 わたし ワタシ ήγλώσα ДИЯЖ 쌍비읍"
Out[12]:
'las cadenas puede tener caracteres extendidos: ñáöłê @€£ 漢字 わたし ワタシ ήγλώσα ДИЯЖ 쌍비읍'
In [13]:
'cuando la cadena utiliza la misma comilla de delimitación, tiene que ser antecedida por el carácter de escape: \' '
Out[13]:
"cuando la cadena utiliza la misma comilla de delimitación, tiene que ser antecedida por el carácter de escape: ' "

cadenas de escape

  • \n : salto de línea
  • \t : tabulador
  • \\ : retrobarra (\)
  • \' : comilla simple
  • \" : comilla doble

aritmética en Python

operadores aritméticos

  • suma: +
In [14]:
2+3
Out[14]:
5
  • resta: -
In [15]:
7-5
Out[15]:
2
  • multiplicación: *
In [16]:
4*3
Out[16]:
12
  • división: /
In [17]:
12/3
Out[17]:
4.0
In [18]:
14/5
Out[18]:
2.8
In [19]:
-14/5
Out[19]:
-2.8
  • división entera: //
In [20]:
14//5
Out[20]:
2
In [21]:
-14//5
Out[21]:
-3
  • resto o módulo: %
In [22]:
14%5
Out[22]:
4
In [23]:
-14%5
Out[23]:
1
  • potencia: **
In [24]:
2**10
Out[24]:
1024
  • negación (unaria): -
In [25]:
-5
Out[25]:
-5
  • agrupación: ()
In [26]:
(2*4)+3
Out[26]:
11
In [27]:
2*(4+3)
Out[27]:
14

orden de precedencia

potencia: **
negación: -
multiplicación, división, división entera, módulo: *, /, //, %
suma, resta: +, -

In [28]:
2*4+3
Out[28]:
11
In [29]:
-2**2
Out[29]:
-4
In [30]:
(-2)**2
Out[30]:
4
In [31]:
2**1/12
Out[31]:
0.16666666666666666
In [32]:
2**(1/12)
Out[32]:
1.0594630943592953

operadores booleanos

Los operadores booleanos o lógicos devuelven los valores True (verdadero) o False (falso).

  • mayor que: >
In [33]:
5 > 3
Out[33]:
True
  • menor que: <
In [34]:
5 < 3
Out[34]:
False
  • igual a: ==
In [35]:
5 == 5
Out[35]:
True
In [36]:
5 == 3
Out[36]:
False
  • distinto de: !=
In [37]:
5 != 3
Out[37]:
True
In [38]:
5 != 5
Out[38]:
False
  • mayor o igual que: >=
In [39]:
5 >= 3
Out[39]:
True
In [40]:
5 >= 5
Out[40]:
True
In [41]:
5 >= 7
Out[41]:
False
  • menor o igual que: <=
In [42]:
3 <= 3
Out[42]:
True
In [43]:
3 <= 5
Out[43]:
True
In [44]:
3 <= 1
Out[44]:
False

operaciones con cadenas

  • suma: + (equivale a la concatenación)
In [45]:
'foo'+'bar'
Out[45]:
'foobar'
In [46]:
'500'+'300'
Out[46]:
'500300'
In [47]:
'500'+300
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-47-22ab47338a57> in <module>()
----> 1 '500'+300

TypeError: Can't convert 'int' object to str implicitly
  • multiplicación: * (equivale a la repetición)

Sólo es válida entre una cadena y un entero.

In [48]:
'5'*8
Out[48]:
'55555555'
In [49]:
3*"ta"
Out[49]:
'tatata'
In [50]:
'foo'*2.5
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-50-ff15801f92db> in <module>()
----> 1 'foo'*2.5

TypeError: can't multiply sequence by non-int of type 'float'
In [51]:
'foo'*'bar'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-51-da27bad05499> in <module>()
----> 1 'foo'*'bar'

TypeError: can't multiply sequence by non-int of type 'str'
  • concatenación
In [52]:
"foo" "bar"
Out[52]:
'foobar'

Variables

En Python una variable es un nombre que se refiere a un objeto que reside en la memoria.
El objeto puede ser de alguno de los tipos vistos (número o cadena de caracteres), o alguno de los otros tipos existentes en Python

In [53]:
a = 20
In [54]:
b = "una cadena de texto"

En Python las variables no deben declararse previamente, se crean directamente mediante el operador de asignación (=)

variable = expresión

Primero se evalúa la expresión, y al objeto resultante se le asigna el nombre de la variable.

In [55]:
la = 440
semitono = 2**(1/12)
la_sostenido = 440 * semitono

Python es un lenguaje de tipos dinámicos. Esto quiere decir que el tipo no está asociado a la variable, sino a su valor.
Por lo tanto, el tipo de la variable no debe declararse, sino que se adapta dinámicamente al tipo del objeto que se le asigna.

In [56]:
A = 440
A = "la4"

La primera sentencia crea la variable A de tipo int con el valor 440, y la segunda sentencia redefine la variable con el tipo str y el valor "la4".

nombres

  • en Python el nombre de una variable (identificador) puede ser cualquier combinación de letras (mayúsculas y minúsculas), números, y guión bajo
  • el primer carácter no puede ser un número
  • los nombres que comienzan con guión bajo (simple o doble, _ __) se reservan para variables con significado especial
  • no pueden usarse como identificadores, las palabras reservadas:
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise

Print

Cuando se escriben expresiones directamente en el intérprete, el resultado evaluado se envía a la salida (eco).
Cuando se ejecuta un programa escrito en Python, se imprime en la salida estándar (la pantalla) mediante la función print()

In [57]:
print(2)
2

In [58]:
print(2**(1/12))
1.0594630943592953

In [59]:
print("do")
do

In [60]:
print("hola, Python")
hola, Python

In [61]:
la = 440
print(la)
440

In [62]:
print(do)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-62-7a3715a50bb4> in <module>()
----> 1 print(do)

NameError: name 'do' is not defined

En una llamada a la función print() se pueden concatenar varias expresiones:

In [63]:
la = 440
print("la frecuencia de la es", la, "Hz")
la frecuencia de la es 440 Hz

Por defecto, la separación entre las expresiones es un espacio en blanco, pero se puede definir otro separador.

In [64]:
la = 440
print("la frecuencia de la es", la, "Hz", sep=' ... ')
la frecuencia de la es ... 440 ... Hz

El separador puede ser un carácter extendido.

In [65]:
print("1", "12", "123", "1234", sep="\t")
print("2345", "234", "23", "2", sep="\t")
1	12	123	1234
2345	234	23	2

Ejemplo 1.1

Convertir temperatura en grados Fahrenheit a grados Celsius.

In [66]:
temp_fahrenheit = 60
temp_celsius = (temp_fahrenheit-32)*5/9
print(temp_celsius)
15.555555555555555

Input

La función input() se puede usar en un programa para ingresar datos durante su ejecución.

In [67]:
gusto = input("díganos su sabor preferido de helado: ")
print("entonces, le vamos a regalar un helado de", gusto)
díganos su sabor preferido de helado: chocolate
entonces, le vamos a regalar un helado de chocolate

La función input() siempre devuelve una cadena de caracteres.

In [68]:
num = input("ingrese un número: ")
print(num*2)
ingrese un número: 23
2323

int()

La función int() devuelve la parte entera de un número de coma flotante, y también puede convertir una cadena de caracteres a un número entero.

In [69]:
int(2.34)
Out[69]:
2
In [70]:
int("234")
Out[70]:
234
In [71]:
a = "200"
print(a*2)
print(int(a)*2)
200200
400

In [72]:
a = input("ingrese un número: ")
print(a*2)
print(int(a)*2)
ingrese un número: 23
2323
46

La función int() sólo procesa correctamente cadenas que contengan exclusivamente números.
Si la cadena contiene cualquier otro carácter, la función devuelve un error.

In [73]:
int("2.5")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-73-b44af7edf778> in <module>()
----> 1 int("2.5")

ValueError: invalid literal for int() with base 10: '2.5'
In [74]:
int("doscientos")
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-74-80acf8647f3d> in <module>()
----> 1 int("doscientos")

ValueError: invalid literal for int() with base 10: 'doscientos'

float()

La función float() es similar a int(), pero devuelve un número de coma flotante.

In [75]:
float("2.5")
Out[75]:
2.5
In [76]:
a = input("ingrese un número flotante: ")
print(a*2)
print(float(a)*2)
ingrese un número flotante: 2.5
2.52.5
5.0

Ejemplo 1.1 bis

Convertir una temperatura ingresada en grados Fahrenheit, a grados Celsius.

In [77]:
temp_fahrenheit = input("ingrese la temperatura en grados Fahrenheit: ")
temp_celsius = (int(temp_fahrenheit)-32)*5/9
print("equivalente en grados Celsius: ", temp_celsius)
ingrese la temperatura en grados Fahrenheit: 77
equivalente en grados Celsius:  25.0

Ejemplo 1.2

A partir de una frecuencia dada, calcular la frecuencia a un número determinado de cents de distancia.

In [78]:
frec_inicial = int(input("ingrese la frecuencia inicial: "))
cents = int(input("ingrese la cantidad de cents: "))
frec_final = frec_inicial*(2**(cents/1200))
print("frecuencia final: ", frec_final)
ingrese la frecuencia inicial: 440
ingrese la cantidad de cents: 50
frecuencia final:  452.8929841231365



Ejercicio 1.1

Escribir un programa que calcule el factor de multiplicación de frecuencia de grados consecutivos en un sistema de afinación que divida la octava en un número arbitrario de partes iguales. El intervalo "octavante" no tiene que ser necesariamente 2.

El programa debe preguntar:

  • el intervalo "octavante"
  • la cantidad de grados dentro de esa "octava"
  • una frecuencia de partida

y debe imprimir en la pantalla:

  • el factor de multiplicación
  • el valor en frecuencia del grado superior y del grado inferior a la frecuencia de partida

La salida en la pantalla debe tener alguna cadena informativa del valor que se está imprimiendo.


hp@eumus.edu.uy