Lista 1 de Exercícios

August 12, 2021

1 Crie uma variável do tipo real, chamada val, que irá receber o
valor 5.2.
[1]: val = 5.2

2 Confira e imprima o tipo da variável criada no item anterior.

[2]: type(val)

[2]: float

[3]: print(val)

5.2

3 Dada a lista impares a seguir, faça os itens descritos:

[4]: impares = [1,3,5,7,9,11,13,15,17,19,21]
impares

[4]: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21]

3.1 Imprima o número 17 da lista impares.

[5]: for i in range(len(impares)):
if impares[i] == 17:
print (impares[i])
i += 1

17

3.2 Imprima a posição do número 19 na lista impares.

[6]: for i in range(len(impares)):
if impares[i] == 19:
print (i)
i += 1

1
 9

3.3 Imprima todos os elementos de impares com exceção do primeiro.

[7]: for i in range(1,len(impares)):
print(impares[i])
i += 1

3
5
7
9
11
13
15
17
19
21

3.4 Imprima todos os elementos de impares com exceção do primeiro e do

último.
[8]: for i in range(1,len(impares)-1):
print(impares[i])
i += 1

3
5
7
9
11
13
15
17
19

3.5 Elabore um meio de imprimir o comprimento de impares, ou seja, quantos

elementos impares contém (sem usar a função len).
[9]: contador = 0
while(id(impares[contador]) != id(impares[-1])):
contador += 1
print (contador+1)

11

2
 3.6 Faça o somatório de todos os elementos de impares (sem usar a função sum).
[10]: soma = 0
for i in range(len(impares)):
soma += impares[i]
print (soma)

121

3.7 Imprima os elementos máximo e mínimo de impares (sem usar as funções

max e min).
[11]: maximo = None
minimo = None
i = 0
while(i < len(impares)):

if maximo == None:
maximo = impares[i]
if impares[i] > maximo:
maximo = impares[i]

if minimo == None:
minimo = impares[i]
if impares[i] < minimo:
minimo = impares[i]

i += 1

print(maximo,minimo)

21 1

3.8 Adicione o número 23 à lista impares.

[12]: impares.append(23)

3.9 Delete o elemento 5 de impares.

[13]: impares.pop(4)

[13]: 9

3
 4 Crie um vetor chamado vet com elementos aleatórios inteiros de
comprimento 50.
[14]: import random as rd
import numpy as np

vet = np.zeros(50)
for i in range (len(vet)):
vet[i] = rd.randint(0,9)
i += 1

4.1 Calcule:
4.1.1 somatório de vet
[15]: def sum_vetor(vet):
soma = 0

for i in range (len(vet)):

soma = vet[i] + soma
i += 1
return soma

[16]: sum_vetor(vet)

[16]: 226.0

[17]: np.sum(vet)

[17]: 226.0

4.1.2 variância de vet

[18]: def media(vet):

return sum_vetor(vet)/len(vet)

def variancia (vet):

somatorio = 0

4
 for i in range(len(vet)):
somatorio += ((vet[i]- media(vet))**2)

return somatorio/len(vet)

[19]: variancia(vet)

[19]: 7.689600000000001

[20]: np.var(vet)

[20]: 7.689600000000001

4.1.3 desvio padrão de vet

[21]: def desvio_padrao(vet):

return +(variancia(vet)**(1/2)),-(variancia(vet)**(1/2))

[22]: desvio_padrao(vet)

[22]: (2.7730128019899225, -2.7730128019899225)

[23]: np.std(vet)

[23]: 2.7730128019899225

4.1.4 médida de vet

[24]: np.mean(vet)

[24]: 4.52

[25]: media(vet)

[25]: 4.52

4.1.5 moda de vet

[26]: def moda(vet):
quantidade_aparencias = np.zeros(len(vet))

## marcando no vetor quantidade, as de aparências de um número

for i in range(len(vet)):
for j in range(len(vet)):
if vet[i] == vet[j]:
quantidade_aparencias[i] = quantidade_aparencias[i] + 1

5
## verificando se há moda

if (sum_vetor(quantidade_aparencias)==len(vet)):
return (print("Não há moda"))

## colhendo a maior quantidade de aparencias

else:
i = 0
maior = None
while(i < len(quantidade_aparencias)):

if maior == None:
maior = int(quantidade_aparencias[i])
if int(quantidade_aparencias[i]) > maior:
maior = int(quantidade_aparencias[i])
i += 1

## verificar se há vetores com a mesma quantidade de aparições entre a moda

contador = 0
for i in range(len(quantidade_aparencias)):
if maior == quantidade_aparencias[i]:
contador +=1

## calculando a quantidade de modas

duplicatas = int(contador/maior)
moda = np.zeros(duplicatas)
k = 0

for i in range(len(quantidade_aparencias)):
if maior == quantidade_aparencias[i]:

b = False

for j in range(duplicatas):
if vet[i] == moda[j]:
b = True

if b == False:
moda[k] = vet[i]
k = k + 1
return print(moda)

6
[27]: moda(vet)

[5.]

[28]: from scipy import stats

stats.mode(vet)

[28]: ModeResult(mode=array([5.]), count=array([8]))

5 Crie uma função que receba uma lista de números e retorne

somente os números pares contidos na lista.
[29]: def retorna_par(lista):
lista2 =[]
for i in range(len(lista)):
if lista[i]%2 == 0:
lista2.append(lista[i])
return lista2

[30]: lista = [1,2,3,4,5,6,7,8,9,10]

[31]: retorna_par(lista)

[31]: [2, 4, 6, 8, 10]

6 Crie uma função que recebe o raio de um círculo e retorna a

área do mesmo.
[32]: def area_circular(raio):
return 3.14*raio**2

7 Programe o método da bisseção para calcular as raízes da

seguinte equação:
f (x) = x3 − x − 2

Consulte o material disponibilizado na página EAD da turma.

[33]: def f(x):

return x**3 -x -2

7
 def metodo_da_bi(f,a,b,erro):

if f(a)*f(b) < 0:
while(abs((b-a)/2) > erro):
c = (a+b)/2

if f(c) == 0:
return c

else:
if f(a)*f(c) < 0:
b = c
else:
a = c
return c
else:
print('Não há como estimar raizes nesse intervalo')

metodo_da_bi(f,-2,2,0.00000001)

[33]: 1.5213796943426132

8 Calcule as raízes da função anterior, porém usando a função

fsolve da biblioteca scipy.
[34]: from scipy.optimize import fsolve
raizes = fsolve(f,5)
raizes

[34]: array([1.52137971])

[35]: np.isclose(f(raizes), np.zeros(len(raizes)))

[35]: array([ True])

9 Programe o método da secante para calcular as raízes da função:

f (x) = x3 − 10x2 − 400

considere uma tolerância igual a 0.0001

[36]: def f(x):

return x**3 -10*x**2 -400

8
 def metodo_secante(f,x0,x1,tolerancia):
x = []
n = 0
x.append(x0)
x.append(x1)

while( abs(f(x[n]) - 0.0) > tolerancia):

x.append(x[n+1] - ((x[n+1] - x[n])/(f(x[n+1])-f(x[n])))*f(x[n+1]))

n += 1
return x[n+1]

metodo_secante(f,0,0.1,0.0001)

[36]: 12.54262834379815

10 Calcule as raízes da função anterior, porém usando a função

fsolve da biblioteca scipy.
[37]: raizes = fsolve(f,20)
raizes

[37]: array([12.54262834])

[38]: np.isclose(f(raizes), np.zeros(len(raizes)))

[38]: array([ True])