Clase_1_Syntaxis_Basica

Vista previa del material en texto

Algoritmos	y	Estructuras	de	Datos.
-	Clase	1	-	Parte	1	-	Syntaxis	Basica	de	Python	-
Cuerpo	Docente
Profesor:	Dr.	Diego	Agustín	Ambrossio.
Jefe	de	Trabajos	Practicos:	Anl.	Sis.	Angel	Leonardo	Bianco.
Día/Horario	:
Teoria:	Martes	19h00	-	23h00.
Practica:	Jueves	17h00	-	19h00.
Material	adaptado	de	la	cátedra	"Introduction	to	Programming"	de	la	Université	du	Luxembourg.
Gracias	a	mis	estimados	colegas	Dr.	Giovanni	Casini	(ISTI-CNR)	y	Dr.	Xavier	Parent	(TU	Wien)!!
Resumen:
Estudiaremos	distintas	estructuras	de	datos	y	cómo	programar	algoritmos	para	hacer	uso	eficientes	de	ellas.	Utilizando	el	lenguaje	de
programación	Python,	haremos	foco	en	la	programación	procedural,	introduciendo	algunos	conceptos	de	la	progrmación	Orientada	a
Objetos.	Finalmente,	cómo	optimizar	algunos	typos	de	algoritmos	particulares.
Algunos	de	los	temas	a	estudiar:
Estructuras	de	Datos.
Recursividad.
Objetos	en	Python.
Algoritmos	de	Ordenamiento	y	Busqueda.
Archivos.
Complejidad	Computacional.
Nociones	de	Computabilidad,	Verificación	y	Validación.
El	material	de	la	cáterda	y	todos	los	recursos	necesarios	estarán	disponibles	en	el	Campus	Virtual.
Evaluación
General
2	Examenes	Parciales
Ejercicios	de	entrega	obligatoria.
Trabajos	Grupales.
Aprobación:
Entrega	de	los	ejercicios	obligatorios	/	Trabajos	Grupales.
Calificación	de	4	(cuatro)	o	más,	en	los	examenes	parciales.
Promoción
Calificación	de	6	o	más	en	cada	examen	parcial	y	un	promedio	general	superior	a	7.
	
	
Operaciones	Simples	en	Python
Operaciones	Aritmenticas
8
2	+	6	#	Suma
2	-	19	#	Resta
-17
54
16.5
16
5
9
Operaciones	Lógicas
Las	operaciones	lógicas	nos	devulven	un	"Valor	de	Verdad"	como	resultado.
Verdadero	 ⇒
⇒
	True	
	True	
Falso	 ⇒
⇒
	False	
	False	
False
True
False
True
El	operador	"or
or
"	(cómo	muchas	de	las	funciones	en	Python)	esta	optimizado.	Es	decir,	es	"lazy"	(peresozo),	si	queremos	evaluar	la	expresión	P1
1
or
or
P2
2
y	P1
1
es	verdadera,	entonces	P1
1
or
or
P2
2
tiene	como	resultado	final	"verdadero"	(True
True
)	aun	antes	de	evaluar	P2
2	-	19	#	Resta
2	*	27	#	Multiplicación
165	/	10	#	Divición.
165	//	10	#	Cociente	de	la	divición	Euclidiana	(parte	entera)
165	%	10	#	Resto	de	la	divición	Euclidiana.
3	**	2	#	Potencia
1	==	2	#	Igualdad
1	!=	2	#	Desigualdad
1	<	2	#	menor	
1	>	2	#	mayor
1	<=	2	#	menor	o	igual	
1	>=	2	#	mayor	o	igual	
not(True)	#	El	operador	lógico	de	"NEGACIÓN"	
True	and	False	#	El	operador	lógico	"Y"
True	or	False	#	El	operador	lógico	"O"
2
.
---------------------------------------------------------------------------
NameError																																	Traceback	(most	recent	call	last)
Cell	In[13],	line	4
						1	#	No	tiene	sentido,	la	varialbe	'var'	no	esta	definida.
						2	#	Ejecutar	esta	linea	nos	generara	un	error.
---->	4	var	==	True	#	
NameError:	name	'var'	is	not	defined
True
---------------------------------------------------------------------------
NameError																																	Traceback	(most	recent	call	last)
Cell	In[15],	line	4
						1	#	En	el	siguiente	caso	var==True	nos	genera	un	error,
						2	#	y	el	programa	finaliza.	
---->	4	var	==	True	or	1	==	1	
NameError:	name	'var'	is	not	defined
Estructura	de	un	algoritmo	en	Pythom
Asignaciones
Sentencias
Decisión
Repeticiones
Iteraciones
Assignación	y	tipos	de	variales	en	Python.
Como	en	cualquier	otro	lenguaje	de	programación,	podemos	asignar	valores	a	un	"nombre	de	variable".	Un	nombre	de	variable,	es	un
identificador	alphanumerico	el	cual	esta	asociado	a	un	espacio	de	memoria.
En	Python	utilizamos	el	symbolo	=.	(en	contraste	con	el	operador	==).
Cada	valor	que	le	asignamos	a	una	variable,	tiene	asignado	un	tipo,	el	cual	definira	el	tipo	de	la	variable	a	cual	el	valor	es	asignado.	Es
decir,	en	Python	el	tipo	de	una	variable	es	asignado	dinamicamente	durante	la	ejecución	del	programa,	dependiendo	del	valor	contenido.
Nota:	la	función	print	nos	permite	escribir	en	la	pantalla/consola.
#	No	tiene	sentido,	la	varialbe	'var'	no	esta	definida.
#	Ejecutar	esta	linea	nos	generara	un	error.
var	==	True	#	
#	En	el	siguiente	caso	1	==	1	es	verdadero,	
#	el	operador	'or'	no	evaluara	la	parte	var==True
#	(no	nos	aparece	el	error)	
1	==	1	or	var	==	True
#	En	el	siguiente	caso	var==True	nos	genera	un	error,
#	y	el	programa	finaliza.	
	
var	==	True	or	1	==	1	
n_entero	=	5																												#	Un	número	entero		
n_con_comma	=	0.3																							#	Un	número	de	punto	flotante
v_bool	=	True																											#	Un	valor	Booleano,	verdadero	o	falso	(True	o	False	respectivamente)
cad_de_caract	=	'cadena	de	caracteres'		#	Una	cadena	de	caracteres	(string),	una	palabra	o	frase	entre	"	"	o	'	'.
complejo=	1	+	1j																								#	Un	número	complejo	(escribimos	j,	en	vez	del	tradicional	i,	para	la	parte	imaginaria)	
print(type(n_entero))									#	es	del	tipo	int'
print(type(n_con_comma))						#	es	del	tipo	'float'
print(type(v_bool))											#	es	del	tipo	'bool'
print(type(cad_de_caract))				#	es	del	tipo	'str'
print(type(complejo))									#	es	del	tipo	'complex'
<class	'int'>
<class	'float'>
<class	'bool'>
<class	'str'>
<class	'complex'>
El	symbolo	de	igualdad--que	utilizamos	para	realizar	asignaciones--no	es	un	operador	symetrico.
Es	decir	v1 = v2	no	es	lo	mismo	que	v2 = v1.
v1=		3
v2=		3
v1=		2
v2=		2
Los	operadores	+=,	-=,	*=,	etc.	nos	permiten	realizar	operaciones	sobre	una	variable	sin	tener	que	nombrarla	dos	veces.
4
8
2	3
v1=		3
v2=		150
Tipos	de	Variable
El	*tipo*	de	una	variable	es	importante.	Siempre	debemos	recordar	cuales	son	los	tipos	de	las	variables	que	hemos	definido,	ya	que
Python	no	provee	ninguna	forma	de	fijar	el	tipo	de	una	variable.
Python	nos	provee	funciones	para	cambiar	el	tipo	de	una	variable.	Si	queremos	cambiar	el	tipo	de	la	variable	v	al	tipo	ftype,	utilizamos
el	siguiente	comando	v = ftype(v).
El	resultado	dependera	del	tipo	de	la	variable	que	queremos	transformar,	e.g.	si	convertimos	una	variable	de	punto	flotatante	a	un	entero
v1	=	2
v2	=	3
v1	=	v2												#	v1	toma	el	valor	de	v2
print("v1=	",v1)
print("v2=	",v2)
v1	=	2
v2	=	3
v2	=	v1												#	v2	toma	el	valor	de	v1
print("v1=	",v1)
print("v2=	",v2)
v1	=	1
v1	+=	3	#	Incrementamos	sobre	v1.	Es	equivalente	a	escribir		"v1	=	v1	+	3"
								#	Este	metodo	es	mas	eficiente	y	facil	de	escribir.
print(v1)
v1	*=	2	#	También	funciona	con	*=
print(v1)	
#	Asignación	Multiple.	El	orden	de	los	parametros	es	importante!
v1,	v2	=	2,	3			
#EQUIVALENTE:
#v1	=	2		
#v2	=	3
print	(v1,v2)
v1	=	150
v2	=	3
#	Python	nos	permite	intercambiar	los	valores	de	las	variables	fácilmente
#	mediante	el	uso	de	asignación	multiple
v1	,	v2		=	v2	,	v1		
#EQUIVALENTE:
#	v3	=	v1
#	v1	=	v2
#	v2	=	v3
print("v1=	",v1)
print("v2=	",v2)
utilizando	la	función	 int() ,	solo	obtendremos	la	parte	entera	de	la	variable.
5
5.0
0.3
0
(5+0j)
Algunos	nombre	de	variables	estan	protegidos.	Es	decir,	no	podemos	usarlos	como	nombres	de	variables	y	asginarles	un	valor.
Por	Ejemplo:
		Cell	In[24],	line	1
				True	=	3		#	True	es	un	nombre	protegido,	por	lo	cual	se	generara	un	error.
				^
SyntaxError:	cannot	assign	to	True
Sólo	algunos	nombres	(o	palabras)	están	protegidos	en	Python,	debemos	tener	cuidado.	Las	"reglas	basicas"	para	nombrar	variables
para	nombrar	variables,	son	dependientes	del	lenguaje	y	del	estilo	de	programación.	Aquí	mencionamos	algunas	reglas	basicas:
asegurarse	de	no	repetir	nombres.
solo	usar	un	caracter	para	las	variable	que	no	son	importantes.
usar	nombres	especificos	para	las	variables	que	son	importantes.
no	usar	nombre	se	variables	muy	largos.
Finalmente,	ejecutando	el	código	a	continuación,	podemos	ver	la	lista	de	nombres	protegidos	de	Python	y	la	lista	de	funciones	pre-
definidas	en	Python.
False	-	None	-	True	-	and	-	as	-	assert	-	async	-	await	-	break	-	class	-	continue	-	def	-	del	-	elif	-	else	-	e
xcept	-	finally	-	for	-	from	-	global	-	if	-	import	-	in	-	is	-	lambda	-	nonlocal	-	not	-	or	-	pass	-	raise	-	re
turn	-	try	-	while	-	with	-	yield	-	
ArithmeticError	-	AssertionError-	AttributeError	-	BaseException	-	BaseExceptionGroup	-	BlockingIOError	-	Broke
nPipeError	-	BufferError	-	BytesWarning	-	ChildProcessError	-	ConnectionAbortedError	-	ConnectionError	-	Connect
ionRefusedError	-	ConnectionResetError	-	DeprecationWarning	-	EOFError	-	Ellipsis	-	EncodingWarning	-	Environmen
tError	-	Exception	-	ExceptionGroup	-	False	-	FileExistsError	-	FileNotFoundError	-	FloatingPointError	-	FutureW
arning	-	GeneratorExit	-	IOError	-	ImportError	-	ImportWarning	-	IndentationError	-	IndexError	-	InterruptedErro
r	-	IsADirectoryError	-	KeyError	-	KeyboardInterrupt	-	LookupError	-	MemoryError	-	ModuleNotFoundError	-	NameErr
or	-	None	-	NotADirectoryError	-	NotImplemented	-	NotImplementedError	-	OSError	-	OverflowError	-	PendingDepreca
tionWarning	-	PermissionError	-	ProcessLookupError	-	RecursionError	-	ReferenceError	-	ResourceWarning	-	Runtime
Error	-	RuntimeWarning	-	StopAsyncIteration	-	StopIteration	-	SyntaxError	-	SyntaxWarning	-	SystemError	-	System
Exit	-	TabError	-	TimeoutError	-	True	-	TypeError	-	UnboundLocalError	-	UnicodeDecodeError	-	UnicodeEncodeError	
-	UnicodeError	-	UnicodeTranslateError	-	UnicodeWarning	-	UserWarning	-	ValueError	-	Warning	-	WindowsError	-	Ze
roDivisionError	-	__IPYTHON__	-	__build_class__	-	__debug__	-	__doc__	-	__import__	-	__loader__	-	__name__	-	__p
ackage__	-	__spec__	-	abs	-	aiter	-	all	-	anext	-	any	-	ascii	-	bin	-	bool	-	breakpoint	-	bytearray	-	bytes	-	ca
llable	-	chr	-	classmethod	-	compile	-	complex	-	copyright	-	credits	-	delattr	-	dict	-	dir	-	display	-	divmod	-	
enumerate	-	eval	-	exec	-	execfile	-	filter	-	float	-	format	-	frozenset	-	get_ipython	-	getattr	-	globals	-	has
attr	-	hash	-	help	-	hex	-	id	-	input	-	int	-	isinstance	-	issubclass	-	iter	-	len	-	license	-	list	-	locals	-	m
ap	-	max	-	memoryview	-	min	-	next	-	object	-	oct	-	open	-	ord	-	pow	-	print	-	property	-	range	-	repr	-	reverse
d	-	round	-	runfile	-	set	-	setattr	-	slice	-	sorted	-	staticmethod	-	str	-	sum	-	super	-	tuple	-	type	-	vars	-	
zip	-	
Algunas	reglas	para	escribir	Sentencias	en	Python.
Todos	los	lenguajes	de	programación	requieren	de	un	gramatica	estricta.	En	general,	cuando	comentemos	un	error,	directamente
obtendremos	un	mensaje	de	error,	en	muy	pocos	casos,	el	programa	continuara	y	generalmente	generando	"peores"	errores.	Debemos
recordar	que	la	gramatica	de	Python	forzada	para	mejorar	la	legibilidad	del	codigo	fuente.
En	Python	la	ejecución	de	un	archivo	.py	ejecutara	cada	linea	del	archivo,	una	luego	de	la	otra.
print(n_entero)											#	n_entero	=	5
print(float(n_entero))
print(n_con_comma)								#	n_con_comma	=	0.3
print(int(n_con_comma))
print(complex(n_entero))
True	=	3		#	True	es	un	nombre	protegido,	por	lo	cual	se	generara	un	error.
import	keyword
for	x	in	keyword.kwlist:
				print(x,end="	-	")#Esta	es	la	lista	de	nombres	(o	palabras)	protegidas.
print()
print()
import	builtins
for	x	in		dir(builtins):	#Funciones	provistas	por	Python	(built-in	functions).		
				print	(x,	end=	"	-	")
Regla	1.	Como	ya	hemos	visto,	para	terminar	una	linea	de	instrucciones	(comandos)	debemos	pasar	a	la	linea	siguiente,	i.e.	Python
utiliza	el	salto	de	linea	(otros	lenguajes	terminan	los	comandos	utilizando	symbolos	como	';',	':',	':',	etc...)	El	salto	de	linea	tiene	un
significado	especial	en	Python.	Por	ello,	es	imposible	escribir	dos	comandos	en	la	misma	linea.
		Cell	In[26],	line	1
				a=3		b=2	#Error
									^
SyntaxError:	invalid	syntax
En	el	siguiente	ejemplo,	escribimos	una	linea	de	codigo	correcta.	Sin	embargo,	es	muy	larga	y	dificulta	la	correcta	lectura	del	programa.
Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt	ut	labore	et	dolore	ma
gna	aliqua.	Ut	enim	ad	minim	veniam,	quis	nostrud	exercitation	ullamco	laboris	nisi	ut	aliquip	ex	ea	commodo	con
sequat.	Duis	aute	irure	dolor	in	reprehenderit	in	voluptate	velit	esse	cillum	dolore	eu	fugiat	nulla	pariatur.	E
xcepteur	sint	occaecat	cupidatat	non	proident,	sunt	in	culpa	qui	officia	deserunt	mollit	anim	id	est	laborum.
La	solución	inmediata	seria	pasar	a	la	siguiente	linea.	Pero	como	los	saltos	de	linea	tienen	un	significado	estructural,	el	interprete
entiende	la	primer	linea	de	comandos	como	incompleta	generando	un	error.
		Cell	In[29],	line	1
				print('Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt
										^
SyntaxError:	unterminated	string	literal	(detected	at	line	1)
Regla	2.	La	forma	que	nos	provee	Python	para	lidear	con	esto,	es	omitir	el	salto	de	linea	añadiendo	la	barra	''	antes	del	salto	de	linea.
Debemos	tener	en	cuenta,	que	al	utilizar	la	barra,	todo	lo	que	este	despues	de	ella	no	será	considerado	(como	si	estuviera	comentado,
ver	siguiente).
Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt	ut	labore	et	doloremag
na	aliqua.	Ut	enim	ad	minim	veniam,	quis	nostrud	exercitation	ullamco	laboris	nisi	ut	aliquip	ex	ea	commodo	cons
equat.	Duis	aute	irure	dolor	in	reprehenderitin	voluptate	velit	esse	cillum	dolore	eu	fugiat	nulla	pariatur.	Exc
epteur	sint	occaecat	cupidatat	non	proident,sunt	in	culpa	qui	officia	deserunt	mollit	anim	id	est	laborum.
Regla	3.	Para	añadir	comentarios	en	el	codigo	fuente	(mejora	la	legibilidad	del	programa)	utilizamos	el	symbolo	numeral	'#'.	Neutraliza
todo	lo	que	este	escrito	hasta	el	salto	de	linea.	Python	no	provee	ninguna	facilidad	para	escribir	comentarios	largos,	debemos	escribir	el
symbolo	numeral	en	cada	linea	donde	se	extiende	el	comentario.	Una	buena	practica	para	mejorar	la	legibilidad	de	los	comentarios
largos,	es	no	escribir	codigo	referido	al	comentario	durante	la	extensión	del	mismo.
Regla	4.	Python	es	un	lenguaje	de	programación	indentado.	Esto	significa	que	todas	las	lineas	con	comandos	comienzan	en	el	mismo
lugar	tienen	el	mismo	'status'	dentro	de	la	lógica	del	programa.	En	otras	palabras,	todos	los	espacios	al	comienzo	de	una	linea	tienen	un
significado	(excepto	cuando	usamos	comentarios	'#'	).
5
a=3		b=2	#Error
a=3
b=2
a,b	=	3,2
print('Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt	ut	labore	et	dolore	magna	aliqua.	Ut	enim	ad	minim	veniam,	quis	nostrud	exercitation	ullamco	laboris	nisi	ut	aliquip	ex	ea	commodo	consequat.	Duis	aute	irure	dolor	in	reprehenderit	in	voluptate	velit	esse	cillum	dolore	eu	fugiat	nulla	pariatur.	Excepteur	sint	occaecat	cupidatat	non	proident,	sunt	in	culpa	qui	officia	deserunt	mollit	anim	id	est	laborum.'
print('Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt
					ut	labore	et	dolore	magna	aliqua.	Ut	enim	ad	minim	veniam,	quis	nostrud	exercitation	ullamco
						laboris	nisi	ut	aliquip	ex	ea	commodo	consequat.	Duis	aute	irure	dolor	in	reprehenderit
						in	voluptate	velit	esse	cillum	dolore	eu	fugiat	nulla	pariatur.	Excepteur	sint	occaecat
						cupidatat	non	proident,	sunt	in	culpa	qui	officia	deserunt	mollit	anim	id	est	laborum.')
print('Lorem	ipsum	dolor	sit	amet,	consectetur	adipiscing	elit,	sed	do	eiusmod	tempor	incididunt	ut	labore	et	dolore
magna	aliqua.	Ut	enim	ad	minim	veniam,\
	quis	nostrud	exercitation	ullamco	\
laboris	nisi	ut	aliquip	ex	ea	commodo	consequat.	Duis	aute	irure	dolor	in	reprehenderit\
in	voluptate	velit	esse	cillum	dolore	eu	fugiat	nulla	pariatur.	\
Excepteur	sint	occaecat	cupidatat	non	proident,\
sunt	in	culpa	qui	officia	deserunt	mollit	anim	id	est	laborum.')
a=1	#	Asignamos	1	a	la	variable	a
a=1	#	Re-asignamos	el	valor	de	a,	podriamos		
				#	seguir	escribiendo	la	finalidad	de
				#	esta	re-asignación,	o	continuar		
				#	ecribiendo	sobre	la	instrucción	a=1.
				
a=1	#	Nuevo	Comentario.
2+3	#	Funciona	sin	problemas	
					3+2	#	Funciona	sin	problemas
5
		Cell	In[34],	line	2
				3+2	#	Aquí	la	primera	y	segunda	linea	deben
				^
IndentationError:	unexpected	indent
Decisión	-	Condición
Para	utilizar	las	instrucciones	condicionales,	debemos	usar	los	dos	puntos	':'.	La	diferentes	palabras	reservadas	de	la	instrucción
condicional	son:	if,	elif	y	else.
Problem
Problemn	positivo
		Cell	In[38],	line	3
				else:	#"if",	"elif",	y	"else"	deben	tener	la	misma	indentación.
				^
SyntaxError:	invalid	syntax
2+3	
	3+2	#	Aquí	la	primera	y	segunda	linea	deben	
					#	tener	la	misma	indentación,	porque	no	hay	cambio	
					#	en	el	flujo	del	programa	como:	
					#	ciclos,	condicionales,	definiciones,	etc	...	
if		0	==	0:
				print('Problem')
else:	
				print('No	Problem')
#	Version	de	una	linea.
print('Problem')	if		0	==	0	else	print('No	Problem')
#Ejemplo:	
n	=	int(input("ingrese	un	numero:	"))
if	n	>	0:	#	Si	0	==	1,	entonces:
				print('n	positivo')#	No	olvidarse	de	la	indentación		0	==	1	Verdadero
																#	En	algunos	IDE	la	indentación	es	automatica.
elif	n	==	0	:
				print("n	es	cero")
else:
				print('n	negativo')		#	0	==	1	Falso
				
if	0==1:
				print('Problem')
				else:	#"if",	"elif",	y	"else"	deben	tener	la	misma	indentación.	
				print('No	Problem')
if	0==1:
				print('Problem')
				
				else:																		#	Error	de	Indentacion
								print('No	Problem')
#	Un	ejemplo	de	como	usar	multiples	instrucciones	if.
n	=	int(input("Ingrese	un	número		:		"))		#	Ingresamos	el	número	n
if	n%7==0:					#	El	mismo	nivel	de	indentación	para	el	"if",	"elif",	y	"else".
				print(n,	"el	residuo	es	0	modulo	7")
elif	n%7==1:	
				print(n,	"el	residuo	es	1	modulo	7")
elif	n%7==2:
				print(n,	"el	residuo	es	2	modulo	7")
elif	n%7==3:
				print(n,	"el	residuo	es	3	modulo	7")
elif	n%7==4:
				print(n,	"el	residuo	es	4	modulo	7")
elif	n%7==5:
				print(n,	"el	residuo	es	5	modulo	7")
else:
				print(n,	"el	residuo	es	6	modulo	7")
#	Manera	más	corta	de	obtener	el	mismo	resultado.
n=int(input("Ingrese	un	número	:	"))
print(n,"	is	congruent	to	",n%7,"modulo	7")
7	el	residuo	es	0	modulo	7
14		is	congruent	to		0	modulo	7
No	es	primo,		24		es	divisible	por	2.
No	es	primo,		12		es	divisible	por	2.
	es	divisible	por	3.
Ejercicio:
#	Ejemplo	de	instrucciones	condicionales	anidadas.			
n	=	int(input("Ingresar	un	número	entre	8	y	49	para	testear	si	es	un	número	primo	:	"))
isprime=True
if	n<7	and	n	>	49:
				print("Impossible!	el	número	no	esta	entre	8	y	49.")
#elif	n>49:
#				print("Impossible!	el	número	es	demaciado	grande.")
else:
				if	2*(n//2)	==	n:	#	n	=	15	;	n//2	=	7	;		7	*	2	=	14
								print("No	es	primo,	",	n,"	es	divisible	por	2.")	#	Tenemos	tres	niveles	de	indentación.	
								isprime=False
				elif	3*(n//3)==n:
								print("Not	es	primo,	",	n,"	es	divisible	por	3.")
								isprime=False
				elif	5*(n//5)==n:
								print("Not	es	primo,	",	n,"	es	divisible	por	5.")
								isprime=False
				elif	7*(n//7)==n:
								print("Not	es	primo,	",n,"	es	divisible	por	7.")
								isprime=False
				else:
								print(n,"	es	primo.")
n	=	int(input("Ingresar	un	número	entre	8	y	49	para	testear	si	es	un	número	primo	:	"))
isprime=True
if	n<7	:
				print("Impossible!	el	número	es	muy	pequeño.")
elif	n>49:
				print("Impossible!	el	número	es	demaciado	grande.")
else:
				if	2*(n//2)	==	n:	#	n	=	15	;	n//2	=	7	;		7	*	2	=	14
								print("No	es	primo,	",	n,"	es	divisible	por	2.")	#	Tenemos	tres	niveles	de	indentación.	
								isprime=False
				elif	3*(n//3)==n:
								print("Not	es	primo,	",	n,"	es	divisible	por	3.")
								isprime=False
				elif	5*(n//5)==n:
								print("Not	es	primo,	",	n,"	es	divisible	por	5.")
								isprime=False
				elif	7*(n//7)==n:
								print("Not	es	primo,	",n,"	es	divisible	por	7.")
								isprime=False
				else:
								print(n,"	es	primo.")
n	=	int(input("Ingresar	un	número	natural	entre	8	y	49:	"))
defect	=	0
if	n<7	:
				print("Impossible!	el	número	no	esta	entre	8	y	49.")
elif	n>49:
				print("Impossible!	el	número	es	demaciado	grande.")
else:
				if	2*(n//2)	==	n:	
								print(	"es	divisible	por	2.")	#	Tenemos	tres	niveles	de	indentación.	
								defect	+=	2
				elif	3*(n//3)==n:
								print("	es	divisible	por	3.")
								defect	+=	3
				elif	5*(n//5)==n:
								print("	es	divisible	por	5.")
								defect	+=	5
				elif	7*(n//7)==n:
								print("es	divisible	por	7.")
								defect	+=	7
				else:
								print("	es	defectivo??	",	n	>	defect	)
Se	necesita	realizar	un	programa	para	asistir	a	un	empleado	de	un	Cine	(o	Teatro).	El	empleado	esta	encargado	de	enviar	a	las
personas	a	la	sala	correcta.
Una	vez	comprada	la	entrada	la	audiencia	se	dirige	al	empleado,	el	cual,	en	base	al	número	que	figura	en	la	entrada	(3	dígitos)	los	envía
a	la	sala	correspondiente.	Si	la	entrada	es	par,	el	empleado	los	dirige	a	la	Sala	1.	Cuando	la	entrada	es	impar	los	dirige	a	la	sala	2.
Recientemente,	por	un	error	en	la	impresión	de	las	entradas	han	salido	muchas	con	el	número	000	,	en	este	caso	el	empleado	debe
comunicarle	al	usuario	que	se	dirija	a	la	administraci'on	para	obtener	una	nueva	entrada.
Solución:
Sala	1
Uso	de	ciclos	while.
Un	bucle	while	se	representa	de	la	siguiete	manera:
1	-	2	-	3	-	4	-	5	-	6	-	7	-	8	-	9	-	10	-	11	-	12	-	
Al	igual	que	para	el	condicional,	debemos	terminar	la	linea	con	la	instrucción	while	con	'	:	',	luego	debemos	indentar	el	bloque	de
comandos	que	será	repetido	en	el	ciclo.
En	general,	cuando	definimos	un	ciclo	while,	debemos	asegurarnos	que	el	ciclo	termine	en	algún	momento.	En	caso	de	omitir	una
terminación	segura	del	ciclo,	el	programa	nunca	ejecutara	los	comandos	que	esten	a	continuación	del	ciclo,	para	retomar	el	control,
deberemos	reiniciar	el	kernel.
Ciclos	"for"
Cuando	debemos	realizar	una	tarea	repetitiva,	es	muy	conveniente	utilizar	los	ciclos	for.	La	forma	estandard	de	escribirlos	es	la
siguiente:
for	variable	in	'contenedor'	:
seguido	de	un	salto	de	linea	y	luego	las	instrucciones	a	ser	repetidas.	Como	cualquier	instrucción	con	:	,	necesitaremos	indentar.
variable	es	cualquier	nombre	de	variable	(no	protegido),	y	'contenedor'	es	un	objeto	contenedor.
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	
Debemoms	tener	cuidado	que	range	no	nos	retorna	un	tipo	de	datos	conveninete.	Igualmente	puede	ser	(o	será)	convertido	al	tipo	lista.
Si	utilizaramoms	el	tipo	lista	directamente,	la	performance	se	vera	reducida.
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	
n	=	int(input("Ingresar	el	número	de	su	entrada:	"))
if	n	<	0	or	n>999	:
				print("Entrada	no	valida.")
else:
				if	n	==	0	:
								print("Por	favor	consiga	otro	ticket.")
				elif	2*(n//2)	==	n:	
								print(	"Sala	1")	#	Tenemos	tres	niveles	de	indentación.	
				else:
								print("Sala	2")
N=int(input("Contaremos	hasta	:	"))
p=0
while	p	<	N:	#	Definimos	la	condición	sobre	la	que	ejecutara	el	ciclo.
				p+=1			#	Hacemos	algo	dentro	del	ciclo.
				print(p,end="	-	")	#	Hacemos	otra	cosa.
#	Ejemplo	de	un	ciclo
for	x	in	range(0,20):
				print(x,end="	")
#	Comparación	con	los	ciclos	"mientras"	
x=0
while	x<20:
				print(x,end="	")
				x+=1
#	Uso	de	ciclos	for,	para	distintos	tipos	de	contenedores.	
for	x	in	{0,1,2}:	#	Conjunto
0	1	2	
A	l	g	o	r	i	t	m	o	s	E	s	t	r	u	c	t	u	r	a	s	D	a	t	o	s	
A	l	g	o	r	i	t	m	o	s	E	s	t	r	u	c	t	u	r	a	s	D	a	t	o	s	
Algunas	veces,	cuando	recorremos	una	lista	 L 	utilizando	un	ciclo	for	nos	gustaría	poder	ver	los	valores	y	los	indices.
L[0]=1
L[1]=5
L[2]=2
L[3]=caballo
L[4]=3
También	podemos	utilizar	la	siguiente	notación	reducida	for	 index,variable	in	L:	
En	este	caso,	tendremos	 L[index]=variable 	durante	la	ejecición	del	ciclo.
L[0]=1
L[1]=5
L[2]=2
L[3]=caballo
L[4]=3
Podemos	interrumpir	el	ciclo	for	(respectivametne	para	while)	utilizando	el	commando	break.
0	1	2	3	4	5	6	
0	1	2	3	4	5	6	10	11	12	13	14	15	16	20	21	22	23	24	25	26	30	31	32	33	34	35	36	40	41	42	43	44	45	46	50	51	52	53	54	
55	56	60	61	62	63	64	65	66	70	71	72	73	74	75	76	80	81	82	83	84	85	86	
Algunas	funciones	útiles	de	Python	-	print,	input,	help.
En	Python,	una	función	es	invocada	de	la	siguiente	forma	 function	(variable_1,	...,	variable_r)
Ya	hemos	visto	angunas	funciones	como	print,	type,	int, ….
En	la	salida	del	programa	anterior,	puede	verse	una	lista	de	las	funciones	provistas	por	Python	(built-in	functions).	Luego,	comenzaremos
a	definir	nuestras	propias	funciones.	Por	el	momento	veremos	algunosejemplos	útiles.
La	función	print
La	función	print	puede	aceptar	muchos	argumentos	de	entrada.	Los	argumentos,	ya	sean	valores	o	nombres	de	variables,	se	imprimiran
en	el	mismo	orden	indicado,	separados	por	un	espacio.
Por	defecto	la	función	print	agrega	un	salto	de	linea	al	finalalizar	la	impresion	de	los	datos.
3
dies	irae
True
				print(x,end='	')
print('')
for	x	in	'AlgoritmosEstructurasDatos':	#	Strings
					print(x,end='	')
print('')
for	x	in	list('AlgoritmosEstructurasDatos'):	#	Listas
					print(x,end='	')
#	Un	modo	sencillo	de	hacerlo.
L=['1','5','2','caballo','3']		
for	index	in	range(0,len(L)):
				print("L[{}]={}".format(index,L[index]))
for		index,variable	in	enumerate(L):	#	Usamos	la	funcion	enumarate	para	acceder	a	las	tuplas	(i,L[i])
				print("L[{}]={}".format(index,variable))
for	x	in	range(0,9):
				if	x>6:
								break	
				print(x,end="	")
for	y	in	range(0,9):
				for	x	in	range(0,9):
								if	x>6:
												break	#	Solo	interrumpimos	el	ciclo	en	"donde	estamos".
								print(10*y+x,end="	")
print(3)	#	Imprime	el	número	(entero)	3.
print('dies	irae')	#	Imprime	el	string	dies	irae
print(True)	#	Imprime	True
2
3	--	dies	irae	--	True*
Help	on	built-in	function	print	in	module	builtins:
print(...)
				print(value,	...,	sep='	',	end='\n',	file=sys.stdout,	flush=False)
				
				Prints	the	values	to	a	stream,	or	to	sys.stdout	by	default.
				Optional	keyword	arguments:
				file:		a	file-like	object	(stream);	defaults	to	the	current	sys.stdout.
				sep:			string	inserted	between	values,	default	a	space.
				end:			string	appended	after	the	last	value,	default	a	newline.
				flush:	whether	to	forcibly	flush	the	stream.
Para	cambiar	el	'terminador'	del	commando	print--que	por	defecto	es	"\n"	(barra	n)--debemos	añadir	el	argumento:	end="terminador".
3*dies	irae*True
3
dies	irae		True
La	función	input
La	función	input	toma	como	argumento	una	cadena	de	caracteres.	Luego,	la	consola	del	systema,	escribe	la	cadena	de	caracteres	y
queda	en	espera	a	que	el	usuario	introduzca	algo	con	el	teclado,	lo	cual	sera	el	resultado	devuelto	por	la	funcion	input.
El	tipo	del	resultado	es	siempre	una	cadena	de	caracteres!!
Por	favor	ingrese	un	número	:	10
10
<class	'str'>
11
La	Función	help
La	función	help	toma	cualquier	función	predefinida	en	el	lenguaje	Python	como	argumento	y	nos	muestra	su	codigo.
Recursos
Descargas
Python	:	https://www.python.org
Atom	:	https://atom.io	(editor)
Anaconda	:	https://www.anaconda.com/download/
GNU	Emacs	:	https://www.gnu.org/software/emacs/	(editor)
Bibliografía.
x	=	2
print(x)	#	Imprime	el	valor	de	la	variable	y	no	el	nombre.
print(3,'dies	irae',True,sep='	--	',	end="	*	")	
#	podemos	imprimir	diferentes	argumentos	
																										#	en	la	misma	linea
help(print)
print(3,end="*")												#	Cambia	el	salto	de	linea	por	un	*	.	
print('dies	irae',end="*")		#	Cambia	el	salto	de	linea	por	un	*	.
print(True)																	#	Imprime	un	salto	de	linea.
print(3)											#	Cambia	el	salto	de	linea	por	un	espacio.
print('dies	irae',end="		")	#	Cambia	el	salto	de	linea	por	un	espacio.
print(True)																	#	Imprime	un	salto	de	linea.
n	=	input("Por	favor	ingrese	un	número	:	")
print(n)
print(type(n))	#	El	tipo	de	la	variable	n	es	'srt'	y	no	'int'.
print(int(n)	+	1)				#	Aquí	vemos	que	pasa	cuando	mezclamos	distintos	tipos	de	datos	(algunos	serán	compatibles).
help(print)
help(input)
help(help)
https://www.python.org/
https://atom.io/
https://www.anaconda.com/download/
https://www.gnu.org/software/emacs/
[Joyanes,	2003]	Joyanes	Aguilar,	L.	(2003).	Fundamentos	de	Programación;	Algoritmos,	Estructuras	de	Datos	y	Objetos	(3a.	ed.).
Madrid:	McGraw-Hill	Interamericana.
[Aho	et	al.,	1998]	Aho,	A.	V.,	Hopcroft,	J.	E.,	&	Ullman,	J.	D.	(1998).	Estructuras	de	datos	y	algoritmos.
[Drozdek,	2007]	Drozdek,	A.	(2007).	Estructura	de	Datos	Y	Algoritmos	en	Java.	Cengage	Learning	Latin	America.
[Brassard	et	al.,	2008]	Brassard,	G.,	&	Bratley,	P.	(2008).	Fundamentos	de	algoritmia.	Madrid:	Pearson	Prentice	Hall.
[Heilman,	2010]	Heileman,Gregory,	L.	(2010).	Estructura	de	datos,	algoritmos	y	programación	orientada	a	objetos.	La	Habana:
Editorial	Félix	Varela.
[Weiss,	2010]	Weiss,	M.	A.	(2010).	Data	structures	&	problem	solving	using	Java.	Boston:	Pearson	Education.
[Goodrich	et	al.,	2018]	Goodrich,	M.	T.,	Tamassia,	R.,	&	Goldwasser,	M.	H.	(2018).	Data	structures	and	algorithms	in	Python.
[Lee	et	al.,	2015]	Lee,	K.	D.,	&	Hubbard,	S.	(2015).	Data	Structures	and	Algorithms	with	Python.	Cham:	Springer	International
Publishing.
[Cormen	et	al.,	2017]	Cormen,	T.	H.,	Leiserson,	C.	E.,	Rivest,	R.	L.,	&	Stein,	C.	(2017).	Introduction	to	algorithms.
[Gamma	et	al.,	1995]	Gamma,	E.,	Helm,	R.,	Johnson,	R.	E.,	&	Vlissides,	J.	(1995).	Design	patterns:	Elements	of	reusable	object-
oriented	software.	Reading,	Mass:	Addison-Wesley.
(La	mayoria	de	los	libros	mencionados	en	ingles,	tienen	al	menos	una	edición	en	español)