Exercício 2

1. Python e Numpy

  • O Python é uma linguagem de programação de alto nível, interpretada, imperativa, orientada a objetos, de tipagem dinâmica e forte, que possui as seguintes:

    • É uma linguagem interpretada.
    • Não há pré-declaração de variáveis, e os tipos das variáveis são determinados dinamicamente.
    • O controle de bloco é feito apenas por indentação; não há delimitadores do tipo BEGIN e END ou { e }.
    • Oferece tipos de alto nível: strings, listas, tuplas, dicionários, arquivos, classes.
    • É orientada a objetos; aliás, em Python, tudo é um objeto.

    Assim sendo, é uma linguagem muito interessante para aplicações tanto comerciais como científicas. Em sua forma nativa, o Python suporta aos seguintes tipos de variáveis:

    Tipo Variável

    Descrição

    Exemplo de sintaxe

    str

    Variável para cadeia de caracteres ASCII

    a = "Exemplo"

    int

    Variável inteira de precisão, prolongada automaticamente ao long

    a = 104843877

    float

    Variável de ponto flutuante

    pi = 3.14159265

    bool

    Variável booleana - True ou False

    a = False

    complex

    Variável de número complexo

    c = 2+3j

    list

    Lista heterogênea com permissão de alteração nos valores

    lista = [4, 'eu', 1]

    tuple

    Tupla heterogênea sem permissão na alteração de valores

    tupla = (1, 'eu', 2)

    dict

    Conjunto associativo de valores

    dic = {1:'eu', 2:'você'}

  • Quais são os tipos de alto nível que Python possui?

    R: O Python possui tipos de alto nível:

    • Strings;
    • Listas;
    • Tuplas;
    • Dicionários;
    • Arquivos;
    • Classes.

(fonte: Async)

  • Procure fazer uma pequena demonstração de cada um dos tipos do Python.

    R:

    • Tipo String: vetor de caracteres ASCII para armazenar conteúdos de texto.
     1 # exemplo de string
     2 a = "Este é um exemplo de string"
     3 print type(a)
     4 
     5 # contando a quantidade de caracteres (inclui-se o espaço)
     6 b = len(a)
     7 print "\nQuantidade de Caracteres de a = " + str(b)
     8 
     9 # substituindo uma palavra por outra
    10 c = a.replace('é','foi')
    11 print c
    12 
    13 #contando a quantidade da uma letra em específica
    14 d = a.count('e')
    15 print "Quantidade de 'e' na cadeia = " + str(d)
    16 
    17 #encontrando a posição de uma determinada palavra
    18 e = a.find('um')
    19 print "A palavra 'um' está na posição " + str(e)
    20 
    21 #colocando tudo em maiúsculo
    22 f = a.upper()
    23 print f
    24 
    25 #colocando tudo em minúsculo
    26 g = a.lower()
    27 print g
    28 
    29 #concatenando uma string
    30 h = a + ' para a disciplina IA368Q'
    31 print h
    
    <type 'str'>
    
    Quantidade de Caracteres de a = 28
    Este foi um exemplo de string
    Quantidade de 'e' na cadeia = 4
    A palavra 'um' está na posição 8
    ESTE é UM EXEMPLO DE STRING
    este é um exemplo de string
    Este é um exemplo de string para a disciplina IA368Q
    
    • Tipo Lista: Assemelh-ase a um vetor em outras linguagens de programação que permite a inserção de vários tipos de variáveis, como até outras listas. Para criar uma lista, usamos colchetes e vírgulas para enumerar os valores.
     1 # exemplo de lista
     2 lista= [1, "Dicionário Fonético", [1, "A", "Alfa"],[2, "B", "Bravo"]]
     3 print type(lista)
     4 
     5 #pegando o segundo item da Lista
     6 a = lista[1]
     7 print a
     8 
     9 #pegando o terceiro item da Lista
    10 b = lista[2]
    11 print b
    12 
    13 #adicionando um item na lista no final
    14 lista.append([3, "C", "Charlie"])
    15 print lista
    16 
    17 #apagando o primeiro item na lista
    18 lista.pop(0)
    19 print lista
    20 
    21 #mais uma lista
    22 lista1= ["Abacaxi", "Caju", "Damasco", "Graviola", "Banana", "Cereja"]
    23 print '\n\n'
    24 print lista
    25 
    26 #ordenando a lista
    27 lista1.sort()
    28 print lista1
    29 
    30 #ivertendo a ordem da lista
    31 lista1.reverse()
    32 print lista1
    
    <type 'list'>
    Dicionário Fonético
    [1, 'A', 'Alfa']
    [1, 'Dicion\xc3\xa1rio Fon\xc3\xa9tico', [1, 'A', 'Alfa'], [2, 'B', 'Bravo'], [3, 'C', 'Charlie']]
    ['Dicion\xc3\xa1rio Fon\xc3\xa9tico', [1, 'A', 'Alfa'], [2, 'B', 'Bravo'], [3, 'C', 'Charlie']]
    
    
    
    ['Dicion\xc3\xa1rio Fon\xc3\xa9tico', [1, 'A', 'Alfa'], [2, 'B', 'Bravo'], [3, 'C', 'Charlie']]
    ['Abacaxi', 'Banana', 'Caju', 'Cereja', 'Damasco', 'Graviola']
    ['Graviola', 'Damasco', 'Cereja', 'Caju', 'Banana', 'Abacaxi']
    
    • Tipo Tupla: A tupla é semelhante a uma lista, porém é imutável e os valores são atribuidos por valores entre parentesis.
     1 # exemplo de lista
     2 tupla= (1, "A", "Alfa")
     3 print type(tupla)
     4 
     5 #pegando o segundo valor da tupla
     6 a = tupla[1]
     7 print a
     8 
     9 #não se pode modificar o valor da tupla (aparecerá um alerta de erro no programa
    10 tupla[1] = "Z"
    
    ERROR execute
    <type 'tuple'>
    A
    ------------------------------------------------------------
    *** Exception while evaluating code:
      File "<string>", line 10, in <module>
    TypeError: 'tuple' object does not support item assignment
    
    ------------------------------------------------------------
    
    
    • Tipo Dicionário: Um dicionário representa uma coleção de elementos onde é possível utilizar um índice de qualquer tipo imutável, ao contrário da lista, onde índices são sempre inteiros seqüencialmente atribuídos. É costumeiro usar os termos chave e valor (key/value) para descrever os elementos de um dicionário - a chave é o índice, e o valor, a informação correspondente àquela chave.
     1 # dicionário: (chave1: valor1, chave2: valor2, ..., chaven: valorn)
     2 dicionario =  {1:"alpha",2:"bravo",3:"charlie",26:"zulu"}
     3 print type(dicionario)
     4 
     5 #apresentando o valor corresponde a primeira chave
     6 print dicionario[1]
     7 
     8 #apresentando as chaves inseridas
     9 print dicionario.keys()
    10 
    11 #apresentando os valores inseridos
    12 print dicionario.values()
    
    <type 'dict'>
    alpha
    [1, 2, 3, 26]
    ['alpha', 'bravo', 'charlie', 'zulu']
    
    • Tipo Arquivo: Manipulação de arquivos.
    1 arquivo = open(find_attachment_file('teste.txt'))
    2 texto = arquivo.read()
    3 print texto
    4 print type(arquivo)
    
    Este é um arquivo texto, servido como exemplo para o exercício 2.
    +--------------------------------------------------------------+
    |Criado por: Wesley Angelino de Souza			       |
    |E-mail: szwesley001@gmail.com				       |
    +--------------------------------------------------------------+
    <type 'file'>
    
    • Tipo Classe
     1 class Pessoa:
     2   nome = None
     3   rg = None
     4   apelido = None
     5   telefone = None
     6 
     7   def __init__(self, nome, rg, apelido, telefone):
     8       self.nome = nome
     9       self.rg = rg
    10       self.apelido = apelido
    11       self.telefone = telefone
    12       print "Instância Pessoa Criada"
    13 
    14   def mostra_telefone(self):
    15       return self.telefone
    16 
    17   def mostra_apelido(self):
    18       return self.apelido
    19 
    20 p1 = Pessoa("Wesley Angelino de Souza", "12345678-9", "Wesley", "14 88261238")
    21 p2 = Pessoa("Jaqueline Scatolin", "11111111-1", "Jake", "14 88050222")
    22 
    23 print p1.mostra_apelido();
    24 print p1.mostra_telefone();
    
    Instância Pessoa Criada
    Instância Pessoa Criada
    Wesley
    14 88261238
    
    • Qual é a diferença entre lista e tupla? Exemplifique.

    R: A diferença essencial é que os valores atribuídos na tupla não podem ser modificados como na lista. A seguir um exemplo:

    • Lista
    1 # exemplo de lista
    2 lista= ["Alfa","Bravo","Charwlie","Delta"]
    3 print lista
    4 # corrigindo o Charwlie por Charlie
    5 lista[2]="Charlie"
    6 # Não existirá erro!!!
    7 print "-------------Nova lista--------------"
    8 print lista
    
    ['Alfa', 'Bravo', 'Charwlie', 'Delta']
    -------------Nova lista--------------
    ['Alfa', 'Bravo', 'Charlie', 'Delta']
    
    • Tupla
    1 # exemplo de tupla
    2 tupla= ("Alfa","Bravo","Charwlie","Delta")
    3 print tupla
    4 # corrigindo o Charwlie por Charlie
    5 tupla[2]="Charlie"
    6 # Acontecerá Erro e não será corrigida a string!!!
    7 print "-------------Nova tupla--------------"
    8 print tupla
    
    ERROR execute
    ('Alfa', 'Bravo', 'Charwlie', 'Delta')
    ------------------------------------------------------------
    *** Exception while evaluating code:
      File "<string>", line 5, in <module>
    TypeError: 'tuple' object does not support item assignment
    
    ------------------------------------------------------------
    
    

    Nos dois códigos é perceptível que, no exemplo de lista, a execução do código foi realizada, diferente do código da tupla, que não permite a mudança nos valores atribuídos.

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

    R: A importância da identação é para estruturar o código, funcionando como delimitadores (como na linguagem C que utiliza o { e } ou o Pascal que utiliza o begin e end. É importante para delimitar os blocos em execução, sobretudo de uma função, comandos condicionais ou laços de repetição. A seguir um exemplo da importância da identação no python:

     1 #neste caso a identação estará em dois comandos, assim a continua com o mesmo valor
     2 a = 5
     3 if a < 2:
     4   print "não passará por aqui"
     5   a = 0
     6 print a
     7 
     8 #aqui a identação é feita em um comando... a sairá zero? sim, por problema na identação.
     9 a = 5
    10 if a < 2:
    11   print "não passará por aqui"
    12 a = 0
    13 print a
    
    5
    0
    
    • Qual os tipos adicionais que o NumPy oferece? Procure exercitar várias operações com matrizes.

    O NumPy extende o Python no suporte a vetores multidimensionais (matrizes), bem como a diversas outras variáveis, como apresenta a tabela a seguir:

    Tipo Variável

    Descrição

    String

     

    string_

    String do Python

    Inteiras

     

    int_

    Inteira do Python

    byte

    Correspondente ao char da linguagem C

    short

    Correspondente ao short da linguagem C

    intc

    Correspondente ao int da linguagem C

    longlong

    Correspondente ao long long da linguagem C

    intp

    Inteira de ponto flutuante

    int8

    Inteira para processadores de 8 bits

    int16

    Inteira para processadores de 16 bits

    int32

    Inteira para processadores de 32 bits

    int64

    Inteira para processadores de 64 bits

    Inteiras sem sinal

     

    ubyte

    Correspondente ao unsigned char da linguagem C

    ushort

    Correspondente ao unsigned short da linguagem C

    uintc

    Correspondente ao unsigned int da linguagem C

    ulonglong

    Correspondente ao unsigned long long da linguagem C

    uintp

    Inteira positiva de ponto flutuante

    uint8

    Inteira para processadores de 8 bits

    uint16

    Inteira para processadores de 16 bits

    uint32

    Inteira para processadores de 32 bits

    uint64

    Inteira para processadores de 64 bits

    Ponto Flutuante

     

    float_

    Ponto flutuante do Python

    single

    Correspondente ao float da linguagem C

    double

    Correspondente ao double da linguagem C

    longfloat

    Correspondente ao long float da linguagem C

    float16

    Float para processadores de 16 bits

    float32

    Float para processadores de 32 bits

    float64

    Float para processadores de 64 bits

    float96

    Float para arquitetura de 96 bits

    float128

    Float para arquitetura de 128 bits

    Booleanas

     

    bool_

    Booleana do Python

    bool8

    Booleana de 8 bits

    Complexas

     

    complex_

    Número complexo do Python

    clongfloat

    Número complexo long float

    complex64

    Número complexo duplo float de 32 bits

    complex128

    Número complexo duplo float de 64 bits

    Além da extensão significativa das variáveis, o NumPy permite a programação utilizando matrizes, como apresentam os exemplos a seguir:

    • Criação de matriz
     1 #criação de uma matriz 3x3
     2 a = array( [ (1,2,3), (4,5,6), (7,8,9) ] )
     3 print "a=\n" + str(a)
     4 
     5 #criação de uma matriz 3x3 de zeros do tipo inteira
     6 b = zeros((3,3), dtype=int16)
     7 print "\nb=\n" + str(b)
     8 
     9 #criação de uma matriz 3x3 preenchida com 1 do tipo inteira
    10 c = ones((3,3), dtype=int16)
    11 print "\nc=\n" + str(c)
    12 
    13 #criando uma matriz 3x3 com valores em uma determinada faixa
    14 d = arange( 0, 45, 5 ). reshape(3,3)
    15 print "\nd=\n" + str(d)
    16 
    17 #criação de uma matriz 3x3 identidade
    18 i = eye((3),dtype=int16)
    19 print "\ni=\n" + str(i)
    
    a=
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    
    b=
    [[0 0 0]
     [0 0 0]
     [0 0 0]]
    
    c=
    [[1 1 1]
     [1 1 1]
     [1 1 1]]
    
    d=
    [[ 0  5 10]
     [15 20 25]
     [30 35 40]]
    
    i=
    [[1 0 0]
     [0 1 0]
     [0 0 1]]
    
    • Operações Básicas matriciais
     1 #criação de uma matriz 3x3
     2 a = array( [ (1,2,3), (4,5,6), (7,8,9) ] )
     3 b = array( [ (1,0,1), (0,1,0), (1,0,1) ] )
     4 print "a=\n" + str(a)
     5 print "\nb=\n" + str(b)
     6 
     7 # subtração
     8 c = a - b
     9 print "\na-b=\n" + str(c)
    10 
    11 # soma
    12 c = a + b
    13 print "\na+b=\n" + str(c)
    14 
    15 # multiplicação por elementos
    16 c = a * b
    17 print "\na*b=\n" + str(c)
    18 
    19 # multiplicação por constantes
    20 c = 3*a
    21 print "\n3*a=\n" + str(c)
    22 
    23 # produto matricial
    24 c = dot(a,b)
    25 print "\naºb=\n" + str(c)
    26 
    27 #soma dos valores da matriz a
    28 c = a.sum()
    29 print "\nsoma dos valores de a = \n" +str(c)
    30 
    31 #valor mínimo da matriz a
    32 c = a.min()
    33 print "\nmínimo valor de a = \n" +str(c)
    34 
    35 #valor máximo da matriz a
    36 c = a.max()
    37 print "\nmáximo valor de a = \n" +str(c)
    38 
    39 #soma de cada coluna da matriz a
    40 c = a.sum(axis=0)
    41 print "\nsoma de cada coluna de a = \n" +str(c)
    42 
    43 #soma de cada linha da matriz a
    44 c = a.sum(axis=1)
    45 print "\nsoma de cada linha de a = \n" +str(c)
    46 
    47 #pegando o valor de cada posição de a e aplicando a raíz quadrada
    48 c = sqrt(a)
    49 print "\nraíz quadrada de cada elemento de a = \n" + str(c)
    
    a=
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    
    b=
    [[1 0 1]
     [0 1 0]
     [1 0 1]]
    
    a-b=
    [[0 2 2]
     [4 4 6]
     [6 8 8]]
    
    a+b=
    [[ 2  2  4]
     [ 4  6  6]
     [ 8  8 10]]
    
    a*b=
    [[1 0 3]
     [0 5 0]
     [7 0 9]]
    
    3*a=
    [[ 3  6  9]
     [12 15 18]
     [21 24 27]]
    
    aºb=
    [[ 4  2  4]
     [10  5 10]
     [16  8 16]]
    
    soma dos valores de a = 
    45
    
    mínimo valor de a = 
    1
    
    máximo valor de a = 
    9
    
    soma de cada coluna de a = 
    [12 15 18]
    
    soma de cada linha de a = 
    [ 6 15 24]
    
    raíz quadrada de cada elemento de a = 
    [[ 1.          1.41421356  1.73205081]
     [ 2.          2.23606798  2.44948974]
     [ 2.64575131  2.82842712  3.        ]]
    
    • Indexação e posicionamento
     1 #criação de uma matriz 3 x 3
     2 a = array( [ (1,2,3), (11,12,13), (21,22,23) ] )
     3 print "\na=\n" + str(a)
     4 
     5 #pegando a posição 2x2 da matriz
     6 c = a[1,1]
     7 print "\na22 = \n"+str(c)
     8 
     9 #pegando a segunda coluna da matriz
    10 c = a[:,1]
    11 print "\nsegunda coluna de a = \n"+str(c)
    12 
    13 #pegando a segunda linha da matriz
    14 c = a[1,:]
    15 print "\nsegunda linha de a = \n"+str(c)
    
    a=
    [[ 1  2  3]
     [11 12 13]
     [21 22 23]]
    
    a22 = 
    12
    
    segunda coluna de a = 
    [ 2 12 22]
    
    segunda linha de a = 
    [11 12 13]
    
    • Manipulando o dimensionamento da matriz
     1 #criação de uma matriz 4 x 4
     2 a = array( [ (1,2,3,4), (5,6,7,8), (9,10,11,12), (13,14,15,16) ] )
     3 print "a=\n" + str(a)
     4 
     5 #pegando a dimensão da matriz
     6 c = a.shape
     7 print "\ndimensão de a = \n"+str(c)
     8 
     9 #encontrando a matriz transposta de a
    10 c = a.transpose()
    11 print "\nmatriz a transposta = \n" + str(c)
    12 
    13 #tornando a matriz unidimensional
    14 c = a.ravel()
    15 print "\nmatriz a unidimensional = \n"+str(c)
    16 
    17 #redimensionando a matriz a após torná-la unidimensional
    18 c.shape = (2,8)
    19 print "\nmatriz a(4x4) transformada em uma matriz 2x8 = \n" +str(c)
    20 
    21 #redimensionando sem torná-la anteriormente unidimensional
    22 c = a.reshape(2,8)
    23 print "\nmatriz a(4x4) transformada em uma matriz 2x8 = \n" +str(c)
    24 
    25 #redimensionando só sabendo a quantidade de linhas desejadas
    26 c = a.reshape(2,-1)
    27 print "\nmatriz a(4x4) transformada em uma matriz 2xn = \n" +str(c)
    
    a=
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]
     [13 14 15 16]]
    
    dimensão de a = 
    (4, 4)
    
    matriz a transposta = 
    [[ 1  5  9 13]
     [ 2  6 10 14]
     [ 3  7 11 15]
     [ 4  8 12 16]]
    
    matriz a unidimensional = 
    [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16]
    
    matriz a(4x4) transformada em uma matriz 2x8 = 
    [[ 1  2  3  4  5  6  7  8]
     [ 9 10 11 12 13 14 15 16]]
    
    matriz a(4x4) transformada em uma matriz 2x8 = 
    [[ 1  2  3  4  5  6  7  8]
     [ 9 10 11 12 13 14 15 16]]
    
    matriz a(4x4) transformada em uma matriz 2xn = 
    [[ 1  2  3  4  5  6  7  8]
     [ 9 10 11 12 13 14 15 16]]
    

2. Graphviz: ferramenta de visualizaçao

Procure estudar o Graphviz ( Graphviz - Graph Visualization Software).

  • Criando grafos utilizando a linguagem Graphviz:

    • Primeiro exemplo, criando um grafo simples de dois vértices, sem orientação na aresta.

      1. graph G {
      2.        1 -- 2;
      3. }
      /media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_001.png

    • Segundo exemplo, criando um grafo simples de dois vértices, com orientação na aresta.

      1. digraph G {
      2.        1 -> 2;
      3. }
      /media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_002.png

    • Terceiro exemplo, criando um grafo simples de dois vértices, com orientação e custo na aresta.

      1. digraph G {
      2.        1 -> 2 [label="1",len=1.00];
      3. }
      /media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_003.png

    • Quarto exemplo, criando um grafo simples de dois vértices, com nomes nos vértices, com orientação e custo em cada aresta.

      1. digraph G {
      2.        "Campinas" -> "Sorocaba" [label="85km",len=85.00];
      3.        "Bauru" -> "Campinas" [label="269km",len=269.00];
      4.        "Bauru" -> "Sorocaba" [label="270km",len=270.00];
      5.        "Campinas" -> "São Paulo" [label="96km",len=96.00];
      6.        "Sorocaba" -> "São Paulo" [label="78km",len=78.00];
      7.        "Bauru" -> "São Paulo" [label="330km",len=330.00];
      8. }
      /media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_004.png

    • Quinto exemplo, Modificando a forma de um dos vértices do grafo do quarto exemplo.

      01. digraph G {
      02.        "Campinas" [color=black, fontsize=24, fontname="Palatino-Italic",
      03.                 fontcolor=red, style=filled, shape="box"];
      04.        "Campinas" -> "Sorocaba" [label="85km",len=85.00, color="blue"];
      05.        "Bauru" -> "Campinas" [label="269km",len=269.00, color="blue"];
      06.        "Bauru" -> "Sorocaba" [label="270km",len=270.00, color="blue"];
      07.        "Campinas" -> "São Paulo" [label="96km",len=96.00];
      08.        "Sorocaba" -> "São Paulo" [label="78km",len=78.00];
      09.        "Bauru" -> "São Paulo" [label="330km",len=330.00];
      10. }
      /media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_005.png

  • Criando grafos utilizando a linguagem Python:

    • 1ª opção: Criando a visualização com a função mmgraphviz É passado o texto do grafo da linguagem Graphviz e posteriormente apresentado usando a função mmgraphviz
 1 grafo = """
 2     digraph G {
 3            "Campinas" [color=black, fontsize=24, fontname="Palatino-Italic",
 4                     fontcolor=red, style=filled, shape="box"];
 5            "Campinas" -> "Sorocaba" [label="85km",len=85.00, color="blue"];
 6            "Bauru" -> "Campinas" [label="269km",len=269.00, color="blue"];
 7            "Bauru" -> "Sorocaba" [label="270km",len=270.00, color="blue"];
 8            "Campinas" -> "São Paulo" [label="96km",len=96.00];
 9            "Sorocaba" -> "São Paulo" [label="78km",len=78.00];
10            "Bauru" -> "São Paulo" [label="330km",len=330.00];
11     }
12 """
13 
14 mmgraphviz(grafo, title='Distância entre cidades')
/media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_006.png

Distância entre cidades

  • 2ª opção: Criando o grafo por programação pelo Python

    É feito um programa do grafo usando a extensão para Python chamada gvgen.

 1 grafo = gvgen.GvGen()
 2 grafo.smart_mode = 1
 3 
 4 bauru = grafo.newItem("Bauru")
 5 sorocaba = grafo.newItem("Sorocaba")
 6 campinas = grafo.newItem("Campinas")
 7 sao_paulo = grafo.newItem("São Paulo")
 8 
 9 cam1 = grafo.newLink(campinas,sorocaba)
10 cam2 = grafo.newLink(bauru,campinas)
11 cam3 = grafo.newLink(bauru,sorocaba)
12 cam4 = grafo.newLink(campinas,sao_paulo)
13 cam5 = grafo.newLink(sorocaba,sao_paulo)
14 cam6 = grafo.newLink(bauru,sao_paulo)
15 
16 grafo.styleAppend("link1", "color", "blue")
17 grafo.styleAppend("link1", "label", "85km")
18 grafo.styleAppend("link1", "len", "85km")
19 grafo.styleApply("link1", cam1)
20 
21 grafo.styleAppend("link2", "color", "blue")
22 grafo.styleAppend("link2", "label", "269km")
23 grafo.styleAppend("link2", "len", "269km")
24 grafo.styleApply("link2", cam2)
25 
26 grafo.styleAppend("link3", "color", "blue")
27 grafo.styleAppend("link3", "label", "270km")
28 grafo.styleAppend("link3", "len", "270km")
29 grafo.styleApply("link3", cam3)
30 
31 grafo.styleAppend("link4", "label", "96km")
32 grafo.styleAppend("link4", "len", "96km")
33 grafo.styleApply("link4", cam4)
34 
35 grafo.styleAppend("link5", "label", "78km")
36 grafo.styleAppend("link5", "len", "78km")
37 grafo.styleApply("link5", cam5)
38 
39 grafo.styleAppend("link6", "label", "330km")
40 grafo.styleAppend("link6", "len", "330km")
41 grafo.styleApply("link6", cam6)
42 
43 grafo.propertyAppend(campinas, "color", "black")
44 grafo.propertyAppend(campinas, "fontcolor", "red")
45 grafo.propertyAppend(campinas, "fontsize", "24")
46 grafo.propertyAppend(campinas, "fontname", "Palatino-Italic")
47 grafo.propertyAppend(campinas, "shape", "box")
48 grafo.propertyAppend(campinas, "style", "filled")
49 
50 import StringIO
51 fd = StringIO.StringIO()
52 grafo.dot(fd)
53 dottext = fd.getvalue()
54 
55 mmgraphviz(dottext, title='Distância entre cidades')
/media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_007.png

Distância entre cidades

Transformação do for do programa na aula por cálculo matricial

 1 from numpy import ones
 2 
 3 def Larcos2MA(L):
 4     #pegando o número máximo da lista de arcos, correspondente a quantidade total de nós
 5     n = L.max()+1
 6     A = ones((n,n)) * float('inf')
 7     A[L[:,0],L[:,1]]=1
 8     #for l in range(L.shape[0]):
 9     #  A[L[l,0],L[l,1]]=1
10 
11     return A
1 import iaOPF
2 from wes_t import Larcos2MA
3 
4 L = array([[0,1],[3,2],[1,0],[3,0]])
5 print L
6 
7 A = Larcos2MA(L)
8 print A
9 mmgraphviz(iaOPF.iaadjmxtcreate(A))
[[0 1]
 [3 2]
 [1 0]
 [3 0]]
[[ Inf   1.  Inf  Inf]
 [  1.  Inf  Inf  Inf]
 [ Inf  Inf  Inf  Inf]
 [  1.  Inf   1.  Inf]]
/media/_xsb/courseIA368Q1S2012/wes_2/GRVIZ44606_008.png