Ajuda Adessowiki | Introdução NumPy Adessowiki

Introdução ao Python no ambiente Adessowiki

Este texto foi adaptado das respostas entregue por alunos nos cursos oferecidos no Adessowiki.

Incluindo código Python no Adessowiki

Para incluir um trecho de programação Python em um documento Adessowiki, usa-se a meta instrução code da seguinte forma:

.. code:: python

   print 'hello world'

Veja o exemplo de incorporação deste trecho neste documento. Você poderá editar este documento para verificar como ele de fato é programado.

1. print 'hello world'
hello world

Note que é necessário deixar uma linha em branco após a instrução code e é necessário deixar um espaço em branco após o "::". Note também que o programa precisa estar identado em relação à instrução code. No documento Adessowiki o código fonte do programa poderá ou não ser mostrado dependendo do valor dos parâmetros show_code e show_output. Normalmente estes dois parâmetros estão habilitados, deixando os programas fontes visíveis e os resultados das saídas do print. É possível incluir quantos trechos de código como este numa data página e as variáveis definidas neles são persistentes, isto é, o código python será executado de forma concatenada com os diversos trechos de código de uma página.

Primeiros scripts em Python

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

  • 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 dados de alto nível: strings, listas, tuplas, dicionários, arquivos, classes.
  • É orientada a objetos.

É uma linguagem moderna e adaptada para o desenvolvimento tanto de aplicações genéricas como científicas. Para aplicações científicas, o Python possui um pacote muito importante e eficiente para o processamento de arrays multidimensionais: Numpy.

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ê'}

Strings:

Pode-se declarar strings tanto usando aspas simples como duplas. Pode-se calcular o tamanho do string usando-se len. Utilizaremos bastante o comando print que imprime uma sequência de variáveis separadas por vírgula:

1. nome1 = 'Faraday'
2. nome2 = "Maxwell"
3. print 'string do tipo:', type(nome1), 'conteúdo:', nome1, "comprimento:", len(nome1)
4. print 'concatenação de:', nome1, " e ", nome2, "resulta em:", nome1 + nome2
string do tipo: <type 'str'> conteúdo: Faraday comprimento: 7
concatenação de: Faraday  e  Maxwell resulta em: FaradayMaxwell

String é um vetor imutável de caracteres. É possível indexar um caractere único e é possível aplicar regras consistentes do Python no tratamento de sequências, tais como fatiamento (slicing) e formas de indexação. Em Python, o primeiro elemento é sempre indexado como zero, assim quando tenho um string de 5 caracteres, ele é indexado de 0 a 4. É possível também representar o último elemento do vetor pelo índice -1.

1. print 'Primeiro caractere de ', nome1, ' é: ', nome1[0]
2. print 'Último caractere de ', nome1, ' é: ', nome1[-1]
3. print 'Repetindo-se strings 3 vezes', 3 * nome1
4. nome1[0] = 'b' # Não se pode alterar elementos de uma string. Este comando ocasionará erro!!
Primeiro caractere de  Faraday  é:  F
Último caractere de  Faraday  é:  y
Repetindo-se strings 3 vezes FaradayFaradayFaraday
------------------------------------------------------------
*** Exception while evaluating code:
  File "<string>", line 4, in <module>
TypeError: 'str' object does not support item assignment

------------------------------------------------------------

Tipos Númericos:

  • Declarando variáveis dos tipos inteiro, booleano, ponto flutuante e complexo e realizando algumas operações simples
01. a = 3
02. print(type(a))
03. b = 3.14
04. print(type(b))
05. c = 3 + 4j
06. print(type(c))
07. d = False
08. print(type(d))
09. print(a + b)
10. print(b*c)
11. print(c/a)
<type 'int'>
<type 'float'>
<type 'complex'>
<type 'bool'>
6.14
(9.42+12.56j)
(1+1.33333333333j)

Observe que em operações envolvendo elementos de tipos diferentes a linguagem realiza a conversão dos elementos ao tipo adequado, conforme a seguinte hierarquia: complexo > ponto flutuante > inteiro

Listas:

-Declarando listas e realizando algumas operações simples

1. lista1 = [1, 1.1, 'um'] # Listas podem conter elementos de diferentes tipos.
2. lista2 = [3+4j, lista1] # Inclusive uma lista pode conter outras listas como elementos!
3. print(type(lista1))
4. print(lista2)
5. lista2[1] = 'Faraday' #Diferentemente das strings, pode-se atribuir novos valores a elementos da lista.
6. print(lista2)
7. lista3 = lista1 +lista2 # Concatenando 2 listas
8. print(lista3)
9. print(2*lista3)
<type 'list'>
[(3+4j), [1, 1.1, 'um']]
[(3+4j), 'Faraday']
[1, 1.1, 'um', (3+4j), 'Faraday']
[1, 1.1, 'um', (3+4j), 'Faraday', 1, 1.1, 'um', (3+4j), 'Faraday']

Tuplas:

-Declarando tuplas e realizando algumas operações simples

01. #Declarando tuplas
02. tupla1 = ()
03. tupla2 = 'Gauss',
04. tupla3 = (1.1, 'Ohm', 3+4j)
05. print(type(tupla3))
06. print(tupla3)
07. x,y,z = tupla3 #Desempacotando os valores armazenados na tupla
08. print(x)
09. print(y)
10. print(z)
11. tupla3[1]  = 'Kirchoff' # Não se pode alterar elementos de uma tupla. Este comando ocasionará erro!!
<type 'tuple'>
(1.1, 'Ohm', (3+4j))
1.1
Ohm
(3+4j)
------------------------------------------------------------
*** Exception while evaluating code:
  File "<string>", line 11, in <module>
TypeError: 'tuple' object does not support item assignment

------------------------------------------------------------

OBS: A diferença entre listas e tuplas é que as listas são variáveis mutáveis, ou seja, pode-se alterar os valores dos seus elementos, enquanto as tuplas são imutáveis. Essas características das listas e das tuplas são exemplificadas nos trechos de código mostrados acima.

Conjuntos

Conjuntos são coleções de elementos que não possuem ordenação e também não apresentam elementos repetidos.

-Declarando conjuntos e realizando algumas operações simples

1. lista1 = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
2. lista2 = ['red', 'blue', 'green','red','red']
3. conjunto1 = set(lista1) # Definindo um conjunto
4. conjunto2 = set(lista2)
5. print(conjunto1) # Observe que os elementos repetidos são contados apenas uma vez
6. print(type(conjunto1))
7. print(conjunto1 | conjunto2) # União de 2 conjuntos
set(['orange', 'pear', 'apple', 'banana'])
<type 'set'>
set(['blue', 'green', 'apple', 'orange', 'pear', 'banana', 'red'])

Dicionários:

Dicionários podem ser definidos como sendo listas associativas que ao invés de associar os seus elementos a índices númericos, associa os seus elementos a palavras-chave.

-Declarando dicionários e realizando algumas operações simples

1. dict1 = {'blue':135,'green':12.34,'red':'ocean'} #definindo um dicionário
2. print(type(dict1))
3. print(dict1)
4. print(dict1['blue'])
5. print(dict1.keys()) # Mostra as chaves do dicionário
6. del dict1['blue'] # Deleta o elemento com  a chave 'blue'
7. print(dict1.keys()) # Mostra as chaves do dicionário após o elemento com a chave 'blue' ser apagado
<type 'dict'>
{'blue': 135, 'green': 12.34, 'red': 'ocean'}
135
['blue', 'green', 'red']
['green', 'red']

A importância da indentação na linguagem Python:

Diferentemente das outras linguagens que utilizam palavras-chave como begin e end ou chaves {, } para delimitar seus blocos (if, for, while, etc.), a linguagem Python utiliza a indentação do código para determinar quais comandos estão aninhados dentro de um bloco, portanto a indentação é de fundamental importância na linguagem Python.

-Exemplo da importância da indentação na linguagem Python

01. #Ex1: O último comando print executa independentemente do valor de x
02. x = -1
03. if x<0:
04.    print('x é menor que zero!')
05. elif x==0:
06.    print('x é igual a zero')
07. else:
08.    print('x é maior que zero!')
09. print('Esta frase é escrita independentemente do valor de x')
10. 
11. #Ex2: Os dois últimos comandos print estão dentro do laço devido a
12. #indentação, portanto só executam se x for maior que zero
13. if x<0:
14.    print('x é menor que zero!')
15. elif x==0:
16.    print('x é igual a zero')
17. else:
18.    print('x é maior que zero!')
19.    print('Esta frase é escrita apenas para x maior que zero')
x é menor que zero!
Esta frase é escrita independentemente do valor de x
x é menor que zero!
[–] Comments
Rafael Justo at 2015-02-26 11:26h
Likes:
Jessica Oliveira
 1
Excelente dica. A indentação neste caso, alem de ter a importancia para a lógica da rotina, também auxilia para um melhor entendimento do código para quem não o escreveu.

Joseph Alves at 2014-09-05 02:14h
Likes:
Roberto Lotufo
 1
Uma boa é selecionar o texto e dar Tab ou Shift+Tab para avançar ou recuar na identação.. poupa um tempo até.

Andre Luiz Oliveira at 2014-09-03 23:43h
 0
Gilda o código deve ser indentado pelo programador, linha a linha.

Gilda de Souza Carvalho at 2014-09-02 14:59h
Likes:
Andre Luiz Oliveira
 1
qual é o comando usado para indentar o código, ou a cada enter o código é automaticamente indentado.