

Seu próximo nível começa aqui
Com a Assinatura Ilimitada, você tem tudo que precisa para sua aprovação.
Com a Assinatura Ilimitada, você combina prática, teoria e método em uma única assinatura com tudo que você precisa para sua aprovação.
Considere o código escrito em linguagem Python abaixo
a = 10
b = 12
for i in range(b):
if i%3 :
a = a + 3
elif i%2 :
a = a + 2
else :
a = a + 1
print(a)
O valor da variável “a” exibido é
38
27
40
52
18
Considere o trecho de código abaixo escrito em Python (versão 3.11.3) para resposta da Questão 25.
cesta = [{
‘fruta ': 'abacaxi ',
‘quantidade ': 7,
'valor': 5.5
},{
'fruta': 'melancia',
'quantidade': 5,
'valor': 3.5
},{
'fruta': 'laranja',
'quantidade': 12,
'valor': 2.5
}]
A sintaxe correta para dobrar o valor da fruta abacaxi é
cesta[0]['valor'] *= 2.
cesta[1]['valor'] *= 2.
cesta['abacaxi']['valor'] *= cesta['abacaxi']['valor'].
cesta['abacaxi']['valor'] = cesta['abacaxi']['valor'] * 2.
Em Python, a execução dos seguintes comandos gera qual saída de dados?
s = 0
x = 1
while x < 10:
s = s + x
x = x + 1
print(s)
9
10
45
55
Observe o código a seguir.

Qual será a saída desse código Python?
Resultado inválido.
Resultado: Múltiplo de 3.
Resultado: Múltiplo de 5.
Resultado: Outro número.
De acordo com a documentação disponibilizada no site oficial da linguagem Python, indique a sentença VERDADEIRA.
A linguagem Python usa recuo para agrupamento de declarações porque Guido van Rossum acredita que o uso de chaves, colchetes ou das palavras reservadas BEGIN/END aumenta a quantidade de linhas do programa.
A linguagem de programação Python, a partir da versão 3.10, implementa a função hash especial para permitir aos usuários a utilização de chaves mutáveis em dicionários.
O método sort, executado em uma lista, por exemplo list.sort(), retorna a lista ordenada.
O emprego de dois pontos “:” é opcional para as instruções de if/while/def/class na linguagem Python a partir da versão 3.10.
As strings imutáveis possuem várias vantagens. Uma delas é o desempenho: saber que uma string é imutável significa que podemos alocar espaço para ela no momento da criação, e os requisitos de armazenamento são fixos e imutáveis.
Analise o código em Python a seguir.
def foo(x):
----return x + 1
def bar(x):
----return foo(x) * 2
print(bar(2))
O resultado exibido será
5
6
8
9
10
Observe o seguinte trecho de código escrito na linguagem Python
n = [1,2,3,4]
for i in range(len(n)//2):
n.append(n[2+i])
Os valores armazenados na variável n após a execução desse trecho de código serão:
[1,2,3,4,3,4]
[1,2,3,4,2,3]
[1,2,3,4]
[2,3,1,2,3,4]
[3,4,1,2,3,4]
Examine a lista abaixo.
L = [1, 2, 3, 4, 5, 6, 7 ]
Considerando a lista L de Python apresentada acima, assinale a opção que imprime os números [2,4,6] da lista.
[print(x) for x in L if x % 2 == 1]
[print(x) for x in L if x % 2]
[print(x) for x in L if x % 2 != 0]
[print(x) for x in L if not (x % 2 != 1 )]
[print(x) for x in L if not (x % 2)]
O método describe() da biblioteca Pandas retorna as linhas superiores e inferiores do DataFrame.
Certo
Errado
Um código escrito na linguagem Python é apresentado a seguir.
from enum import Enum
class Cor(Enum):
VERMELHO = 1
VERDE = 2
AZUL = 3
print(list(Cor))
É correto afirmar que o valor impresso será:
[3]
[Cor.VERMELHO, Cor.VERDE, Cor.AZUL]
[<Cor.VERMELHO: 1>, <Cor.VERDE: 2>, <Cor.AZUL: 3>]
[1, 2, 3]
[VERMELHO: 1, VERDE: 2, AZUL: 3]
Observe o seguinte trecho de código escrito na linguagem Python.
def f(n):
return lambda a : 1 + n
f1 = f(2)
f2 = f(3)
print(f1(3) + f2(1))
Analisando esse trecho de código é correto afirmar que ele irá imprimir o valor
7
5
12
4
14
Analise o código Python a seguir.
def calcula(n):
___return lambda x : x * n
fcalcula = calcula(3)
print(fcalcula(7))
Assinale o valor exibido pela execução desse código.
3
7
21
undefined
Utilizando a linguagem Python, e considerando a situação em que se deseja calcular e exibir a soma dos dez primeiros números inteiros positivos, assinale a alternativa que preenche corretamente as lacunas do código abaixo, respectivamente:
soma = 0
termo = 1
____ termo < = 10:
soma += termo
termo +=
1 print(____)
while; termo.
if; termo.
for; soma.
for; termo.
while; soma.
Pilhas podem ser implementadas em Python por meio de listas em que o último elemento é o topo da pilha, como no exemplo abaixo:
pilha01 = ['a4', 'a3', 'a2', 'a1'] # o elemento 'a1' está
# no topo da pilha
pilha02 = ['b2', 'b1'] # o elemento 'b1' está no topo da pilha
Considere uma função Python, chamada unifica, que recebe duas pilhas como parâmetros e retorna uma terceira, que é o resultado da intercalação dos elementos das duas pilhas recebidas como parâmetros. Um programa Python chamou essa função unifica, passando como parâmetros as duas pilhas do exemplo acima (pilha01 e pilha02). O resultado da intercalação foi a pilha
['a4', 'a3', 'b2', 'a2', 'b1', 'a1']
Qual implementação da função unifica realiza o que foi descrito acima?
def unifica(p1, p2):
p3 = [ ]
while len(p1) > 0:
p3.append(p1.pop())
while len(p2) > 0:
p3.append(p2.pop())
return p3
def unifica(p1, p2):
p3 = [ ]
while len(p1) > 0 and len(p2) > 0 :
p3.append(p1.pop())
p3.append(p2.pop())
return p3
def unifica(p1, p2):
p3 = [ ]
p4 = [ ]
while len(p1) > 0 and len(p2) > 0 :
p3.append(p1.pop())
p3.append(p2.pop())
while len(p3) > 0:
p4.append(p3.pop())
return p4
def unifica(p1, p2):
p3 = [ ]
p4 = [ ]
while len(p1) > 0 or len(p2) > 0 :
if len(p1) != 0:
p3.append(p1.pop())
if len(p2) != 0:
p3.append(p2.pop())
while len(p3) > 0:
p4.append(p3.pop())
return p4
def unifica(p1, p2):
p3 = [ ]
p4 = [ ]
while len(p1) != 0:
if len(p1) != 0:
p3.append(p1.pop())
while len(p2) != 0:
if len(p2) != 0:
p3.append(p2.pop())
while len(p3) > 0:
p4.append(p3.pop())
return p4
Python é uma linguagem de programação que possui as seguintes características: é uma linguagem de alto nível, orientada a objetos e interpretada de script, dentre outras. Sobre tal linguagem de programação, assinale a afirmativa correta.
Com exceção dos comentários funcionais, qualquer texto depois do # será ignorado até o fim da linha.
Os nomes de variáveis, em Python, são referências que não podem ser alteradas em tempos de execução.
Por padrão, a função print() remove os espaços entre as expressões que forem recebidas como parâmetro.
Os nomes das variáveis podem começar com uma letra ou com um número, com exceção do número 0 (zero).
Considere o trecho de código abaixo escrito na linguagem Python 3.x e a saída desejada a seguir:
CÓDIGO PYTHON | SAÍDA DESEJADA |
itens = ['item1', 'item2', 'item3'] precos = [3.50, 4.0, 5.80] # código para gerar o dicionario produtos ................. # fim do código print(produtos) | {'item1': 3.5, 'item2': 4.0, 'item3': 5.8} |
Assinale a alternativa que irá substituir o trecho “.................” com o código Python que irá executar corretamente para produzir a saída desejada:
produtos = {}
for x in itens:
----for y in precos:
-------produtos[x] = y
produtos = {}
for x in itens:
---for y in precos:
------produtos.update( { x : y })
produtos = {}
for x,y in zip(itens,precos):
---produtos.add(x[y])
produtos = { x:y for x,y in zip(itens,precos) }
produtos = {}
for x,y in zip(itens,precos):
---produtos[y] = x
A biblioteca NLTK (Natural Language Toolkit) engloba ferramentas para processamento de linguagem natural, tais como funções de tokenização e radicalização. Dessa forma, considerando o código apresentado:
frase = “Não esqueçam a lista de materiais:
1 lápis e 2 canetas!”
from nltk.tokenize import RegexpTokenizer
tokenizador = RegexpTokenizer(r’\w+’)
tokens = tokenizador.tokenize(frase)
print(tokens)
Qual o resultado correto?
[‘Não’, ‘esqueçam’, ‘a’, ‘lista’, ‘de’, ‘materiais’, ‘1’, ‘lápis’, ‘e’, ‘2’, ‘canetas’]
[‘Não’, ‘esqueçam’, ‘a’, ‘lista’, ‘de’, ‘materiais’, ‘lápis’, ‘e’, ‘canetas’]
[‘Não’, ‘esqueçam’, ‘a’, ‘lista’, ‘de’, ‘materiais’, ‘:’, ‘1’, ‘lápis’, ‘e’, ‘2’, ‘canetas’, ‘!’]
[‘Não’, ‘esqueçam’, ‘a’, ‘lista’, ‘de’, ‘materiais’, ‘:’, ‘lápis’, ‘e’, ‘canetas’, ‘!’]
Em Phyton, a variável de ambiente que tem como função forçar o Phyton a despejar o rastreamento — lista de chamadas que chegaram a um erro — em erros fatais denomina-se
PYTHONTRACEMALLOC.
PYTHONPROFILEIMPORTTIME.
PYTHONASYNCIODEBUG.
PYTHONMALLOC.
PYTHONFAULTHANDLER.
No uso da linguagem Python em modo interativo, inicia-se o interpretador Python e aguarda-se o prompt principal, >>>.
Quando você estiver usando Python como uma calculadora de mesa, qual o resultado da seguinte sequência de comandos (ou seja, qual o valor de????)?
>>>
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
????
100.50
12.5625
113.0625
12.5
113
Analise o código Python a seguir.
x = 0
y = 20
try:
print (y/x)
except:
print("Deu erro!")
else:
print("Ok")
finally:
print ("The end")
A saída produzida pela execução desse trecho é:
None
The end
Deu erro!
The end
Deu erro!
Ok
Ok
The end
None
Ok
The end