Docsity
Docsity

Prepara tus exámenes
Prepara tus exámenes

Prepara tus exámenes y mejora tus resultados gracias a la gran cantidad de recursos disponibles en Docsity


Consigue puntos base para descargar
Consigue puntos base para descargar

Gana puntos ayudando a otros estudiantes o consíguelos activando un Plan Premium


Orientación Universidad
Orientación Universidad

Python: tipos numéricos, variables, operadores y estructuras de control básicas., Ejercicios de Metodología de Investigación

Una serie de conceptos básicos de Python, incluyendo tipos numéricos, asignación de variables, operadores de comparación y estructuras de control como condicionales y bucles. También se muestran ejemplos de código en IPython.

Qué aprenderás

  • ¿Cómo funcionan las operaciones aritméticas básicas en Python?
  • ¿Cómo se utilizan los bucles en Python?
  • ¿Cómo se asignan valores a variables en Python?
  • ¿Qué operadores de comparación existen en Python?
  • ¿Cómo se definen funciones en Python?

Tipo: Ejercicios

2019/2020

Subido el 27/09/2021

hi-im-adc
hi-im-adc 🇨🇴

4 documentos

1 / 11

Toggle sidebar

Esta página no es visible en la vista previa

¡No te pierdas las partes importantes!

bg1
In [1]:
importimport thisthis
In [2]:
print("Tipos numéricos")
In [3]:
2 * 4 - (7 - 1) / 3 + 1.0
In [4]:
print("Las divisiones entre cero lanzaran errores.")
In [5]:
1 / 0
In [6]:
print("Pasa lo mismo con las divisiones de tipo float.")
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!
Out[2]:
'Tipos numéricos'
Out[3]:
7.0
Out[4]:
'Las divisiones entre cero lanzaran errores.'
------------------------------------------------------------------------------------------------------------------------------------------------------
ZeroDivisionErrorZeroDivisionError Traceback (most recent call last)
<ipython-input-5-c4083a4da033><ipython-input-5-c4083a4da033> in <module>
----> 1----> 1 11 // 00
2
ZeroDivisionErrorZeroDivisionError: division by zero
pf3
pf4
pf5
pf8
pf9
pfa

Vista previa parcial del texto

¡Descarga Python: tipos numéricos, variables, operadores y estructuras de control básicas. y más Ejercicios en PDF de Metodología de Investigación solo en Docsity!

In [1]:

import import thisthis

In [2]:

print("Tipos numéricos")

In [3]:

2 * 4 - ( 7 - 1 ) / 3 + 1.

In [4]:

print("Las divisiones entre cero lanzaran errores.")

In [5]:

1 / 0

In [6]:

print("Pasa lo mismo con las divisiones de tipo float.")

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!

Out[2]:

'Tipos numéricos'

Out[3]:

Out[4]:

'Las divisiones entre cero lanzaran errores.'

ZeroDivisionErrorZeroDivisionError Traceback (most recent call last) <ipython-input-5-c4083a4da033><ipython-input-5-c4083a4da033> in ---->----> 11 11 // 00 2

ZeroDivisionErrorZeroDivisionError: division by zero

In [7]:

1.0 / 0.

In [8]:

print("La division entre enteros devolvera el numero real en esta version de python.")

In [9]:

3 / 2

In [11]:

print("Para forzar la division y que el resultado sea entero podremos utilizar el operador ' //'.")

In [12]:

3 // 2

In [13]:

2 + 3 j

In [14]:

( 3 + 2 j) * ( 1 - 1 j)

In [15]:

( 1 j) ** 2

Out[6]:

'Pasa lo mismo con las divisiones de tipo float.'

ZeroDivisionErrorZeroDivisionError Traceback (most recent call last) <ipython-input-7-d5317764bbf2><ipython-input-7-d5317764bbf2> in ---->----> 11 1.01.0 // 0.00.

ZeroDivisionErrorZeroDivisionError: float division by zero

Out[8]:

'La division entre enteros devolvera el numero real en esta version de python.'

Out[9]:

Out[11]:

"Para forzar la division y que el resultado sea entero podremos utilizar el operador '//'."

Out[12]:

1

Out[13]:

(2+3j)

Out[14]:

(5-1j)

Out[15]:

(-1+0j)

complex(_)

In [33]:

print("Algunas funciones adicionales útiles son: ")

In [34]:

max( 0 , - 1 , 1 , 2 )

In [35]:

min( 1 , 2 , 0 , - 1 )

In [36]:

print("Asignación y operadores de comparación")

In [37]:

print("Para poder asignar variables en python debermos utilizar el operador de '='")

In [38]:

a = 1 + 2 j

In [39]:

a = 1 + 2 j a

In [40]:

print("Tambien se puede encadenar varias asignaciones")

In [41]:

x, y = 1 , 2

Out[32]:

(4+0j)

Out[33]:

'Algunas funciones adicionales útiles son: '

Out[34]:

2

Out[35]:

Out[36]:

'Asignación y operadores de comparación'

Out[37]:

"Para poder asignar variables en python debermos utilizar el operador de '='"

Out[39]:

(1+2j)

Out[40]:

'Tambien se puede encadenar varias asignaciones'

x, y

In [42]:

x, y = y, x x, y

In [43]:

print("Existen diferentes multiples operadores de comparación son '==', '!=', '<', '<=', '>' , '>='")

In [44]:

print(x == y)

In [45]:

x, y = 1 , 2 x, y

In [46]:

print(x != y)

In [47]:

print(x < y) print(x <= y) print(x > y) print(x >= y)

In [48]:

print("Existen multiples errores como por ejemplo en este caso:")

In [49]:

1 + 1 j < 0 + 1 j

Out[41]:

(1, 2)

Out[42]:

(2, 1)

Out[43]:

"Existen diferentes multiples operadores de comparación son '==', '!=', '<', '<=', '>', '>=' "

False

Out[45]:

(1, 2)

True

True True False False

Out[48]:

'Existen multiples errores como por ejemplo en este caso:'

print(una_lista[- 1 ]) # El último: 4 + 0j print(una_tupla[:]) # Desde el primero hasta el último print(una_lista[:: 2 ]) # Desde el primero hasta el último, saltando 2: 1, 3.

In [58]:

print("Fíjate en dos detalles:")

print("- Cuando especificamos índices negativos, recorremos el array desde el final hasta el principio. Por eso [-1] da el último elemento, [-2] el penúltimo y así sucesivamente.") print("- Hemos utilizado la notación [::2] para el último caso. Esto es una manera abreviada de escribir [0:-1:2], es decir, si no decimos nada empezamos en el principio y terminamos en el final. Por eso [:] devuelve todos los elementos de la secuencia.")

In [59]:

a = [ [ 1 , 2 , 3 ], [ 4 , 5 ], ] print(a) print(a[ 0 ]) print(a[ 0 ][ 0 ])

In [60]:

print("Estructuras de control (I): condicionales")

In [61]:

print(x, y) if if x < y: print("x es menor que y") print("x sigue siendo menor que y")

In [62]:

if if 1 < 0 : print("1 es menor que 0") print("1 sigue siendo menor que 0") # <-- ¡Mal!

[1, 2]

(1, 2, 3.0, (4+0j), '5') [1, 3.0, '5']

Out[58]:

'- Hemos utilizado la notación [::2] para el último caso. Esto es una manera abreviada de es cribir [0:-1:2], es decir, si no decimos nada empezamos en el principio y terminamos en el f inal. Por eso [:] devuelve todos los elementos de la secuencia.'

[[1, 2, 3], [4, 5]]

[1, 2, 3]

Out[60]:

'Estructuras de control (I): condicionales'

x es menor que y x sigue siendo menor que y

1 sigue siendo menor que 0

In [63]:

print("En este ejemplo la ordenacion no tiene sentido")

In [64]:

if if 1 < 0 : print("1 es menor que 0") print("1 sigue siendo menor que 0")

In [65]:

print("Si queremos añadir ramas adicionales al condicional, podemos emplear la sentencia eli f. Para la parte final debe ejecutarse sin ninguna de las condiciones anteriores que se haya cumplido utilizamos la funcion else")

In [66]:

print(x, y) if if x < y: print("x es menor que y") elif elif x == y: print("x es igual a y") else else: print("x no es ni menor ni igual que y")

In [67]:

print("Estructuras de control (II): bucles")

In [68]:

print("Los bucles también se desmarcan con el sangrado. En Python hay dos tipos de bucles: ' While' y 'For'")

In [69]:

ii = 0 while while ii < 5 : print(ii) ii += 1

Out[63]:

'En este ejemplo la ordenacion no tiene sentido'

FileFile "<ipython-input-64-15a0111f71c6>""<ipython-input-64-15a0111f71c6>",, lineline 33 print("1print("1 siguesigue siendosiendo menormenor queque 0")0") ^^ IndentationErrorIndentationError:: unexpected indent

Out[65]:

'Si queremos añadir ramas adicionales al condicional, podemos emplear la sentencia elif. Par a la parte final debe ejecutarse sin ninguna de las condiciones anteriores que se haya cumpl ido utilizamos la funcion else'

x es menor que y

Out[67]:

'Estructuras de control (II): bucles'

Out[68]:

"Los bucles también se desmarcan con el sangrado. En Python hay dos tipos de bucles: 'While' y 'For'"

In [75]:

for for ii inin range( 3 ): print(ii)

In [76]:

for for jj inin range( 2 , 5 ): print(jj)

In [77]:

print("Definición de funciones")

In [78]:

print("La definicion de una funcion propia esta definido por la sentencia def seguida del no mbre que se desea asignar y entre parentesis los argumentos de entrada.")

In [79]:

def def funcion(x, y): """Función de prueba.""" pass pass

In [80]:

funcion

In [81]:

funcion.doc

In [82]:

def def al_cuadrado(x): """Función que eleva un número al cuadrado.""" y = x ** 2 return return y

In [83]:

Luis Carlos

Out[77]:

'Definición de funciones'

Out[78]:

'La definicion de una funcion propia esta definido por la sentencia def seguida del nombre q ue se desea asignar y entre parentesis los argumentos de entrada.'

Out[80]:

<function main.funcion(x, y)>

Out[81]:

'Función de prueba.'

In [83]:

al_cuadrado( 4 )

In [84]:

print("Los valores de retorno de la función se especifican con la sentencia return. Por ejem plo:")

In [85]:

def def multiplica(x, y=2.0): """Multiplica dos números, por defecto el primero por 2.""" return return x * y

multiplica( 2 , 3 )

In [86]:

multiplica( 4 )

In [87]:

multiplica(x, y=1.0)

Out[83]:

16

Out[84]:

'Los valores de retorno de la función se especifican con la sentencia return. Por ejemplo:'

Out[85]:

6

Out[86]:

Out[87]: