Valdemar W. Setzer
www.ime.usp.br/~vwsetzer (na
seção Recursos
Educacionais); ver a versão
em inglês, tradução desta
Versão 20.2 de 31/12/24
Em termos de tipos de variáveis, Python é considerada
uma linguagem dinâmica e fortemente tipada. Fortemente tipada:
Python não permite operações implícitas entre diferentes
tipos sem conversão explícita. Por exemplo, adicionar uma cadeia
de caracteres (string, ver 2.3 abaixo) a um número
gerará um erro, a menos que a cadeia seja explicitamente convertida em
um número por meio de uma função de conversão de
tipos. Dinamicamente tipada: O tipo de uma variável é determinado
em tempo de execução e pode mudar conforme novos valores são
atribuídos a ela, o que significa que uma variável x adota o tipo
do valor atribuído a ela. Por exemplo, ao executar a atribuição
x = 1, x será do tipo inteiro. Se a atribuição x = 1.5
for executada, daí para diante x se tornará do tipo float, até
mudar de tipo.
Variáveis funcionam como referências (ou ponteiros)
para objetos. Quando um valor é atribuído a uma variável,
ela não armazena diretamente o valor, mas sim uma referência ao
objeto que contém o valor.
Inteiro (int): precisão ilimitada.
Ex.: 1234567890123456789012345
Constantes. Binária. Ex.: 0b101 ou 0B101(valor decimal 5); octal:
0o127 ou 0O127 (87); hexadecimal: 0xA5B ou oXA5B (2651). Constantes hexadecimais
são comumente usadas para represenar números binários em
uma notação mais fácil de ser lida.
Ponto flutuante (float): usualmente implementado usando o tipo double
da linguagem C. Ex: .12345678901234567890 → 0.12345678901234568 (note-se
o arredondamento).
Complexo: contém uma parte real, e uma imaginária indicada
por um j. Exs.: constante (1+2j) ou (1+2J); variável (A+D*1j)
Para converter um tipo para inteiro usar as funções int(), para
ponto flutuante float(), para complexo complex(). Essas funções
devem ser usadas especialmente na entrada de dados, input() que dá
sempre um tipo str de cadeia de caracteres.
O módulo NumPy (ver as referências), que deve ser instalado, permite
o uso de uma grande variedade de tipos numéricos. Para definir uma variável
tipo ponto flutuante de 32 bits, basta dar, p. ex.
x = numpy.float32(1.0)
Exemplo: 'tuv5xyz: ' → 'tuv5xyz:
'; "tuv5xyz: " → 'tuv5xyz: '; 'tuv5x"yz: ' → 'tuv5x"yz:
'; Se é executado o comando Cad='Esta
é uma cadeia' então Cad → 'Esta é uma cadeia'
Cadeia vazia: '' (dois apóstrofes) → '' ou ""
"" → ''. Atenção: " " → '
' (um espaço em branco)
Indexação: o 1º índice indica o elemento
inicial, começando em 0; o 2º o final, começando em 1:
CAD[0] → 'E'; Cad[5:10] → 'é uma]; Cad[10:] → 'é
uma cadeia'
Concatenação de cadeias: 'tuv5xyz: ' + Cad →
'tuv5xyz: Esta é uma cadeia'; 2*Cad → 'Esta é uma cadeiaEsta
é uma cadeia'.
Exemplo: Tup = (A, 5, 3.14, 'bla');
Tup → (1, 5, 3.14, 'bla'). (Para o valor de A ver o item 4 de 1. Observações.)
n-pla vazia: ()
Indexação:
Tup[0] → 1; Tup[1:3] → (5, 3.14); Tup[2:] → ((3.14, 'bla');
2*Tup → (1, 5, 3.14, 'bla', 1, 5, 3.14, 'bla').
É inválido atribuir um valor a um elemento de uma tupla:
Tup[1] = 10
Exemplo: L = [A, 5, 1.2, 'bla']
Lista vazia: []
Indexação: L[2] → 1.2; L[1:4] → [5, 1.2,
'bla']. Note-se que os índices dos elementos vão de 0 a, digamos,
n. L[i:j] indica os elementos começando no elemento de índice
i e terminando no de índice j–1. L[5] → dá um erro
pois não há elemento de índice 5. L[4] = 9 → dá o mesmo erro. Para
adicionar mais um elemento (sempre no fim da lista): L = L + [9]; L → [1,
5, 1.2, 'bla', 9]; L = L + [] não altera L.
Atribuição a um elemento: é válido
fazer L[3]=10; L → [1, 5, 1.2, 10].
Eliminação de um elemento da lista: usa-se o comando
del. Ex. del L[2]; L → [1, 5, 10];
Exemplo: Dic = {5:10, 3:'bla',
'ble':'A', 'A':'8'}; Dic →{5: 10, 3: 'bla', 'ble': 'A', 'A': 8}
Indexação: Dic[5] → 10; Dic[3] → 'bla';
Dic['ble'] → 1; Dic[3] → 'bla'; DIC['A'] → '8'
Note-se que cada elemento de um dicionário é da forma x:y,
onde x é o índice e y é o valor associado
a esse índice. Índices ou valores que são alfabéticos
devem estar entre apóstrofos '...' ou aspas "...".
Obtenção de todos os
índices (keys): Dic.keys() → dict_keys([1, 'ble',
3, 5])
Obtenção de todos os valores: Dic.values() →
dict_values([8, 1, 'bla', 10])
dict_keys e dict_values não podem ser indexadas. Para se trabalhar com
todos os índices ou os valores, pode-se transformá-los em listas
e depois trabalhar com elas {MDG}:
L = [x for x in Dic.keys()]; L → [5, 3, 'ble',
1]
L = [x for x in Dic.values()]; L → [10, 'bla',
1, 8]
Exemplo: S = {1, 'dois', 3, 'quatro'};
S → {3, 1, 'dois', 'quatro'} (Conjuntos não são ordenados
e não podem ser indexados.)
Conjunto vazio: {}
Usos. Número de elementos (cardinalidade):
len(S) → 4. Pertinência: 'dois' in S → True.
União: S | {5} → {1, 3, 'dois', 5, 'quatro'} (S não
mudou!). Interseção: S & {1, 'dois'} → {1, 'dois'}.
Complementação: S {1, 'dois'} → {3, 'quatro'}.
Testa superconjunto próprio: S > {1, 'quatro'} → True.
Superconjunto: >=. Subconjunto próprio: <. Subconjunto:
<=. União exclusiva (elimina os elementos comuns): S ^ {'dois',
5} → {1, 3, 5, 'quatro'}
Há dois tipos de conjuntos: set, em que seus elementos podem ser
mudados, e frozenset
que não pode ter seus elementos mudado. A construção de
um set é automática. Ex.: x = frozenset({1, 2}); x.pop()
→ erro. Conjuntos internos a conjuntos têm que ser do tipo frozenset.
Padrão: range(m,
n, k), com n e k opcionais ou só k
opcional, gerando os inteiros de uma lista r tal que r[i]
= m + k*i, onde i >= 0 e i < abs(n)
Exemplos: list(range(5)) → [0, 1, 2, 3, 4]; list(range(1,
5)) → [1, 2, 3, 4]; list(range(0, 8, 2)) → [0, 2, 4, 6]; list(range(-1,
-10, -2)) → [-1, -3, -5, -7, -9]
Uso em comandos for: ver o comando no item 11 abaixo e no 2.5 acima.
Ao contrário de quase todas as outras linguagens de programação,
Python não tem o tipo array, pois os valores de variáveis
podem ocupar tamanhos diversos. Para representar matrizes, usam-se listas, já
que as mesmas podem ser indexadas como se fossem matrizes. Em outras linguagens,
a declaração de um array produz a inicialização
de seus valores, isto é, a declaração do array faz com
que todos seus elementos passem a existir. Mas o mesmo não ocorre com
as listas de Python; assim, é preciso adicionar cada elemento novo, pela
ordem. Para usar matrizes, é necessário carregar o módulo
NumPy, que permite o uso de vetores e matrizes como se fosse nas linguagens
tradicionais. Supondo que ele está instalado, para ativá-lo e
dar-lhe o nome interno de np dá-se import NumPy as np.
Ver as referências para detalhes como usá-lo.
Exemplos
1. Para definir um vetor de 5 elementos, inicializando com valores 0
(poderia ser outro qualquer, como I ou uma expressão): V=[0 for
I in range(4)]; V → [0, 0, 0, 0]; note-se que V[4] não existe
e não pode receber algum valor, como V[4]=0 ou V[4]=[0]. Para defini-lo:
V=V+[0]. Para varrer todo um vetor de tamanho variável, use len(V) →
4
2. Para definir uma matriz bidimensional, constrói-se uma lista
de listas: M=[[1, 2], [3, 4]]; M → [[1, 2], [3, 4]]; M[1][1] → 4;
M[0][1] → 2; M[1][0] → 3. Inicialização, com vários
valores, de uma matriz com 3 linhas e 4 colunas:
M = [[I+J+1 for I in range(2)] for J in range(3)];
M → [[1, 2], [2, 3], [3, 4]]; M[2][1] → 4
Para dimensões maiores, basta estender as receitas.
3. Para varrer todos elementos e exibir os seus valores: 5. Para obter linhas: 6. Para obter colunas: |
4. Para gerar uma matriz com valores
crescentes: J=1 {PC} Chamou a atenção para a inicialização do J 7. Para aplicar uma função,
p.ex. sqrt a todos os elementos de M: |
Em Python, um iterável (iterable) é um objeto capaz ao qual se pode fazer accesso a seus membros um de cada vez, permitindo que ele seja varrido em um comando de malha de repetição for. Exemplos comuns de iteráveis incluem listas, tuplas, dicionários e conjuntos.
Op |
Significado e tipos dos operandos |
Exemplos |
+ |
Operador binário (com dois argumentos): soma de int, float, ou complex; concatenação de cadeias de caracteres (strings), de listas e de n-plas |
A+B → 3, D+E → 3.5; A+D → 2.2; (A+D*1j)+(E+C*1j) →
(3.3+4.2j); |
+
|
Operador unário (com um argumento): sem efeito | +A → 1 |
– |
Operador binário de subtração de int, float ou complex; complementação de conjuntos |
C–B → 1; F–D → 2.2; F–A → 2.4 |
–
|
Operador unário de troca de sinal | –A → –1 |
* |
Multiplicação int, float ou complex |
B*C → 6; D*E → 2.76; B*D → 2.4; (A+D*1j)+(E+C*1j) → (3.3+4.2j) |
/ |
Divisão int, float, resulta float ou complex |
C/B → 1.5; F/E → 1.4782608695652175; C/D → 2.5; |
// |
Divisão de int, resulta int, ou de float por int ou float só parte inteira |
C//B → 1; F//D → 2.0; F//B → 1.0; |
% |
Resto int da divisão de ints, parte inteira se divisão de floats |
C%B → 1; F//D → 2.0; F//B → 1.0 |
** |
Potenciação de int, float ou complex |
B**C → 8; B**D → 2.2973967099940698; D**B → 1.44; D**E → 1.5209567545525315; (1+1j)**2 → 2j; 27**(1/3) → 3 (raiz cúbica) |
== |
Testa igualdade de int, float complex ou string, resulta True (verdadeiro) ou False (ver tabela de operadores lógicos); com vários == em um só comando dá True somente se cada um dos pares consecutivos for igual |
B==A*2 → True; A==B → False; A==D → False; A==int(D) → True; (A+B*1j)==(1+2j) → True; G=='abc’ → True; G==H → False; 1==1==1 → True; 1==1==2 → False; |
!= |
Diferente, idem |
A!=B → True; A!=D → True; A!=int(D) → False; (1+2j)!=(2+2j)
→ True; |
> |
Maior do que, idem sem complex; testa superconjunto próprio |
B>A → True; A>B → False; D>A → True; E>D → True; H>G → True; 3>2>1 → True; 3>2>3 → False; |
< |
Menor do que, idem; subconjunto próprio |
A<B → True; B<A → False; etc. |
>= |
Maior ou igual, idem; superconjunto |
B>=A → True; B>=D → True; H>=G True; etc. |
<= |
Menor ou igual, idem; subconjunto |
B<=A → False; etc. |
&
|
"e" bit a bit de valores binários, resultado decimal no IDLE; intersecção de conjuntos | 0b0101 & 0b0001 → 1; bin(0b1100 & 0b1010) → '0b1010' (na exibição corta os 0s à esquerda) |
|
|
"ou inclusivo" bit a bit, resultado decimal no IDLE; união de conjuntos | bin(0b1100 | 0b1010) → '0b1110' |
^
|
"ou exclusivo" bit a bit. resultado decimal no IDLE; união exclusiva de conjuntos | bin(0b0110 ^ 0b1010) → '0b1100' |
>>
|
deslocamento bit a bit para a direita inserindo 0s à esquerda (equivale a divisão por pow(2,n) | J = 10; bin(J) → '0b1010'; bin(J>>1) → '0b101' (zeros à esquerda não são exibidos) |
<<
|
deslocamento bit a bit para a esquerda inserindo 0s à direita (equivale a divisão por pow(2,n) | J = 10; bin(J) → '0b1010'; bin(J<<2) → '0b101000' |
is
|
Teste de identidade de objetos | |
is not | Teste de não identidade de objetos | |
= |
Atribuição simples ou múltipla, lado direito int, float, complex ou string; ambos os lados podem ser uma n-pla sem "(" e ")" |
A=1; A → 1; A=D; A → 1.2 (A mudou de int para float); |
+= |
x += y equivale a x = x + y |
J=1; J=+2; J → 3; J=(1+2j); J+=(2+3j); J → (3+5j) |
–= |
x -= y equivale a x = x – y, inclusive de conjuntos |
J=3; J–=2; J → 1 |
*= |
x *= y equivale a x = x |
J=2; J*=3; J → 6 |
/= |
x /= y equivale a x = x /y |
J=6; J/=3; J → 2.0 |
//=
|
x // y equivale a x = x // y | J=15; J//=4; J → 3; J=15.5; J//=3.7; J → 4.0 |
%= |
x %= y equivale a x = x%y |
J=6; J%=4; J → 2.0; J=6; J%=2; J → 0 |
**=
|
x **= y equivale a x = x**y | J=2; J**=3; J→ 8 (Não disponível na versão 2 do Python) |
>>=
|
x >>= y equivale a x = x>>y | J=0b1010; J>>=2; bin(J) → '0b10' (zeros à esquerda não são exibidos) |
<<=
|
x <<= y equivale a x = x<<y | J=0b1010; J<<=2; bin(J) → '0b101000' |
&=
|
x &= y equivale a x = x&y, inclusive de conjuntos | J=0b1100; K=0b1010; J&=K; bin(J) → '0b1000' |
^=
|
x ^= y equivale a x = x^y, inclusive de conjuntos | J=0b1100; K=0b0110; J^=K; bin(J) → '0b1010' |
|=
|
x |= y equivale a x = x|y, inclusive de conjuntos | J=0b1100; K=0b1010; J|=K; bin(J) → '0b1110' |
if
|
Expressão condicional: |
J = 1 if 4>3 else 2 → 1 J = 5 * (1 if B<A else 3*A); → 15 |
Op |
Significado |
Exemplos |
No que segue, supõe-se a execução prévia de L1T = True; L2T = True; L1F = False; L2F = False | ||
True | Constante indicando "verdadeiro" | Atenção: true não é aceito, dá erro de variável não definida |
False | Constante indicando "falso" | Idem para false; são considerados como False: None, 0, 0.0, 0j, ' ', (), [], {}; outros valores como True |
not | Negação: muda True para False e vice-versa | not L1T → False; not L1F → True |
x or y | "ou" inclusivo; dá falso somente se x e y forem falsos | L1T or L2T → True; L1T or L1F → True; L1F or L1T → True; L1F or L2F → False |
x and y | "e"; dá verdadeiro somente se x e y forem verdadeiros | L1T and L2T → True; L1T and L1F → False; L1F and L1T → False; L1F and L2F → False |
x in y | se x está na string, n-pla, lista ou conjunto y dá True, senão False | 'a' in 'false' → True; 5 in (2, 5, 3) → True; 3 in [2, 5, 3] → True; 4 in [2, 5, 3] → False |
x not in y | Contrário de in | 'a' not in 'false' → False; 5 not in (2,
5, 3) → False; 3 not in [2, 5, 3] → False; 4 not in [2, 5, 3] → True |
is |
Teste de identidade de dois objetos. Determina se duas variáveis apontam para o mesmo objeto. |
x = y = 0; x is y → True; ; x = 0; y = 1; print(x is y ) → False |
is not | Teste de identidade de dois objetos. Determina
se duas variáveis não apontam para o mesmo objeto. |
x = y = 0; x is not y → False; x = 0; y = 1; print(x is not 1) → True |
5. FUNÇÕES NATIVAS (Ver a lista oficial em https://docs.python.org/3/library/functions.html ; os exemplos foram testados com o IDLE ou com o Editor do IDLE; nesse último caso a exibição de resultados é feita com Print().
Função |
Significado |
Exemplos |
abs() |
Valor absoluto; módulo no caso de complexo |
abs(-1) → 1; abs (2) → 2; abs((1+2j)) → 2.23606797749979 |
S.add(x) | Insere x no iterável (V. item 2.10) S |
S = {1, 2, 'três'}; S.add('quatro'); S → {1, 2, 'três',
'quatro'} |
aiter() | Cria um iterável assíncrono. Usada em programação assíncrona (permite execução concurrente, sem esperar que operações sejam completadas). A programação normal é síncrona, uma operação de cada vez, sequencialmente | Exige a importação de módulos específicos, como o asyncio para entrada/saída. Ver exemplos. |
all(x) |
Retorna True se todos elementos do iterável x tiverem valor True ou se x for vazio, e False se algum elemento de x for False |
a = [True, True, True]; b = [True, True, False]; c = []; all(a), all(b), all(c) → (True, False, True) |
anext() | Usada em programação assíncrona (v. aiter). Permite obter o próximo item de um iterável asíncrono | Parte do módulo asyncio. Ver exemplo. |
any() |
Retorna True se qualquer elemento for True e False se estiver vazio. |
a = [True, True, True]; b = [True, True, False]; c = []; any(a), any(b), any(c) ? (True, True, False) |
ascii(x) | Retorna x como cadeia, pulando caracteres que não são do tipo ASCII {EF} | numero = 123; list = [1, 2, "Olá"];
tuple = ("a", "b", "c") print(ascii(numero), ascii(lista), ascii(tupla)) → 123 [1, 2, 'Ol\xe1'] ('a', 'b', 'c') |
bin() |
Converte um int em binário |
bin(B) → '0b10'; bin(20) → '0b10100' |
x.bit_length() | Comprimento de bits significativos do binário x | 0b101010.bit_length() → 6; 0b001010.bit_length() → 4 |
bool() |
Retorna True se o argumento é verdadeiro, False se não há argumento ou ele é falso |
bool(B>A) → True; bool(C>D) → False; bool() → False |
breakpoint() #msg | Interrome a execução, emitindo a mensagem msg, e ativa o depurador (debugger) pdb. | for i in range(5): if i == 2: breakpoint() # Interrupção aqui print(i) → 0 1 -> breakpoint() # Interrupção aqui (Pdb) |
bytearray(x,c,er) |
Retorna um objeto bytearray que é uma matriz dos bytes do iterável x usando o código de tipo c, utf-8 em hexadecimal se c é ausente; er é uma cadeia com uma mensagem de erro se algum caractere não pode ser convertido |
prime = [2, 3, 5, 7]; byte = bytearray(prime); print(byte) → bytearray(b'\x02\x03\x05\x07') |
bytes(x,c,er) | O mesmo que bytearray mas o resultado é um objeto que não pode ser modificado | for i in range(10): if i == 6: breakpoint() # Pause execution here print(i) |
callable() |
Retorna True se o argumento dessa função for uma função já definida, False caso contrário. |
x = 10; print(callable(x)) → False |
chr() |
Caractere correspondente ao código ASCII do argumento (entre 0 e 255) |
chr(97) → 'a'; chr(150) → '\x96' (converteu para hexadecimal, pois não achou o caractere) |
classmethod() |
Permite ativar diretamente o método de uma classe, sem precisar instanciar a classe {EF} |
class CM: |
x.clear() | Remove todos os elementos do iterável x (V. 2.10) | x = {1, 2, 'três'}; x.clear(); x → set() [indica conjunto vazio]; x |= {9}; x → {9} |
compile(s,file,mo) |
Permite compilar e executar um objeto s (p.ex. uma string) retornando o resultado se o modo for 'exec', podendo ser 'eval' se s for uma expressão, 'single' se contém um comendo iterativo; file se s está em um arquivo {EF} |
string = 'a=8;b=7;soma=a+b\nprint(soma)' # a=8;b=7;print(a+b) |
complex(re,im) |
Converte em complexo com parte real re e imag. im |
complex(1) → (1+0j); complex(2.5) → (2.5+0j) |
x.conjugate() | Dá o conjugado do complexo x | x = (1+2j); x.conjugate() → (1-2j) [não está funcionando na versão 3.13.1] |
delattr(cl,atr) |
Elimina o atributo atr da classe cl |
class A: |
dict() |
Cria um dicionário {EF} |
n = dict(x=5, y=0); print(n, type(n)) → {'x': 5, 'y': 0} <class 'dict'> |
dir() |
No IDLE lista o nome das variáveis da sessão |
n = [10]; print(dir()) → [..., n] |
x.discard(y) | Remove o elemento y do conjunto x, se y está em x | x = {1, 2, 'três'}; x.discard('três'); x → {1, 2} |
divmod(x,y) |
Dá a dupla ordenada (x // y, x % y) |
divmod (C,B) → (1,1), divmod (C,D) → (2.0, 0.6000000000000001) |
x.encode(c) | Codifica a cadeia x usando o tipo de código c | |
enumerate(x) |
Retorna o iterável (V. 2.10) x enumerando cada um de seus elementos {EF} |
lis = ['a', 'b', 'c']; print(list(enumerate(lis))) → [(0, 'a'), (1, 'b'), (2, 'c')] |
eval(x) |
Executa a cadeia (string) x e retorna seu valor. x pode ser o resultado de uma input(). x não pode ser um comando composto. |
eval('2*3') → 6 eval("'abc'[1]") → 'b' |
exec('c',gl,loc) | Executa imediatamente o código c; gl e loc são dicionários permitindo especificar variáveis e métodos globais e locais a serem usados, garantindo segurança |
exec('print("A soma de 5 e 10 é", (5+10))') &rarr A soma de 5 e 10 é 15 exec('x = 10\ny = 20\nprint("Sum:", x + y)') → Sum: 30 |
exit() | Termina a execução do programa | Requer ométodo sys, incorporado com import sys. Uso: sys.(exit |
filter(f, L) |
Aplica a função f a cada elemento da lista L, e resulta nos elementos de L para os quais f for True |
Ver exemplo no item "notação lambda" |
float() |
Converte para float |
float(B) → 2.0; |
float.as_integer_ratio() | Dá um par de inteiros cuja razão é o argumento | float.as_integer_ratio(1.5) → (3,2) |
float.is_integer() | Dá True se o argumento for inteiro, False em caso contrário | float.is_integer(1.5) → False; float.is_integer(3.0) → True |
format(x,f) |
Retorna valor de x no formato f. Ver a grande lista de formatos {EF} |
a = 123; print(format(a, 'x')); print(format(a, 'b')) → 7b 1111011 |
frozenset() |
Constrói um conjunto que não pode ser mudado |
x = frozenset({1, 2}); x → {1, 2}; x.pop() dá erro |
getattr(obj,atr,err) |
Retorna o valor de um atributo atr do objeto obj. Se o atributo não existe em obj, retorna err. |
class Cla: |
globals() |
Retorna um dicionário com os nomes e valores de todas as variáveis globais {EF} |
a = 1; b = 2; print(globals()) → {..., 'a': 1, 'b': 2} |
hasattr(clobj,atr) |
Retorna True se a classe ou clobj tem o atributo atr {EF} |
class A: |
hash(x) |
Retorna um inteiro único que representa x, que pode ser apenas uma string, um número ou uma n-pla. O valor pode mudar de uma sessão para outra |
hash('Bom dia!') → -2257218869280192840 hash((1,2,3)) → 529344067295497451 |
help() |
No modo interativo (IDLE), dá a documentação do argumento |
help(int) |
hex() |
Converte um int para um hexadecimal |
hex (8) → '0x8'; hex (50) → '0x32'; hex(C) → '0x3' |
id(x) |
Quando o objeto x é criado, é associado um número (endereço) único a x, que é retornado pela função {EF} |
a = 5; b = 6; print('a', id(a), 'b' id(b), '123' id(123) → |
__import__() |
Importação de módulos. É o mesmo que o comando import. |
|
input("mensagem") |
Espera o usuário dar uma entrada, seguida de Enter. Retorna o valor da entrada de um dado no tipo string; pode exibir mensagem ao ser executado. Não funcionou no compilador on-line W3 (item 1-3) |
dia=input('Entre com o valor do dia:'); → "Entre com o valor do dia:" 20 Enter dia → '20' (como string); para calcular é preciso converter, p.ex. diaint=int(input('Entre...')) ou diaint=int(dia); diaint → 20 |
int() |
Converte para int |
int(D) → 1; int('123') → 123 |
is not | Teste de não identidade objetos. Determina se duas
variáveis apontam para objetos diferentes. |
x = y = 0; x is not y → False |
x.isdisjoint(y) | True se o conjunto x é disjunto do conjunto y, False em caso contrário | {1, 2, 'três'}.isdisjoint({4, 'cinco'}) → True {1, 2, 'três'}.isdisjoint({2, 'cinco'}) → False |
isinstance(clobj,t) |
Retorna True se a classe ou objeto clobj é do mesmo tipo que t; se t é uma n-pla, retorna True see obj é um dos tipos da tupla {EF} |
print (isinstance("Olá", (float, int, str, list, dict, tuple))) → True |
issubclass(c1,c2) |
Retorna True se a classe c1 for uma subclasse da classe c2, False em caso contrário{EF} |
class A: |
iter(x) |
Retorna um índice para os elementos do iterável (V. 2.10) x {EF} |
x = iter(["a", "b", "c"]) |
s.join(x) | Método da classe string. Concatena as partes da lista, tupla ou conjunto x, separando-as com a string s. | SeparaComVirgulas = ','.join(['a', 'b', 'c']); SeparaComVírgulas → 'a,b,c' |
len(x) |
Dá o número de elementos de um iterável (V. 2.10) neste caso, a cardinalidade |
len(G) → 3; len((1,2,3,4)) → 4; len((A,B,G)) → 3; len([1,B,5,7])
→ 4 |
list() |
Converte os elementos de um iterável em lista; sem argumento dá a lista vazia |
list(G) → ['a', 'b', 'c']; list((1, 2, 3)) → [1, 2, 3]; list({1,2,3}) → [1, 2, 3] |
locals() |
Retorna um dicionário com os nomes e valores de variáveis locais a um programa ou função |
def f(x): |
lower() | Converte as letras uma string para minúsculas | 'BLA3#'.lower() → 'bla3#'; nome = input('Digite seu nome:').lower(); print(nome) |
s.lstrip('c') | Método da classe string. Elimina todos os caracteres c do começo da string s, ignorando brancos até c; se c é omitido, elimina os brancos no começo de s | s='x y z'; s.lstrip('x') → s=(' x y
z )'; s.lstrip('x') → ' y z'; s.lstrip() → 'x
y z'; s=(' x y z '); s.lstrip() → 'x y z '; s.lstrip(' x,') → 'y z '; s.lstrip('x y') → 'z ' |
map(f,L) |
Aplica a função f a cada elemento de um ou mais iteráveis (V. 2.10) L |
list (map (abs, [2,-3,4,-5])) → [2, 3, 4, 5] |
max(x) |
Dá o maior dos elementos do iterável x |
max (1,2,3) → 3; max (['a', 'b', 'c']) → 'c'; max ('a', 'b',
'c') → 'c'; |
memoryview(x) |
Retorna um objeto com com a respresentação interna de x {EF} |
a = bytearray('ABC', 'utf-8'); m = memoryview(a); print(list(m[1:3]))
→ |
min() |
Como max, para o menor |
min (1,2,3) → 1; min (['a', 'b', 'c'])
→ 'a'; min ('a', 'aa', 'aaa') → a; |
next(x) |
Retorna o próximo valor do iterável x {EF} |
a = [5, 6, 7]; b = iter(a); print(next(b), next(b)) → 5 6 |
object() |
Retorna a classe que é a base de todas as classes; não se pode definir atributos a ela, mas ela tem os atributos comuns a todas as classes, como __init__ e __string__ (EF} |
obj = object(); print(dir(obj)) → |
oct() |
Converte para octal |
oct(15) → '0o17' |
open(arq,m) |
Abre o arquivo de caminho e nome arq tornando-o um objeto, no modo m, que pode ser r (somente leitura), w (gravação, cria arq se não existe), a (adiciona uma cadeia a arq, cria se não existe), x (cria arq, erro se sejá existe), b (arquivo binário, como p.ex. de imagem), t (arquivo de texto, padrão). arq torna-se uma classe, com atributos |
f = open('nome', 'w'); f.write('Texto'); f = open('nome', 'r') |
ord() |
Contrário de chr |
ord ('a') → 97 |
x.pop() | Returns iterable x without its last element | x = {1, 2, 'three'}; x.pop(); x → {1,2} |
pow(x.y) |
Equivalent to x**y |
pow(2,3) → 8; pow(4,0.5) → 2.0; pow (4,-2) → 0.625 |
print(x) |
Saída de dados. x pode conter vários objetos e expressões separados por vírgulas, bem como cadeias a serem exibidas como constantes, e parâmetros de formato de linha (\...) |
print(A,D) → 1 1.2; print ('A =',A) → A = 1; print ('A*3 =',A*3,'\nD
=',D) → |
property(cl) |
Usada dentro de uma classe cl, permite alterar os valores dos atributos de cl {EF} |
See examples here |
random |
Uma classe. Exige importar o módulo random. Algumas funções
dessa classe: |
Os resultados obtidos com o IDLE podem ser outros, dependendo
da "semente": 1. import random; random.randint(10, 100) → 12; random.randint(10, 100) → 67 2. random.random() → 0.05462293624556047; random.random() → 0.36903357168070205 3. random.uniform(2,5) → 3.983840861586745 4. random.choice([1,2,3,4,5])) → 3; random.choice([1,2,3,4,5])) → 4 5. x=[1,2,3,4]; random.shuffle(x); x → [3, 1, 4, 2]; random.shuffle(x); x → [4, 1, 2, 3] |
range() |
Cria virtualmente uma lista virtual, para ser usada em um comando for. in indica a ordem do primeiro elemento, fim a ordem do último, e passo (se omitido, fica 1) os incrementos na ordem. |
range(C): equivale a [0, 1, 2]; range(1, 5) a [1, 2, 3, 4, 5]; |
reduce(fu,li) |
Essa função é parte do médulo operator. Ela aplica a função fu a todos elementos da lista li. Requer incorporar o módulo functools, permitindo que operadores (itens 3 e 4 acima) sejm especificados como funções. Uma outra possibilidade é usar a notação lambda (item 10 abaixo), definindo uma funçãto com um operador. |
import functools |
reload(x) |
Reloads a function x defined in a present module |
Look for examples |
repr() |
Retorna o valor de x em forma de string. x pode ser um objeto de uma classe, recriando-o. Útil para depuração. (Procure por exemplos com classes.) |
x = "abc"; y= [1, 2, 3]; print(repr(x, repr(z)) → ("'abc'", '[1, 2, 3]') |
reversed(x) |
Retorna o iterável (V. 2.10) x em sua ordem reversa. Ná se aplica a sets {EF} |
print(list((reversed('abc')))); print(list((reversed(('d','e','f')))))
→ |
round(x,n) |
x arredondado na n-ésima casa decimal; sem n arredonda para o inteiro |
round(3.5566,3) → 3.557; round(4.5555,3) → 4.555; |
s.rstrip(c) | Idem a lstrip, elimina a string c à direita da string s | print("exemplo!!!".rstrip("!"), "exemplo!!! ".rstrip("!")) → exemplo exemplo!!! {EF} |
set() |
Constroi um conjunto que pode ser mudado |
set([1, 2, 'three']) → {1, 2, 'three'}; set() → set() |
setattr(cl, 'atr', val) |
Define um valor val para o atributo atr da classe cl {EF} |
class Person: |
|
Define indices de um iterável para ser usado posteriormente para extrair parte do iterável. in, fim e passo como na função range() |
T= ("a", "b", "c", "d", "e",
"f"); y = slice(2); T[y] →
('a', 'b') |
sorted() |
Ordena uma lista |
sorted ([1,4,2]) → [1, 2, 4]; sorted([B,A]) → [1,2] |
staticmethod(cl, m) |
Converte um método m de uma classe cl em um método estático, que pode ser usado sem se instanciar a classe em um objeto da mesma |
class Cl: |
str() |
Converte int ou float para string |
str(C) → '3'; str(D) → '1.2' |
c.strip(s) | Método da classe string. Dá a string s sem a string c no começo e no fim. Sem o c, considera brancos. Ver também lstrip e rstrip | s = ' x y z '; s.strip() → 'x y z'; s = 'xyxyzzzxyxyxy'; s.strip('xy') → 'zzz' |
sum() |
Soma os elementos de uma lista, n-pla ou conjunto |
sum([A,B,C, 4, D]) → 11.2; sum((1,2,3)) → 6; sum ({1, 2, 3}) → 6 |
super() |
Permite que uma classe C2 que herda as propriedades de uma classe C1 utilize os atributos dessa última |
class C1: #Exemplo baseado em um da W3 Schools |
time.sleep(n) | Interrompe a execução de um programa por n segundos.
Exige a carga do móduo time: import time |
import time; print(10); time.sleep(5); print(20) →
10 [pause] 20 Não funciona no compilador on-line da W3 School; funciona no IDLE |
tuple() |
Converte um iterável em uma lista ordenada |
tuple('abc') → ('a', 'b', 'c'); tuple([1, 2, 3]) → (1, 2, 3);
|
type() |
Se o argumento for uma variável, dá seu tipo; se for um objeto, o tipo do mesmo. Pode ser usado para criar uma classe dinamicamente. |
type (A) → <class 'int'>; type (D) → <class 'float'>; type (G) → <class 'str'> |
upper() | Converte as letras de uma string para maiúsculas | 'bla3#'.upper() → 'BLA3#' |
vars(obj) |
Dá o atributo __dict__ do objeto obj. Permite ver os atributos de obj em forma de dicionário. Outros atributos usados pelo sistema também aparecem |
class Ex: |
zip() |
x deve ser um número de iteráveis em paralelo, em princípio com mesmo número de elementos em cada iterável. O resultado sera de duplas, triplas etc., juntando elementos correspondentes dos iteráveis. É como se transformasse linhas em colunas. |
for I in zip([1, 2, 3], ['a',
'b', 'c']): |
Para usar essas funções, é necessário executá-las no IDLE ou inserir em um programa o comando import math, que ativa o módulo (module) math, e preceder cada função de math., p.ex. math.sqrt(4), math.e etc; os resultados são sempre do tipo float, a menos de observação em contrário. Para cálculos com números complexos, dar import cmath .
Função |
Significado |
Exemplos |
atan(x) | Arcotangente, argumento e resultado em radianos | math.atan(2) → 1.1071487177940904; |
ceil(x) | O menor inteiro >= x | math.ceil(4.7) → 5 |
cos(x) | Cosseno, x e resultado em radianos |
math.cos(math.pi/2) → 6.123233995736766e-17 (devia ser zero; não é devido à aproximação); math.cos(math.pi) → -1.0 |
degrees(x) | Converte x em graus para radianos | math.degrees(math.pi) → 180.0 |
e | A constante e | math.e → 2.718281828459045 |
exp(x) | e**x | math.exp(1) → 2.718281828459045; math.exp(2) → 7.38905609893065 |
factorial(x) | Fatorial de x de tipo int, resultado int | math.factorial(5) → 120 |
floor(x) | Maior int <= x | math.floor(4.7) → 4 |
fsum | Somatória | Como a sum() da tabela Funçoes Nativas, mas arredondando |
inf | A constante infinito (maior número em float representável) | math.inf → inf |
log(x, base) | Logaritmo de x na base (opcional); sem base dá o log na base e | math.log(10) → 2.302585092994046; math.log(100,10) → 2.0 |
log10() | Logaritmo na base 10 | math.log10(100) → 2.0; em geral mais precisa que math.log(x,10) |
log2() | Logaritmo na base 2 | math.log2(8) → 3.0 |
modf(x) | Dá a parte decimal e a inteira de x | math.modf(1.25) → (0.25, 1.0) |
pi | O número pi | math.pi → 3.141592653589793 (ver exs. em sen, cos, tan) |
radians(x) | Converte x em radianos para graus | math.radians(180) → 3.141592653589793 |
sin(x) | Seno, x e resultado em radianos | math.sin(math.pi/2) → 1.0; math.sin(math.pi) → 1.2246467991473532e-16 (devia ser zero; não é devido à aproximação) |
sqrt() | Raiz quadrada | math.sqrt(4) → 2.0; math.sqrt(5.6) → 2.3664319132398464 |
tan(x) | Tangente, x e resultado em radianos |
math.tan(math.pi) → 1.2246467991473532e-16 (devia ser zero); |
trunc(x) | Parte inteira de x | math.trunc(3.5) → 3 |
Funções |
Significado
|
Exemplos
|
append() | Adiciona um elemento ao final da lista | L=[1, 2, 3, 4]; L=L+[5] → [1, 2, 3, 4, 5]; L=L+'#' → [1, 2, 3, 4, 5, '#'] |
clear() | Limpa uma string ou um set | L = [1, 2, 'três'];
L.clear(); print('d',x) → [] L= {1, 2, 'três}; L.clear(); print('c',x); → set(); |
copy() | Retorna uma cópia
da lista como um novo objeto |
L = [1, 2, 'três']; Lnova= L.copy(); print(Lnova) → [1, 2, 'três'] |
count(v) | Retorna o número de elementos com o valor v |
L=[1, 2, 3, 2, 4]; Conta_L= L.count;
print(Conta_L) → 2 |
extend(s) | Adiciona os elementos da lista s (ou qualquer iterável, (V. 2.10), ao final da lista atual | L=[1,2,3,4]; L.extend([5,6]); print(L) →[1, 2, 3, 4, 5, 6] |
index(e,c,f) |
Retorna o índice daprimeira ocorrência de e, começando no índice c e terminando no índice f |
L = [1,2,'três'];
i1 = L.index(1); i2 = L.index('três'); print(i1,i2) → 0 2 L = [1, 2, 3, 4, 1, 1, 1, 4, 5]; i1 = L.index(1, 4, 8); i2= L.index(1, 2, 8); print(i1,i2) &rar; 4 4 |
insert(p,e) | Adiciona um elemento e na posição p | L = [1, 2, 3, 4]; L.insert(2, 10); print(L) →[1, 2, 10, 3, 4] |
lstrip() | Remove espaços em branco ou caracteres especificados no início de uma string | Como strip(), mas só do começo |
pop(e,p) | Remove o elemento e na posição p; se p não for fornecido, remove o último elemento da lista | L = [1, 2, 3, 2,
4]; L.pop(3); print(L) → [1, 2, 3, 4]; print(L.pop()); → [1, 2,
3] pop() [pode ser usado para desempilhar o topo de uma pilha] |
remove() | Remove o primeiro item com o valor especificado |
L = [1, 2, 3, 2, 2]; L.remove(2); print(L)
→ [1, 3, 2, 2] |
replace('a','b') | Substitui ocorrências de 'a' por 'b' | OLA = 'O?lá,
b?o?m di?a!?!'; OLA_Limpo = OLA.replace('?', ''); print(OLA_Limpo) → Olá, bom dia!! [os duplos apóstrofos são essenciais] |
reverse() | Inverte a ordem da listt | L = [1, 2, 3, 4]; L.reverse(); print(L) → [4, 3, 2, 1] |
sort() | Ordena a lista | L = [1, 3, 4, 2]; L.sort(); print(L) → [1, 2, 3, 4] |
s.split(sep) | Método da classe string. Gera uma lista com os elementos da string s separados pela string sep; se sep for omitido, usa branco como separador | s='a,b,3'; s.split(') → ['a', 'b', '3']; s='x#y#z'; s.split('#') → ['x', 'y', 'z'] |
strip() | Remove espaços em branco ou caracteres especificados no início e no fim de uma cadeia | OLA = " Olá,
bom dia!! "; OLA_Limpo = OLA.strip(); print(OLA_Limpo) → Olá,
bom dia!! OLA = ",,##?? Olá, bom dia!! ,,##?? "; OLA_Limpo = OLA.strip(',#? '); print(OLA_Limpo) → Olá, bom dia!! [O espaço em branco no final da cadeia é essencial; a função interrompe a remoção de caracteres de ambas as extremidades quando encontra um caractere que não está nos caracteres especificados.] |
rstrip() | Remove espaços em branco ou caracteres especificados no fim de uma string | Como a strip(), mas no fim da cadeia |
translate() | Remove uma subcadeia usando None | OLA = 'O?la, b?o?m di?a!?!';
OLA_Limpo = OLA.translate({ord('?'): None}); print (OLA_Limpo) → Ola, bom dia!! |
8. PRECEDÊNCIA (ORDEM DE EXECUÇÃO)
Ordem |
Operador/função |
Exemplos |
1
|
( ... ) | (... ignorado pelo interpretador) |
2
|
função() | abs(-5)+2 → 7 |
3
|
+ e - unários | -5-2 → -7; -(5-2) → -3 |
4
|
*, /, % e // | |
5
|
+ e - binários (soma e subtração) | |
6
|
& ("e" bit a bit) | |
7
|
| e ^ | |
8
|
<=, <, >, >= | |
9
|
=, %=, /=, //= e –= | |
10
|
+=, *= e **= | |
11
|
in, not in | |
12
|
not, or, and |
Na sequência de um programa, a declaração
de uma função deve sempre vir antes de seu uso. Uma função
f pode ser declarada com parâmetros, dentro dos parênteses
seguintes ao nome, como em def f(x,y). Naativação de uma
função f, popularmente denominada de chamada" da função
(function call), são "passados" argumentos que
serão usados no lugar dos parâmetros, pela ordem, p.ex. f(10,"abc");
na execução de f, x assume o valor 10 e y o valor 'abc'.
Os exemplos seguintes usaram o interpretador IDLE,
daí o promtp >>>.
Sintaxe |
Exemplos no IDLE |
# Declaração (atenção para o alinhamento
vertical) # Uso da função No IDLE, é necessário dar uma linha em branco para encerrar a declaração de uma função (sobre o IDLE, ver o item 16 abaixo). |
>>> def soma(a,b): # declaração |
Essa notação permite que se declare uma função sem dar-lhe um nome, colocando-a em qualquer lugar em que uma função possa ser ativada.
Sintaxe |
Exemplos no IDLE |
lambda lista-de-parâmetros: expressão com esses parâmetros |
>>> y = lambda x: x**2 >>> min = lambda x,y: x if x < y
else y >>> itens = [1, 2, 3, 4, 5]; >>> number_list = range(-5, 10) |
Um identificador declarado dentro de uma função
é somente local a ela (válido dentro dela); declarado fora da
função, antes ou depois dela, em um escopo (isto é, espaço
de validade) englobando diretamente a função, ele é global,
e pode ser usado tanto fora como dentro da função. O uso de um
identificador local evita muitos erros, pois só a função
onde ele está declarado pode modificar seu valor; esse identificador
fica "encapsulado" na função. Nesse sentido, o correto
é passar valores para a função e obtê-los por meio
de parâmetros na sua declaração (argumentos na sua ativação).
|
Para converter um identificador local em global: >>> def F(): |
Uma função F2 pode ser declarada dentro de uma outra função F1. Nesse caso, F2 torna-se local a F1 e não pode ser ativada fora de F1:
>>> def F1(): |
>>> def F1(): |
Se a função F2 estiver declarada dentro de F1, a declaração nonlocal faz com que uma variável V declarada em F2 passe a ter o escopo de F1, mas não é válida fora de F1. V tem que ter um valor atribuído a ela em F1 antes da declaração nonlocal:
>>> def F1(): |
>>> def F1(): >>> def F2(): >>> Local =1 >>> print(Local) ... ... >>> F2 NameError: name 'F2' is not defined |
Classes podem ser conceitualmente encaradas como uma extensão dos tipos e de funções, e são usadas para se obter mais encapsulamento. Ao contrário das funções, as classes não contêm parâmetros na declaração de seu nome; para serem usados com argumentos na ativação ("chamada") da classe, eles devem ser declarados no corpo da classe com um primeiro atributo; em geral é costume chamá-lo de self (ver exemplo abaixo), mas pode ter um nome qualquer. A função nativa __init_() declara as propriedades iniciais da classe e é ativada toda vez que é criado um objeto da classe (ver abaixo). Em seu corpo, as classes podem conter declarações de variáveis e de funções (estas, denominadas de métodos da classe), que se tornam locais a elas. Cada elemento declarado em uma classe é denominado "atributo" ou (para englobar funções) propriedade da classe, e é referenciado pelo nome da classe, um ponto e o nome da propriedade. Como as funções, as classes devem ser definidas antes de serem usadas. Podem-se atribuir valores aos elementos de uma classe fora dela. Uma classe pode ser atribuída a uma variável V; nesse caso V recebe uma instância da classe, um objeto com todas as propriedades da classe, podendo-se produzir quantas instâncias de uma classe que se quiser. É possível alterar o valor de um atributo de um objeto (ver exemplo abaixo). Uma classe C2 pode ser declarada como sendo subordinada a outra classe C1; C2 é denominada subclasse de C1, e C1 uma superclasse de C2. Nesse caso, C2 "herda" todas as propriedades de C1, mas pode ter suas próprias propreidades locais, que não são acessíveis por C1. Uma classe pode ser criada dinamicamente usando a função type(N,B,dic), onde N será o nome da classe, B uma n-pla que serve de base, da qual a classe sento criada herda os atributos (isto é, N será uma subclasse de B), e dic é um dicionaário contendo os nomes dos atributos e valores que N vai conter. Para eliminar um objeto já criado p, usar del p. Ver outras funções que se aplicam a classes no item 5 acima.
class C: """Esta é uma classe.""" #(Atributo implícito: __doc__, para documentação X = 13 def FdeC (Y): return Y + 1 print(C.X) #Acesso a um dos agtributos de C → 13 print(C.FdeC(2)) #Acesso à funcção de C → 3 print(C.__doc__) #Documentação no cabeçalho de C → Esta é uma classe ObjC = C() #Instanciação: criação de um objeto print(ObjC.X) 13 |
Criação dinâmica de uma nova classe Se C2 for declarada como uma subclasse de uma classe C1, usar C1 em lugar de object; nesse caso, C2 herda todos os atributos de C2 |
class pessoa: |
class Person: Age = 84 p1 = Person # Criação do objeto p1 print(p1.Age) p1.Age = 48 # Modificação do valor do atributo do objeto print(p1.Age)→ 84 48 |
Polimorfismo é a capacidade de um mesmo operador, função, ou objeto de uma classe operar com argumentos de tipos diferentes. Por exemplo, o operador + pode indicar soma de inteiros, concatenação de cadeias ou de n-plas. etc. A função len(x) aceita, como argumento x, cadeias (dando o número de toques), ou uma lista, n-pla ou conjunto (dando o número de elementos). Tudo isso é pré-definido. O polimorfismo de funções ou métodos de classes é algo definido pelo programador. Uma mesma função f pode ocorrer em classes diferentes. Nesse caso, f pode ser aplicada a várias instâncias (objetos) dessas classes, como exemplificado abaixo. Isso ajuda a implementar e usar uma "programoteca" pessoal já existem as de módulos disponíveis e a de muitos colaboradores, permitindo a re-utilização de partes de um programa.
class Azul: |
class Felino: def __init__(self, animal): self.F=animal def som(self): return self.F, "faz miau" class Canino: def __init__(self, animal): self.C = animal def som(self): #polimorfismo do método som return self.C, "faz au au" for i in (Felino('gato'), Canino('cão')): #i assume o objeto de uma classe print(i.som()) → ('gato', 'faz miau') ('cão', 'faz au au') |
A noção de herança também se aplica às
classes: é possível declarar uma classe C2 como sendo uma subclasse
de outra classe C1. A linguagem C++ introduziu em C a noção
de classes, e como em C não havia declaração de função
dentro de função, essa sintaxe passou para a C++ em relação
às classes. Python preservou essa estrutura. Para que C2 herde todas
as propriedades de C1 é necessário declará-las como no
esquema seguinte:
def F1(): # propriedades próprias de F1; as de F2 não estão disponíveis def F2(): # propriedades próprias de F2; as de F1 estão disponíveis |
class C1: # Superclasse
de C2 # propriedades próprias de C1; as de C2 não estão disponíveis class C2(C1): # Subclasse de C1 # propriedades próprias de C2; as de C1 estão disponíveis |
A noção de herança é muito útil, pois no
exemplo pode-se declarar a classe C2 sem que seus atributos próprios
sejam alterados fora dela. Isso facilita o encapsulamento, isto é,
isolamento em relação a influências externas. Ver
exemplos.
Finalmente, uma observação filosófica: na noção de herança tem-se mais uma denominação indevida na computação, que está cheia de antropomorfismos enganosos: minerais e vegetais não herdam; apenas animais e seres humanos herdam. As máquinas estão em um nível inferior aos minerais.
Syntax |
Examples (testados no Azure, V. Ambientes abaixo) |
|||
13.1 Bloco (de comandos): Comando; Comando; ... ; Comando #todos na mesma linha ou todos alinhados verticalmente à esquerda, ou em alguma coluna, se o bloco estiver imerso em algum comando: Comando |
J=2 |
|||
13.2 if comando de escolha lógica # atenção para o alinhamento vertical |
J = 2; K = 3; L= 4 # válido para todos os exemplos seguintes |
|||
if J < K: print(J); print(K)→
if K>J : """ O ":"
pode estar em qualquer coluna desta linha """ {PC} corrigiu o (5, 7) if K < J: N=5 |
f K < J: N=5
|
13.3 while comando de repetição da execução (malha de execução, loop) de um bloco de comandos while Expressão Lógica: Comando; """opcional: O comando else é executado quando a Expressão
Lógica der valor False. |
Atenção: ao usar o comando while
no IDLE, ele é executado até o fim (até Epressão
Lógica ficar com valor False) antes de se poder dar o
próximo comando. |
|||
M = 1 M = 1 |
M = 1 i = 0; L = [] |
# Exemplo de malha de I = 1 |
13.4 for comando de malha de repetição for Variável in Lista de Expressões: Os valores da Lista de Expressões são atribuídos à Variável; para cada atribuição o Bloco do for é executado uma vez. Quando a lista é esgotada, é executado o bloco do else, se este existir. O comando break interrompe a execução da malha
de repetição e vai para o próximo comando depois
do for. |
for I in range(3): #começa
em 0! for
I in range(2,4): # começa em 2 Frutas = ['caju','caqui','manga'] for I in range(5): |
for letra in 'xyz': Uso do else e dois fors encaixados |
Uso do for em varredura de iteráveis (V. 2.10) | ||||||
for i in [1, 2, 3]: print (i) → |
for car in "123": print (car) → |
for indice in {'um':1,
'dois':2}: print (indice) → dois um |
13.5 match...case comandode escolhas múltiplas | |
match Expressão:
|
Suponhamos que a variável Cor tenha um valor 'azul', ou verde', ou 'roxo', ou nenhum desses, e que se queira exibir o valor : match Cor: O comando match substitui com muitas vantagens um encadeamento de if's quando se testa somente o valor de certa expressão: if <Expressão> = ... : |
13.6 import inclusão de um módulo Este comando inclui um módulo em um programa, ou somente algumas de suas funcionalidades. P.ex., para usar uma função matemática como sqrt (raiz quadrada), é necessário importar o módulo math. Mas se o programa usa apenas a função sqrt, ela pode ser importada isoladament usndo o comando from. from módulo import função Para usar um outro nome de um módulo (alias): |
import math; math.sqrt (4) → from math import pi; pi → import math; math.e → |
|
13.5 try comando de detecção de exceção (erro) try: comando1 Os comandos 1 a 5 podem ser blocos de comandos. O comando try
verifica se algo em comando1 é indefinido ou produz um erro,
de modo que comando1 não pode ser executado. Se assim for, o
comando2 e o comando3 são executados (pode haver um só
ou mais comandos except). O comando4 do else (opcional)
é executado se não houve algum erro no comando1. O comando5
do finally (opcional) é executafdo independentemente de
ter havido um erro no comando1. Como o nome try diz, ele serve
também para se testar se haverá um erro em comando1, antes
que o erro ocorra e a execução pare. |
try: Suponha a existência de uma lista de nome L. O comando try pode ser usado para verificar se o elemento L[j] não está na lista L , caso em que o valor de j é maior do que o índice do último elemento de L, ou negativo, cf. o item 2.5 acima: try: |
|
13.8 pass ignora um comando Esse comando, inserido dentro de um outro composto, faz com que o sistema
ignore esse outro. Ele é muito prático durante a elaboração
de um programa. Ver o exemplo. |
def UmaFuncao(x): O corpo de UmaFuncao ainda não foi programado, mas já se sabe que ele deverá sê-lo e a função ficará nesse trecho do programa. Com isso garante-se que o programa todo será executado; sem o pass ele não o seria, haveria um erro de sintaxe. No 2º exemplo do try acima, se nada deve ser feito se o L[j] não estiver na lista, pode-se usar try: L[j] |
|
13.9 raise força uma exceção Esse comando força a ocorrência de um erro, e encerra a execução Veja descrição e exemplos do raise. Os exemplos à direita foram copiados dessa página. raise SystemExit("Mensagem")
|
a = 5 No exemplo abaixo, testa-se se uma conversão de tipo é válida; ValueError é uma classe que produz a impressão de seu nome e do argumento: s = 'jabuticaba'' No resultado, além das linhas do exemplo acima e mensagens,
aparece: raise ValueError("Cadeia não pode ser convertida para inteiro") |
|
13.10 yield x força x como resultado de uma função Este comando deve ser usado dentro de uma função, gerando
um resultado para a mesma. Ele não interrompe a execução
da função, ao contrário de return, que retorna
um só valor e encerra a execução da função.
O yield pode ser colocado em vários locais dentro de uma
função, e gerará o valor da função
toda vez que for executado. Já o return também
pode ocorrer em vários locais, mas se for executado encerra a
execução da função. O exemplo ao lado foi tirado daqui. |
def ParOuImpar(x): |
"Módulo" é uma denominação
dada em Python para um programa M que pode ser inserido em um programa P. Para
isso é necessário que P "importe" M, usando no primeiro
o comando import M. Na importação, é possível
mudar localmente o nome de um módulo M para MM com import M as
MM. Para se criar um módulo M, deve-se criar o programa de M e depois
armazená-lo com algum nome, por exemplo M, e a extensão necessária
.py, isto é, M.py . Dessa maneira, é possível criar e usar
bibliotecas de programas ("programotecas"), reutilizando programas
já testados. Um módulo M pode conter suas próprias variáveis
e funções, que são usados como se M fosse uma classe. Se
uma variável V e uma função f são declaradas dentro
de M, para usá-las no programa P emprega-se M.V e M.f(). Abaixo são citados alguns módulos
bem úteis. Para usá-los, é necessário ver a
documentação correspondente, que pode ser encontrada usando-se
Python e o nome do módulo.
14.2 Alguns módulos
As seguintes palavras não podem ser usadas como nomes de identificadores (variáveis e funções):
assert and as break class continue def del elif else except False finally for from global if import in lambda match None nonlocal not or pass is raise return True try while with yield |
17.4 Uso do depurador do IDLE (Debugger)
Para detectar erros em um programa armazenado localmente, pode-se usar o Debugger
do IDLE. Ver um excelente tutorial dele em
www.cs.uky.edu/~keen/help/debug-tutorial/debug.html
1. Carregue um programa no Editor (ver item 3 acima). 2. Insira
breakpoints, pontos de parada, em lugares onde se quer que a execução
pare, por exemplo para se verificar o valor de variáveis ou a sequência
de execução de comandos. Para isso, no Editor acione o botão
direito do mouse na linha onde quer inserir um ponto de parada, e acione
Set Breakpoint. Aparece uma tarja amarela na linha. Para se eliminar um ponto
de parada, idem Clear Breakpoint. 3. No Editor, acione Window →
Show Line Numbers; aparecem os números das linhas do programa, importante
para se acompanhar o Debugger. 4. No IDLE, acione Debug →
Debugger; aparece a mensagem DEBUG ON. Repetindo, desliga-se a execução
do Debugger e aparece DEBUG OFF no IDLE. 5. No Editor, acione Run →
Run Module; aparece uma janela Debug Control. Nela, abaixo dos buttons
aparece o nome do programa e na área de trabalho uma linha com tarja
azul com > e no fim dela o número da linha onde foi inserido o ponto
de parada onde a execução parou. 6. Acionando o button
Step o programa será executado linha a linha, sendo a atual trajada
de cinza, antes de ser executada. Se a linha contiver uma atribuição
de um valor a uma variável, depois da execução dessa
linha essa variável é exibida na janela do Debugger e o valor
que ela recebeu aparece na área Locals, juntamente com identificadores
e valores de todas as variáveis que já receberam valor (assim
pode-se conferir o que ocorrerá com a condição de comandos
como o if e o while). Esse comando Step é talvez o mais
útil, pois permite acompanhar toda a execução. 7.
Acionando-se o button Go o programa é executado sem parar até
o próximo ponto de parada. Assim, se houver dúvida sobre a execução
de um trecho do programa, pode-se delimitá-lo com dois pontos de parada,
desviar inicialmente para o primeiro com o Go, e daí em diante usar
o Step; ao se atingir o segundo ponto, pode-se dar novamente o Go para ir
para o ponto inicial da parada. 8. Se houver a execução
de uma função input(), o processo vai parar. É necessário
ir à janela do IDLE e dar o valor solicitado e Enter. O valor dado,
com a variável que recebeu a entrada, aparecem na seção
Locals. 9. Se ocorrer um erro durante a execução do programa,
a mensagem aparecerá na janela do Debugger. 10. O button Quit
deve encerrar a execução do debugger. 11. Ainda não
descobri para que serve o button Out, talvez para desviar para o janela
do Editor.