slack user… Seja a mudança que você quer ver no mundo – Dalai Lama

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
• 2.2. Tipos numéricos
• 2.3. Tipo lista
  • 2.3.1. Copiando uma lista
  • 2.3.2. Alguns métodos de lista
• 2.4. Tupla
• 2.5. String
  • 2.5.1. Métodos de edição em string
  • 2.5.2. Métodos com saída booleana em string
  • 2.5.3. Métodos de pesquisa e divisão em string
  • 2.5.4. Outros métodos inclusos em string
• 2.6. Dicionários
  • 2.6.1. Métodos de um dicionário
• 2.7. Mais algumas palavras sobre variáveis no Python
  • 2.7.1. Booleanos e condicionais
  • 2.7.2. Alocando variáveis imutáveis
  • 2.7.3. Removendo objetos da memória
  • 2.7.4. Octal e hexadecimal
• Conclusão

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 "<stdin>", line 1, in <module>
TypeError: can't convert complex to float; use abs(z)
</module></stdin>

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:

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.

Tab 01: Métodos para comparação entre listas

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.

Tab 02: Métodos para implementar operadores matemáticos, como soma, subtração, produto, ...

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__, …

Tab 03: Métodos diversos de uma lista

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:

Tab 04: Alguns método indispensáveis em uma lista

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.

Tab 05: Métodos de edição no tipo string.

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.

Tab 06: Métodos de saída booleana no tipo string.

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.

Tab 07: Métodos de pesquisa e divisão em lista da string

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.

Tab 08: Métodos explícitos de dicionários

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:

Tab 01: Condicionais utilizadas no Python

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.

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.

<< Python 1 – Uma introdução ao Python Python 3 – Estruturas de controle >>

You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.