Exercício 2 - Introdução aos conceitos e Ferramentas

Autor:tiagofrepereira
Data:06/03/2012

1. Python e Numpy

O Python é uma linguagem de programação de alto nível que possui as seguintes características:

  • É interpretada;
  • É orientada a objetos;
  • Não há declaração de variáveis;
  • A tipagem é dinamica e forte;
  • "Quais os tipos de alto nível que o Python possui?"

    Os tipos de alto nível do python são:

    • Listas
    • Tuplas
    • Strings
    • Dicionário
    • Arquivo
    • Classe
  • "Procure fazer uma pequena demonstração de cada um dos tipos do Python""

     1 ##########
     2 #Listas
     3 ##########
     4 A = [1,2,3]
     5 print(A)
     6 #inserindo um elemento na lista
     7 A.append(4)
     8 print(A)
     9 print(type(A))
    10 print("\n")
    11 
    12 ########
    13 #Tuplas
    14 ########
    15 A = ((1,'Tupla 1'),(2,'Tupla 2'))
    16 print(A)
    17 print(type(A))
    18 print("\n")
    19 
    20 ############
    21 #Dicionário
    22 ############
    23 A = {1:"Elem1",2:"Elem2"}
    24 print(A)
    25 
    26 #Apresentando as chaves
    27 print(A.keys())
    28 
    29 #Apresentando os valores
    30 print(A.values())
    31 
    32 print(type(A))
    33 
    34 print("\n")
    35 
    36 #########
    37 #Strings
    38 ########
    39 A = "Teste de "
    40 A = A + "STRING"
    41 print(A)
    42 print(type(A))
    43 print("\n")
    44 
    45 
    46 #####
    47 #Classe
    48 ######
    49 class A:
    50     atributo1=None
    51     def __init__(entrada1):
    52         atributo1 = entrada1
    53 
    54     def getAtributo1():
    55         return self.atributo1
    56 
    57 print(type(A))
    58 print("\n")
    59 
    60 ######
    61 # Arquivos
    62 ######
    63 file = open(find_attachment_file('attachment2.txt'))
    64 A = file.read()
    65 print(A)
    66 print(type(file))
    67 print("\n")
    
    [1, 2, 3]
    [1, 2, 3, 4]
    <type 'list'>
    
    
    ((1, 'Tupla 1'), (2, 'Tupla 2'))
    <type 'tuple'>
    
    
    {1: 'Elem1', 2: 'Elem2'}
    [1, 2]
    ['Elem1', 'Elem2']
    <type 'dict'>
    
    
    Teste de STRING
    <type 'str'>
    
    
    <type 'classobj'>
    
    
    *******
    Texto do arquivo
    
    Tiago de Freitas Pereira
    *******
    
    <type 'file'>
    
  • "Qual é a diferença entre lista e tupla? Exemplifique."

    Lista é um conjunto valores acessados através de um índice numérico (em outras liguagens um tipo análogo são os vetores), inteiro, começando em zero e podendo armazenar valores de qualquer tipo

    As tuplas também são um conjunto de valores acessados através de um índice com a exceção de serem imutáveis, ou seja, uma vez atribuído um valor para uma tupla ela não pode mais ser alterada.

  • "Qual é a importância da indentação na linguagem?"

    No python, a indentação tem o papel de controlar blocos de código (como loops, expressões condicionais ou funções). Diferente de linguagens de programação como C ou Pascal que possui delimitadores específicos, o Python utiliza-se apenas da indentação. De certa forma, isto força o programador a manter o código organizado.

  • "Qual os tipos adicionais que o NumPy oferece? Procure exercitar várias operações com matrizes."

    O Numpy é um pacote do Python que possui facilitadores para trabalhar com arrays de N dimensões. Sua manipulação é muito semelhante ao matlab. Os tipos adicionais que o numpy oferece a linguagem python são:

    Tipo de dado

    Descrição

    bool

    Boleano (True or False) ocupa 1 byte

    int

    Inteiro (número de bits depende da plataforma (32 bits ou 64 bits)

    int8

    Inteiro de 8 bits (-128 to 127)

    int16

    Inteiro de 16 bits (-32768 to 32767)

    int32

    Inteiro de 32 bits (-2147483648 to 2147483647)

    int64

    Inteiro de 64 bits (9223372036854775808 to 9223372036854775807)

    uint8

    Inteiro sem sinal de 8 bits (0 to 255)

    uint16

    Inteiro sem sinal de 16 bits (0 to 65535)

    uint32

    Inteiro sem sinal de 32 bits (0 to 4294967295)

    uint64

    Inteiro sem sinal de 64 bits (0 to 18446744073709551615)

    float

    Float

    float16

    Float de meia precisão (16 bits): 1 bit de sinal + 5 bits para o exponente + 10 bits para a mantissa

    float32

    Float de precisão simples (32 bits): 1 bit de sinal + 8 bits para o exponente + 23 bits para a mantissa

    float64

    Float de precisão dupla (64 bits): 1 bit de sinal + 11 bits para o exponente + 52 bits para a mantissa

    complex

    Número complexo.

    complex64

    Número complexo representado por 2 floats de 32 bits; um para a parte real e outro para a imaginária

    complex128

    Número complexo representado por 2 floats de 64 bits; um para a parte real e outro para a imaginária

    Abaixo segue algumas operações com matrizes utilizando o numpy

     1 from numpy import *
     2 
     3 #Criando 2 arrays
     4 A = array([[1,2],[1,2]])
     5 B = array([[1,3],[1,3]])
     6 
     7 #Multiplição de matrizes
     8 print(A*B)
     9 print("\n")
    10 
    11 #Soma de matrizes
    12 print(A+B)
    13 print("\n")
    14 
    15 #Transformando uma matriz A que é 2x2 para uma matriz que C 1x4
    16 C =A.reshape(1,4)
    17 print(C)
    18 print("\n")
    
    [[1 6]
     [1 6]]
    
    
    [[2 5]
     [2 5]]
    
    
    [[1 2 1 2]]
    

2. Graphviz: ferramenta de visualização

Criando grafo com o graphviz

/media/_xsb/courseIA368Q1S2012/tia_ex02/GRVIZ80331_001.png

Criando grafo programaticamente.

Neste exemplo, dada uma lista representando as arestas de uma grafo, sua representação em forma de matriz de adjacência é criada usando a rotina Larcos2MA, criado em sala de aula e visualizado utilizando a forma programática do graphviz. Os nós pares estão em vermelho e com forma quadrada.

 1 from tia_test1 import *
 2 from numpy import *
 3 
 4 
 5 graph = gvgen.GvGen()
 6 graph.smart_mode = 1
 7 graph.styleDefaultAppend("color", "black")
 8 
 9 
10 #Criando um digrafo
11 L = array([[0,1],[3,2],[1,0],[3,0],[4,5],[1,1],[1,4],[2,5],[0,5],[1,6],[0,6],[3,6]])
12 
13 #Transformando este digrafo em forma de matriz de adjacência
14 mAdj = Larcos2MA(L)
15 print("Matriz de adjacência")
16 print(mAdj)
17 
18 size= len(mAdj)
19 #Criando os nós do grafo
20 nodes = []
21 for i in range(size):
22     nodes.append(graph.newItem(str(i)))
23     #Modificando os nós de rótulo par
24     if(i%2==0):
25         graph.propertyAppend(nodes[i], "shape", "box")
26         graph.propertyAppend(nodes[i], "fontcolor", "red")
27 
28 
29 #Criando as arestas do grafo
30 for i in range(size):
31     for j in range(size):
32         if(mAdj[i][j]==1):
33             graph.newLink(nodes[i],nodes[j])
34 
35 
36 import StringIO
37 fd = StringIO.StringIO()
38 graph.dot(fd)
39 dottext = fd.getvalue()
40 
41 mmgraphviz(dottext, title='Exemplo de grafo feito de forma programática')
Matriz de adjacência
[[ Inf   1.  Inf  Inf  Inf   1.   1.]
 [  1.   1.  Inf  Inf   1.  Inf   1.]
 [ Inf  Inf  Inf  Inf  Inf   1.  Inf]
 [  1.  Inf   1.  Inf  Inf  Inf   1.]
 [ Inf  Inf  Inf  Inf  Inf   1.  Inf]
 [ Inf  Inf  Inf  Inf  Inf  Inf  Inf]
 [ Inf  Inf  Inf  Inf  Inf  Inf  Inf]]
/media/_xsb/courseIA368Q1S2012/tia_ex02/GRVIZ80331_002.png

Exemplo de grafo feito de forma programática

3. Exercício Extra

Este exercício está resolvido em Larcos2MA e está empacotado em formato de biblioteca.