Professional Documents
Culture Documents
Guia Essencial
2.2.1. IF ...........................................................................................................11
2
2.3.12. Técnicas de Laço em estruturas de dados ..........................................29
3. Python e C .......................................................................................................34
4. Extras ...............................................................................................................44
5. Apêndice ..........................................................................................................46
6. Bibliografia .......................................................................................................49
3
Índice de Tabelas
Tabela 1: Descrição dos operadores em Python ......................................................10
Tabela 2: Especificadores de formato e tipos em C ..................................................47
Tabela 3: Modificadores de formato ..........................................................................47
Tabela 4: Exemplos de chamadas da função Py_BuildValue().................................48
4
Índice de Códigos Fonte
5
“para nosso amigo e professor”
6
1. Motivação
Por que Python? A procura de uma nova linguagem eficiente e de fácil
implementação acaba aqui. Python é a resposta para esta procura, pois além de ser uma
linguagem de alto nível, esta é de simples e rápida programação. Por ser uma linguagem
interpretada, o Python não precisa ser compilado e vinculado durante o processo de
desenvolvimento e isto economiza um tempo razoável.
Um ponto forte do Python é a extensão com C/C++. A combinação pode ser feita
tanto de C para Python, quanto de Python para C. Essa facilidade permite um grande
aumento do leque de possibilidades para a programação em Python. Como escrever um
programa com a finalidade do uso como uma linguagem de extensão.
7
2. Conceitos Básicos
2.1. Sintaxe e Convenções Léxicas
8
identação como esse são comuns quando se inicia a programação em Python vindo de
outras linguagens e deve-se ficar atento durante a programação, reforçando ainda mais a
necessidade de um editor especial.
2.1.2. Blocos
Um bloco é delimitado através da identação de todas suas instruções pela mesma
quantidade de espaços ou tabulações, conforme visto no trecho de código acima.
2.1.3. Instruções
Uma instrução termina no fim de uma linha, mas pode continuar por diversas linhas
se uma linha física terminar com \, ( ) aberto, [ ] ou um par de { }, ou uma string com três
aspas abertas. É possível ter também diversas instruções em uma mesma linha,
separadas por ponto-e-vírgula. Vale lembrar que em Python instruções executam de forma
seqüencial, uma após a outra, a menos que as instruções de fluxo de controle (if, while, for,
etc.) sejam utilizadas.
2.1.4. Comentários
Comentários em Python começam com “#” e continuam válidos pela linha inteira.
9
Identificadores podem incluir letras, números e o caracter underscore, mas devem
sempre começar com um caracter não numérico. Identificadores que começam ou
terminam com underscore apresentam na maioria das vezes significados especiais e não
são o alvo desta apostila. Uma lista completa destes identificadores especiais pode ser
encontrada em [2]
2.1.6. Operadores
A Tabela 1 abaixo apresenta uma lista dos operadores de expressão mais comuns
do Python. Assim como em C, os operadores possuem diferentes ordens de precedência,
estando abaixo organizados de acordo com tais ordens (operadores em células inferiores
possuem precedência mais alta). A lista completa de operadores pode ser obtida em [3].
Operador Descrição
X or Y Ou lógico. Y é avaliado somente se X for falso
X and Y E lógico. Y é avaliado apenas se X for verdadeiro
not X Negação lógica
X < Y , X > Y , X >= Y, X <= Y Operadores de comparação. Podem ser encadeados
X < Y < Z.
X == Y, X <> Y, X != Y Operadores de igualdade
X is Y, X is not Y Testes de identidade de objeto
X in S, X not in S Verifica se X está presente em uma sequência S
X|Y Ou Bitwise
X^V Ou exclusivo Bitwise
X&V E Bitwise
X << Y, X >> Y Deslocamento de X a esquerda e a direita por Y bits.
X + Y, X - Y Adição/concatenação, subtração.
X[i], X[i:j], X.atrr, X(...) Indexação, slicing*, ref. De atributos, chamada de função.
( ... ) , [ ... ] , { ... } Tupla, lista, dicionário
Tabela 1: Descrição dos operadores em Python
10
2.2. Controle de Fluxo
2.2.1. IF
A construção “IF” em Python é similar à utilizada em C. As instruções “IF”, “ELSE” e
“ELIF” são utilizadas de acordo com a estrutura abaixo:
IF teste:
Comandos
Elif:
Comandos
Else:
Comandos
A seção “elif” pode aparecer zero ou mais vezes e a seção “else” é opcional, assim
como em C. A principal diferença está na delimitação do bloco de comando que em Python
é feita pelo uso de “:” e pela própria identação.
HINT 1: A instrução “elif” é uma abreviação de “else IF” e é útil para evitar identação
excessiva e melhorar a legibilidade do código. A construção “IF...elif...elif...” substitui as
construções “switch e case” utilizadas em outras linguagens.
HINT 2: Instruções “IF/else” alinhadas são mais rápidas de serem testadas do que
instruções “IF/IF”.
11
2.2.2. WHILE
A instrução “while” é semelhante à mesma instrução em C. O laço é executado
enquanto a condição for verdadeira.
while condição :
Comandos
else:
Comandos
A instrução “else” é opcional e ela será executada ou quando o loop inteiro ocorrer
ou se o loop não for executado nenhuma vez. Como no exemplo:
-loop inteiro:
-sem loop
12
2.2.3. FOR
A construção “for” em Python se difere um pouco das construções de outras
linguagens de programação. Na linguagem Pascal a instrução itera sobre progressões
aritméticas, em C é possível definir tanto o passo da iteração, quanto a condição de
parada. Já em Python a iteração é dada sobre uma sequência (lista ou string), na mesma
ordem desta.
Comandos
[Else:
Comandos]
-sem loop:
13
-break:
HINT 1: Para modificar uma lista em execução, por exemplo, para duplicar os itens,
deve-se gerar uma cópia da lista e modificar sobre esta cópia. Como função “slice” serve
também para fazer uma cópia em alto nível (superficial) do objeto da sequencia, utiliza-se
ela:
CUIDADO: Dentro do loop “for”, as comparações são feitas com elementos da lista
e não com os índices (como em C). Como no exemplo acima (na condição do “if”), x é
comparado com o elemento da lista ‘c’ e não com seu índice.
14
2.2.4. RANGE
A instrução “range” tem o intuito de gerar listas com progressões aritméticas.
15
2.3. Estrutura de Dados
2.3.1. STRINGS
O Python manipula strings de diversas formas. A delimitação pode ser feita ou com
aspas simples (‘texto’), ou com aspas duplas (“texto”), ou com triplas simples ou triples
duplas (‘’’texto’’’, ou “””texto”””)
A quebra de linha é feita somente com o “\n”, e ao inserir uma string, o símbolo “\”
gera uma quebra de linha na inserção da string, entretanto a quebra de linha não é salva
na string. Exemplo:
- Exemplo \n:
-Exemplo \n\:
16
A utilização de triplas aspas (duplas ou simples) gera a quebra de linha automática
tanto na inserção quanto na própria String, como no exemplo:
As strings podem ser concatenadas (+) e repetidas (*) com o uso dos respectivos
operadores.
-repetidas
17
Para compreender melhor, segue-se um esquema com os índices:
A B C D E F
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
18
2.3.3. Listas
Listas são sequências de objetos arbitrários. Os valores dentro de uma lista não
precisam ser do mesmo tipo. Os objetos dentro da lista são separados por vírgulas e entre
colchetes. Sua indexação é iniciada em “0” da esquerda para direita e em “-1” da direita
para esquerda. Diferente de “Strings” as listas podem ser modificadas.
Adiciona um objeto (x) no final da lista. Este objeto pode ser uma lista.
19
-insert( i , x)
-remove(x)
Remove o elemento de valor igual a (x). Caso seja desejado remover com o
valor do índice, combina-se “remove(lista[x])”.
-pop(i)
20
-index(x)
-count(x)
-sort()
-reverse()
Inverte a ordem dos elementos da lista, sem criar uma nova lista.
21
-del
2.3.5. Pilhas
A utilização de pilhas em Python é bem simples. Vale lembrar que em pilhas
(“o último a entrar, é o primeiro a sair”). Utilizaremos uma lista com a combinação dos
comandos “append(x)” e “pop()”. A utilização do “pop()” sem argumentos, remove o último
elemento da lista e retorna o mesmo.
2.3.6. Filas
A utilização de filas também é possível com listas. Vale lembrar que em filas
(“o primeiro a entrar, será o primeiro a sair”). De maneira semelhante a pilhas, utilizaremos
a combinação de listas com os comandos “append(x)” e “pop(0)”. O comando “pop()”
dessa vez terá argumento “0”, para dessa forma retornar o primeiro elemento que foi
inserido.
22
2.3.7. Ferramentas de Programação Funcional com Filas
O Python possui 3 ferramentas para programação funcional com filas:
-filter(função, sequencia)
-map(função, sequencia)
-reduce(função(x,y), sequencia,z)
23
A ferramenta “reduce” aplica a “função” de dois em dois (os parâmetro da
função devem ser dois) e o resultado é substituído no lugar das duas entradas e a
função dá continuidade com o objeto resultante e o próximo objeto da lista, até o fim
da mesma. A variável “z” é opcional e ela dá inicio da operação reduce.
x+y+’a’+x = 111222a111
x+y+’a’+x = 111222a111333a111222a111
24
Caso a operação seja chama com uma sequencia vazia e sem valor “z”, o
retorno será um erro. Caso a operação tenha somente um objeto na sequencia e
sem valor “z”, o retorno será este objeto. Caso seja utilizado o “z” e a sequencia
vazia, o retorno será o “z”.
25
2.3.9. Tuplas
Python também possui Tuplas. Esse tipo de sequencia é imutável e tem
diversas utilidades como base de dados. A sintaxe é dada ou entre parênteses ou
simplesmente sem parênteses, colchetes e chaves. A criação de Tuplas possui o
nome de “tuple packing” , ou seja, quando se empacota os valores em uma tupla. A
operação reversa (sequence unpacking) também é possível.
26
2.3.10. Sets
Sets são seqüências com dados não duplicados e não necessariamente ordenados.
O comando set() pode ser atribuído a uma lista ou apenas à uma palavra. Caso seja a uma
lista, o retorno será uma lista sem itens duplicados. Já no caso de uma palavra, o retorno
será uma lista com todas as letras separadas em objetos distintos. O comando set permite
algumas manipulações com os dados, como união, concatenação, etc. Como no exemplo:
27
2.3.11. Dicionários
Outra estrutura de dados presente em Python são os dicionários, também
chamados de “memória associativa” ou “vetor associativo”. Diferentemente de sequencia,
dicionários não são indexados por valores inteiros, mas sim por chaves “Keys”. Essas
chaves podem ser qualquer tipo imutável de sequencia, como strings e inteiros. Tupla
também pode ser usada se possuir somente valores imutáveis. Listas não podem ser
utilizadas, pois são mutáveis.
-keys()
-has_key()
28
-dict()
-enumerate()
29
-zip()
-reversed()
-sorted
30
2.4. Módulos e Funções
31
Adicionalmente, é possível importar apenas determinadas funções de um módulo,
utilizando a sintaxe abaixo:
O nome da função deve ser um identificador válido, conforme visto na seção 3.1.5.
A lista de parâmetros é separada por vírgula e assim como qualquer outro bloco em
Python, é a identação que delimita o corpo da função. Opcionalmente pode-se ter na linha
anterior ao corpo da função um string literal com informações sobre a função, podendo ser
posteriormente usado em documentação externa, analogamente a ferramenta JavaDoc
presente em Java.
2.5.1. Recursão
Assim como outras linguagens, Python permite o uso de recursão em
funções, isto é, uma função que chama a si própria em seu corpo. O exemplo abaixo
mostra a criação de uma função recursiva para o clássico “Números de Fibonacci”:
32
Código 2-3: Função recursiva de Fibonacci.
33
Código 2-5: Chamadas de funções com argumentos padrão.
3. Python e C
Uma das grandes vantagens de Python é a possibilidade de se trabalhar em
conjunto com outras linguagens de programação, em especial C e C++. Em vias gerais,
existem dois modos de se utilizar Python em conjunto com C em um mesmo processo:
Chamadas de código em C por Python ou; chamadas de código em Python por C. No
primeiro caso, módulos de Python são implementados em linguagem C/C++, permitindo
realizar chamadas de funções (da linguagem e de system calls) e criar novos tipos de
objetos, ações essas que o Python não conseguiria realizar diretamente. No segundo caso,
desenvolvem-se aplicações escritas em C/C++ capazes de carregar e executar scripts de
Python.
34
Os exemplos abaixo foram desenvolvidos em ambiente Linux utilizando a
distribuição Python 2.6, o compilador gcc nativo e a biblioteca de Python distutils.
Instruções para desenvolvimento em ambiente Windows podem ser obtidas em [4].
35
O argumento self só é usado quando funções em C implementam métodos
built-in e não propriamente uma função. O argumento args é um ponteiro para uma tupla
em Python contendo os argumentos. Tais argumentos são objetos Python e precisam ser
convertidos para tipos de dados aceitos por C antes de poder realizar as devidas
manipulações. A conversão é feita pela função PyArg_ParseTuple(), cujos argumentos são
a tupla contendo os argumentos do Python (args), o tipo(s) para conversão (“i” para inteiro,
“s” para string, etc.) e a variável(is) que armazenará(ão) o resultado da conversão (arg0).
Exemplos de chamadas da função PyArg_ParseTuple() são descritas na seção 5.1.
36
Finalmente, com todos os wrappers definidos e listados, é necessário inicializar o
módulo, feito através da função Py_ InitModule(), que recebe como argumentos o nome a
ser usado para o método e a lista de wrappers recém criada. A função de inicialização
deve sempre se chamar initnome(), onde nome corresponde ao nome do módulo a ser
inicializado pela Py_InitModule(), neste caso, module.
37
Por fim, todos os módulos inicializados são passados para a função setup() para
criação de um pacote de módulos, cujos atributos são nome do pacote, versão atual
(usada para controle de versões), descrição do pacote e conjunto de módulos pertencentes
a ele.
38
3.2. Embarcando Python em C
39
PyRun_SimpleString("import ");
PyRun_SimpleString("math\n");
Note ainda o uso obrigatório no final de cada linha de comando do identificador “\n”,
necessário para o interpretador reconhecer o término de um comando. Por fim, a função
Py_Finalize() é a ultima função a ser chamada quando do embedding de Python, pois esta
desliga o interpretador e libera todos os recursos alocados durante o processo de
embedding.
40
#python setup.py install
41
Código 3-6: Arquivo reverse.py usado como exemplo para embeeding.
Lembre-se que para utilizar este módulo, deve-se ser criado um arquivo de
configuração semelhante ao criado na seção 3.1 e executar o comando para instalação do
módulo descrito na seção 3.2.1.
Suponha que desejamos acessar a função rstring, que no caso acima é um atributo
do objeto reverse, passar como parâmetro uma string a ser revertida e por fim imprimir na
tela a string invertida (estas duas ultimas ações executadas na aplicação host em C). Para
permitir a troca de informações entre o módulo Python embarcado e a aplicação host em C
primeiramente pode ser descrita com a seguinte sequência de passos:
42
3. Chamar a função desejada
4. Converter o objeto Python de retorno em uma variável C.
O objeto de retorno da função (mod) é usado então para captura da função rstring,
atrvés do acesso de seu correspondente atributo pela função PyObject_GetAttrString().
Novamente o retorno é um objeto e o código abaixo ilustra a captura da função no módulo.
O objeto resultante é uma referencia a função, podendo ser usado para chamadas
da função através de um wrapper em C. Com a função devidamente referenciada em um
objeto (strfunc), deve-se construir a lista de argumentos a ser passada a ela. Neste caso,
como há apenas um argumento para a função, pode-se usar a já vista Py_BuildValue()
para converter a string a ser passada como parâmetro em um objeto para rstring, seguindo
o código abaixo..
43
Char *string = NULL;
PyArg_Parse(strret,"s",&string);
printf("String Invertida:%s\n",string);
4. Extras
4.1. Desempenho
Assim como outras linguagens, Python fornece uma ferramenta para medição de
profiling e desempenho de código, úteis para comparar diferentes abordagens de um
problema e identificar pontos críticos e programas escritos na linguagem. Os módulos
utilizados para medidas de desempenho são: timeit, profile e pstats. O trecho de código
abaixo exemplifica o uso do módulo timeit para comparação de desempenho entre duas
abordagens de declaração e instanciação de variáveis.
44
>>> Timer('a,b=1,2;').timeit()
0.05402044160980779
>>> Timer('a=1;b=2;').timeit()
0.050916166610463165
45
>>> zlib.decompress(string2)
'Esta frase sera comprimida com o comando zlib.compress()'
>>> print string
Esta frase sera comprimida com o comando zlib.compress()
>>> print string2
xœs-.ITH+J,NU(N-JTHÎÏ-(ÊÌÍL3òAdb^J¾BUNf’-XC
5. Apêndice
5.1. Conversão de dados de Python para C
A função acima, utilizada no exemplo da seção 3.1, converte uma tupla de objetos
de args para uma série de variáveis em C. O parâmetro format corresponde aos possíveis
tipos das variáveis para conversão.
46
“f” Float float *r
“d” Float double *r
“O” Qualquer PyObject **r
“O!” Qualquer PyTypeObject *type, PyObject **r
Tabela 2: Especificadores de formato e tipos em C
47
A chamada desta função constrói um objeto em Python através de variáveis em C.
O parâmetro format é análogo ao utilizado nas funções PyArg_Parse* e os outros
parâmetros da função são as variáveis a serem convertidas. A tabela a seguir ilustra
chamadas para a função Py_BuildValue().
Extension(...,
library_dirs=['/usr/X11R6/lib'],
libraries ['X11', 'Xt'])
48
6. Bibliografia
[1] BEAZLEY, D. M. Python - Essential Reference. Indianapolis: New Riders Publishing, 2001.
[2] DEITEL, H. M. et al. Python - How to Program. New Jersey: Deitel, 2002.
[4] PYTHON SOFTWARE FOUNDATION. The Python Standard Library, 2010. Disponivel em:
<http://docs.python.org/library/>.
[6] VAN ROSSUM, G. Tutorial Python. [S.l.]: Python Software Foundation, 2005.
49