Introdução ao Python

Neste artigo, abordaremos o básico do Python. Estamos cada vez mais próximos do objetivo. Em geral, em breve começaremos a trabalhar com as principais bibliotecas da Data Science e usaremos o TensorFlow (para escrever e implantar redes neurais, você entenderá o Deep Learning).

Instalação

O Python pode ser baixado em python.org. No entanto, se ainda não estiver instalado, em vez disso
Eu recomendo o pacote de distribuição Anaconda, que já inclui a maioria das bibliotecas necessárias para trabalhar no campo da ciência de dados.

Se você não estiver usando a distribuição Anaconda, certifique-se de instalar o gerenciador de pacotes pip, o que facilita a instalação de pacotes de terceiros, pois precisaremos de alguns deles. Também vale a pena instalar o shell IPython interativo muito mais amigável. Lembre-se de que a distribuição do Anaconda vem com pip e IPython.

Espaço em branco

Muitas linguagens de programação usam blocos de código diferenciados.
aparelho. O recuo é usado no 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 ( "  ") 

Isso facilita a leitura do código, mas ao mesmo tempo segue a formatação. O espaço entre parênteses e colchetes é ignorado, o que facilita a escrita de expressões detalhadas:

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

e fácil de ler código:

 #   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 a instrução, a barra invertida é usada na próxima linha; no entanto, esse registro raramente será usado:

 two_plus_three = 2 + \ 3 

A formatação do código com espaço em branco torna difícil copiar e colar o código no shell do Python. Por exemplo, tentando copiar o seguinte código:

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

no shell padrão do Python lançará um erro:

 #    :     IndentationError : expected an indented blk 

porque para o intérprete, uma sequência vazia indica o final de um bloco de código com um loop for.

O IPython possui uma função mágica "% paste" que cola corretamente tudo na área de transferência, incluindo espaço em branco.

Módulos (Importando Bibliotecas)

Algumas bibliotecas do ambiente de programação baseadas em Python não são carregadas por padrão. Para que essas ferramentas sejam usadas, você deve importar os módulos que as contêm.

Uma abordagem é simplesmente importar o próprio módulo:

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

Aqui re é o nome do módulo que contém funções e constantes para trabalhar com expressões regulares. Ao importar o módulo inteiro dessa maneira, você pode acessar as funções prefixando-as com re.

Se já existe uma variável com o nome re no código, você pode usar o alias do módulo:

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

O alias também é usado nos casos em que o módulo importado possui um nome complicado ou quando o módulo acessa frequentemente o módulo.

Por exemplo, ao visualizar dados com base no módulo matplotlib , geralmente
use o seguinte alias padrão:

 import matplotlib.pyplot as plt 

Se você precisar obter vários valores específicos do módulo, poderá importá-los explicitamente e usar sem restrições:

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

Funções

Uma função é uma regra que recebe zero ou mais argumentos de entrada e retorna o resultado correspondente. No Python, as funções são geralmente definidas usando a instrução def:

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

Funções em Python são tratadas como objetos de primeira classe. Isso significa que eles podem ser atribuídos a variáveis ​​e transmitidos para outras funções da mesma maneira que qualquer outro argumento:

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

Além disso, você pode criar facilmente funções anônimas curtas ou expressões lambda:

  = apply_to_one(lambda :  + 4) # = 5 

Expressões lambda podem ser atribuídas a variáveis. No entanto, é recomendável usar o operador def:

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

Além disso, você pode passar argumentos padrão para parâmetros de função, que devem ser especificados apenas quando um valor diferente do padrão é esperado:

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

Às vezes, é aconselhável especificar argumentos por nome:

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

No futuro, as funções serão usadas com muita frequência.

Linhas

As cadeias de caracteres (ou sequências de caracteres) nos dois lados são limitadas a aspas simples ou duplas (elas devem corresponder):

 single_quoted_string = '    ' #  double_quoted_string = "  " #  

A barra invertida é usada para codificar caracteres especiais. Por exemplo:

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

Se você precisar da barra invertida, que ocorre diretamente
nos nomes de diretório no sistema operacional Windows, usando r '"' é possível criar uma sequência não formatada :

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

Blocos de texto com várias linhas são criados usando o modo triplo simples (ou
duplo) citações:

 multi_line_string = """   .        """ 

Exceções

Quando algo dá errado, o Python lança uma exceção. Exceções não tratadas fazem com que o programa pare inesperadamente. As exceções são tratadas usando as instruções try e except :

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

Embora em muitas linguagens de programação o uso de exceções seja considerado um estilo de programação ruim, no Python não há nada com que se preocupar se for usado para tornar o código mais limpo, e às vezes faremos exatamente isso.

Listas

Provavelmente a estrutura de dados mais importante do Python é uma lista. Esta é apenas uma coleção (ou coleção) ordenada, semelhante a uma matriz em outras linguagens de programação, mas com funcionalidade 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 

Você pode definir o valor e acessar o enésimo elemento da lista usando colchetes:

  = 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] 

Além disso, colchetes são usados ​​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 possui uma instrução ln que verifica se um elemento pertence a uma lista:

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

A verificação consiste em visualizar todos os elementos, um de cada vez; portanto, vale a pena usá-lo somente quando se souber com certeza que a lista é pequena ou se não importa quanto tempo leva para verificar.

As listas são fáceis de encadear:

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

Se você quiser deixar a lista x inalterada, poderá usar a adição de listas:

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

Geralmente, um elemento é adicionado às listas em uma operação:

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

Muitas vezes, é conveniente descompactar uma lista se você souber quantos elementos ela contém:

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

Se o número de elementos não for o mesmo nos dois lados da expressão, uma mensagem de erro ValueError será exibida.

Para um valor descartado, um sublinhado é geralmente usado:

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

Tuplas

As tuplas são primos imutáveis ​​(ou imutáveis) das listas.

Quase tudo o que pode ser feito com uma lista sem fazer alterações pode ser feito com uma tupla. Em vez de colchetes, uma tupla é formada com colchetes, ou eles podem ficar sem eles:

 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 ( "   " ) 

As tuplas fornecem uma maneira conveniente de retornar vários valores das funções:

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

Tuplas (e listas) também são usadas em várias atribuições:

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

Dicionários

Um dicionário ou lista associativa é outra estrutura de dados básica.

Nele, os valores são associados às chaves, o que permite recuperar rapidamente o valor correspondente a uma chave específica:

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

O valor da chave pode ser acessado usando colchetes:

 rigory_aleksee = grades[ "Grigoriy"] # = 80 

Se você tentar solicitar um valor que não esteja no dicionário, você receberá uma mensagem de erro KeyError:

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

Você pode procurar por uma chave usando o operador in:

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

Os dicionários têm um método get () que, ao procurar uma chave ausente, em vez de gerar uma exceção, retorna o valor padrão:

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

A atribuição do valor-chave é realizada usando os mesmos colchetes:

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

Os dicionários são frequentemente usados ​​como uma maneira fácil de representar
dados:

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

Além de procurar chaves individuais, você pode entrar em contato com todos de uma 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 

As chaves devem ser imutáveis; em particular, listas não podem ser usadas como chaves. Se você precisar de uma chave composta, é melhor usar uma tupla ou encontrar uma maneira de converter a chave em uma string.

Dicionário padrão

Deixe o documento precisar contar as palavras. A solução óbvia para o problema é criar um dicionário no qual as chaves sejam palavras e os valores sejam as frequências das palavras (ou o número de ocorrências de palavras no texto). Durante a verificação de palavras, se a palavra atual já estiver no dicionário, sua frequência aumentará e, se estiver ausente, será adicionada ao dicionário:

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

Além disso, você pode tirar proveito de um método chamado "é melhor pedir perdão do que permissão" e detectar o erro ao tentar acessar a chave ausente:

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

O terceiro truque é usar o método get (), que supera normalmente a situação com a falta de chaves:

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

Todas essas técnicas são um pouco complicadas e, por esse motivo, é aconselhável usar o dicionário defaultdict (que também é chamado de dicionário com: valor padrão). Parece um dicionário comum, exceto por um recurso - ao tentar acessar uma chave que não está nele, ele primeiro adiciona um valor usando a função sem argumentos, que é fornecida quando é criada. Para usar dicionários defaultdict, você deve importá-los do módulo de coleções:

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

Além disso, o uso de dicionários defaultdict é útil quando se trabalha com listas, dicionários e até mesmo com funções definidas pelo usuário:

 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] } 

Esses recursos serão necessários quando dicionários forem usados ​​para "coleção"
resultados para uma determinada chave e quando é necessário evitar duplicados
verifica a presença de uma chave no dicionário.

Counter Dictionary

Uma subclasse de dicionários de contador transforma uma sequência de valores em um objeto do tipo defaultdict (int), onde as teclas são mapeadas para frequências ou, mais precisamente, as teclas são exibidas (map) em frequência.

Ele será usado principalmente na criação de histogramas:

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

Sua funcionalidade facilita bastante a resolução do problema de contagem de frequências de palavras:

 #      word_counts = Counter (document) 

O dicionário do contador possui o método most_common (), que geralmente é útil:

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

Muitos

O conjunto ou estrutura de dados do conjunto é uma coleção de elementos não ordenados sem repetições:

 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 

Muitos serão usados ​​por duas razões. Primeiro, a operação em conjuntos é muito rápida. Se você precisar verificar um grande conjunto de elementos para pertencer a uma determinada sequência, a estrutura de dados do conjunto é mais adequada para isso do que uma 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 #    

O segundo motivo é obter elementos exclusivos no conjunto de dados:

 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] 

Muitos serão usados ​​com muito menos frequência do que dicionários e listas.

Estruturas de controle

Como na maioria das outras linguagens de programação, as ações podem ser executadas por condição usando a instrução if:

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

Além disso, você pode usar o operador triplo se-então-outra linha, que às vezes será usado posteriormente:

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

Python tem um loop whlle:

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

No entanto, o loop for será usado com mais frequência com o operador in:

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

Se você precisar de uma lógica de controle de loop mais complexa, poderá usar os operadores

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

Como resultado, 0, 1, 2 e 4 serão impressos.

Veracidade

Variáveis ​​booleanas no Python funcionam da mesma maneira que na maioria das outras linguagens de programação, com apenas uma exceção - elas estão em maiúsculas:

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

Para indicar um valor inexistente, é usado um objeto None especial, que corresponde a null em outros idiomas:

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

Python pode usar qualquer valor em que seja esperado um tipo booleano booleano. Todos os seguintes elementos têm um valor booleano de False:

• Falso .
• Nenhuma
• set () (conjunto):
• [] (lista vazia);
• {} (dicionário vazio);

Praticamente tudo o resto é considerado verdadeiro. Isso facilita o uso de instruções if para verificar listas vazias. linhas vazias, dicionários vazios, etc. Às vezes, porém, isso leva a erros difíceis de reconhecer, se você não levar em consideração o seguinte:

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

Aqui está uma maneira mais fácil de fazer o mesmo:

 first_char = s and s [0] 

porque o operador lógico e retorna o segundo valor, se o primeiro for verdadeiro, e o primeiro valor, se for falso. Da mesma forma, se x na expressão a seguir for um número ou possivelmente Nenhum, o resultado será de alguma forma um número:

 safe  =  or 0 #   

A função all interna do Python pega uma lista e retorna True somente quando cada item da lista é verdadeiro, e a função interna retorna true quando pelo menos um elemento é verdadeiro:

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