Este artigo é a parte 2 de 3 na série Python

Python

Índice

Neste segundo artigo vou focar os tipos padrões do Python. Se Python fosse uma linguagem comum, isto não passaria de apresentar tipos básicos como inteiros, ponto flutuante, string, … No entanto, os tipos no Python são muitos poderosos e mesmo depois de algumas muitas dezenas de linhas, não foi possível aborda todo o conteúdo possível.

Todos os exemplos apresentados neste texto foram realizados através do interpretador do Python. Para testá-los, inicie o interpretador com o comando python ou pelo idle, como apresentado no artigo anterior, Python: 1 – Uma introdução ao Python.

Sumário

2.1. Introdução a tipagem no Python

Para iniciar uma variável no Python, basta iniciá-la com algum valor que o interpretador irá associar a ela o tipo que se ajustar ao valor passado.

>>> a = 5
>>> b = 'loop'
>>>
>>> type(a)
<type 'int'>
>>> type(b)
<type 'str'>

2.2. Tipos numéricos

O Python reconhece nativamente três tipos numéricos: inteiro, real e complexo.

O tipo inteiro é dividido em int e long nas versões 2.6 e anteriores. Na versão 3 o tipo long deixa de existir e o int não terá mais limite.

>>> a = 5
>>> b = long(a)
>>> b
5L

As operações com inteiros retornam inteiros:

>>> a-=5
>>> a+=10
>>> b = a/4
>>> a, b
(15, 3)

O Python suporta a atribuição múltipla, sempre avaliando as expressões e depois associando os valores as respectivas variáveis, como mostra as linhas abaixo:

>>> a,b,c = 1,3,5
>>> a,b,c = a*2, a+b+c, a*b*c
>>> a,b,c
(2, 9, 15)

Observe que nas operações acima, as associações dos valores somente foram processadas após a avaliação das expressões. Desta forma:

  • a*2 retorna 1*2=2;
  • a+b+c retorna 1+3+5=9;
  • e a*b*c retorna 1*3*5=15.

Isto é muito útil na troca de valores entre duas variáveis, dispensando uma terceira para armazenagem temporária, como é de praxe em muitas linguagens,

>>> a,b = 2,5
>>> print 'a =',a,'  b =',b
a = 2   b = 5
>>> 
>>> a,b = b,a   # efetuando a troca entre os valores de 'a' e 'b'
>>> print 'a =',a,'  b =',b
a = 5   b = 2

É também possível associar um único valor a várias variáveis, simultaneamente,

>>> a = b = c = d = 9
>>> a,b,c,d
(9, 9, 9, 9)

A precedência no tipo numérico resultante obedece a ordem:

int -> long -> float -> complex

independente da operação matemática.

>>> 3 + 2             # int + int = int
5  
>>> 3 + 2L            # int + long = long
5L
>>> 3 + 2L + 3.       # ... + float = float
8.0
>>> 3 + 2L + 3. + 0j  # ... + complex = complex
(8+0j)

A conversão de tipo pode ser feita com as funções: int; long; float; e complex.

>>> pi = 3.1415926535897931
>>> r = 5
>>> a = pi*r**2
>>> a = int(pi*r**2)
>>> a
78

>>> c = complex(3,-4)
>>> c
(3-4j)
>>> float(c)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can't convert complex to float; use abs(z)

Como pode ver, não é possível converter um complexo para float, ou mesmo int e long. Para se converter um complexo se deve trabalhar em uma de suas componentes, parte real ou imaginária, ou com o seu método, como abaixo:

>>> d = float(c.real)
>>> d
3.0
>>> c.real
3.0
>>> abs(c)   # retorna o módulo do complexo: sqrt(real**2 + imag**2)
5.0

2.3. Tipo lista

Lista é um conjunto linear de elementos mutáveis, como um vetor no C, indexado por um inteiro. Uma lista é definida, declarando os elementos entre colchetes como abaixo:

>>> pares = [2,4,6,8,10]
>>> pares[3]
8
>>> direcoes = ['norte', 'sul', 'leste', 'oeste']
>>> direcoes[0]
'norte'

Uma lista pode conter todo tipo de dados, inclusive outras listas como elemento.

>>> lista_mista = [0, direcoes[2], 12.5, 2+4j, pares]
>>> lista_mista
[0, 'leste', 12.5, (2+4j), [2, 4, 6, 8, 10]]
>>> lista_mista[1]
'leste'

A indexação de uma lista é bem flexível no Python, permitindo indexar os elementos do final da lista para o início, com índices negativos, usando -1, para o último elementos, -2 para o penúltimo e assim sucessivamente. É claro que também aceita a indexação tradicional, com índices positivos. A figura a seguir apresenta os índices positivos e negativos para a lista pares, definida acima:

lista

Segue abaixo alguns exemplos com indexação positiva e negativa,

>>> lista_mista[2]
12.5
>>> lista_mista[-2:]
[(2+4j), [2, 4, 6, 8, 10]]
>>> lista_mista[-3]
12.5

Ainda é possível indexar intervalos de elementos em uma lista, colocando o índice inicial, separado por dois pontos, e o índice final, como segue o exemplo abaixo,

>>> numeros = [0,1,2,3,4,5,6,7,8,9,10]
>>> numeros[2:5]
[2, 3, 4]
>>> numeros[5:]
[5, 6, 7, 8, 9, 10]
>>> numeros[-5:]
[6, 7, 8, 9, 10]
>>> numeros[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2.3.1. Copiando uma lista

Copiar uma lista pode revelar algumas surpresas. Algo como:

>>> a = [1,2,3,4]
>>> b = a
>>> a,b
([1, 2, 3, 4], [1, 2, 3, 4])
>>> a[2] = 6
>>> a, b
([1, 2, 6, 4], [1, 2, 6, 4])

pode não gerar o resultado desejado. A explicação é simples, quanto se faz a igualdade (b = a), o que o Python faz é apontar o conteúdo de a para a variável b. Com isto, ao se alterar o valor do elemento de índice 2, de a, b também estará sendo alterada, já que este é um link para o conteúdo de a.

Para fazer uma cópia da lista a em b, deve-se indexar os elementos que se deseja copiar. A linha abaixo garante uma cópia de a em b:

>>> a = [1,2,3,4]
>>> b = a[:]
>>> print a, b
[1, 2, 3, 4] [1, 2, 3, 4]
>>> a[2] = 8
>>> print a, b
[1, 2, 8, 4] [1, 2, 3, 4]

2.3.2. Alguns métodos de lista

Como afirmei anteriormente, variáveis em Python são objetos, e por isto possuem diversos métodos interessantes, que podem simplificar muito a elaboração de um programa. Para conhecer todos os métodos de um objeto, utilize a função dir():

>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', 
'__delslice__', '__doc__', '__eq__', '__format__', '__ge__', 
'__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', 
'__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', 
'__lt__', '__mul__', '__ne__', '__new__', '__reduce__', 
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__', 
'__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', 
'__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 
'pop', 'remove', 'reverse', 'sort']

Boa parte dos métodos se repetem nos diferentes objetos do Python, mas alguns são únicos em alguns tipos. A primeira tabela apresenta os métodos responsáveis pelos operadores de comparação entre listas, Tab 01.

[TABLE=12]

Seu retorno é um booleano, True ou False, dependendo do resultado da comparação.

As linhas abaixo apresenta o uso das operadores apresentados acima:

>>> print a, b
[1, 2, 8, 4] [1, 2, 3, 4]
>>> a == b
False
>>> a > b
True
>>> a < b
False
>>> a >= b
True
>>> a
[1, 2, 8, 4]
>>> b[3] = 10
>>> a
[1, 2, 8, 4]
>>> b
[1, 2, 3, 10]
>>> a > b
True

A comparação é feita elementos a elemento, até que o primeiro sucesso. A tabela a segui mostras os operadores soma e multiplicação, presentes em uma lista.

[TABLE=13]

O rmult é empregado quando o operador da esquerda não suporta uma multiplicação com o tipo empregado. Seria uma sobrecarga do operador de multiplicação com tipos diferentes.

>>> 2*a
[1, 2, 8, 4, 1, 2, 8, 4]
>>> a*2
[1, 2, 8, 4, 1, 2, 8, 4]
>>> a + b
[1, 2, 8, 4, 1, 2, 3, 10]
>>> a += b         # o mesmo que a = a + b
>>> a
[1, 2, 8, 4, 1, 2, 3, 10]

Alguns outros tipos, como inteiro e float, suportam ainda __radd__, __div__, __idiv__, …

[TABLE=14]

Abaixo segue alguns exemplos dos métodos apresentados acima:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a.__getitem__(1)
2
>>> a.__setitem__(2, 'y')
>>> a
[1, 2, 'y', 4, 5, 6, 7, 8, 9, 0]
>>> a.__getslice__(3,5)
[4, 5]
>>> a.__setslice__(3,5,[2,3])
>>> a
[1, 2, 'y', 2, 3, 6, 7, 8, 9, 0]
>>> a.__delitem__(3)
>>> a
[1, 2, 'y', 3, 6, 7, 8, 9, 0]
>>> a.__len__()
9
>>> a.__contains__('y')
True

Geralmente não se usa a forma explicita destes métodos, como acima, mas sim a forma mais implícita e intuitiva. As linhas abaixo repetem o exercício anterior, de forma mais intuitiva:

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> a[1]
2
>>> a[2] = 'y'
>>> a
[1, 2, 'y', 2, 3, 6, 7, 8, 9, 0]
>>> a[3:5]
[4, 5]
>>> a[3:5] = [2, 3]
>>> a
[1, 2, 'y', 2, 3, 6, 7, 8, 9, 0]
>>> del a[3]
>>> a
[1, 2, 'y', 3, 6, 7, 8, 9, 0]
>>> len(a)
9
>>> 'y' in a
True

A próxima tabela apresenta alguns métodos muitos úteis para se trabalhar com listas:

[TABLE=15]

Segue abaixo algumas aplicações dos métodos acima:

>>> lista = ['leste', 12, 2, 4, 6, 8, 10, 2, 4, 4]
>>> lista.append('leste')
>>> lista                
['leste', 12, 2, 4, 6, 8, 10, 2, 4, 4, 'leste']
>>> lista.count('leste')                       
2                                              
>>> lista.count(4)
3
>>> lista.index(10)
6
>>> lista.insert(6, 'oeste')
>>> lista
['leste', 12, 2, 4, 6, 8, 'oeste', 10, 2, 4, 4, 'leste']
>>> lista.pop()
'leste'
>>> lista
['leste', 12, 2, 4, 6, 8, 'oeste', 10, 2, 4, 4]
>>> lista.remove('leste')
>>> lista.remove('oeste')
>>> lista
[12, 2, 4, 6, 8, 10, 2, 4, 4]
>>> lista.reverse()
>>> lista
[4, 4, 2, 10, 8, 6, 4, 2, 12]
>>> lista.sort()
>>> lista
[2, 2, 4, 4, 4, 6, 8, 10, 12]

2.4. Tupla

Uma tupla também é um conjunto linear de elementos, indexados por um inteiro, assim como uma lista, diferido apenas por seus elementos serem imutáveis. A declaração de uma tupla é feita, colocando os elementos entre colchetes.

>>> a = (1, 2, 3, 4, 5)
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', 
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', 
'__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', 
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', 
'__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', 
'__str__', '__subclasshook__', 'count', 'index']

Observe que uma tupla possui os mesmos métodos de uma lista, excetuando aqueles relativos a alteração do valor dos elementos da tupla, uma vez que seus elementos são imutáveis.

A tentativa de alterar o conteúdo de um elemento de uma tupla gera um erro TypeError, com mostrado abaixo:

>>> a[1]
2
>>> a[1] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

2.5. String

Uma string em Python também é um conjunto linear de elementos imutáveis, mas de tamanho variável. Uma string em Python pode ser definida entre aspas simples ou duplas:

>>> msg1 = "Isto é uma 'mensagem' ..."
>>> msg2 = 'Mas "frequentemente" (agora sem trema) me perguntam ...'
>>> print msg1
Isto é uma 'mensagem' ...
>>> print msg2
Mas "frequentemente" (agora sem trema) me perguntam ...

Assim como as listas/tuplas, os elementos de uma string podem ser acessadas por índices ou slices:

>>> msg1[0]
'I'
>>> print msg2[5:19]
frequentemente
>>> print msg1 + msg2
Isto é uma 'mensagem' ...Mas "frequentemente" (agora 
sem trema) me perguntam ...
>>> print msg1[-18:]
uma 'mensagem' ...

Uma string pode conter várias linhas, usando o caractere de quebra de linha “\”, e ainda pode possuir caracteres de controle como mudança de linha, “\n”, tabulações, “\t”, entre outros.

>>> msg="Falar é completamente fácil, \
... quando se têm palavras em mente \
... que expressem sua opinião.\n\n\
... Difícil é expressar por gestos e atitudes \
... o que realmente queremos dizer, \
... o quanto queremos dizer, \
... antes que a pessoa se vá."
>>>
>>> print msg
Falar é completamente fácil, quando se têm palavras em mente que 
expressem sua opinião.

Difícil é expressar por gestos e atitudes o que realmente queremos 
dizer, o quanto queremos dizer, antes que a pessoa se vá.

Os métodos do tipo string são muito promissores, permitindo de fazer várias edições em uma string, como remover conteúdos, substituir, capitular, levantar e abaixar caixa, entre outras. A tabela abaixo apresenta alguns destes métodos do tipo string. Para uma lista completa utilize o comando dir() sobre uma variável tipo string.

2.5.1. Métodos de edição em string

A tabela a seguir apresenta os métodos utilizados para editar uma string.

[TABLE=17]

Se observar, a grande maioria das operações efetuadas em uma string, podem ser feitas com estes métodos. Para operações mais específicas, com o uso de Expressões Regulares, existem módulos especiais, que serão apresentados bem mais adiante.

As linhas abaixo apresentam alguns exemplos de uso dos médotos acima:

>>> a = 'carlos drummond de andrade'
>>> a.capitalize()
'Carlos drummond de andrade'
>>> a.ljust(60)
'carlos drummond de andrade                                  '
>>> a.rjust(60)
'                                  carlos drummond de andrade'
>>> a.center(60)
'                 carlos drummond de andrade                 '
>>> b = ['poeta', 'brasileiro', '(1902 - 1987)']
>>> d = ' '.join(b)
>>> d
'poeta brasileiro (1902 - 1987)'
>>> d.replace('19', '')
'poeta brasileiro (02 - 87)'
>>> c = a.center(60)
>>> c.lstrip()
'carlos drummond de andrade                 '
>>> c.rstrip()
'                 carlos drummond de andrade'
>>> c.strip()
'carlos drummond de andrade'
>>> f = a.title()
>>> f
'Carlos Drummond De Andrade'
>>> f.swapcase()
'cARLOS dRUMMOND dE aNDRADE'
>>> a.upper()
'CARLOS DRUMMOND DE ANDRADE'

O método translate dá um pouco mais de trabalho de aplicar, pois é necessário construir uma string com todos os caracteres da tabela ascii. Isto é facilmente construído com o método maketrans do módulo string. As linhas abaixo apresentam o uso do método translate, substituindo as vogais pelo números de 1 a 5. 

>>> from string import maketrans
>>> vogais = "aeiou"
>>> numeros = "12345"
>>> trantab = maketrans(vogais, numeros)
>>> print trantab[97:123]
1bcd2fgh3jklmn4pqrst5vwxyz
>>> a
'carlos drummond de andrade'
>>> a.translate(trantab)
'c1rl4s dr5mm4nd d2 1ndr1d2'

Este exemplo foi retirado do link http://www.tutorialspoint.com/python/string_translate.htm. Tem muitos outros exemplos bastante interessantes no site.

2.5.2. Métodos com saída booleana em string

Alguns métodos geram um booleano (True/False), que permitem testar o conteúdo e formatação da string. A tabela abaixo apresenta estes métodos.

[TABLE=18]

A seguir algumas linhas de código para demonstrá-las.

>>> a = 'aq123'
>>> b = '123'
>>> c = 'qwer'
>>> d = 'aq23&%'
>>> a.isalnum() | b.isalnum() | c.isalnum()
True
>>> d.isalnum()
False
>>> a.isdigit()
False
>>> b.isdigit()
True
>>> a.isupper()
False
>>> a.islower()
True

2.5.3. Métodos de pesquisa e divisão em string

Os métodos apresentados a seguir, são úteis na pesquisa por conteúdos específicos na string, e a divisão da string em uma lista.

[TABLE=16]

As linhas abaixo, poem em ação alguns destes métodos,

>>> a = 'carlos drummond de andrade'                      
>>> a = 'carlos\ndrummond\n de andrade'                      
>>> a.count('a')
3               
>>> a.find('an')
20              
>>> a.index('an')
20
>>> a.partition('drummond')
('carlos\n', 'drummond', '\n de andrade')
>>> a.find('a')
1
>>> a.rfind('a')
24
>>> a.split(' ')
['carlos\ndrummond\n', 'de', 'andrade']
>>> a.splitlines()
['carlos', 'drummond', ' de andrade']

2.5.4. Outros métodos inclusos em string

Além dos métodos apresentados, existe ainda métodos para adicionar operações de adição, multiplicação, operadores de comparação, entre outros. As linhas abaixo apresentam alguns destes comandos.

>>> a = 'carlos '
>>> b = 'drummond '
>>> c = 'de andrade'
>>> a+b+c
'carlos drummond de andrade'
>>> d = a+b+c
>>> 'andrade' in d
True
>>> 2*a
'carlos carlos '
>>> a > b
False
>>> a.__len__()
7
>>> len(a+b+c)
26

2.6. Dicionários

Dicionários são arrays associativas, que pode usar como índices qualquer valor imutável. Dicionários são declarados entre chaves, como nos exemplos abaixo,

>>> cadastro = {'nome': 'Alberto', 'idade': 36, 'Sexo': 'M', 'Altura': 1.76}
>>> cadastro['idade']
36

Os índices de um dicionário são não ordenados, sendo arranjados de forma aleatória, independente da ordem de declaração.

>>> cadastro.keys()
['idade', 'Sexo', 'Altura', 'nome']

2.6.1. Métodos de um dicionário

dicionário possui um conjunto de métodos especiais para tratar de suas particularidades. A tabela abaixo apresenta estes métodos.

[TABLE=19]

Abaixo segue alguns exemplos da aplicação do tipo dicionário,

>>> c = {'idade': 36, 'nome': 'Alberto', 'Altura': 1.76, 'sexo': 'M'}
>>> c
{'idade': 36, 'sexo': 'M', 'Altura': 1.76, 'nome': 'Alberto'}
>>> d = c.copy()
>>> d
{'idade': 36, 'nome': 'Alberto', 'Altura': 1.76, 'sexo': 'M'}
>>> c.clear()
>>> c
{}
>>> d.get('nome')
'Alberto'
>>> d['nome']
'Alberto'
>>> d.has_key('sexo')
True
>>> d.items()
[('idade', 36), ('nome', 'Alberto'), ('sexo', 'M'), ('Altura', 1.76)]
>>> d.keys()
['idade', 'nome', 'sexo', 'Altura']
>>> d.values()
[36, 'Alberto', 'M', 1.76]

2.7. Mais algumas palavras sobre variáveis no Python

2.7.1. Booleanos e condicionais

O Python incorporou o tipo booleano a partir da versão 2.2, para representar resultados de condicionais. Os booleanos possuem dois valores únicos: True e False.

As condicionais usadas no Python são apresentadas na tabela abaixo:

[TABLE=20]

Nas linhas abaixo, são mostradas algumas exemplos de comparações. 

>>> x = y = z = 1
>>> x == y
True
>>> # verifica a igualdade entre as variáveis da direita parta a esquerda
>>> x == y == z
True
>>> z += 1
>>> x == y == z
False

Na comparação entre listas e tuplas, os elementos são comparados um a um, até que ocorra a primeira discordância.

>>> a = ['a', 1, 9, 3]
>>> 3 in a
True
>>> 'b' in a
False
>>> 'b' not in a
True
>>> b
['a', 1, 9, 3]
>>> b[2] = 10
>>> b[-1] = 0
>>> b
['a', 1, 10, 0]
>>> a > b     # comparação feita elemento a elemento
False
>>> a < b
True

O Python considera falso a booleana False, o número 0 (zero) e qualquer estrutura de dado vazia, como string, lista, tupla ou dicionário.

>>> foo = []
>>> if foo:
...   print 'Está cheia...'
... else:
...   print 'Está vazia...'
...
Está vazia...

2.7.2. Alocando variáveis imutáveis

A abordagem do Python com as variáveis, o leva a trata-las como imutáveis. A figura abaixo ilustra o processo.

python-variaveis

Na figura, o objeto inteiro 6 é criado e depois associado ao nome a. Ao executar a segunda linha (b = a), o interpretador, cria um link do nome b, para a objeto inteiro 6. Ao alterar o conteúdo de a, o interpretador cria um novo objeto float, com valor 12.3, e em seguida, aponta a nome de a para este novo objeto.

É claro que tudo isto é invisível para o usuário final, mas ilustra bem como o Python trata variáveis na memória. Objetos órfãos são colocados em uma fila e destruídos em seu devido tempo, liberando a memória.

A condicional is é uma boa ferramenta para mostra claramente toda esta discussão:

>>> a = 6
>>> b = a
>>> a is b
True
>>> # a e b são o mesmo objeto (inteiro 6)
>>> a = 12.3
>>> a is b
False
>>> # a e b são objetos distintos

Observe que após a atribuição “b = a”, as duas variáveis passam a apontar para o mesmo objeto. Somente após a segunda atribuição a variável “a”, é que as variáveis passam a apontar para objetos diferentes. Veja o que ocorre com uma operação semelhante, em uma lista.

>>> a = [1,2,3]
>>> b = a
>>> a is b
True
>>> # a e b são o mesmo objeto lista
>>> b[2]=5
>>> a is b
True
>>> # a e b ainda são o mesmo objeto lista
>>> a,b
([1, 2, 5], [1, 2, 5])

Agora, o mesmo processo, fazendo uma cópia da lista:

>>> a = [1,2,3]
>>> b = a[:]
>>> # b é um novo objeto lista, com uma cópia de a
>>> a is b
False
>>> b[2]=5
>>> a,b
([1, 2, 3], [1, 2, 5])

2.7.3. Removendo objetos da memória

Em geral o Python remove objetos não usáveis da memória automaticamente,

>>> a = [1,2,3]
>>> b = a
>>> a,b
([1, 2, 3], [1, 2, 3])
>>> a = None
>>> b
[1, 2, 3]
>>> a
>>> b = None
>>> a,b
(None, None)

Nas linhas acima, as variáveis a e b foram criadas apontando para o mesmo objeto lista. Quando None é passado para a, o conteúdo da lista ainda pode ser alcançado através de b. Mas ao associar None para b, o conteúdo da lista fica inacessível. Neste momento o Python coleta o objeto lista e o coloca em uma pilha de remoção.

Uma outra forma de remover um objeto é com o uso do comando del. 

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
>>> a = b = 2
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'b']
>>> a,b
(2, 2)
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> b
2
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'b']

como pode ver o comando del vai um pouco além do que associar None a uma variável, ele remove a variável do escopo atual, como pode ser verificado na saída do comando dir.

O comando del ainda pode ser usado para remover uma variável (objeto integer, float, string, list,…) ou elementos de uma lista ou dicionário.

>>> z = {'nome': 'alberto', 'idade': 38, 'status': True}
>>> z
{'idade': 38, 'status': True, 'nome': 'alberto'}
>>> del(z['status'])
>>> z
{'idade': 38, 'nome': 'alberto'}

2.7.4. Octal e hexadecimal

Python possui uma sintaxe especial para números em octal e hexadecimal. Números em octal são escritos iniciando com um ‘0’,

>>> 012
10
>>> 013
11

já os números em hexadecimal, são escrito iniciando por um ‘0x’,

>>> 0x12
18
>>> 0xff
255

Na versão 3 do Python, a declaração de um valor em octal, foi alterada e uma declaração para binários foi adicionada. Nesta versão, números em octal não são mais prefixados com apenas um ‘0’, e sim por ‘0o’, onde o ‘o’ pode ser maiúsculo ou minúsculo. Números na base binário são prefixados com ‘0b’, como em ‘0b10011’.

Conclusão

Para completar a base de dados, ainda ficou faltando os tipos classe e arquivo. Este dois tipos ficam mais ricamente apresentados após passar as estruturas de controle de fluxo do programa, no próximo artigo.