Tipos de variables

boolean, int, floats, complex, strings, tuples y lists

type(expression) devuelve el tipo de variable, type(True):bool  –  True con mayúculas.

Casting  float(2):2.0   int(1.1):1    int(‘1’):1    int(‘A’) Error    str(1):”1”    str(4.5):’4.5’    int(True):1  bool(0): False

25 // 6 –> 4 Integer division

Strings

Son objetos que tienen sus métodos propios.

Name = “Michael Jackson”, se pueden usar “ o  ‘   –  se acceden los elementos por sus índices.

Name[0]: ‘M’ y en orden inverso Name[-1]:’n’ para ir de atrás para adelante

Name[0:4]:”Micha”  Name[::2]:”McalJcsn” es cada letra par    Name[0:5:2]:”Mca” las pares hasta el 5

len(Name):15   Concatenación con +

Strings son inmutables. Name[0] = ‘X’ NO cambia el valor de la primera letra del string

\ para caracteres de escape – print(“Michael \nJackson”)    \t  es TAB    \\  es backslash

A=”Hola”  B=A.upper()   B:”HOLA” ;  B=A.replace(‘HO’,’CO’)    B:”COLA”   ;    Name.find(“el”):5 no existe-> –1

Se pueden comparar String con ==

2 * “hola mundo” es igual a “hola mundo hola mundo”

Con triples comillas, se incluye un texto libre con varias líneas x ej

“””

Esta es una muestra de

un string de varias líneas definido con triples comillas.

“””

Los F-srting son los formateados. Se ponen variables entre {}, con un !r al final de la variable, esta aparece entre comillas, Con !a, se expresa el código ascii. ejemplos

str.strip() saca los espacios antes y despues del string, str.lsstrip() lo s de la izquierda y str.rstrip() derecha

str = ‘prueba’

print(f”Esta es una {str} de {str!r}”)

>> Esta es una prueba de ‘prueba’

‘-5’.zfill(4)

>> ‘–005’

words = “uno, dos, tres”

lstwords = words.split(‘,’)     // Separa según separador en una lista

print(lstwords)

>> [‘uno’, ‘dos’, ‘tres’]

‘-’.join(lstwords)             // junta las palabras con un – entre ellas

>> ‘uno-dos-tres’

Tuples

Tuple1 = (“disco”, 10, 1.2)  Se acceden por índices como los Strings   Tuple1[0]: “disco”  Tuple[-1]:1.2

Operaciones entre Tuples:  Tuple2 = Tuple1 + (“hard rock”, 10)      (“disco”, 10, 1.2, “hard rock”, 10)

Tuple2[0:3] : (“disco”, 10, 1.2)   –    El último valor de índice es uno más del que se quiere obtener y es len().

Tuples son inmutables. No se pueden manipular sino que hay que crear otro.

RatingsSorted = sorted(Ratings)

Se puede hacer Nesting donde un tuple contenga a otro. NT=(1,2,(“pop”,”rock”)), NT[2]:(”pop”, “rock”)[1]=”rock”

Collections

Lists

Son mutable y pueden contener strings, números, tuples y lists.

A=[“Mucharl Jackson”, 10.1, 1982, [1,2], (‘A’, 1)]

Se acceden por subíndices Para B=[1,2,[3,’a’],[4,’b’]] , B[3][1] es igual a ‘b’

Para borrar el elemento n-avo, del(B[n])

Slicing

B[3:5] representa todos los elementos entre el índice 3 y 5 (excluido)

B[:5] todos los elementos desde el principio hasta el 5 (excluido)

B[5:] todos los elementos desde el 5 hasta el final incluido

B[:] todos los elementos de la lista

B[-1] último elemento, B[-2] penúltimo elemento

Conversión de String a List, usa como separador el space  –  “hard rock”.spli()  [“hard”,”rock”]

Se puede seleccionar el separador “A,B,C”.split(“,”)  [“A”, ”B”, ”C”]

A=B[:]  ó  A=list(B) Copia una lista en una nueva variable con diferente espacio de memoria

La funcion sorted(lista) devuelve una nueva lista ordenada –sin modificar la original- que hay que guardar en otra variable de tipo lista, Exite min(), max(), len(), list(), range()

B.sort() ordena la lista actual modificándola.

B.extend([“pop”, 10]) agrega a la cola de una existente, también suma listas con +

CUIDADO, si se trata de un numpy.array, entonces se suman elemento a elemento.

B.append([“pop”, 10]) agrega solo un elemento y en este caso es una lista.

append(item), insert(item, pos), remove(pos), pop([pos]), clear(), index(item), count(item), reverse(), copy()

Arrays

similares a las listas pero se puede operar aritméticamente sobre ellos. Si se divide por un número, lo hace por cada elemento.

B es un array([1, 2, 3, 4]),        B[1] –>2,        B > 2   es un array([False, False, True, True])

B[B > 2]  ->  array([3, 4])  !!!!!!!!!!!! Así se puede sacar un subset de un array a otro o reeplazar un valor determinado en todo el array.

factorials = map(math.factorial, range(5))

factorials = [math.factorial(num) for num in range(5)]

factorials_of_odds = (math.factorial(num) for num in xrange(10**10) if num % 2 != 0)

xrange(10**10) ** is the exponent operator ^. The usual range function, when called with 10**10 as an argument, would have to allocate and keep in memory a ten billion–elements list. Instead of preallocating such a big list, xrange returns an iterator, which only when iterated over, produces elements up to ten billion, one at a time.

Se puede inicializar un array indicando el tipo de dato a guardar vals = array(‘i’, [3,4,5]) o sin valores

vals.typecode tiene el tipo de variable del array.

Dictionary

Son listas donde el primer elemento es el key y el segundo el contenido, se usan entre {}

Dict={“A”:1,”B”:”2″,”C”:[3,3,3],”D”:(4,4,4),’E’:5,’F’:6}

Dict[“D”] es (4,4,4)

Se agrega directamente haciendo una asignación de un nuevo key

Dict[‘Z’] = ‘piojo’ ; para borrar:  del(Dict[‘B’]) y borra el key y el value

“Z” in Dict da True o False según exista o no en el diccionario.

Dict.keys() devuelve una lista con todos los keys  [“A”, ”B”, ”C”, ”D”, “E”, ”Z”]

Dict.values() devuelve una lista con todos los valores  [1, ”2”, [3,3,3], (4,4,4), 5, ”piojo”]

Sets

Son listas desordenadas sin índice con elementos únicos y pueden contener cualquier tipo de dato.

Se puede convertir una lista en un set con la función set()

album_list = [“MJ”, “Thriller”, “Thriller”, 1982]

album_set = set(album_list)

album_set: {“MJ”, “Thriller”, 1982}  elimina los repetidos ya que deben ser elementos únicos

Se agrega album_set.add(“nuevo item”) y se elimina con album_set.remove(“item”), si se agrega un item dos veces, lo ignora  “MJ” in album_set devuelve True

Se pueden usar operadores tal como diagramas de Venn set3 = set1 & set2 (intersección), la unión se hace mediante un método  set1.union(set1) – se puede chequear si es subset con set3.issubset(set1)

Control de Flujo

La indentación marca los diferentes bloques de ejecución

if (condition):
    statement
elif (condition):
    statement
else:
    statement

for i in range(0,5):
    var[i] = 0

for elemento in lista_de_elementos:
   statement

for i, x in enumerate([“a”, “b”, “c”]):
   print(i, x)

salida: 0a 1b 2c

while(condition):
    statement

 For Else

for num in nums:     
     if num % 5 == 0           print(num)
          break
else:
     print(“not found”)

en este código, con el else indentado a la altura del for, se ejecuta SI NO HIZO NINGUN BREAK

Operador Ternario

value if condition else alternative

print(2 if x<0 else 2)

ShortHand Ternary

>>> output = None
>>> msg = output or "No data returned"
>>> print(msg)
No data returned

Funciones

def f1(input):

    output=XXXX

return output

 

def ImprimirNombres(* nombres)       # cantidad variables de parámetros.

    global GlobalVar                                  # Declaración de variable global accesible por fuera de la func.

    for nombre in nombres:

           print(nombre)

def a_function(arg1, arg2=“default”, *args, **kwargs):

“””This is a short piece of documentation for this function. It can span multiple lines. “””

print “arg1:”, arg1 # arg1 is a mandatory parameter

print “arg2:”, arg2 # arg2 is an optional parameter
with a default value

print “args:”, args # args is a tuple of positional parameters

print “kwargs:”, kwargs # kwargs is a dictionary of keyword parameters

>>> a_function(10)

arg1: 10

arg2: default

args: ()

kwargs: {}

>>> a_function(10, “twenty”, arg3=30, arg4=“forty”)

arg1: 10

arg2: twenty

args: ()

kwargs: {‘arg3’: 30, ‘arg4’: ‘forty’}

>>> a_function(arg2=“twenty”, arg1=10, arg3=30, arg4=“forty”)

arg1: 10

arg2: twenty

args: ()

kwargs: {‘arg3’: 30, ‘arg4’: ‘forty’}

Multireturn

def multi_return():

# These are automatically wrapped up

# and returned in one tuple

>>> values = multi_return()

return 10, 20, ‘thirty’      # Devuelve más de un valor y se empaqueta automáticamente en un tuple

>>> print values

(10, 20, ‘thirty’)

# La función puede recibir los valores también de esta forma

>>> a, b, c = multi_return()  # igualando 3 variables a una función que devuelve tres valores.

>>> print a, b, c

10 20 thirty

Classes

class class1(object)

    def __init___ (self, val1=5, val2):   ‘default value 5

            self.val1=val1

            self.val2=val2

Se crea un objeto  O1 = class1(val1, val2)

..

Swap variable values

a, b = b, c

Ingreso de datos

x = input(“ingrese nombre: ”)   Input siempre devuelve un str.

x = input(“ingrese un caracter: ”)[0]

x = int(input(“Ingresar un número: ”))

x = eval(input(“Ingresar un fórmula: ”))

x = int(sys.argv[1])  así entran los parámetros de ejecución, argv[0] es el nombre del programa. Import sys

Bitwise

NOT  ~12  ->  -13    ,    AND    12 & 13  ->  12    ,    OR    12 | 13  ->  13    ,    12 ^ 13 –> 1    ,    10 << 2 –> 40

Importación de Módulos

import math permite usar las funciones con math.sqr   x=math.sqr(2) math.e  math.pi

import math as m permite usar las funciones con m.sqr   x=m.sqr(2) m.e  m.pi también anda math.

from math import sqr, pow  importa solo esas funciones y se usa directamente x=pow(3) sin math.

from math import *  levanta todas las funcoines para usar directamente sin math. ni alias.

if so<\strong><\span><\code>