\documentclass[10pt,a4paper]{article}

% Packages
\usepackage{fancyhdr}           % For header and footer
\usepackage{multicol}           % Allows multicols in tables
\usepackage{tabularx}           % Intelligent column widths
\usepackage{tabulary}           % Used in header and footer
\usepackage{hhline}             % Border under tables
\usepackage{graphicx}           % For images
\usepackage{xcolor}             % For hex colours
%\usepackage[utf8x]{inputenc}    % For unicode character support
\usepackage[T1]{fontenc}        % Without this we get weird character replacements
\usepackage{colortbl}           % For coloured tables
\usepackage{setspace}           % For line height
\usepackage{lastpage}           % Needed for total page number
\usepackage{seqsplit}           % Splits long words.
%\usepackage{opensans}          % Can't make this work so far. Shame. Would be lovely.
\usepackage[normalem]{ulem}     % For underlining links
% Most of the following are not required for the majority
% of cheat sheets but are needed for some symbol support.
\usepackage{amsmath}            % Symbols
\usepackage{MnSymbol}           % Symbols
\usepackage{wasysym}            % Symbols
%\usepackage[english,german,french,spanish,italian]{babel}              % Languages

% Document Info
\author{juliancnn}
\pdfinfo{
  /Title (python3-para-principiantes.pdf)
  /Creator (Cheatography)
  /Author (juliancnn)
  /Subject (Python3 para principiantes Cheat Sheet)
}

% Lengths and widths
\addtolength{\textwidth}{6cm}
\addtolength{\textheight}{-1cm}
\addtolength{\hoffset}{-3cm}
\addtolength{\voffset}{-2cm}
\setlength{\tabcolsep}{0.2cm} % Space between columns
\setlength{\headsep}{-12pt} % Reduce space between header and content
\setlength{\headheight}{85pt} % If less, LaTeX automatically increases it
\renewcommand{\footrulewidth}{0pt} % Remove footer line
\renewcommand{\headrulewidth}{0pt} % Remove header line
\renewcommand{\seqinsert}{\ifmmode\allowbreak\else\-\fi} % Hyphens in seqsplit
% This two commands together give roughly
% the right line height in the tables
\renewcommand{\arraystretch}{1.3}
\onehalfspacing

% Commands
\newcommand{\SetRowColor}[1]{\noalign{\gdef\RowColorName{#1}}\rowcolor{\RowColorName}} % Shortcut for row colour
\newcommand{\mymulticolumn}[3]{\multicolumn{#1}{>{\columncolor{\RowColorName}}#2}{#3}} % For coloured multi-cols
\newcolumntype{x}[1]{>{\raggedright}p{#1}} % New column types for ragged-right paragraph columns
\newcommand{\tn}{\tabularnewline} % Required as custom column type in use

% Font and Colours
\definecolor{HeadBackground}{HTML}{333333}
\definecolor{FootBackground}{HTML}{666666}
\definecolor{TextColor}{HTML}{333333}
\definecolor{DarkBackground}{HTML}{34424D}
\definecolor{LightBackground}{HTML}{F8F9F9}
\renewcommand{\familydefault}{\sfdefault}
\color{TextColor}

% Header and Footer
\pagestyle{fancy}
\fancyhead{} % Set header to blank
\fancyfoot{} % Set footer to blank
\fancyhead[L]{
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{C}
    \SetRowColor{DarkBackground}
    \vspace{-7pt}
    {\parbox{\dimexpr\textwidth-2\fboxsep\relax}{\noindent
        \hspace*{-6pt}\includegraphics[width=5.8cm]{/web/www.cheatography.com/public/images/cheatography_logo.pdf}}
    }
\end{tabulary}
\columnbreak
\begin{tabulary}{11cm}{L}
    \vspace{-2pt}\large{\bf{\textcolor{DarkBackground}{\textrm{Python3 para principiantes Cheat Sheet}}}} \\
    \normalsize{by \textcolor{DarkBackground}{juliancnn} via \textcolor{DarkBackground}{\uline{cheatography.com/106895/cs/21454/}}}
\end{tabulary}
\end{multicols}}

\fancyfoot[L]{ \footnotesize
\noindent
\begin{multicols}{3}
\begin{tabulary}{5.8cm}{LL}
  \SetRowColor{FootBackground}
  \mymulticolumn{2}{p{5.377cm}}{\bf\textcolor{white}{Cheatographer}}  \\
  \vspace{-2pt}juliancnn \\
  \uline{cheatography.com/juliancnn} \\
  \end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Cheat Sheet}}  \\
   \vspace{-2pt}Published 17th February, 2020.\\
   Updated 17th February, 2020.\\
   Page {\thepage} of \pageref{LastPage}.
\end{tabulary}
\vfill
\columnbreak
\begin{tabulary}{5.8cm}{L}
  \SetRowColor{FootBackground}
  \mymulticolumn{1}{p{5.377cm}}{\bf\textcolor{white}{Sponsor}}  \\
  \SetRowColor{white}
  \vspace{-5pt}
  %\includegraphics[width=48px,height=48px]{dave.jpeg}
  Measure your website readability!\\
  www.readability-score.com
\end{tabulary}
\end{multicols}}




\begin{document}
\raggedright
\raggedcolumns

% Set font size to small. Switch to any value
% from this page to resize cheat sheet text:
% www.emerson.emory.edu/services/latex/latex_169.html
\footnotesize % Small font.

\begin{multicols*}{2}

\begin{tabularx}{8.4cm}{x{2.32 cm} x{5.68 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Operadores Matematicos}}  \tn
% Row 0
\SetRowColor{LightBackground}
`+ | - | * | \%` & Suma | resta | multiplicacion | resto (modulo) \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
`a / b` & Division float(a/b) \tn 
% Row Count 3 (+ 1)
% Row 2
\SetRowColor{LightBackground}
`a // b` & Devision entera int(a/b) \tn 
% Row Count 4 (+ 1)
% Row 3
\SetRowColor{white}
`a **  b` & Exponente a\textasciicircum{}b \tn 
% Row Count 5 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Además de int y float, soporta otros tipos de números, como Decimal y Fraction. y numeros complejos usando el sufijo {\bf{\textbackslash{}`j\textbackslash{}`}} o {\bf{\textbackslash{}`J\textbackslash{}`}}}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.76 cm} x{4.24 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Giladas especiales}}  \tn
% Row 0
\SetRowColor{LightBackground}
\textbackslash{}``{\bf{\_}}`\textbackslash{}` & {[}modo interactivo{]} última expresión impresa es asignada a la variable `\_` \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
`{\bf{pass}}` & No hace nada, se usa para rellenar algo obligatorio en futura implementacion \tn 
% Row Count 8 (+ 4)
% Row 2
\SetRowColor{LightBackground}
`{\bf{del a{[}0{]}\{\{nl\}\}del a\{\{nobreak\}\}}}` & Elimina el item a{[}0{]} \{\{nl\}\}Elimina a \tn 
% Row Count 10 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Cadena de caracteres}}  \tn
% Row 0
\SetRowColor{LightBackground}
`'cadena'\{\{nl\}\}"cadena"` & Cadenas con comiilas simplles o dobles \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
`""" ... cadena multilinea ... """` & Comillas triples para multilinea.\{\{nl\}\} Fin de línea son incluídos \{\{nl\}\} automáticamente, es posible \{\{nl\}\}prevenir esto agregando\{\{nl\}\} una \textbackslash{} al final de la línea. \tn 
% Row Count 11 (+ 9)
% Row 2
\SetRowColor{LightBackground}
`r"sin \textbackslash{}n caracteres especiales"` & r, para raw, cadenas crudas \tn 
% Row Count 13 (+ 2)
% Row 3
\SetRowColor{white}
`str\_a + str\_a` & Concatenacion \tn 
% Row Count 14 (+ 1)
% Row 4
\SetRowColor{LightBackground}
`2*str\_a` & Repeticion \tn 
% Row Count 15 (+ 1)
% Row 5
\SetRowColor{white}
`str{[}a:b{]}` & rebanada desde el indice a (incluido) hasta b sin incluir \tn 
% Row Count 18 (+ 3)
% Row 6
\SetRowColor{LightBackground}
`str{[}:b{]}` & rebanada parcial hasta b (b excluido) \tn 
% Row Count 20 (+ 2)
% Row 7
\SetRowColor{white}
`str{[}b:{]}` & rebanada parcial desde b (b incluido) \tn 
% Row Count 22 (+ 2)
% Row 8
\SetRowColor{LightBackground}
`str = 'cadadena negativa'\{\{nl\}\}hola{[}:-5{]}\{\{nl\}\}hola{[}-5:{]}` & \{\{nl\}\}'cadadena neg' \{\{nl\}\}'ativa'\{\{nl\}\} \tn 
% Row Count 25 (+ 3)
% Row 9
\SetRowColor{white}
`\{\{ar\}\} texto = ('cadenas en '\{\{nl\}\}'difrentes lineas.')` & Multilinea \tn 
% Row Count 28 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Las cadenas son inmutables \newline Las cadenas de texto se pueden indexar (subíndices), el primer carácter de la cadena tiene el índice 0. No hay un tipo de dato para los caracteres; un carácter es simplemente una cadena de longitud uno.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Loops}}  \tn
% Row 0
\SetRowColor{LightBackground}
`while condicion:\{\{nl\}\}~~~~{\emph{...sentencias...}}\{\{nl\}\}else:\{\{nl\}\}~~~~{\emph{...sentencias...}}` & else opcional, se ejecuta luego\{\{nl\}\} de terminado el bucle \tn 
% Row Count 7 (+ 7)
% Row 1
\SetRowColor{white}
`for element in {\emph{iterable}}:\{\{nl\}\}~~~~{\emph{...sentencias...}}\{\{nl\}\}else:\{\{nl\}\}~~~~{\emph{...sentencias...}}` & else opcional, se ejecuta luego \{\{nl\}\}de terminado el bucle \tn 
% Row Count 14 (+ 7)
% Row 2
\SetRowColor{LightBackground}
`break` & corta el bucle \tn 
% Row Count 15 (+ 1)
% Row 3
\SetRowColor{white}
`continue` & salta a la siguiente iteracion \tn 
% Row Count 17 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{El continue y el brack funcionan como en c. \newline Si el break se ejecuta no se ejecuta el else. \newline Si necesitás modificar la secuencia sobre la que estás iterando mientras estás adentro del ciclo primero hace una copia. \newline `for p in palabras{[}:{]}: \# hace una copia`}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Conjuntos}}  \tn
% Row 0
\SetRowColor{LightBackground}
`canasta = \{'manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banana'\}` & \{'pera', 'manzana', 'banana', 'naranja'\} \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
`'naranja' in canasta` & True \tn 
% Row Count 6 (+ 2)
% Row 2
\SetRowColor{LightBackground}
`'yerba' in canasta` & False \tn 
% Row Count 7 (+ 1)
% Row 3
\SetRowColor{white}
`a = set('abracadabra')` & \{a', 'r', 'b', 'c', 'd'\} \tn 
% Row Count 9 (+ 2)
% Row 4
\SetRowColor{LightBackground}
`a - b` & Elementos en a pero no en b \tn 
% Row Count 11 (+ 2)
% Row 5
\SetRowColor{white}
`a \& b` & Elementos en a y b \tn 
% Row Count 12 (+ 1)
% Row 6
\SetRowColor{LightBackground}
`a \textasciicircum{} b` & Elementos en a y b pero no en ambos \tn 
% Row Count 14 (+ 2)
% Row 7
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{Tambien soporta `a + b`, `a | b`} \tn 
% Row Count 15 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Es una colección no ordenada y sin elementos repetidos. \newline Incluyen verificación de pertenencia, eliminación de entradas duplicadas. Soportan operaciones matemáticas como la unión, intersección, diferencia, y diferencia simétrica. \newline Las llaves o la función set() pueden usarse para crear conjuntos.  \newline Soportada la comprensión de conjuntos.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Diccionario}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{\textgreater{}\textgreater{}\textgreater{} tel = \{'jack': 4098, 'sape': 4139\} \newline \textgreater{}\textgreater{}\textgreater{} tel{[}'guido'{]} = 4127 \newline \textgreater{}\textgreater{}\textgreater{} tel \newline \{'sape': 4139, 'jack': 4098, 'guido': 4127\} \newline \textgreater{}\textgreater{}\textgreater{} tel{[}'jack'{]} \newline 4098 \newline \textgreater{}\textgreater{}\textgreater{} del tel{[}'sape'{]} \newline \textgreater{}\textgreater{}\textgreater{} tel{[}'irv'{]} = 4127 \newline \textgreater{}\textgreater{}\textgreater{} tel \newline \{'jack': 4098, 'irv': 4127, 'guido': 4127\} \newline \textgreater{}\textgreater{}\textgreater{} list(tel.keys()) \newline {[}'irv', 'guido', 'jack'{]} \newline \textgreater{}\textgreater{}\textgreater{} sorted(tel.keys()) \newline {[}'guido', 'irv', 'jack'{]} \newline \textgreater{}\textgreater{}\textgreater{} 'guido' in tel \newline True \newline \textgreater{}\textgreater{}\textgreater{} 'jack' not in tel \newline False \newline  \newline El constructor dict() crea un diccionario directamente desde secuencias de pares clave-valor: \newline \textgreater{}\textgreater{}\textgreater{} dict({[}('sape', 4139), ('guido', 4127), ('jack', 4098){]}) \newline \{'sape': 4139, 'jack': 4098, 'guido': 4127\}} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Las tuplas pueden usarse como claves si solamente contienen cadenas, números o tuplas; si una tupla contiene cualquier objeto mutable directa o indirectamente, no puede usarse como clave. No podés usar listas como claves}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Formateo de datos}}  \tn
% Row 0
\SetRowColor{LightBackground}
`str()` & representaciones legibles por humanos \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
`repr()` & representaciones que pueden ser leídas por el el intérprete \tn 
% Row Count 6 (+ 4)
% Row 2
\SetRowColor{LightBackground}
`repr(x).rjust({[}n{]})\{\{nl\}\}str.ljust({[}n{]})\{\{nl\}\}str.center({[}n{]})` & Ajusta \tn 
% Row Count 10 (+ 4)
% Row 3
\SetRowColor{white}
`str.zfill()` & Rellena cadena de numeros con 0 \tn 
% Row Count 12 (+ 2)
% Row 4
\SetRowColor{LightBackground}
`str.format()` & Las llaves y caracteres son reemplazadas \tn 
% Row Count 14 (+ 2)
% Row 5
\SetRowColor{white}
`print('\{1\} y \{0\}'.format('carne', 'huevos'))` & Un número en las llaves se refiere a la posición del objeto pasado en el métod \tn 
% Row Count 19 (+ 5)
% Row 6
\SetRowColor{LightBackground}
`print('Esta \{comida\} es \{adjetivo\}.'.format( comida='carne', \seqsplit{adjetivo='espantosa'))`} & Argumentos nombrados en el método, serán referidos usando el nombre del argumento. \tn 
% Row Count 24 (+ 5)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Modulos \& packeage}}  \tn
% Row 0
\SetRowColor{LightBackground}
`import {\emph{fibo}}` & Importa {\emph{fibo.py}}.\{\{nl\}\}No mezcla el espacio de nombres. \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
\seqsplit{`fibo.nombreMetodo(args)`} & llamada a metodo \tn 
% Row Count 5 (+ 2)
% Row 2
\SetRowColor{LightBackground}
`from fibo import fib, fib2` & importa fib y fib2 \{\{nl\}\}mezcla el espacio de nombres \tn 
% Row Count 8 (+ 3)
% Row 3
\SetRowColor{white}
`\_\_name\_\_` & Nombre del modulo \tn 
% Row Count 9 (+ 1)
% Row 4
\SetRowColor{LightBackground}
`from fibo import *` & Importa todaslo que no tengan prefijo `{\bf{\_}}` ) \tn 
% Row Count 12 (+ 3)
% Row 5
\SetRowColor{white}
`if \_\_name\_\_ == "\_\_main\_\_":\{\{nl\}\}~~~~...sentencias...` & Se ejecuta solo como script y no como import \tn 
% Row Count 16 (+ 4)
% Row 6
\SetRowColor{LightBackground}
`dir({[}{\emph{nombreModulo}}{]})` & Lista las definiciones de un modulo \tn 
% Row Count 18 (+ 2)
% Row 7
\SetRowColor{white}
`from paquete import \seqsplit{submodulo\_especifico`} & n se recomienda a menos que el módulo que estás importando necesite usar submódulos con el mismo nombre desde otros paquetes. \tn 
% Row Count 25 (+ 7)
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Si en \_\_init\_\_.py define una lista \_\_all\_\_, se toma como la lista de los nombres de módulos que deberían ser importados cuando se hace from package import *.} \tn 
% Row Count 29 (+ 4)
% Row 9
\SetRowColor{white}
\mymulticolumn{2}{x{8.4cm}}{Un módulo puede contener  declaraciones ejecutables y definiciones de funciones. Las declaraciones son para inicializar el módulo.} \tn 
% Row Count 32 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Modulos \& packeage (cont)}}  \tn
% Row 10
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Los archivos \_\_init\_\_.py se necesitan para hacer que Python trate los directorios como que contienen paquete} \tn 
% Row Count 3 (+ 3)
% Row 11
\SetRowColor{white}
`from .. import {\emph{nombremod}}` & Importa relativo \tn 
% Row Count 5 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Errores y excepciones}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{`class B(Exception):\{\{nl\}\}~~pass\{\{nl\}\}class C(B):\{\{nl\}\}~~pass\{\{nl\}\}class D(C):\{\{nl\}\}~~pass\{\{nl\}\}for cls in {[}B, C, D{]}:\{\{nl\}\}~~try:\{\{nl\}\}~~~~raise cls()\{\{nl\}\}~~except D:\{\{nl\}\}~~~~print("D")\{\{nl\}\}~~except C:\{\{nl\}\}~~~~print("C")\{\{nl\}\}~~except B as instanciaExepcion:\{\{nl\}\}~~~~print("B")\{\{nl\}\}~~else:\{\{nl\}\}~~~~pass\{\{nl\}\}~~finally:\{\{nl\}\}~~~~pass`} \tn 
% Row Count 11 (+ 11)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Imprimirá B, C, D, en ese orden.Si las clausulas de except estuvieran invertidas (con except B primero), habría impreso B, B, B.} \tn 
% Row Count 14 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Una clase en una clausula except es compatible con una excepción si la misma esta en la misma clase o una clase base de la misma} \tn 
% Row Count 17 (+ 3)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Una clausula except listando una clase derivada no es compatible con una clase base} \tn 
% Row Count 19 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{El último except puede omitir nombrar qué excepción captura, para servir como comodín} \tn 
% Row Count 21 (+ 2)
% Row 5
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Tienen un bloque `{\bf{else}}` opcional,cuando está debe seguir a los except. Se ejecutasi el bloque try no genera una excepción.} \tn 
% Row Count 24 (+ 3)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Tienen un bloque `{\bf{finally}}` opcional,cuando está se ejecuta siempre a la salida sin importar si se lanzo la excepcion} \tn 
% Row Count 27 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Ambitos}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{def prueba\_ambitos(): \newline     def hacer\_local(): \newline         algo = "algo local" \newline     def hacer\_nonlocal(): \newline         nonlocal algo \newline         algo = "algo no local" \newline     def hacer\_global(): \newline         global algo \newline         algo = "algo global" \newline     algo = "algo de prueba" \newline     hacer\_local() \newline     print("Luego de la asignación local:", algo) \newline     hacer\_nonlocal() \newline     print("Luego de la asignación no local:", algo) \newline     hacer\_global() \newline     print("Luego de la asignación global:", algo) \newline  \newline prueba\_ambitos() \newline print("In global scope:", algo)} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Luego de la asignación local: algo de prueba \newline Luego de la asignación no local: algo no local \newline Luego de la asignación global: algo no local \newline En el ámbito global: algo global}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Variables}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{No existen variables privadas de instancia} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Por convención un nombre prefijado con un guión bajo debería tratarse como una parte no pública de la API} \tn 
% Row Count 4 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Cualquier identificador con 2 guiones bajos `{\emph{\_\_algo}}` es textualmente reemplazado por\{\{nl\}\} \_nombredeclase\_\_algo\{\{nl\}\}). Se modifica el nombre del identificador sin importar su posición sintáctica, siempre y cuando ocurra dentro de la definición de una clase.} \tn 
% Row Count 10 (+ 6)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{La modificación de nombres es útil para dejar que las subclases sobreescriban los métodos sin romper las llamadas a los métodos desde la misma clase.} \tn 
% Row Count 14 (+ 4)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{`class Mapeo:\{\{nl\}\}~~def \_\_init\_\_(self, iterable):\{\{nl\}\}~~~~\{\{nl\}\}self.lista\_de\_items = {[}{]}\{\{nl\}\}~~~~self.\_\_actualizar(iterable)\{\{nl\}\}~~def actualizar(self, iterable):\{\{nl\}\}~~~~for item in iterable:\{\{nl\}\}~~~~~~self.lista\_de\_items.append(item)\{\{nl\}\}~~\_\_actualizar = actualizar \# copia privada del actualizar() original class SubClaseMapeo(Mapeo):\{\{nl\}\}~~def actualizar(self, keys, values):\{\{nl\}\}~~~~~~\# provee una nueva signatura para actualizar()\{\{nl\}\}~~~~~~\{\{nl\}\}\# pero no rompe \_\_init\_\_()\{\{nl\}\}~~~~~~\{\{nl\}\}for item in zip(keys, values):\{\{nl\}\}~~~~~~self.lista\_de\_items.append(item)`} \tn 
% Row Count 31 (+ 17)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Iteradores / Generadores}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{la sentencia for llama a iter() en el objeto contenedor. La función devuelve un objeto iterador que define el método \_\_next\_\_() que accede elementos en el contenedor de a uno por vez. Cuando no hay más elementos, \_\_next\_\_() levanta una excepción StopIteration que le avisa al bucle del for que hay que terminar.} \tn 
% Row Count 7 (+ 7)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Para implementar un iterador un método \_\_iter\_\_() que devuelva un objeto con un método \_\_next\_\_(). Si la clase define \_\_next\_\_(), entonces alcanza con que \_\_iter\_\_() devuelva self:} \tn 
% Row Count 11 (+ 4)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Se escriben como funciones regulares pero usan la sentencia yield cuando quieren devolver datos. Cada vez que se llama next() sobre él, el generador continúa desde donde dejó (y recuerda todos los valores de datos y cual sentencia fue ejecutada última).} \tn 
% Row Count 17 (+ 6)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Expresiones generadoras: Algunos generadores simples pueden ser codificados concisamente como expresiones usando una sintaxis similar a las listas por comprensión pero con paréntesis en vez de corchetes. Estas expresiones se utilizan en situaciones donde el generador es usado inmediatamente por una función que lo contiene. Las expresiones generadoras son más compactas pero menos versátiles que definiciones completas de generadores, y tienden a utilizar menos memoria que las listas por comprensión equivalentes.} \tn 
% Row Count 28 (+ 11)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.28 cm} x{4.72 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Interprete}}  \tn
% Row 0
\SetRowColor{LightBackground}
`python -c {\emph{comando {[}arg{]}}}` & ejecuta las sentencias en {\emph{comando}} \{\{nl\}\} python -c "print(2+2)" \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
`python -m module {[}arg{]}` & ejecuta el código de module como si se hubiese ingresado su nombre completo en la línea de comandos \tn 
% Row Count 8 (+ 5)
% Row 2
\SetRowColor{LightBackground}
\# -*- coding: encoding -*- & Espeficica codificacion diferente a UTF8\{\{nl\}\}\# -{\emph{- coding: cp-1252 -}}- \tn 
% Row Count 12 (+ 4)
% Row 3
\SetRowColor{white}
`python -i {\emph{script.py}}` & Ejecuta el script y entra en modo interactivo \tn 
% Row Count 14 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{3.84 cm} x{4.16 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Listas}}  \tn
% Row 0
\SetRowColor{LightBackground}
`list.append (x)` & Agrega un ítem al final de la lista\{\{nl\}\} Equivale a a{[}len(a):{]} = {[}x{]}. \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
`list.extend (iterable)` & Extiende la lista agregándole todos los ítems del iterable. Equivale a a{[}len(a):{]} = iterable. \tn 
% Row Count 9 (+ 5)
% Row 2
\SetRowColor{LightBackground}
`list.insert (i, x)` & Inserta un ítem en una posición dada. \tn 
% Row Count 11 (+ 2)
% Row 3
\SetRowColor{white}
`list.remove (x)` & Quita el primer ítem de la lista cuyo valor sea x. \{\{nl\}\}Es un error si no existe tal ítem. \tn 
% Row Count 16 (+ 5)
% Row 4
\SetRowColor{LightBackground}
`list.pop ({[}, i{]}) ` & Quita el ítem en la posición dada y lo devuelve.\{\{nl\}\}Si no se especifica un índice, a.pop() quita y devuelve el último ítem de la lista. \tn 
% Row Count 24 (+ 8)
% Row 5
\SetRowColor{white}
`list.clear ()` & Quita todos los elementos de la lista.\{\{nl\}\} Equivalente a del a{[}:{]} \tn 
% Row Count 28 (+ 4)
% Row 6
\SetRowColor{LightBackground}
`list.index (x{[}, start{[}, end{]}{]}) ` & Devuelve un índice basado en cero\{\{nl\}\} del primer ítem cuyo valor sea x. \{\{nl\}\}Excepción ValueError si no existe tal ítem \tn 
% Row Count 35 (+ 7)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{3.84 cm} x{4.16 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Listas (cont)}}  \tn
% Row 7
\SetRowColor{LightBackground}
`list.count (x)` & Devuelve el número de veces que x aparece en la lista. \tn 
% Row Count 3 (+ 3)
% Row 8
\SetRowColor{white}
`list.sort (key=None, reverse=False)` & Ordena los ítems de la lista in situ \tn 
% Row Count 5 (+ 2)
% Row 9
\SetRowColor{LightBackground}
`list.reverse () ` & Invierte los elementos de la lista in situ. \tn 
% Row Count 8 (+ 3)
% Row 10
\SetRowColor{white}
`list.copy ()` & evuelve una copia superficial de la lista. Equivalente a a{[}:{]} \tn 
% Row Count 12 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Tipo de datos mutables. \newline Pueden ser indexadas y rebanadas. \newline Pueden contener diferentes tipos (mala practica) \newline Las rebanada devuelve una copia superficial de la lista \newline Ineficiente para tratar como FIFO, usar 'from collections import deque'}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Funciones comunes}}  \tn
% Row 0
\SetRowColor{LightBackground}
`range(end)\{\{nl\}\}range(start,end)\{\{nl\}\}range(start,end,step)` & el objeto devuelto por range() se comporta\{\{nl\}\}como si fuera una lista, pero no lo es.\{\{nl\}\}Es un objeto que devuelve los ítems sucesivos\{\{nl\}\}de la secuencia deseada cuando iterás sobre\{\{nl\}\}él, pero realmente no construye la lista, \tn 
% Row Count 12 (+ 12)
% Row 1
\SetRowColor{white}
`enumerate({\emph{iterable}})` & Agrega un contador al iterable y devuelve un enumerate \tn 
% Row Count 15 (+ 3)
% Row 2
\SetRowColor{LightBackground}
`reversed({\emph{iterable}})` & Invierte el orden in place \tn 
% Row Count 17 (+ 2)
% Row 3
\SetRowColor{white}
`sort({\emph{iterable}})` & Ordena \tn 
% Row Count 18 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Sobre funciones}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la función y la lista de parámetros} \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{La primer sentencia del cuerpo de la función puede ser opcionalmente una cadena de texto literal; esta es la cadena de texto de documentación de la función, o docstring.} \tn 
% Row Count 7 (+ 4)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función (tabla de símbolos loca)} \tn 
% Row Count 10 (+ 3)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{La referencia a variable mira las tablas en orden:\{\{nl\}\}1) Tabla de simbolos local.\{\{nl\}\}2)Tabla de simbolos local de la funcion externa\{\{nl\}\}3) Tabla de simbolos global\{\{nl\}\}4) Nombres predefinidos} \tn 
% Row Count 14 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Cadenas de texto de documentación}}  \tn
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{La primer línea debe ser siempre un resumen corto y conciso del propósito del objeto. No se debe mencionar explícitamente el nombre o tipo del objeto. \newline % Row Count 4 (+ 4)
Esta línea debe empezar con una letra mayúscula y terminar con un punto. \newline % Row Count 6 (+ 2)
Si hay más líneas en la cadena de texto de documentación, la segunda línea debe estar en blanco, separando visualmente \newline % Row Count 9 (+ 3)
el resumen del resto de la descripción. Las líneas siguientes deben ser uno o más párrafos describiendo las convenciones \newline % Row Count 12 (+ 3)
para llamar al objeto, efectos secundarios, etc% Row Count 13 (+ 1)
} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Argumento de funciones}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{def ventadequeso(tipo, *argumentos, **palabrasclaves): \newline     print("-{}- ¿Tiene", tipo, "?") \newline     print("-{}- Lo siento, nos quedamos sin", tipo) \newline     for arg in argumentos: \newline         print(arg) \newline     print("-" * 40) \newline     for c in palabrasclaves: \newline         print(c, ":", palabrasclaves{[}c{]}) \newline  \newline ventadequeso("Limburger",  \newline     "Es muy liquido, sr.", \newline     "Realmente es muy muy liquido, sr.", \newline     cliente="Juan Garau", \newline     vendedor="Miguel Paez", \newline  \newline -{}- ¿Tiene Limburger ? -{}- Lo siento, nos quedamos sin Limburger Es muy liquido, sr. Realmente es muy muy liquido, sr. \newline -{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}- cliente : Juan Garau vendedor : Miguel Paez puesto : Venta de Queso Argentino \newline     puesto="Venta de Queso Argentino" \newline  \newline \# Otro ejemplo  \newline \textgreater{}\textgreater{}\textgreater{} def loro(tension, estado='rostizado', accion='explotar'): \newline ... print("-{}- Este loro no va a", accion, end=' ') \newline ... print("si le aplicás", tension, "voltios.", end=' ') \newline ... print("Está", estado, "!") \newline  \newline \textgreater{}\textgreater{}\textgreater{} d = \{"tension": "cinco mil", "estado": "demacrado", \newline ... "accion": "VOLAR"\} \newline \textgreater{}\textgreater{}\textgreater{} loro(**d) \newline -{}- Este loro no va a VOLAR si le aplicás cinco mil voltios. Está demacrado !} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Cuando un parámetro formal de la forma **nombre está presente al final, recibe un diccionario conteniendo todos los argumentos nombrados excepto aquellos correspondientes a un parámetro formal.\{\{nl\}\}Puede ser combinado con un parámetro formal de la forma *nombre que recibe una tupla conteniendo los argumentos posicionales además de la lista de parámetros formales. ({\emph{nombre debe ocurrir antes de }}*nombre).}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Lista de comprensión}}  \tn
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{{[}(x, y) for x in {[}1,2,3{]} for y in {[}3,1,4{]} if x != y{]} \newline {[}(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4){]} \newline \# Es equivalente a: \newline combs = {[}{]} \newline for x in {[}1,2,3{]}: \newline     for y in {[}3,1,4{]}: \newline         if x != y: \newline             combs.append((x, y)) \newline \# Printeo \newline combs \newline {[}(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4){]}} \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Una lista de comprensión consiste de corchetes rodeando una expresión seguida de la declaración for y luego cero o más declaraciones for o if. El resultado será una nueva lista que sale de evaluar la expresión en el contexto de los for o if que le siguen.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Iteracion}}  \tn
% Row 0
\SetRowColor{LightBackground}
caballeros = \{'gallahad': 'el puro', 'robin': 'el valiente'\} \{\{nl\}\}for k, v in caballeros.items():\{\{nl\}\}~	~	~	~	 print(k, v) & Obtener al mismo tiempo\{\{nl\}\} la clave y su valor \tn 
% Row Count 8 (+ 8)
% Row 1
\SetRowColor{white}
for i, v in enumerate({[}'ta', 'te', 'ti'{]}):\{\{nl\}\}~	~	~	~	pint(i,v) & Obtener al mismo tiempo\{\{nl\}\} indice y valor \tn 
% Row Count 13 (+ 5)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{preguntas = {[}'nombre', 'objetivo', 'color favorito'{]}\{\{nl\}\}respuestas = {[}'lancelot', 'el santo grial', 'azul'{]}\{\{nl\}\}~	~	~	~	print('Cual es tu \{0\}? \{1\}.'.format(p, r))} \tn 
% Row Count 17 (+ 4)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Sobre condiciones}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Las condiciones usadas en las instrucciones `while` e `if` pueden contener cualquier operador, no sólo comparaciones.} \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Los operadores de comparación `{\bf{in}}` y `{\bf{not in}}` verifican si un valor está (o no está) en una secuencia.} \tn 
% Row Count 6 (+ 3)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Los operadores `{\bf{is}}` e `{\bf{is not}}` comparan si dos objetos son realmente el mismo objeto; esto es significativo sólo para objetos mutables como las listas.} \tn 
% Row Count 10 (+ 4)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Todos los operadores de comparación tienen la misma prioridad, la cual es menor que la de todos los operadores numericos} \tn 
% Row Count 13 (+ 3)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Las comparaciones pueden encadenarse. Por ejemplo, `a \textless{} b == c` verifica si a es menor que b y además si b es igual a c.} \tn 
% Row Count 16 (+ 3)
% Row 5
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Las comparaciones pueden combinarse mediante los operadores booleanos and y or, y el resultado de una comparación puede negarse con not. Estos tienen prioridades menores que los operadores de comparación; entre ellos not tiene la mayor prioridad y or la menor, o sea que A and not B or C equivale a (A and (not B)) or C.} \tn 
% Row Count 23 (+ 7)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Operadores booleanos `{\bf{and}}` y `{\bf{or}}` son los llamados operadores cortocircuito: sus argumentos se evalúan de izquierda a derecha, y la evaluación se detiene en el momento en que se determina su resultado.} \tn 
% Row Count 28 (+ 5)
% Row 7
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Cuando se usa como un valor general y no como un booleano, el valor devuelto de un operador cortocircuito es el último argumento evaluado} \tn 
% Row Count 31 (+ 3)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Sobre condiciones (cont)}}  \tn
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{`non\_nulo = cadena1 or cadena2 or cadena3 \{\{nl\}\}non\_nulo \{\{nl\}\}` 'Trondheim'} \tn 
% Row Count 2 (+ 2)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Tuplas y secuencias}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Una tupla consiste de un número de valores separados por comas} \tn 
% Row Count 2 (+ 2)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{`t = 12345, 54321, 'hola!' \{\{nl\}\}`\# t{[}0{]}\{\{nl\}\} 12345`\{\{nl\}\}t (12345, 54321, 'hola!')`} \tn 
% Row Count 4 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Las tuplas son inmutables, perosí se puede crear tuplas que contengan objetos mutables, como las listas.} \tn 
% Row Count 7 (+ 3)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{`x, y, z = t` desempaqueta la tupla} \tn 
% Row Count 8 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Manejo de archivos}}  \tn
% Row 0
\SetRowColor{LightBackground}
`open('archivo', 'modo')`\{\{nobreak\}\} & devuelve un objeto archivo\{\{nl\}\}r/w(overwrite)/a \tn 
% Row Count 3 (+ 3)
% Row 1
\SetRowColor{white}
`with open('archivo') as f:\{\{nl\}\}~~datos\_leidos = f.read()`\{\{nobreak\}\} & El archivo es cerrado luego de que el bloque termina, incluso si se generó una excepción. \tn 
% Row Count 8 (+ 5)
% Row 2
\SetRowColor{LightBackground}
`f.read()\{\{nl\}\}f.read(nbytes)` & lee todo el archivo o n bytes \tn 
% Row Count 10 (+ 2)
% Row 3
\SetRowColor{white}
`f.readline()` & Lee una linea (deja \textbackslash{}n si existe) \tn 
% Row Count 12 (+ 2)
% Row 4
\SetRowColor{LightBackground}
`for linea in f:\{\{nl\}\}~~print(linea, end='')` & Para leer líneas de un archivo, podés iterar sobre el objeto archivo. Esto es eficiente en memoria y rápido \tn 
% Row Count 18 (+ 6)
% Row 5
\SetRowColor{white}
`list(f) \{\{nl\}\} f.readlines()` & Lee todas las lineas, devuelve una lista \tn 
% Row Count 20 (+ 2)
% Row 6
\SetRowColor{LightBackground}
`f.write(str)` & escribe en el archivo \tn 
% Row Count 22 (+ 2)
% Row 7
\SetRowColor{white}
`f.tell()` & devuelve un entero que indica la posición actual en el archivo representada como número de bytes desde el comienzo del archivo en modo binario y un número opaco en modo texto. \tn 
% Row Count 31 (+ 9)
\end{tabularx}
\par\addvspace{1.3em}

\vfill
\columnbreak
\begin{tabularx}{8.4cm}{x{4 cm} x{4 cm} }
\SetRowColor{DarkBackground}
\mymulticolumn{2}{x{8.4cm}}{\bf\textcolor{white}{Manejo de archivos (cont)}}  \tn
% Row 8
\SetRowColor{LightBackground}
\seqsplit{`f.seek(desplazamiento}, desde\_donde)` & cambiar la posición del objeto archivo.La posición es calculada agregando el desplazamiento a un punto de referencia; el punto de referencia se selecciona del argumento desde\_donde. Un valor desde\_donde de 0 mide desde el comienzo del archivo, 1 usa la posición actual del archivo, y 2 usa el fin del archivo como punto de referencia. desde\_donde puede omitirse, el default es 0 \tn 
% Row Count 20 (+ 20)
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\SetRowColor{LightBackground}
\mymulticolumn{2}{x{8.4cm}}{Si se agrega b al modo el archivo se abre en modo binario. \newline Se debería usar este modo para todos los archivos que no contengan texto ya que cuando se lee en modo texto, por defecto se convierten los fines de lineas que son específicos a las plataformas (\textbackslash{}n en Unix, \textbackslash{}r\textbackslash{}n en Windows) a solamente \textbackslash{}n ropiendo si es binario el archivo}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}--}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Clases}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Soporta herencia multiple} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{(dinamico) Se crean en tiempo de ejecución, y pueden modificarse luego de la creación.} \tn 
% Row Count 3 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Los miembros de la clase son publicos (En terminologia de c++)} \tn 
% Row Count 5 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Todas las funciones miembro son \{\{link="https://es.wikipedia.org/wiki/Funci\%C3\%B3n\_virtual"\}\}virtuales\{\{/link\}\}.} \tn 
% Row Count 8 (+ 3)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{No hay atajos para hacer referencia a los miembros del objeto desde sus métodos: la función método se declara con un primer argumento explícito que representa al objeto, el cual se provee implícitamente por la llamada} \tn 
% Row Count 13 (+ 5)
% Row 5
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Como en Smalltalk, las clases mismas son objetos} \tn 
% Row Count 14 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Los tipos de datos integrados pueden usarse como clases base para que el usuario los extienda.} \tn 
% Row Count 16 (+ 2)
% Row 7
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Hay sobrecarga de operadores} \tn 
% Row Count 17 (+ 1)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{objetos clases, metodos e instancias}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{una definición de clase, se crea un nuevo espacio de nombres, el cual se usa como ámbito local. y  Cuando una definición de clase se finaliza normalmente se crea un objeto clase.} \tn 
% Row Count 4 (+ 4)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{soportan dos tipos de operaciones: hacer referencia a atributos e instanciación.} \tn 
% Row Count 6 (+ 2)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{\_\_doc\_\_ también es un atributo válido, que devuelve la documentación asociada a la clase} \tn 
% Row Count 8 (+ 2)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{x = MiClase(), crea una nueva instancia de la clase} \tn 
% Row Count 10 (+ 2)
% Row 4
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Los miembros pueden ser de existencia dinamica, la clase es mutable} \tn 
% Row Count 12 (+ 2)
% Row 5
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{x.f() es exactamente equivalente a MiClase.f(x)} \tn 
% Row Count 13 (+ 1)
% Row 6
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Los atributos de datos tienen preferencia sobre los métodos con el mismo nombre;} \tn 
% Row Count 15 (+ 2)
% Row 7
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{El ámbito global asociado a un método es el módulo que contiene su definición. (Una clase nunca se usa como un ámbito global.)} \tn 
% Row Count 18 (+ 3)
% Row 8
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{Todo valor es un objeto, y por lo tanto tiene una clase (también llamado su tipo). Ésta se almacena como objeto.\_\_class\_\_.} \tn 
% Row Count 21 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{`def \_\_init\_\_(self): \newline ~~self.datos = {[}{]}` \newline Cuando se instancia se llama al metodo init de la clase. \newline usar verbos para los métodos y sustantivos para los atributos.}  \tn 
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}

\begin{tabularx}{8.4cm}{X}
\SetRowColor{DarkBackground}
\mymulticolumn{1}{x{8.4cm}}{\bf\textcolor{white}{Herencia}}  \tn
% Row 0
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{`class \seqsplit{ClaseDerivada(ClaseBase):`}} \tn 
% Row Count 1 (+ 1)
% Row 1
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Las referencias a métodos se resuelven de la siguiente manera:\{\{nl\}\}*se busca el atributo de clase correspondiente,descendiendo por la cadena de clases base si es necesario, y la referencia al método es válida si se entrega un objeto función.} \tn 
% Row Count 6 (+ 5)
% Row 2
\SetRowColor{LightBackground}
\mymulticolumn{1}{x{8.4cm}}{un método de la clase base que llame a otro método definido en la misma clase base puede terminar llamando a un método de la clase derivada que lo haya redefinido. por que todas los metodos son virtuales} \tn 
% Row Count 11 (+ 5)
% Row 3
\SetRowColor{white}
\mymulticolumn{1}{x{8.4cm}}{Hay una manera simple de llamar al método de la clase base directamente: simplemente llamás a ClaseBase.metodo(self, argumentos)} \tn 
% Row Count 14 (+ 3)
\hhline{>{\arrayrulecolor{DarkBackground}}-}
\end{tabularx}
\par\addvspace{1.3em}


% That's all folks
\end{multicols*}

\end{document}