Funções predefinidas II

Eis a lista de funções predefinidas do Python atualmente.

Segue-se a exposição de algumas dessas funções de âmbito mais geral. As primeiras funções já foram apresentadas no artigo anterior.

As funções chr() e ord() convertem uma letra ASCII no seu valor numérico e vice-versa.

>>> chr(65)
'A'
>>> ord('B')
66
>>> chr(225)
'\xe1'

As funções complex(), str(), int(), long() e float() convertem string para número ou vice-versa.
A função hex() converte um inteiro para o formato hexadecimal.
A função oct() converte um inteiro para o formato octal.

>>> complex("5+2j")
(5+2j)
>>> str(3+6)
'9'
>>> int("4")
4
>>> float("3.14")
3.14
>>> hex(1234)
'0x4d2'
>>> oct(123)
'0173'

divmod(a,b) calcula a divisão inteira e o resto da divisão inteira entre dois números (a//b,a%b).

>>> divmod(7,3)
(2, 1)

enumerate(sequence, start=0) devolve uma sequência enumerada

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

A função eval() é semelhante à função homónima do Javascript: avalia uma expressão contida numa string.

>>> x = 1
>>> print eval('x+1')

O comando exec() permite executar código contido numa string. A função execfile() executa código contido num ficheiro.

>>> exec("x=3")
>>> print x
3

As funções file() e open() permitem criar e/ou abrir um ficheiro, mas a última é preferível.
A função format(value[, format_spec]) converte um valor para um formato definido por format_spec (ver documentação).

>>> s = "python string!"
b = "i am a {0}".format(s)
>>> a =  "i am a %s" % s
print "--{:^30}--".format(s)
>>> b = "i am a {0}".format(s)
>>> print a
'{0}{1}{0}'.format('abra', 'cad')
i am a python string!

>>> print b
i am a python string!
>>> print "--{:^30}--".format(s)
'Coordinates: {latitude}, {longitude}'.format(**coord)

--        python string!        --
>>>
>>> '{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
>>>
>>> '{0}{1}{0}'.format('abra', 'cad')
'abracadabra'
>>>
>>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
'Coordinates: 37.24N, -115.81W'
>>>
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
'Coordinates: 37.24N, -115.81W'

globals() devolve um dicionário (objeto JSON) com a tabela de símbolos globais.
locals() devolve um dicionário (objeto JSON) com a tabela de símbolos locais.

>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> locals()
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}

len() devolve o número de elementos de um objeto.

>>> len("Olá")
3
>>> len([1,3,5])
3
>>> len(globals())
4

map(function, iterable, …) aplica uma função aos valores de um iterável.
max(iterable[, key]) ou max(arg1, arg2, *args[, key]) determinam o máximo de um conjunto de elementos.
min(iterable[, key]) ou min(arg1, arg2, *args[, key]) determinam o máximo de um conjunto de elementos.
sum(iterable[, start]) soma os elementos de um iterável.

>>> map(lambda x: 2*x, [1,2,4,6,2,3])
[2, 4, 8, 12, 4, 6]
>>> max([1,2,4,6,2,3])
6
>>> min([1,2,4,6,2,3])
1
>>> sum([1,2,4,6,2,3])
18

next(iterator[, default]) obtém o próximo elemento de um iterador.

pow(x, y[, z]) calcula a potÊncia de x elevado a y módulo z, de forma eficiente. z é opcional, e nesse caso pode calcular-se x ** y.

>>> pow(2,3,5)
3
>>> pow(2,3)
8
>>> 2**3
8

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout) imprime objetos num fluxo (stream).

range() cria um intervalo de inteiros.

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5,10)
[5, 6, 7, 8, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

O Python foi criado com o nome de um grupo de animadores britânicos, tal como se percebe pelo exemplo da função raw_input().

>>> s = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"

reduce(function, iterable[, initializer]) aplica uma função de dois arguemntos, iterativamente a um iterável. Por exemplo, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calcula ((((1+2)+3)+4)+5).

>>> def soma(x,y):
...   return x+2*y
...
>>> reduce(soma, [1, 2, 3, 4, 5])
29

round() arredonda um número.

>>> round(3.14)
3.0
>>> round(3.14,1)
3.1
>>> round(3.7)
4.0

frozenset, list, set, tuple e dict são funções que permitem criar iteráveis ou coleções.

sorted(iterable[, cmp[, key[, reverse]]]) ordena um iterável.

>>> sorted( [1,2,4,6,2,3], cmp=lambda x,y: cmp(x, y) )
[1, 2, 2, 3, 4, 6]
>>> sorted( [1,2,4,6,2,3], cmp=lambda x,y: cmp(y, x) )
[6, 4, 3, 2, 2, 1]

tuple([iterable]) cria um tuplo a partir de um iterável.

>>> tuple("xpto")
('x', 'p', 't', 'o')

A função type(object) obtém o tipo de um objeto.

>>> type("xpto")
<type 'str'>
>>> type([1,2,4,6,2,3])
<type 'list'>
>>> type(3+6j)
<type 'complex'>

A função type(name, bases, dict) pode ser usada com 3 prâmetros. Nesse caso cria uma classe. As duas instruções seguintes são equivalentes.

>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

unichr(i) devolve a string Unicode, cujo código é i.

zip([iterable, …]) cria uma lista de tuplos emparelhados pelo índice dos argumentos. A lista gerada tem o comprimento do iterável mais curto.

>>> zip([1,2,3],"abc")
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> zip([1,2,3,4,5,6],"xpto")
[(1, 'x'), (2, 'p'), (3, 't'), (4, 'o')]