semana = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes',

'Sábado', 'Domingo']

for dia in semana:

print(dia)

Ejercicio 1
Crea un array o arreglo unidimensional donde le indiques el tamaño por teclado y crear
una función que rellene el array o arreglo con los múltiplos de un número pedido
por teclado. Por ejemplo, si defino un array de tamaño 5 y elijo un 3 en la función, el
array contendrá 3, 6, 9, 12, 15. Muestralos por pantalla usando otra función distinta.

n = int(input(u"Ingrese el tamaño del arreglo"))

m = int(input(u"Ingrese el número de múltiplos"))
A = []
for i in range (0,n):
A.append(i*m)
print A

Ver solución en Codeskulptor

Ejercicio 2
Crea dos arrays o arreglos unidimensional es que tengan el mismo tamaño (lo pedirá por
teclado), en uno de ellos almacenarás nombres de personas como cadenas, en el otro array
o arreglo ira almacenando la longitud de los nombres.

A = int(input(u"Ingrese el tamaño de los arreglos"))

B = []
C = []
for i in range (0,A):
B.append(input("Ingrese nombre de las personas"))
print B
for j in range (0,A):
C.append(len(B[j]))
print C

Ver solución en Codeskulptor

Ejercicio 3
Dado el siguiente arreglo de números:
[1, 5, 8, 3, 30, 9, 13]
Imprimir en pantalla programáticamente los números impares mayores a 3.

A = [1, 5, 8, 3, 30, 9, 13]

 B = []
for i in A:
if i>3 and i%2!=0:
B.append(i)
print B

Ver solución en Codeskulptor

Ejercicio 4
Dada las siguientes notas almacenadas en un arreglo:
[20, 15, 12, 11, 8, 4, 1]
Elimine la nota más baja programáticamente sin usar la función (min) y escriba en
pantalla. Luego programáticamente calcule el promedio de notas descontando la nota
eliminada.

A = [20, 15, 12, 11, 8, 4, 1]

maxi = 20
mini = maxi
for i in A:
if i<mini:
mini=i
print u"El promedio más bajo es:",mini
A.remove(mini)
print A
suma = 0
for j in A:
suma+=j
print suma
print suma/len(A)

a = ["a1","a2","a3"]

b = ["b1","b2"]

c = a+b

print (c)

Listas en Python
25 julio, 2017

Declaración de lista
lista = list()

lista = []

lista = [1, 2, 3, 4]

lista = [1, 2, 'Hola', [3, 4]]

Visualizar los elementos de una lista
print(lista[0])
# 1
for i in range(len(lista)):
print(lista[i])
# 1
# 2
# Hola
# [3, 4]

Añadir elementos a una lista

lista.append(5)
print(lista)
# [1, 2, 'Hola', [3, 4], 5]
lista.append([6,7])
print(lista)
# [1, 2, 'Hola', [3, 4], 5, [6, 7]]
lista.extend([8,8,8])
print(lista)
# [1, 2, 'Hola', [3, 4], 5, [6, 7], 8, 8, 8]

Borrar elementos de una lista

lista.remove(2)
print(lista)
# [1, 'Hola', [3, 4], 5, [6, 7], 8, 8, 8]

Contar número de apariciones de un elemento

n = lista.count(8)
print(n)
# 3

Determinar la posición en la que se encuentra un

elemento en la lista
n = lista.index(1)
print(n)
# 1
n = lista.index('Hola')
print(n)
# 1

Devolver la lista al revés

lista.reverse()
print(lista)
# [8, 8, 8, [6, 7], 5, [3, 4], 'Hola', 1]
Añadir valores nulos a la lista
lista.append(float('NaN'))
print(lista)

Eliminar valores nulos de lista simple

import numpy
lista = ['A', 'B', numpy.nan, 'D']
lista = [x for x in lista if str(x) != 'nan']
print(lista)
# ['A', 'B', 'D']

Eliminar duplicados
lista = ['A','B','C','D','A','A']
lista = set(lista)
print(sorted(lista)) # Es necesario ordenarlo ya que lo descolora
# ['A', 'B', 'C', 'D']

Reemplazar partes de string en una lista

lista = ['pececin','pececillo','pececilla']
lista = [words.replace('pece', 'salmon') for words in lista]
print(lista)

# ['salmoncin', 'salmoncillo', 'salmoncilla']

Eliminar espacios delante y detrás las palabras

lista = ['pececin ',' pececillo ',' pececilla']
lista = [words.split() for words in lista]
print(lista)

# [['pececin'], ['pececillo'], ['pececilla']]

Eliminar espacios demás entre palabras

lista = ['pececin primero',' pececillo segundo',' pececilla
tercera']
lista = [words.replace(' ', ' ') for words in lista]
lista = [words.replace(' ', ' ') for words in lista]
print(lista)

# ['pececin primero', ' pececillo segundo', ' pececilla tercera']

Dividir dos listas elemento por elemento

a = [10,20,30,40,50,60,70,80,90]
b = [10,20,30,40,50,60,70,80,90]
c = [x/y for x, y in zip(a, b)]
print(c)

# [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]

Calcular media una parte del array

import numpy as np

l = np.array([1, 2, 3, 4])

print( l[l>2] )
print( np.mean(l[l>2]) )

Python: Uso de input y raw_input

Posted by artgoce

17

11 Votes

Ambas funciones son validas a la hora de crear una sentencia que solicite datos, pero
¿Que diferencia tienen?.

La función input está destinada a la entrada de cualquier caracter, siempre y cuando este
mismo sea notificado como es. Es decir, si ingresamos números, simplemente sera así lo
que nos dirá Python:

valor = input (“Ingrese cantidad: “)

print “Usted ingreso: ” +
valor + “!”

>>> Ingrese cantidad: 40

>>> Usted
ingreso: “40”!

¿Que pasaría si ingresamos un String?

nombre = input (“¿Cual es tu nombre? “)
print “Hola, ” +
nombre+ “!”

>>> ¿Cual es tu nombre? Arturo

Traceball (most
recent calls last):
File “C:\python\prueba.py”, line 2,
in?

Este error se debe a que Python supone que el ingreso sera un String y requiere que sea
definido. Para solucionarlo bastaría con adicionar lo siguiente:

>>> ¿Cual es tu nombre? “Arturo”

>>> Hola, Arturo

Aunque el problema está solucionado, dudo que el usuario final ingrese su nombre de
esa manera.
¿Entonces que hacemos?. Recurrimos a la función raw_input, esta función hará que
Python
almacene lo que sea dentro de un String.

nombre = raw_input (“¿Cual es tu nombre? “)

print “Hola, ” +
nombre+ “!”

>>> ¿Cual es tu nombre? Arturo

>>> Hola,
Arturo!

valor = raw_input (“Ingrese cantidad: “)

print “Usted ingreso: ” + valor + “!”

>>> Ingrese cantidad: 40

>>> Usted ingreso: 40!

from numpy.random import random

a=random((5, 2))

print (a)

Arreglos bidimensionales
Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo
bidimensional está simultáneamente en una fila y en una columna.

En matemáticas, a los arreglos bidimensionales se les llama matrices, y son muy

utilizados en problemas de Ingeniería.

En un arreglo bidimensional, cada elemento tiene una posición que se identifica

mediante dos índices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales también son provistos por NumPy, por lo que debemos
comenzar importando las funciones de este módulo:

from numpy import *

Al igual que los arreglos de una dimensión, los arreglos bidimensionales también
pueden ser creados usando la función array, pero pasando como argumentos una lista
con las filas de la matriz:

a = array([[5.1, 7.4, 3.2, 9.9],

[1.9, 6.8, 4.1, 2.3],
[2.9, 6.4, 4.3, 1.4]])

Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:

>>> array([[1], [2, 3]])

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.

Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaños de
cada dimensión. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres filas y
cuatro columnas:

>>> a.shape
(3, 4)

Los arreglos también tienen otro atributo llamado size que indica cuántos elementos
tiene el arreglo:

>>> a.size
12

Por supuesto, el valor de a.size siempre es el producto de los elementos de a.shape.

Hay que tener cuidado con la función len, ya que no retorna el tamaño del arreglo, sino
su cantidad de filas:

>>> len(a)
3
Las funciones zeros y ones también sirven para crear arreglos bidimensionales. En vez
de pasarles como argumento un entero, hay que entregarles una tupla con las cantidades
de filas y columnas que tendrá la matriz:

>>> zeros((3, 2))

array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])

>>> ones((2, 5))

array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])

Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplom la
función random:

>>> from numpy.random import random

>>> random((5, 2))
array([[ 0.80177393, 0.46951148],
[ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])

Operaciones con arreglos bidimensionales

Al igual que los arreglos de una dimensión, las operaciones sobre las matrices se aplican
término a término:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[2, 3, -1],
... [1, 0, 1]])

>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])

>>> a ** b
array([[25, 1, 0],
[ 0, 1, 2]])

Cuando dos matrices aparecen en una operación, ambas deben tener exactamente la
misma forma:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[ 2, 3],
... [-1, 1],
... [ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single
shape
Obtener elementos de un arreglo bidimensional
Para obtener un elemento de un arreglo, debe indicarse los índices de su fila i y su
columna j mediante la sintaxis a[i, j]:

>>> a = array([[ 3.21, 5.33, 4.67, 6.41],

[ 9.54, 0.30, 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76],
[ 8.72, 1.47, 0.77, 8.78]])
>>> a[1, 2]
2.14

>>> a[4, 3]
8.78

>>> a[-1, -1]

8.78

>>> a[0, -1]

6.41

También se puede obtener secciones rectangulares del arreglo usando el operador de

rebanado con los índices:

>>> a[2:3, 1:4]

array([[ 0.54, 0.71, 2.56]])

>>> a[1:4, 0:4]

array([[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76]])

>>> a[1:3, 2]
array([ 2.14, 0.71])

>>> a[0:4:2, 3:0:-1]

array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71, 0.54]])

>>> a[::4, ::3]

array([[ 3.21, 6.41],
[ 8.72, 8.78]])

Para obtener una fila completa, hay que indicar el índice de la fila, y poner : en el de las
columnas (significa «desde el principio hasta el final»). Lo mismo para las columnas:

>>> a[2, :]
array([ 5.62, 0.54, 0.71, 2.56])

>>> a[:, 3]
array([ 6.41, 6.57, 2.56, 8.76, 8.78])

Note que el número de dimensiones es igual a la cantidad de rebanados que hay en los
índices:

>>> a[2, 3] # valor escalar (arreglo de cero dimensiones)

2.56

>>> a[2:3, 3] # arreglo de una dimensión de 1 elemento

array([ 2.56])

>>> a[2:3, 3:4] # arreglo de dos dimensiones de 1 x 1

array([[ 2.56]])

Otras operaciones
La trasposicion consiste en cambiar las filas por las columnas y viceversa. Para
trasponer un arreglo, se usa el método transpose:

>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])

>>> a.transpose()
array([[ 3.21, 9.54, 5.62],
[ 5.33, 0.3 , 0.54],
[ 4.67, 2.14, 0.71],
[ 6.41, 6.57, 2.56]])

El método reshape entrega un arreglo que tiene los mismos elementos pero otra forma.
El parámetro de reshape es una tupla indicando la nueva forma del arreglo:

>>> a = arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

>>> a.reshape((4, 3))

array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])

>>> a.reshape((2, 6))

array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])

La función diag aplicada a un arreglo bidimensional entrega la diagonal principal de la

matriz (es decir, todos los elementos de la forma a[i, i]):

>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])

>>> diag(a)
array([ 3.21, 0.3 , 0.71])

Además, diag recibe un segundo parámetro opcional para indicar otra diagonal que se
desee obtener. Las diagonales sobre la principal son positivas, y las que están bajo son
negativas:
>>> diag(a, 2)
array([ 4.67, 6.57])
>>> diag(a, -1)
array([ 9.54, 0.54])

La misma función diag también cumple el rol inverso: al recibir un arreglo de una
dimensión, retorna un arreglo bidimensional que tiene los elementos del parámetro en la
diagonal:

>>> diag(arange(5))
array([[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 2, 0, 0],
[0, 0, 0, 3, 0],
[0, 0, 0, 0, 4]])

Reducciones por fila y por columna

Algunas operaciones pueden aplicarse tanto al arreglo completo como a todas las filas o
a todas las columnas.

Por ejemplo, a.sum() entrega la suma de todos los elementos del arreglo. Además, se le
puede pasar un parámetro para hacer que la operación se haga por filas o por columnas:

>>> a = array([[ 4.3, 2.9, 9.1, 0.1, 2. ],

... [ 8. , 4.5, 6.4, 6. , 4.3],
... [ 7.8, 3.1, 3.4, 7.8, 8.4],
... [ 1.2, 1.5, 9. , 6.3, 6.8],
... [ 7.6, 9.2, 3.3, 0.9, 8.6],
... [ 5.3, 6.7, 4.6, 5.3, 1.2],
... [ 4.6, 9.1, 1.5, 3. , 0.6]])
>>> a.sum()
174.4
>>> a.sum(0)
array([ 38.8, 37. , 37.3, 29.4, 31.9])
>>> a.sum(1)
array([ 18.4, 29.2, 30.5, 24.8, 29.6, 23.1, 18.8])

El parámetro indica a lo largo de qué dimensión se hará la suma. El 0 significa «sumar a

lo largo de las filas». Pero hay que tener cuidado, ¡por que lo que se obtiene son las
sumas de las columnas! Del mismo modo, 1 significa «a lo largo de las columnas, y lo
que se obtiene es el arreglo con las sumas de cada fila.

Las operaciones a.min() y a.max() funcionan del mismo modo:

>>> a.min()
0.1
>>> a.min(0)
array([ 1.2, 1.5, 1.5, 0.1, 0.6])
>>> a.min(1)
array([ 0.1, 4.3, 3.1, 1.2, 0.9, 1.2, 0.6])

a.argmin() y a.argmax() también:

>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])

.---------------------

Resolución de sistemas lineales

Repasemos el producto matriz-vector:

Esta operación tiene dos operandos: una matriz y un vector. El resultado es un vector. A
los operandos los denominaremos respectivamente A y x, y al resultado, b.

Un problema recurrente en Ingeniería consiste en obtener cuál es el vector x cuando A y

b son dados:

La ecuación matricial Ax=b

es una manera abreviada de expresar un sistema de ecuaciones lineales. Por ejemplo, la

ecuación del diagrama es equivalente al siguiente sistema de tres ecuaciones que tiene
las tres incógnitas w, y y z

36w+51y+13z52w+34y+74z7y+1.1z=3=45=33
En matemáticas, este sistema se representa matricialmente así:

⎡⎣⎢36525134713741.1⎤⎦⎥⎡⎣⎢wyz⎤⎦⎥=⎡⎣⎢34533⎤⎦⎥
La teoría detrás de la resolución de problemas de este tipo usted la aprenderá en sus
ramos de matemáticas. Sin embargo, como este tipo de problemas aparece a menudo en
la práctica, aprenderemos cómo obtener rápidamente la solución usando Python.

Dentro de los varios módulos incluídos en NumPy (por ejemplo, ya vimos

numpy.random), está el módulo numpy.linalg, que provee algunas funciones que
implementan algoritmos de álgebra lineal, que es la rama de las matemáticas que estudia
los problemas de este tipo. En este módulo está la función solve, que entrega la
solución x de un sistema a partir de la matriz A y el vector b:

>>> a = array([[ 36. , 51. , 13. ],

... [ 52. , 34. , 74. ],
... [ 0. , 7. , 1.1]])
>>> b = array([ 3., 45., 33.])
>>> x = solve(a, b)
>>> x
array([-7.10829222, 4.13213834, 3.70457422])

Podemos ver que el vector x en efecto satisface la ecuación Ax = b:

>>> dot(a, x)
array([ 3., 45., 33.])
>>> b
array([ 3., 45., 33.])

Sin embargo, es importante tener en cuenta que los valores de tipo real casi nunca están
representados de manera exacta en el computador, y que el resultado de un algoritmo
que involucra muchas operaciones puede sufrir de algunos errores de redondeo. Por esto
mismo, puede ocurrir que aunque los resultados se vean iguales en la consola, los datos
obtenidos son sólo aproximaciones y no exactamente los mismos valores:

>>> (dot(a, x) == b).all()

False