Funções embutidas

Definição

Funções embutidas (built-in) são funções que já estão disponíveis no Python para utilização (não há a necessidade de importá-las de algum módulo). A próxima seção discute as funções embutidas do Python 3.10: abs(), aiter(), all(), any(), anext(), ascii(), bin(), bool(), breakpoint(), bytearray(), bytes(), callable(), chr(), classmethod(), compile(), complex(), delattr(), dict(), dir(), divmod(), enumerate(), eval(), exec(), filter(), float(), format(), frozenset(), getattr(), globals(), hasattr(), hash(), help(), hex(), id(), input(), int(), isinstance(), issubclass(), iter(), len(), list(), locals(), map(), max(), memoryview(), min(), next(), object(), oct(), open(), ord(), pow(), print(), property(), range(), repr(), reversed(), round(), set(), setattr(), slice(), sorted(), staticmethod(), str(), sum(), super(), tuple(), type(), vars(), zip(), __import__()

Exemplos

• abs(x) – Retorna o valor absoluto (não negativo) de um número.

a = -4
b = -3.65
c = -3.10
d = -3.4 + 2.3j
print("abs(a) =", abs(a), "abs(b) =", abs(b), "abs(c) =", abs(c), "abs(d) =", abs(d))

A resposta do programa é

abs(a) = 4 abs(b) = 3.65 abs(c) = 3.1 abs(d) = 4.104875150354758

• aiter() – Retorna um iterador assíncrono para um iterável assíncrono. No exemplo abaixo, temos a classe Numeros com dois métodos: __aiter__ e __anext__. O método __aiter__ é usado para inicializar o objeto e o método __anext__ é executado a cada iteração. Logo, a função aiter() retorna a instância de um objeto (iterador assíncrono) da classe Numeros (iterável assíncrono) com i igual a zero; e a função anext() incrementa i, toda vez que é chamada, após dormir por 1 segundo.

from asyncio import sleep, run

class Numeros:
    def __aiter__(self):
        self.i = 0
        return self
    async def __anext__(self):
        await sleep(1)
        self.i += 1
        return self.i

async def gerarNumeros():
    ObjFuncao = aiter(Numeros())
    try:
        while True:
            num  = await anext(ObjFuncao)
            print(num)
            if num >= 5:
                break
    except StopAsyncIteration:
        return

run(gerarNumeros())

• all(item) – Retorna True se todos os elementos de item são verdadeiros ou se item for vazio.

lista1 = [1, 6, "abc", True]
print("lista1 =", all(lista1))
lista2 = []
print("lista2 =", all(lista2))
lista3 = [1, False, "abc", True]
print("lista3 =", all(lista3))

A saída mostrada pelo programa:

lista1 = True
lista2 = True
lista3 = False

• any(item) – Retorna True se algum elemento de item for verdadeiro. Se item for vazio, retorna False.

lista1 = [1, 6, "abc", True]
print("lista1 =", any(lista1))
lista2 = []
print("lista2 =", any(lista2))
lista3 = [1, False, "abc", True]
print("lista3 =", any(lista3))

Ao final da execução, o programa mostra:

lista1 = True
lista2 = False
lista3 = True

• anext() – Retorna o próximo item de um iterador assíncrono. Veja aiter() para um exemplo.

• ascii(objeto) – Substitui qualquer caractere não ascii do objeto por sequências de escapes \x, \u or \U.

frase1 = "Que ninguém se engane, só se consegue a simplicidade através de muito trabalho"
frase2 = "äçïÜ"
frase3 = '''Frase com
quebra de linha'''
lista = ["maça", "limão", "constituição"]

print("\x50\x79\x74\x68\x6f\x6e\x20\xe9\x20\x31\x30\x21")
print(ascii(frase1))
print(ascii(frase2))
print(ascii(frase3))
print(ascii(lista))

A resposta do programa é

Python é 10!
'Que ningu\xe9m se engane, s\xf3 se consegue a simplicidade atrav\xe9s de muito trabalho'
'\xe4\xe7\xef\xdc'
'Frase com\nquebra de linha'
['ma\xe7a', 'lim\xe3o', 'constitui\xe7\xe3o']

• bin(x) – Retorna o valor binário de um número inteiro. Como esta função retorna o valor com o prefixo ‘0b’, pode-se usar a função format() no lugar da bin() para omitir o prefixo.

a = 12
b = 1560
c = -12
print("*** com '0b'")
print("a =", bin(a))
print("b =", bin(b))
print("c =", bin(c))
print("\n*** sem '0b'")
print("a =", format(12, 'b'))
print("b =", format(1560, 'b'))
print("c =", format(-12, 'b'))

A saída do programa é mostrada abaixo.

*** com '0b'
a = 0b1100
b = 0b11000011000
c = -0b1100

*** sem '0b'
a = 1100
b = 11000011000
c = -1100

• bool(x) – Retorna um valor booleano (True ou False). Se x é falso, zero ou foi omitido, a função retorna False; senão a função retorna True.

a = [1, "aba", False]
b = []
c = 2.56
d = False
e = 0
print("a =", bool(a))
print("b =", bool(b))
print("c =", bool(c))
print("d =", bool(d))
print("e =", bool(e))

O resultado do programa é:

a = True
b = False
c = True
d = False
e = False

• breakpoint() – Para a execução do programa e entra no modo de depuração do Python.

a = 10
b = 5
if a + b == 15:
   breakpoint()
   print("a + b =", a + b)
print("*** Fim do programa")

Note que a função breakpoint() é chamada dento da estrutura if. É então aberto uma linha de comandos para que o usuário possa interagir com o programa. No exemplo abaixo, são verificados os valores das variáveis a e b. Depois o caractere c é digitado para que a execução do programa continue. A sigla pdb corresponde a “Python Debugger”.

> /home/morganna/Área de Trabalho/teste.py(5)<module>()
-> print("a + b =", a + b)
(Pdb) print(a)
10
(Pdb) print(b)
5
(Pdb) print(a**b)
100000
(Pdb) c
a + b = 15
*** Fim do programa

São outros exemplos de comandos que podem ser usados no depurador:

      h(elp) h(help) – lista os comandos disponíveis no depurador.

(Pdb) h

Documented commands (type help <topic>):
========================================
EOF    c          d        h         list      q        rv       undisplay
a      cl         debug    help      ll        quit     s        unt      
alias  clear      disable  ignore    longlist  r        source   until    
args   commands   display  interact  n         restart  step     up       
b      condition  down     j         next      return   tbreak   w        
break  cont       enable   jump      p         retval   u        whatis   
bt     continue   exit     l         pp        run      unalias  where    

Miscellaneous help topics:
==========================
exec  pdb

      l(list) – lista o código fonte do programa.

(Pdb) l
  1  	a = 10
  2  	b = 5
  3  	if a + b == 15:
  4  	   breakpoint()
  5  ->	   print("a + b =", a + b)
  6  	print("*** Fim do programa")
[EOF]

• bytearray() – Retorna um objeto bytearray (vetor de bytes). Esta função pode ter três argumentos: source (se for um valor inteiro, indica o tamanho do vetor com bytes nulos; se for uma string, define o conteúdo do vetor; se for um objeto, é usado para inicializar um vetor); encoding (codificação usada com a string); error (especifica o que fazer no caso de erro). Sem nenhum argumento é definido, é criado um vetor de tamanho zero. Um objeto bytearray pode ser modificado.

vetor1 = bytearray("Python é 10!", 'utf-8')
print("vetor1 = ", vetor1, ", tam =", len(vetor1))
vetor2 = bytearray("Python é 10!", 'utf-16')
print("vetor2 = ", vetor2, ", tam =", len(vetor2))
vetor3 = bytearray(3)
print("vetor3 = ", vetor3, ", tam =", len(vetor3))
vetor4 = bytearray([1, 23, 18])
print("vetor4 = ", vetor4, ", tam =", len(vetor4))
vetor5 = bytearray()
print("vetor5 = ", vetor5, ", tam =", len(vetor5))

A saída mostrada pelo programa é

vetor1 =  bytearray(b'Python \xc3\xa9 10!') , tam = 13
vetor2 =  bytearray(b'\xff\xfeP\x00y\x00t\x00h\x00o\x00n\x00 \x00\xe9\x00 \x001\x000\x00!\x00') , tam = 26
vetor3 =  bytearray(b'\x00\x00\x00') , tam = 3
vetor4 =  bytearray(b'\x01\x17\x12') , tam = 3
vetor5 =  bytearray(b'') , tam = 0

É possível modificar um objeto bytearray como mostra o exemplo abaixo.

vetor = bytearray("abc", 'utf-8')
print("vetor = ", vetor, ", tam =", len(vetor))
vetor[1:2] = b'x'
print("vetor = ", vetor, ", tam =", len(vetor))

Note que apenas um byte foi modificado.

vetor =  bytearray(b'abc') , tam = 3
vetor =  bytearray(b'axc') , tam = 3

• bytes() – Retorna um objeto bytes (vetor de bytes). Esta função pode ter três argumentos: source (se for um valor inteiro, indica o tamanho do vetor com bytes nulos; se for uma string, define o conteúdo do vetor; se for um objeto, é usado para inicializar um vetor); encoding (codificação usada com a string); error (especifica o que fazer no caso de erro). Sem nenhum argumento é definido, é criado um vetor de tamanho zero. Um objeto bytes não pode ser modificado.

vetor1 = bytes("Python é 10!", 'utf-8')
print("vetor1 = ", vetor1, ", tam =", len(vetor1))
vetor2 = bytes("Python é 10!", 'utf-16')
print("vetor2 = ", vetor2, ", tam =", len(vetor2))
vetor3 = bytes(3)
print("vetor3 = ", vetor3, ", tam =", len(vetor3))
vetor4 = bytes([1, 23, 18])
print("vetor4 = ", vetor4, ", tam =", len(vetor4))
vetor5 = bytes()
print("vetor5 = ", vetor5, ", tam =", len(vetor5))

O resultado do programa é

vetor1 =  b'Python \xc3\xa9 10!' , tam = 13
vetor2 =  b'\xff\xfeP\x00y\x00t\x00h\x00o\x00n\x00 \x00\xe9\x00 \x001\x000\x00!\x00' , tam = 26
vetor3 =  b'\x00\x00\x00' , tam = 3
vetor4 =  b'\x01\x17\x12' , tam = 3
vetor5 =  b'' , tam = 0

• callable(objeto) – Retorna True se o objeto é chamável e retorna False no caso contrário. Um objeto é chamável quando pode ser chamado usando o operador ().

x = 10
def teste():
  print("ok")
print("x é chamável =", callable(x))
print("teste é chamável =", callable(teste))

A resposta é

x é chamável = False
teste é chamável = True

• chr(x) – Retorna o caractere que corresponde ao inteiro x no código Unicode.

print("char 65 (Hex 41)        =", chr(65))
print("char 97 (Hex 61)        =", chr(97))
print("char 956 (Hex 03BC)     =", chr(956))
print("char 9757 (Hex 261D)    =", chr(9757))
print("char 65312 (Hex FF20)   =", chr(65312))
print("char 128522 (Hex 1F60A) =", chr(128522))

O programa apresenta a seguinte saída:

char 65 (Hex 41)        = A
char 97 (Hex 61)        = a
char 956 (Hex 03BC)     = μ
char 9757 (Hex 261D)    = ☝
char 65312 (Hex FF20)   = ＠
char 128522 (Hex 1F60A) = 😊

• classmethod() – Transforma um método de instância em um método de classe. Um método de instância pode acessar livremente atributos e outros métodos da classe do objeto instanciado. Um método de classe é uma função que não depende do conteúdo de um objeto ou da execução da instância de uma classe. O exemplo abaixo mostra o uso de um método de instância. Note que é necessário criar um objeto, antes de usar o método.

class Aluno:
    nome = "Maria Flor"
    idade = 18
    def dadosAluno(info):
        print("Nome:", info.nome, ", idade:", info.idade)
estudante = Aluno()
estudante.dadosAluno()

Entretanto, é possível transformar o método dadosAluno() em método de classe e usá-lo sem a necessidade de criar um objeto da classe Aluno.

class Aluno:
    nome = "Maria Flor"
    idade = 18
    def dadosAluno(info):
        print("Nome:", info.nome, ", idade:", info.idade)
Aluno.dadosAluno=classmethod(Aluno.dadosAluno)
Aluno.dadosAluno()

Outra forma de fazer essa transformação é usar o decorador @classmethod.

class Aluno:
    nome = "Maria Flor"
    idade = 18
    @classmethod
    def dadosAluno(info):
        print("Nome:", info.nome, ", idade:", info.idade)
Aluno.dadosAluno()

docs.python.org/pt-br/3/library/functions.html#exec(abrir em uma nova aba)

Todos os programas acima apresentam a mesma saída:

Nome: Maria Flor , idade: 18

• compile() – Compila o argumento em código ou em objeto AST (Abstract Syntax Tree). O código pode ser executado por exec() ou eval(). O primeiro exemplo, mostrado abaixo, compila o código que apresenta o resultado da multiplicação de duas variáveis x e y. O segundo argumento de compile(), representado por uma string vazia, corresponde ao nome do arquivo onde o código poderia ser lido.

programa = 'x=5\ny=10\nprint("resultado =",x * y)'  
codigo = compile(programa, '', 'exec')  
exec(codigo)

O segundo exemplo lê um arquivo Python, cria uma string e executa o script lido. Note que o segundo parâmetro da função compile() não precisa novamente ser definido.

arq = open('teste.py', 'r')
programa = arq.read()
arq.close()
codigo = compile('programa', '', 'exec')
exec(programa)

A função eval() do Python avalia dinamicamente uma expressão. O terceiro exemplo de compile() verifica uma expressão lógica (10 < 20 ?) e em seguida calcula o resultado de 10^2. O resultado do programa é: True e 100.

x = 10
res = compile('x < 20', '', 'eval')
print(eval(res))
res = compile('x ** 2', '', 'eval')
print(eval(res))

O quarto exemplo cria um objeto AST. AST é uma ferramenta Python usada para interagir diretamente com o código python e modificá-lo. Dado um código-fonte, o compilador identifica palavras-chave e cria tokens. Cada token representa um “átomo” de uma instrução. Os tokens são então organizados em uma árvore onde os nós são os “átomos” das instruções. O compilador pode aplicar várias otimizações ao AST e, finalmente, convertê-lo em código binário.

import ast
astparse = ast.parse('''  
a = 10 
b = 20
print(a+b)  
''')  
print()   
exec(compile(astparse, filename="", mode="exec"))

Para ver a estrutura do objeto AST do programa acima use:

print(ast.dump(astparse, indent=5))

A resposta é

Module(
     body=[
          Assign(
               targets=[
                    Name(id='a', ctx=Store())],
               value=Constant(value=10)),
          Assign(
               targets=[
                    Name(id='b', ctx=Store())],
               value=Constant(value=20)),
          Expr(
               value=Call(
                    func=Name(id='print', ctx=Load()),
                    args=[
                         BinOp(
                              left=Name(id='a', ctx=Load()),
                              op=Add(),
                              right=Name(id='b', ctx=Load()))],
                    keywords=[]))],
     type_ignores=[])

• complex() – Retorna um número complexo com o valor real + imag*1j ou converte uma string ou número para um número complexo.

z = complex(4, -2)
print("(1) z =", z)
z = complex(1)
print("(2) z =", z)
z = complex()
print("(3) z =", z)
z = complex("4-7j")
print("(4) z =", z)

A saída do programa mostra:

(1) z = (4-2j)
(2) z = (1+0j)
(3) z = 0j
(4) z = (4-7j)

• delattr() – Remove um atributo de um objeto. No exemplo abaixo, o atributo email é deletado da classe Aluno. Note que estudante é um objeto da classe Aluno.

class Aluno:  
    matricula = 202212100076 
    nome = "Maria Flor"  
    email = "flor@gmail.com"
estudante = Aluno()
print(dir(estudante), "\n")
delattr(Aluno,'email')
print(dir(estudante))

Como consequência, o atributo email é deletado do objeto estudante que é uma instância de Aluno. Não é possível deletar atributos de objetos.

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'email', 'matricula', 'nome'] 

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'matricula', 'nome']

• dict() – Cria um novo dicionário.

dicionario = dict(nome = "Maria Flor", idade = 18, curso = "BSI")
print(dicionario)
print("nome =", dicionario["nome"])

• dir() – Devolve a lista de nomes no escopo local atual se nenhum argumento for passado. Devolve a lista de atributos válidos para o argumento passado.

class Aluno:  
    matricula = 202212100076 
    nome = "Maria Flor"  
    email = "flor@gmail.com"
lista = [1, "abc"]
num = 12.5
print("***** dir() =", dir(), "\n")
print("***** dir(Aluno) =", dir(Aluno), "\n")
print("***** dir(lista) =", dir(lista), "\n")
print("***** dir(num) =", dir(num))

A saída do programa é:

***** dir() = ['Aluno', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'lista', 'num'] 

***** dir(Aluno) = ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'email', 'matricula', 'nome'] 

***** dir(lista) = ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] 

***** dir(num) = ['__abs__', '__add__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__int__', '__le__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__round__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__setformat__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']

• divmod() – retorna o quociente (valor inteiro) e o resto da divisão.

a = 4.3
b = 1.5
print(divmod(a, b))
print(divmod(b, a))

Abaixo a resposta do programa. Note que: a) 2.0 \times 1.5 + 1.2999 \approx 4.3 ; b) 0 \times 4.3 + 1.5 = 1.5 .

(2.0, 1.2999999999999998)
(0.0, 1.5)

• enumerate() – Devolve um objeto enumerado. O argumento precisa ser um objeto que suporta iteração.

alunos = ['Maria', 'Pedro', 'José', 'Tereza']
numeros = {1, 5, 91, 102}
dicionario = dict(nome = "Maria Flor", idade = 18, curso = "BSI")
print(list(enumerate(alunos)))
print(list(enumerate(numeros, start=2)))
print(list(enumerate(dicionario, start=5)))

Abaixo a resposta.

[(0, 'Maria'), (1, 'Pedro'), (2, 'José'), (3, 'Tereza')]
[(2, 1), (3, 91), (4, 5), (5, 102)]
[(5, 'nome'), (6, 'idade'), (7, 'curso')]

• eval() – avalia o argumento passado.

a = 5
print(eval('a**3'))
b = eval('5 > 3')
print(b)
eval('print("a =", a)')
expressao = 'a*(a+1)*(a+2)'
print(eval(expressao))

A saída apresentada pelo programa é:

125
True
a = 5
210

• exec() – executa código Python.

programa = 'a = 10\nb=5\nprint("Resultado =", a*b)'
exec(programa)

O programa tem como resposta:

Resultado = 50

• filter() – Recebe dois argumentos: um elemento iterável e uma função. Os elementos que compõem o elemento interável são testados pela função. Se o resultado do teste for False, o elemento é descartado; se o resultado do teste for True, o elemento é retornado. Se a função fornecida for None, todos os elementos considerados False são removidos (o objeto None no Python denota falta de valor).

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
NumeroPar = filter(lambda x: (x%2 == 0), numeros)
print("Numeros pares:", list(NumeroPar))
lista = ["a", "0", 0, "None", None, "2", 2]
nova_lista = filter(None, lista)
print("Valores verdadeiros:", list(nova_lista))

O programa acima apresenta dois exemplos do uso da função filter(). O primeiro exemplo seleciona os números pares em uma lista que possui valores de 1 a 10. O segundo exemplo retira os elementos None e 0 da lista, pois eles correspondem ao valor booleano False. Note que os elementos “None” e “0” não são removidos.

Numeros pares: [2, 4, 6, 8, 10]
Valores verdadeiros: ['a', '0', 'None', '2', 2]

• float() – Recebe um número ou uma string e retorna um número de ponto flutuante.

print(float('+1.2345'))
print(float('   -12345'))
print(float('1e-00012345'))
print(float('+1.2345E6'))
print(float('+1.2345E-6'))
print(float('-Infinity'))
print(float('+Infinity'))

A resposta do programa é:

1.2345
-12345.0
0.0
1234500.0
1.2345e-06
-inf
inf

• format() – formata o(s) valor(es) especificado(s) e os insere dentro do espaço reservado da string. O espaço reservado é definido usando colchetes.

txt = "{}, é {}! Vamos {}?"
print(txt.format("Python", "10", "aprender"))

import math
txt = chr(928) + " = {:.6f}"
print(txt.format(math.pi))

O programa apresenta dois exemplos com a função format(). No primeito exemplo, três argumentos são passados para a função. No segundo exemplo, o valor de \pi é mostrado com seis casas decimais. Abaixo a resposta do programa.

Python, é 10! Vamos aprender?
Π = 3.141593

Outros formatos podem ser usados com a função format(). Veja a página da w3school para mais detalhes.

• frozenset() – Cria um conjunto (set) imutável a partir de um conjunto mutável. Isto significa que os elementos do novo conjunto não podem ser nem alterados e nem deletados. Além disso, novos elementos não podem ser incluídos.

letras = ('a', 'b', 'c', 'd', 'e')
conj_imut = frozenset(letras)
print('O conjunto imutável:', conj_imut)
try:
  conj_imut.add('f')
except:
  print("Não é possível incluir um novo elemento no conjunto")
try:
  conj_imut.remove('b')
except:
  print("Não é possível excluir um elemento do conjunto")

Veja que após criar o conjunto imutável, o Python não permite incluir ou deletar elementos nesse conjunto.

O conjunto imutável: frozenset({'b', 'e', 'a', 'd', 'c'})
Não é possível incluir um novo elemento no conjunto
Não é possível excluir um elemento do conjunto

• getattr() – Retorna o valor de um determinado atributo de um objeto.

class Aluno:
  nome  = "Maria Flor"
  idade = 18
  curso = "BSI"
nome  = getattr(Aluno, 'nome')
curso = getattr(Aluno, 'curso')
print(nome, "faz o curso", curso, "da UNIRIO")

O programa fornece a seguinte resposta:

Maria Flor faz o curso BSI da UNIRIO

• globals() – Usado para atualizar variáveis globais e para retornar informações sobre as variáveis globais. No exemplo mostrado abaixo, temos uma variável global ‘a’ e uma variável local ‘a’ dentro da função teste(). A variável global ‘a’ é alterada dentro da função teste().

a = 5
print("A variável 'a' no início do programa:",a)
def teste():
   globals()['a'] = 25
   a = 30
   print("A variável local 'a' dentro da função teste:",a)
teste()
print("A variável global 'a' depois da função teste:",a)
print("\n", globals())

A saída do programa é:

A variável 'a' no início do programa: 5
A variável local 'a' dentro da função teste: 30
A variável global 'a' depois da função teste: 25

 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f0ff08e5270>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/morganna/Área de Trabalho/Python_220330/testes/teste_funcao.py', '__cached__': None, 'a': 25, 'teste': <function teste at 0x7f0ff094a0e0>}

• hasattr() – Responde com True se o argumento é um dos atributos do objeto, e responde com False no caso contrário.

class Aluno:
  nome  = "Maria Flor"
  idade = 18
  curso = "BSI"
if hasattr(Aluno, 'nome'):
   print("Existe atributo nome no objeto Aluno")
else:
   print("Não existe atributo nome no objeto Aluno")
if hasattr(Aluno, 'cidade'):
   print("Existe atributo cidade no objeto Aluno")
else:
   print("Não existe atributo cidade no objeto Aluno")

Abaixo a resposta mostrada pelo programa.

Existe atributo nome no objeto Aluno
Não existe atributo cidade no objeto Aluno

• hash() – Retorna o valor hash de um objeto (se houver um). Explicação: hash é um algoritmo matemático no qual ocorre uma transformação do dado em um número.

print('Hash para 12345:', hash(12345))
print('Hash para 12.345:',hash(12.345))
print('Hash para "Python é 10!":', hash('Python é 10!'))
print('Hash para (1,2,3,4,5):', hash((1,2,3,4,5)))

Abaixo a resposta do programa.

Hash para 12345: 12345
Hash para 12.345: 795515838178725900
Hash para "Python é 10!": 9085620290049123719
Hash para (1,2,3,4,5): -5659871693760987716

• help() – Invoca o sistema de ajuda embutido.

x = help(print)
print(x)

• hex() – Converte um número inteiro para uma string hexadecimal.

print("Hexadecimal de 23  é " + hex(23))
print("Hexadecimal de -23 é " + hex(-23))                                               
print("Hexadecimal de 'a' é " + hex(ord('a')))
print("Hexadecimal de 2.3 é " + float.hex(2.3))

O resultado do programa é mostrado abaixo.

Hexadecimal de 23  é 0x17
Hexadecimal de -23 é -0x17
Hexadecimal de 'a' é 0x61
Hexadecimal de 2.3 é 0x1.2666666666666p+1

• id() – Retorna a identidade de um objeto. Esta identidade é única e constante para o objeto durante a sua existencia.

a = "Python"
print("id(a) =", id(a))
b = "Python"
print("id(b) =", id(b))
if id(a) == id(b):
   print("id(a) = id(b)")
else:
   print("id(a) não é = id(b)")
lista = ["abc", "Python", "123"]
print("id(lista[0]) =", id(lista[0]))
print("id(lista[1]) =", id(lista[1]))
print("id(lista[2]) =", id(lista[2]))
print("id(lista)    =", id(lista))
print("id(21) =", id(21))
print("id(99) =", id(99))

A resposta do programa é mostrada abaixo. Note que as variáveis ‘a’ e ‘b’ são dois nomes para um mesmo valor.

id(a) = 140199966322352
id(b) = 140199966322352
id(a) = id(b)
id(lista[0]) = 140199966311600
id(lista[1]) = 140199966322352
id(lista[2]) = 140199966628912
id(lista)    = 140199968098304
id(21) = 140199967097712
id(99) = 140199967100208

• input() – Recebe uma entrada na linha de comando e retorna uma string.

nome = input('Entre com o seu nome: ')
print('Olá, ' + nome)

• int() – Devolve um objeto inteiro construído a partir de um número ou de uma string. Devolve zero se nenhum argumento for fornecido.

a = '12'
b = 6
print('a + b = ', int(a) + b)
c = 12.78
print("c = ", int(c))

A resposta é

a + b =  18
c =  12

• isinstance() – Retorna True se um objeto é instância de uma determinada classe.

if isinstance(5, int):
   print("5 é um número inteiro")
if isinstance("abc", str):
   print("'abc' é uma string")
class Aluno:
  nome = "Maria"
x = Aluno()
if isinstance(x, Aluno):
   print("x é uma instância da classe Aluno")

• issubclass() – Retorna True se uma classe é uma subclasse de uma outra classe.

print('bool é uma subclasse de int: ', issubclass(bool, int))
class meuCurso:
  curso = 'BSI'
class meusDados(meuCurso):
  nome = "Maria Flor"
  curso = meuCurso
if issubclass(meusDados, meuCurso):
   print("meusDados é uma subclasse de meuCurso")

A resposta fornecida pelo programa é

bool é uma subclasse de int:  True
meusDados são uma subclasse de meuCurso

• iter() – Retorna um objeto iterável.

lista = iter([1, "ab", 13, 2.4, False])
for i in range(0, 5):
  print(next(lista))

O resultado do programa é mostrado abaixo.

1
ab
13
2.4
False

• len() – Devolve o comprimento (o número de itens) de um objeto.

string = "Python é 10!"
lista = [1, "ab", 13, 2.4, False]
conjunto = {1, "teste", "abc"}
print("Tamanho da string = ",   len(string))
print("Tamanho da lista = ",    len(lista))
print("Tamanho do conjunto = ", len(conjunto))

O programa responde:

Tamanho da string =  12
Tamanho da lista =  5
Tamanho do conjunto =  3

• list() – Cria uma lista.

string = "Python é 10!"
lista = [1, "ab", 13, 2.4, False]
conjunto = {1, "teste", "abc"}
print("De uma string = ",  list(string))
print("De uma lista = ",   list(lista))
print("De um conjunto = ", list(conjunto))

A resposta é:

De uma string =  ['P', 'y', 't', 'h', 'o', 'n', ' ', 'é', ' ', '1', '0', '!']
De uma lista =  [1, 'ab', 13, 2.4, False]
De um conjunto =  [1, 'teste', 'abc']

• locals() – Retorna informações sobre as variáveis locais.

def teste():
    a = 10
    b = 15
    print("\nDentro da função teste()")
    print(locals())
teste()
c = 30
print("\nNo escopo global")
print(locals())

A resposta é:

Dentro da função teste()
{'a': 10, 'b': 15}

No escopo global
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f86b34ad270>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/morganna/Área de Trabalho/testes/teste_funcao.py', '__cached__': None, 'teste': <function teste at 0x7f86b35120e0>, 'c': 30}

• map() – Aplica uma função em cada item do iterador.

def funcao1(a):
  return len(a)
x = map(funcao1, ('UNIRIO', 'BSI', 'CCET'))
print(list(x))

lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
x = map(lambda a, b: a + b, lista1, lista2)
print(list(x))

def funcao2(a, b):
  return a + b
x = map(funcao2, ('UNIRIO: ', 'BSI: ', 'CCET: '), ('universidade', 'curso', 'centro'))
print(list(x))

lista = [2, 4, 6, 8, 10]
def funcao3(num):
  return num * num
x = map(funcao3, lista)
print(list(x))

Abaixo a resposta do programa.

[6, 3, 4]
[5, 7, 9]
['UNIRIO: universidade', 'BSI: curso', 'CCET: centro']
[4, 16, 36, 64, 100]

• max() – Devolve o maior item em um iterável ou o maior de dois ou mais argumentos.

x = max("Maria", "João", "Anatália")
print(x)
x = max([2, 78, 101, 4, 31])
print(x)
x = max(3, 7)
print(x)

Abaixo é mostrada a resposta.

Maria
101
7

• memoryview() – Devolve um objeto de “visão da memória” criado a partir do argumento fornecido.

vetor = bytearray('ABC', 'utf-8')
print('Antes atualização:', vetor)
res = memoryview(vetor)
print(res[1])
print(bytes(res[1:2]))
res[1] = 90
print('Depois da atualização:', vetor)
print(res[1])
print(bytes(res[1:2]))

Resposta do programa é:

Antes atualização: bytearray(b'ABC')
66
b'B'
Depois da atualização: bytearray(b'AZC')
90
b'Z'

• min() – Devolve o menor item em um iterável ou o menor de dois ou mais argumentos.

x = min("Maria", "João", "Anatália")
print(x)
x = min([2, 78, 101, 4, 31])
print(x)
x = min(3, 7)
print(x)

A saída do programa é:

Anatália
2
3

• next() – Retorna o próximo item de um iterador.

lista= iter(["UNIRIO", "BSI", "CCET"])
while True:
   item = next(lista, 'fim')
   if item == 'fim':
      print('*** Fim da lista')
      break
   else:
      print(item)

A resposta é mostrada abaixo.

UNIRIO
BSI
CCET
*** Fim da lista

• object() – Retorna um objeto vazio. Não é possível adicionar propriedades e métodos ao objeto criado.

objeto = object()
print("Tipo do objeto : ", type(objeto))
print("Atributos do objeto : ")
print(dir(objeto))

A saída do programa é:

Tipo do objeto :  <class 'object'>
Atributos do objeto : 
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

• oct() – Converte um número inteiro para uma string em base octal.

print(oct(12))
print(oct(26))
print(oct(int('32')))

Abaixo a resposta do programa.

0o14
0o32
0o40

• open() – Abre um arquivo. O exemplo abaixo abre um arquivo para a escrita, escreve no arquivo, fecha o arquivo e depois abre o arquivo para leitura.

arq = open("teste.txt", "w")
arq.write("Primeira linha do arquivo novo\n")
arq.write("Segunda linha do arquivo\n")
arq.write("Fim do arquivo")
arq.close()
arq = open("teste.txt", "r")
print(arq.read())

Abaixo a resposta da execução do programa.

Primeira linha do arquivo novo
Segunda linha do arquivo
Fim do arquivo

A tabela a seguir mostra outros modos de abrir um arquivo.

Caractere	Significado
‘r’	Abre para leitura
‘w’	Abre para escrita
‘x’	Abre o arquivo para escrita, falha se o arquivo já existe
‘a’	Abre, no final do arquivo, para escrita
‘b’	Abre no modo binário
‘t’	Abre no modo texto
‘+’	Abre para atualizações (leitura e escrita)

• ord() – Retorna o código Unicode de um caractere.

print("a =", ord("a"))
print("A =", ord("A"))
print("$ =", ord("$"))
print("# =", ord("#"))
print("@ =", ord("@"))

O programa mostra a resposta abaixo.

a = 97
A = 65
$ = 36
# = 35
@ = 64

• pow() – Retorna a potência de um número. Se um terceiro número é fornecido, a função retorna o resto da divisão da potência por um número.

x = pow(5, 3)
print("5  ** 3      =", x)
x = pow(5, -3)
print("5  ** -3     =", x)
x = pow(-5, -3)
print("-5 ** -3     =", x)
x = pow(5, 3, 2)
print("(5 ** 3) % 2 =", x)

Abaixo a resposta do programa.

5  ** 3      = 125
5  ** -3     = 0.008
-5 ** -3     = -0.008
(5 ** 3) % 2 = 1

• print() – Imprime uma mensagem na saída padrão.

print("Python é 10!")
a = "Python é"
b = " 10!"
print(a + b)
x = 10 / 3
print("x = ", x)

A resposta é:

Python é 10!
Python é 10!
x =  3.3333333333333335

• property() – Cria e retorna um atributo de propriedade. No exemplo abaixo, a propriedade area retorna o valor da área de um retângulo.

class Retangulo(object):
    def __init__(self, largura, altura):
        self.largura = largura
        self.altura  = altura
    def area(self):
        return self.largura * self.altura
    area = property(area)
objeto = Retangulo(4, 7)
print("área =", objeto.area)

A saída do programa é

área = 28

• range() – Retorna uma sequência de números dado o valor inicial, o valor final e o incremento (por padrão é o valor 1).

print("Números ímpares menores que 20:")
for i in range(1, 21, 2):
  print(i)

Abaixo o resultado da execução do programa.

Números ímpares menores que 20:
1
3
5
7
9
11
13
15
17
19

• repr() – Retorna uma string contendo uma representação imprimível de um objeto.

print(repr(12))
print(repr(12.45))
print(repr(True))
print(repr((5+7)/3))
class Aluno:
    nome = "Maria Flor"
    def __repr__(self):
        return repr(self.nome)
print(repr(Aluno()))

Abaixo a resposta.

12
12.45
True
4.0
'Maria Flor'

• reversed() – Retorna um iterador reverso.

print(list(reversed([21, 19, -40, 33, -3])))
print(list(reversed("Python é 10!")))
print(list(reversed(('P', 'y', 't', 'h', 'o', 'n'))))
for i in reversed(["a", "e", "i", "o", "u"]):
  print(i)

O programa mostra como saída:

[-3, 33, -40, 19, 21]
['!', '0', '1', ' ', 'é', ' ', 'n', 'o', 'h', 't', 'y', 'P']
['n', 'o', 'h', 't', 'y', 'P']
u
o
i
e
a

• round() – Arredonda o valor de um número dado um determinado número de casas decimais. Se o numero de casas decimais não for fornecido, o número é arredondado para o valor inteiro mais próximo.

import math
pi = math.pi
print("pi =", pi)
print("pi =", round(pi, 3))
print("pi =", round(pi, 2))
print("pi =", round(pi, 1))
print("pi =", round(pi))

A resposta é:

pi = 3.141592653589793
pi = 3.142
pi = 3.14
pi = 3.1
pi = 3

• set() – retorna um conjunto.

a = set()
print("a =", a)
b = set(("UNIRIO", "BSI", "CCET"))
print("b =", b)
def numPar(num):  
   if num % 2 == 0:  
      return num 
pares = filter(numPar,[3, 6, 18, 12, 71, 23, 42])
c = set(pares)
print("c =", c)

A resposta do programa é mostrada abaixo.

a = set()
b = {'CCET', 'BSI', 'UNIRIO'}
c = {18, 12, 42, 6}

• setattr() – Permite alterar ou incluir um atributo.

class Aluno:  
    nome  = ""  
    curso = ""  
    def __init__(self, nome, curso):  
      self.nome = nome  
      self.curso = curso             
aluno = Aluno("Maria Flor", "Matemática")
print("*** Dados originais")
print("Nome  =", aluno.nome)  
print("Curso =", aluno.curso)
setattr(aluno, 'curso','BSI') 
setattr(aluno, 'email','flor@unirio') 
print("*** Dados modificados")
print("Nome  =", aluno.nome)  
print("Curso =", aluno.curso)
print("Email =", aluno.email)

A saída do programa é:

*** Dados originais
Nome  = Maria Flor
Curso = Matemática
*** Dados modificados
Nome  = Maria Flor
Curso = BSI
Email = flor@unirio

• slice() – Retorna um objeto fatiado. A função permite especificar o início e o fim do fatiamento de uma sequência (string, tupla, lista, range ou bytes). Note que o índice final da função não entra no fatiamento.

tupla = ("a", "b", "c", "d", "e", "f", "g", "h")
print("Tupla =", tupla)
print("Tupla(3)     =", tupla[slice(3)])
print("Tupla(2,6)   =", tupla[slice(2,6)])
print("Tupla(1,7,2) =", tupla[slice(1,7,2)])
print()
string = 'Python é 10!'
print("String =", string)
print("String(3)     =", string[slice(3)])
print("String(3,8)   =", string[slice(3,8)])
print("String(1,8,2) =", string[slice(1,8,2)])
print()
lista = [1, 'ab', 64, 'teste', 2.3, 12, 'BSI']
print("Lista = ", lista)
print("Lista(2)     =", lista[slice(2)])
print("Lista(1,4)   =", lista[slice(1,4)])
print("Lista(2,6,2) =", lista[slice(2,6,2)])
print()
r = range(10)
print("Range = ", r)
print("Range(3)     =", r[slice(3)])
print("Range(3,8)   =", r[slice(3,8)])
print("Range(2,6,2) =", r[slice(2,6,2)])
print()
string = 'Python é 10!'
bytes = bytes(string, 'utf-8')  
print("Bytes =", bytes)
print("Bytes(3)     =", bytes[slice(3)])
print("Bytes(3,8)   =", bytes[slice(3,8)])
print("Bytes(1,8,2) =", bytes[slice(1,8,2)])

A resposta do programa é mostrada abaixo.

Tupla = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')
Tupla(3)     = ('a', 'b', 'c')
Tupla(2,6)   = ('c', 'd', 'e', 'f')
Tupla(1,7,2) = ('b', 'd', 'f')

String = Python é 10!
String(3)     = Pyt
String(3,8)   = hon é
String(1,8,2) = yhné

Lista =  [1, 'ab', 64, 'teste', 2.3, 12, 'BSI']
Lista(2)     = [1, 'ab']
Lista(1,4)   = ['ab', 64, 'teste']
Lista(2,6,2) = [64, 2.3]

Range =  range(0, 10)
Range(3)     = range(0, 3)
Range(3,8)   = range(3, 8)
Range(2,6,2) = range(2, 6, 2)

Bytes = b'Python \xc3\xa9 10!'
Bytes(3)     = b'Pyt'
Bytes(3,8)   = b'hon \xc3'
Bytes(1,8,2) = b'yhn\xc3'

• sorted() – Retorna uma lista ordenada.

tupla = ("b", "g", "a", "d", "f", "c", "h", "e")
print("Tupla ordenada =", sorted(tupla))
print("Tupla reversa  =", sorted(tupla, reverse=True))

Abaixo a resposta do programa.

Tupla ordenada = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
Tupla reversa  = ['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

• staticmethod() – Transforma um método de classe em um método estático. Um método estático não requer uma criação de instância de classe e apenas lida com os parâmetros. O exemplo abaixo mostra duas formas de fazer essa transformação: usando a função staticmethod() e usando o decorador @staticmethod.

class Calculadora:
  def soma_numeros(num1, num2):
    return num1 + num2
  @staticmethod
  def multiplica_numeros(num1, num2):
      return num1 * num2
Calculadora.soma_numeros = staticmethod(Calculadora.soma_numeros)
print('Soma =', Calculadora.soma_numeros(5, 31))
print("Multiplicação =", Calculadora.multiplica_numeros(4, 8))

A saída do programa é:

Soma = 36
Multiplicação = 32

• str() – Converte um determinado valor em uma string.

a = str(3.5 + 2.4)
b = str(4.5)
print("a =", a, ", type =", type(a))
print("b =", b, ", type =", type(b))

Abaixo a resposta do programa.

a = 5.9 , type = <class 'str'>
b = 4.5 , type = <class 'str'>

• sum() – soma todos os itens de um iterável. Se um valor é fornecido, assume que a soma tem inicialmente este valor.

tupla = (1, 2, 3, 4, 5)
print("Tupla =", tupla)
print("Soma tupla =", sum(tupla))
print("Soma tupla + 10 =", sum(tupla, 10))

A resposta é:

Tupla = (1, 2, 3, 4, 5)
Soma tupla = 15
Soma tupla + 10 = 25

• super() – Retorna um objeto que representa a classe pai.

class Pai:
  def __init__(self, texto):
    self.mensagem = texto
  def mostraMensagem(self):
    print(self.mensagem)
class Filho(Pai):
  def __init__(self, texto):
    super().__init__(texto)
objeto = Filho("Python é 10!")
objeto.mostraMensagem()

O programa apresenta a seguinte resposta:

Python é 10!

• tuple() – Retorna uma tupla.

string = "Python"
print("Tupla a partir de uma string =", tuple(string))
lista = [1, 2, 3]
print("Tupla com 3 itens =", tuple(lista))
num = 21.5
dicionario = { 'nome' : 'Maria Flor', 'Curso' : 'BSI' } 
print("Tupla a partir de um dicionário =", tuple(dicionario))

A resposta do programa é:

string = "Python"
print("Tupla a partir de uma string =", tuple(string))
lista = [1, 2, 3]
print("Tupla com 3 itens =", tuple(lista))
dicionario = { 'nome' : 'Maria Flor', 'Curso' : 'BSI' } 
print("Tupla a partir de um dicionário =", tuple(dicionario))

• type() – Retorna o tipo do objeto.

string = "Python"
print("Tipo =", type(string))
lista = [1, 2, 3]
print("Tipo =", type(lista))
tupla = (1, 2, 3)
print("Tipo =", type(tupla))
conjunto = {1, 2, 3}
print("Tipo =", type(conjunto))
num = 21
print("Tipo =", type(num))
num = 21.5
print("Tipo =", type(num))
dicionario = { 'nome' : 'Maria Flor', 'Curso' : 'BSI' } 
print("Tipo =", type(dicionario))

A saída do programa é:

Tipo = <class 'str'>
Tipo = <class 'list'>
Tipo = <class 'tuple'>
Tipo = <class 'set'>
Tipo = <class 'int'>
Tipo = <class 'float'>
Tipo = <class 'dict'>

• vars() – Retorna o atributo dict de um objeto. O atributo dict é um dicionário que contém os atributos alteráveis ​​do objeto.

class Aluno:
  nome  = 'Maria Flor'
  Curso = 'BSI'
  idade = 18
print(vars(Aluno))

O programa apresenta a seguinte saída:

{'__module__': '__main__', 'nome': 'Maria Flor', 'Curso': 'BSI', 'idade': 18, '__dict__': <attribute '__dict__' of 'Aluno' objects>, '__weakref__': <attribute '__weakref__' of 'Aluno' objects>, '__doc__': None}

• zip() – Retorna um iterador de tuplas onde o primeiro item do iterador corresponde aos primeiros itens das tuplas, o segundo item corresponde aos segundos itens das tuplas, e assim por diante. Se os iteradores ​​tiverem comprimentos diferentes, o iterador com menos itens decide o comprimento do novo iterador.

a = ("UNIRIO", "BSI", "CCET")
b = ("univesidade", "curso", "centro")
c = (1, 2, 3, 4, 5)
print(list(zip(a,b,c)))

Abaixo a resposta do programa.

[('UNIRIO', 'univesidade', 1), ('BSI', 'curso', 2), ('CCET', 'centro', 3)]

• __import__() – É chamada pela instrução de importação.

num = __import__('math')
print("pi = ", num.pi)

A resposta é:

pi =  3.141592653589793