Desbravando Python - Funções Built-in: Parte 01

Posted by Gilson Filho on Qui 02 junho 2016

Olá pessoal,

Nesse post vamos focar nas funções built-in do Python. Serão divididos em cinco partes.

O qué esses built-ins?

Quando for programar módulos e scripts, eles vão estar sempre disponíveis, ou seja, não precisa fazer importação dos mesmos, porque estão embutidos. Então vamos para elas.

Essa função retorna um valor absoluto de um número. Ele aceita como argumento números inteiros ou de ponto flutuante. Mas se o valor do argumento for um número complexo, sua magnitude vai ser retornada.

In [5]:
# Números inteiros
abs(2)
Out[5]:
2
In [6]:
# Números do tipo ponto flutuante
abs(3.1416)
Out[6]:
3.1416
In [10]:
# Números complexos
abs(2j)
Out[10]:
2.0

all(iterable)

Link: https://docs.python.org/3/library/functions.html#all Ele retorna True se todos os elementos de um iterável forem verdadeiros, ou se ele estiver vazio. É equivalente a isso:

In [12]:
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

Segue um exemplo de como essa função funciona:

In [17]:
# Criando uma nova lista
lista = [1, 2, 3, 4, 5, 6]
all(lista)
Out[17]:
True
In [25]:
# Criando uma lista vazia
lista_vazia = []
all(lista_vazia)
Out[25]:
True

Como pode ver, valores que em operações lógicas, retornam True. No caso de uma lista vazia, sendo vazia, não tem valores que podem remeter a algum valor falso. Agora no próximo caso é diferente:

In [26]:
# Criando lista com valores que em operações lógicas retorna sempre falso
lista = [None, 0, '']
all(lista)
Out[26]:
False

E se tivéssemos valores que remetem a resultados verdadeiros e falsos?

In [35]:
# Criando lista com valores que em operações lógicas retornam falso ou verdadeiro
lista = [None, 0, 1, '', 2, "teste"]
all(lista)
Out[35]:
False

Como pode ver, para retornar verdadeiro todos os valores precisam remetar a True em operações lógicas.

any(iterable)

Link: https://docs.python.org/3/library/functions.html#any

Jà no caso dessa função, se existir algum valor que em operações lógicas retornam verdadeiro, o seu retorno será também verdadeiro. Ele funcionaria dessa forma:

In [37]:
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

Segue um exemplo:

In [39]:
# Criando uma lista
lista = [1, 2, 3]
any(lista)
Out[39]:
True
In [41]:
# Criando uma lista vazia
lista = []
any(lista)
Out[41]:
False

Como pode ver, como não existe qualquer valor que retorne True, ele irá retornar False. Agora se existir pelo menos um valor?

In [43]:
# Criando lista
lista = [0, None, False, '', 1]
any(lista)
Out[43]:
True

Temos o valor 1 que retorna True, então a função também vai retornar verdadeiro.

ascii(object)

Link: https://docs.python.org/3/library/functions.html#ascii

Como a função repr() que vamos explicar mais a frente, ele retorna um string que contêm uma representação impressa de um objeto. Mas pode ocorrer de retornar caracteres "não-ASCII" também.

In [46]:
ascii(str)
Out[46]:
"<class 'str'>"

bin(x)

Link: https://docs.python.org/3/library/functions.html#bin

Converte um número inteiro para um string binário. Se x não for um objeto do tipo inteiro, ele deve implementar o método __index__() para retornar um inteiro.

In [48]:
bin(2)
Out[48]:
'0b10'
In [56]:
class NonInteger(object):
    def __index__(self):
        return 2
    
bin(NonInteger())
Out[56]:
'0b10'

class bool(x)

Link: https://docs.python.org/3/library/functions.html#bool

Retorna um valor booleano, ou seja um True ou False. O valor de x será convertido para o procedimento de teste padrão de veracidade, ou melhor, efetuar uma verificação lógica da mesma. Se x é falso ou for omitido, ele retornará False, caso contrário retornará True.

In [64]:
# Valores que retornam True
var1 = 10
var2 = 'ABC'
var3 = 10.123

print("bool() de var1: ", bool(var1))
print("bool() de var2: ", bool(var2))
print("bool() de var3: ", bool(var3))
bool() de var1:  True
bool() de var2:  True
bool() de var3:  True
In [66]:
# Valores que retornam False
var1 = None
var2 = 0
var3 = ''
var4 = []

print("bool() de var1: ", bool(var1))
print("bool() de var2: ", bool(var2))
print("bool() de var3: ", bool(var3))
print("bool() de var4: ", bool(var4))
bool() de var1:  False
bool() de var2:  False
bool() de var3:  False
bool() de var4:  False

O bool() é uma subclasse de int. Nós vamos explicar melhor na seção de Tipos numéricos, então ignore isso por enquando, mas lembre-se que ela não pode ser estendida:

In [58]:
class NotWorkBoolSubClass(bool):
    pass
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-58-b7e68adf59a1> in <module>()
----> 1 class NotWorkBoolSubClass(bool):
      2     pass

TypeError: type 'bool' is not an acceptable base type

class bytearray([source[, encoding[, errors]]])

Link: https://docs.python.org/3/library/functions.html#bytearray

Ele retorna um novo array de bytes.

A classe bytearray é uma sequência mutável de inteiros em um intervalo de 0 <= x < 256.

In [68]:
# Criando nova lista
lista = [1, 2, 3]
bytearray(lista)
Out[68]:
bytearray(b'\x01\x02\x03')

Parâmetros variados e opcionais podem ser usados para inicializar o array de diferentes maneiras:

1 - Se for um string, você deve declarar sua codificação. bytearray() deve converter sua string para bytes usando str.encode()

In [71]:
bytearray("Conteudo a ser convertido")
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-71-697e34fada0a> in <module>()
----> 1 bytearray("Conteudo a ser convertido")

TypeError: string argument without an encoding
In [73]:
bytearray("Conteudo a ser convertido", "utf-8")
Out[73]:
bytearray(b'Conteudo a ser convertido')

2 - Se for um inteiro, o array deve conter o tamanho do número e ser inicializado com byte nulo.

In [81]:
var1 = bytearray(2)
var2 = bytearray(4)

print(var1)
print(var2)
bytearray(b'\x00\x00')
bytearray(b'\x00\x00\x00\x00')

3 - Se for um objeto em conformidade com interface buffer, um buffer somente leitura de um objeto deve ser usado para inicializar o array de bytes

In [87]:
bytearray(range(10))
Out[87]:
bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t')

4 - Se for um iterável, ele deve ser um iterável de inteiros no intervalo e 0 <= x < 256, que são usados como conteúdos iniciais de um array

In [89]:
values = bytearray([3000, 4000, 5000])
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-89-c18c149f2bad> in <module>()
----> 1 values = bytearray([3000, 4000, 5000])

ValueError: byte must be in range(0, 256)

5 - Sem algum argumento, o array de tamanho zero é criado.

In [92]:
result = bytearray()

print(result)
print(len(result))
bytearray(b'')
0

bytes([source[, encoding[, errors]]])

Link: https://docs.python.org/3/library/functions.html#bytes

Retorna um novo objeto de bytes, que é uma sequência imutável de inteiros em um intervalo de 0 <= x < 256.

In [95]:
bytes(10)
Out[95]:
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

O bytes é uma versão imutável do bytesarray, e tem os mesmos métodos não-mutávels e a mesma indexação e comportamento de slicing.

In [98]:
foo = bytearray(5)
foo.pop()
Out[98]:
0
In [100]:
foo = bytes(5)
foo.pop()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-100-64564ad0bf45> in <module>()
      1 foo = bytes(5)
----> 2 foo.pop()

AttributeError: 'bytes' object has no attribute 'pop'
In [103]:
foo = bytes(5)
foo[2:]
Out[103]:
b'\x00\x00\x00'

callable(object)

Link: https://docs.python.org/3/library/functions.html#callable

Ele retorna True se o argumento aparenta ser callable, e é false se não for. Mas é bom lembrar que, se ele retornar verdadeiro, é possível que a chamada desse objeto falhe, mas se ele for falso, chamando o objeto nunca poderá ser bem sucedido. Note que classes que são callable é quando elas possuem o método __call__().

In [105]:
callable(str)
Out[105]:
True
In [107]:
callable(2)
Out[107]:
False

chr(i)

Link: https://docs.python.org/3/library/functions.html#chr

Retorna uma representação em string de um caractere a partir do código Unicode, que é o inteiro i. Segue um exemplo:

In [110]:
print(chr(97))
print(chr(8364))
a
€

O inverso disso é feito pela função ord().

classmethod(function)

Link: https://docs.python.org/3/library/functions.html#classmethod

Ele cria um método de classe. Esse método de classe recebe implicitamente a classe como primeiro argumento, assim como um método de instância recebe a instância pela palavra-chave self. Para declarar um método de classe faça da seguinte forma:

In [3]:
class C:
    @classmethod
    def f(cls, arg1, arg2, **kwargs):
        pass

O classmethod é um decorador, então pode ser usado para outros métodos que deseja. Ele pode ser chamado através da classe direito, ou pela instância. Segue um exemplo:

In [11]:
# Criando a classe C
class C:
    @classmethod
    def f(cls, message):
        print("Funcao f() sendo executada: {0}".format(message))

# Executando o método de classe
C.f("Pela classe direta")
C().f("Pela instancia criada")
Funcao f() sendo executada: Pela classe direta
Funcao f() sendo executada: Pela instancia criada

Observação: Métodos de classe são diferentes dos métodos estáticos do C++ ou Java. Se deseja procurar esse tipo de método veja staticmethod() nesse post.

compile(source, filename, mode, flags=0, _dontinherit=False, optimize=-1)

Link: https://docs.python.org/3/library/functions.html#compile

Compila o código-fonte em uma fonte ou em um objeto AST. Objetos de código podem ser executados pelos exec() ou eval(). O parâmetro source pode ser um string normal, um string byte ou um objeto AST.

In [10]:
fonte = "print('Hello World')"

# Cria um objeto code object para ser executado pelo exec futuramente
source = compile(fonte, 'foo.py', 'exec')

O argumento filename deve ser o arquivo que deve conter o código a ser lido. Jà o argumento mode especifica que tipo de código deve ser compilado, ele pode ser exec se a fonte consiste em uma sequência de declarações, eval que consistem em uma expressão simples ou single se consistema em uma simples declaração interativa.

Segue um exemplo:

In [12]:
source = compile("var = 3\nprint('Valor e: {0}'.format(var))", 'modulefoo', 'exec')
exec(source)
Valor e: 3

Como vimos, criamos um objeto que contém o código python, e definimos um exemplo de módulo chamado de modulefoo. Esse nosso módulo representa um arquivo, mas ele fica na memória para ser executado pelo exec, como especificamos na função compile. Esse tipo de função é bem vindo em situações que precisa de um script customizado, como em metaprogramação.

complex([real[, imag]])

Link: https://docs.python.org/3/library/functions.html#complex

Retorna um número complexo com o valor real mais imag*1j ou converte uma string ou um número para número complexo. Se o primeiro parâmetro for um string, ele irá ser interpretado como um número complexo e a função deve ser chamada sem um segundo parâmetro. Já o segundo parâmetro, não pode ser uma string, então fique atento a isso.

Cada argumento pode ser qualquer tipo numérico (incluindo o próprio complexo). Se o parâmetro imag for omitido, o padrão é zero e o construtor serve uma conversão numérica do tipo int e float. Se ambos os argumentos são omitidos, ele retorna 0j.

In [20]:
# Inserindo um número inteiro, sem imag
complex(2)
Out[20]:
(2+0j)
In [21]:
# Inserindo uma string que tem formato de
# um número complexo
complex('1+2j')
Out[21]:
(1+2j)
In [22]:
# Criando número complexo passando o valor
# e o imag
complex(4, 2)
Out[22]:
(4+2j)
In [24]:
# Criando número complexo sem valor
complex()
Out[24]:
0j

delattr(object, name)

Link: https://docs.python.org/3/library/functions.html#delattr

Remove um atributo de um objeto. Faz o contrário do setattr(), que insere atributos em um objeto. O primeiro parâmetro é o objeto instanciado, e o segundo é uma string que representa o nome de um dos atributos que a possui.

The string must be the name of one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For example, delattr(x, 'foobar') is equivalent to del x.foobar.

In [30]:
class ObjectFoo(object):
    def __init__(self, *args, **kwargs):
        self.attr1 = 'attr_foo'
        self.attr2 = 'attr_bar'
    
    def test(self):
        print("Foo bar")
        
foo = ObjectFoo()
print("Atributo foo.attr1: ", foo.attr1)

delattr(foo, 'attr1')
print("Atributo foo.attr1: ", foo.attr1)
Atributo foo.attr1:  attr_foo
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-30-481db05efb93> in <module>()
     11 
     12 delattr(foo, 'attr1')
---> 13 print("Atributo foo.attr1: ", foo.attr1)

AttributeError: 'ObjectFoo' object has no attribute 'attr1'

A função delattr é equivalente a isso:

In [32]:
class ObjectFoo(object):
    def __init__(self, *args, **kwargs):
        self.attr1 = 'attr_foo'
        self.attr2 = 'attr_bar'
    
    def test(self):
        print("Foo bar")
        
foo = ObjectFoo()
print("Atributo foo.attr1: ", foo.attr1)

del foo.attr1
print("Atributo foo.attr1: ", foo.attr1)
Atributo foo.attr1:  attr_foo
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-32-ca6ae27f44ba> in <module>()
     11 
     12 del foo.attr1
---> 13 print("Atributo foo.attr1: ", foo.attr1)

AttributeError: 'ObjectFoo' object has no attribute 'attr1'

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Link: https://docs.python.org/3/library/functions.html#func-dict

Cria um novo dicionário. O objeto dict é uma classe de dicionário, mas vamos focar nele no post de Tipos de Mapeamento - dict.

In [36]:
# Criando dicionario

dict1 = dict(foo=1, bar=2)
dict1
Out[36]:
{'bar': 2, 'foo': 1}
In [37]:
# Criando dicionario a partir de outro e estendendo-o
dict1 = dict(foo=1, bar=2)
other_dict = dict(dict1, key_1="other")
other_dict
Out[37]:
{'bar': 2, 'foo': 1, 'key_1': 'other'}
In [45]:
# Criando um novo dicionário a partir de uma lista
lista = [("foo", 1), ("bar", 1), ("foobar", 1)]
new_dict = dict(lista, other_key="value")
new_dict
Out[45]:
{'bar': 1, 'foo': 1, 'foobar': 1, 'other_key': 'value'}

dir([object])

Link: https://docs.python.org/3/library/functions.html#dir

Sem argumento ele lista os nomes no escopo local.

In [47]:
dir()
Out[47]:
['In',
 'ObjectFoo',
 'Out',
 '_',
 '_13',
 '_14',
 '_15',
 '_16',
 '_17',
 '_18',
 '_19',
 '_20',
 '_21',
 '_22',
 '_23',
 '_24',
 '_3',
 '_34',
 '_36',
 '_37',
 '_4',
 '_44',
 '_45',
 '_46',
 '_5',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_i10',
 '_i11',
 '_i12',
 '_i13',
 '_i14',
 '_i15',
 '_i16',
 '_i17',
 '_i18',
 '_i19',
 '_i2',
 '_i20',
 '_i21',
 '_i22',
 '_i23',
 '_i24',
 '_i25',
 '_i26',
 '_i27',
 '_i28',
 '_i29',
 '_i3',
 '_i30',
 '_i31',
 '_i32',
 '_i33',
 '_i34',
 '_i35',
 '_i36',
 '_i37',
 '_i38',
 '_i39',
 '_i4',
 '_i40',
 '_i41',
 '_i42',
 '_i43',
 '_i44',
 '_i45',
 '_i46',
 '_i47',
 '_i5',
 '_i6',
 '_i7',
 '_i8',
 '_i9',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 '_sh',
 'dict1',
 'exit',
 'fonte',
 'foo',
 'get_ipython',
 'lista',
 'new_dict',
 'other_dict',
 'quit',
 'source',
 'var']

Como pode ver, alguns objetos e classes que criamos nesse post, ele ficou disponível no escopo local. Agora quando passa um objeto como argumento, ele lista os atributos disponíveis do mesmo.

In [49]:
instance = ObjectFoo()
dir(instance)
Out[49]:
['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'attr1',
 'attr2',
 'test']

Se o objeto tem um método chamado __dir__(), esse método deve ser chamado e deve retornar uma lista de atributos. Isto habilita os objetos de implementarem as funções customizadas de __getattr__() ou __getattribute__(), para ser a forma da função dir() reportar esses atributos.

Se o objeto não prover __dir__(), a função tenta fazer o melhor para coletar informações sobre o objeto passado pelo atributo __dict__, se definido, e do tipo do objeto. A lista resultando não é necessariamente completo, e pode ser impreciso quando ele tem o __getattr__() customizado.

O mecanismo padrão do dir() pode ser diferente com variados tipos de objetos, sendo que mais uma vez as tentativas de serem dados relevantes do que as mais completas. Assim:

  • Se o objeto é um objeto de um módulo, a lista vai conter os nomes dos atributos do módulo;
  • Se o objeto é um type ou objeto de classe, a lista vai conter os nomes dos seus atributos, e recursivamente os atributos das suas classes base;
  • Caso contrário, as listas vão conter os nomes dos atributos do objeto, da sua classe e de forma recurso, vindo das classes base.

No próximo post, vamos abordar a segunda parte das funções built-in. Até mais!



Comments !