aula1

O tutorial oficial do Python está em http://docs.python.org/tutorial. Existe também um bom tutorial em portugues que pode ser visto em: http://br.geocities.com/sdiasneto/aprendendopython/index.html

Existem algumas estruturas de dados em Python que são importante conhecer. As sequências em Python podem ser: strings, listas e tuplas. Ele tem ainda estruturas para representar conjuntos (sets) e dicionário. Vale a pena ler um tutorial sobre Python para entender estas variações de estruturas de dados e como operá-las.

1 s = 'este eh um string'
2 l = [5,'abc',10]
3 t = 1,2,3
4 print 'Tipo=',type(s),'s=',s
5 print 'Tipo=',type(l),'l=',l
6 print 'Tipo=',type(t),'t=',t
Tipo= <type 'str'> s= este eh um string
Tipo= <type 'list'> l= [5, 'abc', 10]
Tipo= <type 'tuple'> t= (1, 2, 3)

Existe o módulo array que é uma forma eficiente de processar listas que são homogêneas. Existe ainda o módulo Numpy que é feito para processar arrays multidimensionais. É graças ao Numpy que o Python se torna eficiente para o processamento científico baseado em matrizes. Observe que o Numpy utiliza o mesmo nome array para a definição do array multidimensional.

Um tutorial do Numpy em ingles está em http://www.scipy.org/Tentative_NumPy_Tutorial

Como imagens podem ser representadas por uma matriz de pixels, processamento de imagens pode ser eficientemente processado por linguagens que processam matrizes. O Python possui o pacote Numpy que é feito para processar matrizes.

  1. Criando matrizes usando array() e typecodes

Existem inúmeras formas de se criar matrizes. A mais básica é usando a função array(). Ela cria um array a partir de uma lista:

1 a = array([1.2, 3.5, -1])
2 print 'Tipo=',type(a), 'a=', a
Tipo= <type 'numpy.ndarray'> a= [ 1.2  3.5 -1. ]

O segundo argumento da função array() serve para indicar o tipo do elemento (pixel), que podem ser int, float ou complex. Em particular, em imagens onde o pixel é de 8 bits sem sinal, usa-se o typecode uint8:

1 a = array([1,2,3], float)
2 print a
3 b = array([255,0,128], uint8)
4 print b
[ 1.  2.  3.]
[255   0 128]
  1. Estilo de varredura pixel a pixel, (não aconselhável)

Normalmente aprendemos a programar em C ou em Pascal e a forma usual de processamento de uma matriz é a sua varredura pixel-a-pixel. Como exemplo disto, vejamos um exemplo para criar uma matriz (ou imagem bidimensional) na forma de xadrez onde os pixels com valores 0 e 1 são dispostos na forma de um tabuleiro de xadrez. Existem inúmeras soluções para este problema. A forma usual para um programador C é o estilo de varredura de pixels colocada abaixo:

1 w,h = 5,10
2 A = zeros( (h,w) )
3 for i in range(0,h):
4   for j in range(0,w):
5     A[i,j] = (i+j) % 2
6 
7 print A
[[ 0.  1.  0.  1.  0.]
 [ 1.  0.  1.  0.  1.]
 [ 0.  1.  0.  1.  0.]
 [ 1.  0.  1.  0.  1.]
 [ 0.  1.  0.  1.  0.]
 [ 1.  0.  1.  0.  1.]
 [ 0.  1.  0.  1.  0.]
 [ 1.  0.  1.  0.  1.]
 [ 0.  1.  0.  1.  0.]
 [ 1.  0.  1.  0.  1.]]
  1. Estilo matricial, utilizando matriz de índices

É possível, entretanto, utilizar linguagens que são apropriadas para processamento matricial, como por exemplo o MATLAB (Matricial Lab) e o Python utilizando sua biblioteca NumPy. Neste caso, a idéia é converter a linha do laço no exemplo anterior de forma matricial, evitando assim, laços explícitos no programa. A idéia é que a expressão (i+j)%2 seja completamente matricial. Para isto, criamos as matrizes I e J, que contém os índices i,j. Construir estas matrizes I e J é facilitada pela função iameshgrid (nome influenciado pela função MATLAB meshgrid). Veja abaixo. Modifique o código na sua área e imprima os valores de I e J para entender melhor o seu conteúdo. Observe que neste caso, não existe mais as varreduras explícitas feitas com for.

1 w,h = 5,3
2 J,I = iameshgrid( range(0,w), range(0,h) )
3 A = (I+J) % 2
4 print A
[[0 1 0 1 0]
 [1 0 1 0 1]
 [0 1 0 1 0]]

Para ver o help da função iameshgrid utilize:

1 help(iameshgrid)
Help on function iameshgrid in module ia636_numpy:

iameshgrid(vx, vy)
    - Purpose
        Create two 2-D matrices of indexes.
    - Synopsis
        x, y = iameshgrid(vx, vy)
    - Input
        vx: Gray-scale (uint8 or uint16) or binary image (logical)..
            Vector of indices of x coordinate.
        vy: Gray-scale (uint8 or uint16) or binary image (logical)..
            Vector of indices of y coordinate.
    - Output
        x: Gray-scale (uint8 or uint16) or binary image (logical).. 2-D
           matrix of indexes of x coordinate.
        y: Gray-scale (uint8 or uint16) or binary image (logical).. 2-D
           matrix of indexes of y coordinate.
    - Description
        This function generates 2-D matrices of indices of the domain
        specified by arange1 and arange2. This is very useful to
        generate 2-D functions. Note that unlike other functions, the
        order of the parameters uses the cartesian coordenate
        convention. arange1 is for x (horizontal), and arange2 is for y
        (vertical).
    - Examples
        #
        #   example 1
        #
        (x, y) = iameshgrid(numpy.arange(1,3,0.5), numpy.arange(2,4,0.6))
        print x
        print y
        print x + y
        #
        #   example 2
        #
        (x, y) = iameshgrid(range(256), range(256))
        iashow(x)
        iashow(y)
        iashow(x + y)
        z = numpy.sqrt((x-127)**2 + (y-127)**2)
        iashow(z)

Exercícios

  1. Qual é a principal diferença entre uma lista e um tupla?
  2. Qual é a principal diferença entre um string e uma lista?
  3. Como se declara um tupla de um único elemento?