Introducción a Python

En este artículo, cubriremos los conceptos básicos de Python. Nos estamos acercando cada vez más a la meta, en general, pronto comenzaremos a trabajar con las bibliotecas principales de Data Science y utilizaremos TensorFlow (para escribir e implementar redes neuronales, comprenderá Deep Learning).

Instalación

Python se puede descargar desde python.org. Sin embargo, si aún no está instalado, en su lugar
Recomiendo el paquete de distribución de Anaconda, que ya incluye la mayoría de las bibliotecas necesarias para trabajar en el campo de la ciencia de datos.

Si no está utilizando la distribución Anaconda, asegúrese de instalar el administrador de paquetes pip, que facilita la instalación de paquetes de terceros, ya que necesitaremos algunos de ellos. También vale la pena instalar el shell de IPython interactivo mucho más fácil de usar. Tenga en cuenta que la distribución de Anaconda viene con pip e IPython.

Espacio en blanco

Muchos lenguajes de programación usan bloques de código diferenciadores.
frenillos La sangría se usa en Python:

#      for for i in [ 1, 2, 3, 4, 5] : print (i) #     for i for j in (1, 2, , 4, 5 ] : print ( j ) #     for j print (i + j) #     for j print (i) #     for i print ( "  ") 

Esto hace que el código sea fácil de leer, pero al mismo tiempo hace que siga el formato. Se ignora el espacio entre paréntesis y corchetes, lo que facilita la escritura de expresiones detalladas:

 #    long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20) 

y código fácil de leer:

 #   list_of_lists = [ [ 1 , 2, 3 ) , [4, 5, 6 ] , [ 7 , 8, 9 ] ] #      easy_to_read_list_of_lists = [1, 2, 3 ) , [4, 5, 6 ) , [7, 8, 9 ) ] 

Para continuar con la declaración, la barra invertida se usa en la siguiente línea, sin embargo, dicho registro rara vez se usará:

 two_plus_three = 2 + \ 3 

Formatear código con espacios en blanco hace que sea difícil copiar y pegar código en el shell de Python. Por ejemplo, intentando copiar el siguiente código:

 for i in [ 1, 2, 3, 4, 5] : #      print (1) 

en el shell estándar de Python arrojará un error:

 #    :     IndentationError : expected an indented blk 

porque para el intérprete, una cadena vacía indica el final de un bloque de código con un bucle for.

IPython tiene una función mágica "% pegar" que pega correctamente todo en el portapapeles, incluido el espacio en blanco.

Módulos (Importando Bibliotecas)

Algunas bibliotecas de entorno de programación basadas en Python no se cargan de manera predeterminada. Para poder utilizar estas herramientas, debe importar los módulos que las contienen.

Un enfoque es simplemente importar el módulo en sí:

 import re my_regex = re.compile ("[0-9]+",re.I) 

Aquí está el nombre del módulo que contiene funciones y constantes para trabajar con expresiones regulares. Al importar todo el módulo de esta manera, puede acceder a las funciones prefijándolas con re.

Si ya hay una variable con el nombre re en el código, puede usar el alias del módulo:

 import re as regex my_regex = regex.compile("[0-9)+",regex.I) 

El alias también se usa en los casos en que el módulo importado tiene un nombre engorroso o cuando el módulo accede con frecuencia al módulo.

Por ejemplo, al visualizar datos basados ​​en el módulo matplotlib , generalmente
use el siguiente alias estándar:

 import matplotlib.pyplot as plt 

Si necesita obtener varios valores específicos del módulo, puede importarlos explícitamente y usarlos sin restricciones:

 from collections import defaultdict , Counter lookup = defaultdict(int) my_counter = Counter() 

Las funciones

Una función es una regla que toma cero o más argumentos de entrada y devuelve el resultado correspondiente. En Python, las funciones generalmente se definen usando la declaración def:

 def double() : """,  ,     docstring,  ,    . ,       2""" return  * 2 

Las funciones en Python se tratan como objetos de primera clase. Esto significa que pueden asignarse a variables y pasarse a otras funciones de la misma manera que cualquier otro argumento:

 #   f   def apply_to_one(f): '""'  f      """ return f(1) my _ double = double #       = apply_to_one(my_double) # = 2 

Además, puede crear fácilmente funciones anónimas cortas o expresiones lambda:

  = apply_to_one(lambda :  + 4) # = 5 

Las expresiones lambda pueden asignarse a variables. Sin embargo, se recomienda utilizar el operador def:

 another double = lmbd : 2 *  #    def another_double (x) : return 2 *  #   

Además, puede pasar argumentos predeterminados a los parámetros de la función, que deben especificarse solo cuando se espera un valor diferente al predeterminado:

 def my_print (message="oe   " ): print (message ) my_print ( "pe") #  '' my_print () #  '   ' 

A veces es recomendable especificar argumentos por nombre:

 #   def subtract ( a=0, =0 ) : return  - b subtract (10, 5)#  5 subtract (0, 5)#  -5 subtract (b=5 )#  ,      

En el futuro, las funciones se utilizarán con mucha frecuencia.

Líneas

Las cadenas de caracteres (o secuencias de caracteres) en ambos lados están limitadas a comillas simples o dobles (deben coincidir):

 single_quoted_string = '    ' #  double_quoted_string = "  " #  

La barra invertida se usa para codificar caracteres especiales. Por ejemplo:

 tab_string = "\t" #    len (tab_string)# = 1 

Si necesita la barra invertida, que ocurre directamente
en los nombres de directorio en el sistema operativo Windows, luego usando r '"' puede crear una cadena sin formato :

 not_tab_string = r"\t" #   ' \ '  ' t ' len (not_tab_string) # = 2 

Los bloques de texto de varias líneas se crean usando triple simple (o
doble) citas:

 multi_line_string = """   .        """ 

Excepciones

Cuando algo sale mal, Python lanza una excepción. Las excepciones no controladas hacen que el programa se detenga inesperadamente. Las excepciones se manejan usando las declaraciones try y except :

 try: print (0 / 0) except ZeroDivisionError : rint ( "    ") 

Aunque en muchos lenguajes de programación el uso de excepciones se considera un mal estilo de programación, en Python no hay nada de qué preocuparse si se usa para hacer que el código sea más limpio, y a veces lo haremos.

Listas

Probablemente la estructura de datos más importante en Python es una lista. Esta es solo una colección ordenada (o colección), similar a una matriz en otros lenguajes de programación, pero con funcionalidad adicional.

 integer_list = [1, 2, ] #    heterogeneous_list = ["", 0.1 , True] #   list_of_lists = [integer_list, heterogeneous_list, [] ] #   list_length = len(integer_list) #  = 3 list_sum = sum(integer_list)#    = 6 

Puede establecer el valor y acceder al enésimo elemento de la lista utilizando corchetes:

  = list(range (10)) #   {0, 1 , . . . , 9] zero =  [0] # = 0 ,  -, .  .  1-  = 0 one = x [1] # = 1 nine =  [-1] # = 9, -    eight =  [-2] # = 8, -     [0] = -1 #   = { - 1 , 1 , 2, 3, . . . , 9] 

Además, los corchetes se usan para "cortar" listas:

 first_three = [:] #   = [-1 , 1, 2] three_to_end = [3:] #    = {3, 4, ... , 9] one_to_four = [1:5] #     = {1 , 2, 3, 4] last_three = [-3:] #   = { 7, 8, 9] without_first_and_last = x[1:-1] #     = {1 , 2, ... , 8] _ of _ = [:] #   = [ -1, 1, 2, ... , 91 

Python tiene una instrucción ln que verifica si un elemento pertenece a una lista:

 1 ln [1, 2, 3] #True 0 ln [1, 2, 3] #False 

La verificación consiste en ver todos los elementos de uno en uno, por lo tanto, vale la pena usarlo solo cuando se sabe con certeza que la lista es pequeña o que no importa cuánto tiempo demore la verificación.

Las listas son fáciles de encadenar:

  = [1, 2, 3] . extend ( [ 4, 5, 6] ) #   = {1, 2, 3, 4, 5, 6} 

Si desea dejar la lista x sin cambios, puede usar la adición de listas:

  = [1, 2, 3]  =  + [4, 5, 6] #= (1, 2, 3, 4, 5, 6] ;    

Por lo general, se agrega un elemento a las listas en una operación:

  = [1, 2, 3] x.append (0)#   = [1,2,3,0] =  [-1] # = 0 z = len (x)# = 4 

A menudo es conveniente descomprimir una lista si sabe cuántos elementos contiene:

 ,  = [1, 2] #   = 1,  = 2 

Si el número de elementos no es el mismo en ambos lados de la expresión, se mostrará un mensaje de error ValueError.

Para un valor descartado, generalmente se usa un guión bajo:

 _,  = [1, 2] #   == 2,     

Tuplas

Las tuplas son primos inmutables (o inmutables) de listas.

Casi todo lo que se puede hacer con una lista sin hacer cambios se puede hacer con una tupla. En lugar de corchetes, una tupla se hace con corchetes, o pueden prescindir de ellos:

 my_list = [1, 2] #   my_tuple = (1, 2) #   other_tuple = 3, 4 #    my_list [1] = 3 #  my_list = [1 , 3] try: my_tuple [1] = 3 except ypeError : print ( "   " ) 

Las tuplas proporcionan una forma conveniente de devolver múltiples valores de las funciones:

 #        def sum_and_product (x,  ) : return ( + ) , ( * ) sp = sum_and_product (2, 3) # = (5, 6) s,  = sum_and_product (S, 10) # s = 15,  = 50 

Las tuplas (y listas) también se usan en múltiples tareas:

 ,  = 1, 2 #   = 1,  = 2 ,  = ,  #   -;   = 2,  = 1 

Diccionarios

Un diccionario o una lista asociativa es otra estructura de datos básica.

En él, los valores están asociados con claves, lo que le permite recuperar rápidamente el valor correspondiente a una clave específica:

 empty_dict = {} #   - empty_dict2 = dict () #   - grades = { "Grigoriy" : 80, "Tim" : 95 } #   (  ) 

Se puede acceder al valor clave usando corchetes:

 rigory_aleksee = grades[ "Grigoriy"] # = 80 

Si intenta solicitar un valor que no está en el diccionario, recibirá un mensaje de error KeyError:

 try: kates_grade = grades [ "Kate "] except eyError: rint ( "    ! " ) 

Puede buscar una clave con el operador in:

 grigoriy_has_grade = "Grigoriy" in grades #true kate_has_grade = "Kate" in grades #false 

Los diccionarios tienen un método get () que, cuando busca una clave faltante, en lugar de lanzar una excepción, devuelve el valor predeterminado:

 grigoriy_grade = grades. get ( "Grigoriy ", 0) # =80 kates_grade = grades.get ("Kate" , 0) # = 0 no_ones_grade = grades.get ( "No One" ) #    = None 

La asignación del valor clave se realiza utilizando los mismos corchetes:

 grades [ "Tim" ] = 99 #    grades [ "Kate"] = 100 #    num_students = len(grades) # = 3 

Los diccionarios a menudo se usan como una forma fácil de representar estructuras
datos:

 tweet = { "user" : " grinaleks", "text" : "   -  ", " retweet_count" : 100, "hashtags " : [ "# data", " #science", " #datascience " , " #awesome", "#yolo" ] } 

Además de buscar claves individuales, puede contactar a todos a la vez:

 tweet_keys = tweet.keys() #   tweet_values = tweet.values() #   tweet_items = tweet.items() #   (, ) "user" in tweet_keys # True,    in  "user" in tweet # -,   in  "grinaleks" in tweet_values # True 

Las llaves deben ser inmutables; en particular, las listas no pueden usarse como claves. Si necesita una clave compuesta, entonces es mejor usar una tupla o encontrar una manera de convertir la clave en una cadena.

Diccionario por defecto

Deje que el documento necesite contar las palabras. La solución obvia al problema es crear un diccionario en el que las claves sean palabras y los valores sean las frecuencias de las palabras (o el número de apariciones de palabras en el texto). Al verificar palabras, si la palabra actual ya está en el diccionario, entonces su frecuencia aumenta, y si está ausente, se agrega al diccionario:

 #   word_ counts = { } document = { } #  ;    for word in document : if word in word counts: word_counts [word] += 1 else : word_counts [word] = 1 

Además, puede aprovechar un método llamado "es mejor pedir perdón que permiso" y detectar el error al intentar acceder a la clave que falta:

 word_ counts = { } for word in document : try: word_counts [word] += 1 except eyError : word_counts [word] = 1 

El tercer truco consiste en utilizar el método get (), que supera la situación con gracia cuando faltan claves:

 word_counts = { } for word in document : previous_count = word_counts.get (word, 0) word_counts [word] = previous_count + 1 

Todas estas técnicas son un poco engorrosas, y por esta razón es aconsejable usar el diccionario defaultdict (que también se llama diccionario con: valor predeterminado). Parece un diccionario normal, excepto por una característica: cuando se intenta acceder a una clave que no está en ella, primero agrega un valor utilizando la función sin argumentos, que se proporciona cuando se crea. Para usar los diccionarios defaultdict, debe importarlos desde el módulo de colecciones:

 from collections import defaultdict word_counts = defaultdict(int) # int ()  0 for word in document : word_counts[word] += 1 

Además, el uso de diccionarios defaultdict es práctico cuando se trabaja con listas, diccionarios e incluso con funciones personalizadas:

 dd_list = defaultdict (list)# list ()    dd_list [2].append (l) #  dd_list  (2: {1] } dd_dict = defaultdict (dict ) # dict ()    dict dd_dict ["Grigoriy"] [ "City" ] = "Seattle" # { "Grigoriy" : { "City" : Seattle"} dd_pair = defaultdict (lambda: [0,0] ) dd_pair [2][1] = 1 #  dd_pair  (2 : {0,1] } 

Estas características serán necesarias cuando los diccionarios se usen para la "colección"
resultados para una determinada clave y cuando es necesario evitar duplicados
comprueba la presencia de una clave en el diccionario.

Diccionario de contador

Una subclase de diccionarios de contador transforma una secuencia de valores en un objeto por defecto (int), donde las teclas se asignan a frecuencias o, más precisamente, las teclas se muestran (mapa) en frecuencia.

Se utilizará principalmente al crear histogramas:

 from collections import Counter  = Counter([0,1,2,0]) #    = { 0 : 2, 1 : 1, 2 : 1 } 

Su funcionalidad hace que sea bastante fácil resolver el problema de contar frecuencias de palabras:

 #      word_counts = Counter (document) 

El diccionario de contador tiene el método most_common (), que a menudo es útil:

 #  10       () for word, count in word_counts.most_common(10) : print (word, count ) 

Muchos

El conjunto o la estructura de datos establecida es una colección de elementos desordenados sin repeticiones:

 s = set ()#    s.add (1) #  s = { 1 } s.add (2) #  s = { 1, 2 } s.add (2) # s    = { 1, 2 }  = len (s) # = 2  = 2 in s # = True z = 3 in s # = False 

Muchos se usarán por dos razones. Primero, la operación en los sets es muy rápida. Si necesita verificar que un conjunto grande de elementos pertenezca a una secuencia determinada, entonces la estructura de datos del conjunto es más adecuada para esto que una lista:

 #  - stopwords_list = [ "a", "an" , "at "] + hundreds_of_other_words + [ "yet ", " you"] " zip" in stopwords_list # False,     #  - stopwords_set = set(stopwords_list) " zip" in stopwords_set #    

La segunda razón es obtener elementos únicos en el conjunto de datos:

 item_list = [1, 2, 3, 1, 2, 3] #  num_items = len( item_list) #  = 6 item_set = set(item_list) #   (1, 2, 3} num_distinct_items = len(item_set) #   = 3 distinct_item_list = list(item_set) #    = [1,2,3] 

Muchos se usarán con mucha menos frecuencia que los diccionarios y las listas.

Estructuras de control

Como en la mayoría de los otros lenguajes de programación, las acciones se pueden realizar por condición utilizando la instrucción if:

 if 1 > 2: message " 1    2 . . . " elif 1 > 3: message "elif  'else if '" else: message = "      ,  else " 

Además, puede usar el operador triple de una sola línea if-then-else, que a veces se usará más adelante:

 parity = "" if  % 2 ===  else " " 

Python tiene un bucle whlle:

  = 0 while  < 10: print (x, " 10")  += 1 

Sin embargo, el bucle for se usará más a menudo con el operador in:

 for  in range (lO) : print (x, " 10" ) 51 

Si necesita una lógica de control de bucle más compleja, puede usar los operadores

 continue  break: for  1n range (10) : 1f  == 3: continue #      if  == 5: break print (x) #    

Como resultado, se imprimirán 0, 1, 2 y 4.

Veracidad

Las variables booleanas en Python funcionan de la misma manera que en la mayoría de los otros lenguajes de programación, con solo una excepción: están en mayúsculas:

 one_is_less_than_two = 1 < 2 #True true_equals_false = True == False #False 

Para indicar un valor inexistente, se utiliza un objeto None especial, que corresponde a nulo en otros idiomas:

  = None print (x == None )#  True,    - print (  is None ) #  True - 

Python puede usar cualquier valor donde se espera un tipo booleano booleano. Todos los siguientes elementos tienen un valor booleano de False:

• Falso .
• Ninguno
• set () (set):
• [] (lista vacía);
• {} (diccionario vacío);

Casi todo lo demás se considera cierto. Esto facilita el uso de las declaraciones if para verificar si hay listas vacías. líneas vacías, diccionarios vacíos, etc. A veces, sin embargo, esto conduce a errores difíciles de reconocer, si no tiene en cuenta lo siguiente:

 s = some_function_that_returns_a_string () #    if s: first_char = s [0] #     else: first char = "" 

Aquí hay una manera más fácil de hacer lo mismo:

 first_char = s and s [0] 

porque el operador lógico y devuelve el segundo valor, si el primero es verdadero, y el primer valor, si es falso. De manera similar, si x en la siguiente expresión es un número o posiblemente Ninguno, entonces el resultado será de alguna manera un número:

 safe  =  or 0 #   

La función integrada de Python toma una lista y devuelve True solo cuando cada elemento de la lista es verdadero, y cualquier función incorporada devuelve verdadero cuando al menos un elemento es verdadero:

 all ( [True, 1, { 3 }]) # True all ( [True, 1, {}] ) # False, {} =  any ( [ True, 1, {}]) # True, True =  all ( [] ) # True,      any ( [ ] ) # False,