Colabore! Saiba mais screen_rotation

Ao navegar por este site , você concorda com a Política de Uso de Dados.

| | | | |

2 Linguagem de Programação 2.3 Dados 2.5 Dados Booleanos

2.4 Dados Numéricos e Operações

Compre o e-book deste material aqui!

Números são tipos de dados usualmente manipulados em programas de computador. Números inteiros e não inteiros são tratados de forma diferente. Mas, antes de discorrermos sobre essas diferenças, vamos estudar operadores numéricos básicos.

Operações Numéricas Básicas

As seguintes operações numéricas estão disponíveis na linguagem Python:

•

+ adição

⬇

11 + 2
```
3
```
•

- subtração

⬇

11 - 2
```
-1
```
•

* multiplicação

⬇

12*3
```
6
```
•

/ divisão

⬇

15/2
```
2.5
```
•

** potenciação

⬇

12**3
```
8
```
•

// divisão inteira

⬇

15//2
```
2
```
•

% resto da divisão

⬇

15 % 2
```
1
```

A ordem de precedência das operações deve ser observada em Python. Uma expressão é executada da esquerda para a direita, mas os operadores tem a seguinte precedência¹⁰¹⁰endnote: ¹⁰Consulte na web a lista completa de operadores e suas precedências em The Python Standard Library: Expressions: Operator precedence.:

1.

**
2.

-x (oposto de x)
3.

*, /, //, %
4.

+, -

Utilizamos parênteses para impor uma precedência diferente, i.e. expressões entre parênteses () são executadas antes das demais.

Exemplo 2.4.1.

Estudamos a seguinte computação:

⬇

12+8*3/2**2-1

7.0

Uma pessoa desavisada poderia pensar que o resultado está errado, pois

	$\displaystyle 2+8=10,$		(2.13)
	$\displaystyle 10\cdot 3=30,$		(2.14)
	$\displaystyle 30\div 2=15,$		(2.15)
	$\displaystyle 15^{2}=225,$		(2.16)
	$\displaystyle 225-1=224.$		(2.17)

Ou seja, o resultado não deveria ser $224$ ? Não, em Python, a operação de potenciação ** tem a maior precedência, depois vem as de multiplicação * e divisão / (com a mesma precedência, sendo que a mais a esquerda é executada primeiro) e, por fim, vem as de adição + e subtração - (também com a mesma precedência entre si). Ou seja, a instrução acima é computada na seguinte ordem:

	$\displaystyle 2^{2}=4,$		(2.18)
	$\displaystyle 8\cdot 3=24,$		(2.19)
	$\displaystyle 24\div 4=6,$		(2.20)
	$\displaystyle 2+6=8,$		(2.21)
	$\displaystyle 8-1=7.$		(2.22)

Para impormos uma ordem diferente de precedência, usamos parêntese. No caso acima, escrevemos

⬇

1((2 + 8)*3/2)**2 - 1

224.0

Observação 2.4.1.

(Espaços entre Operandos.) O uso de espaços entre os operandos, em geral, é arbitrário, mas conforme utilizados podem dificultar a legibilidade do código. Por exemplo,

⬇

12 *- 3 + 2

-4

Essa expressão é computada na seguinte ordem

	$\displaystyle-\leavevmode\nobreak\ 3=-3$		(2.23)
	$\displaystyle 2\cdot(-3)=-6$		(2.24)
	$\displaystyle-6+2=-4.$		(2.25)

Observamos que ela seria melhor escrita da seguinte forma

⬇

12*-3 + 2

-4

2.4.1 Números Inteiros

Em Python, números inteiros são alocados por registros com um número arbitrário de bits. Com isso, os maior e menor números inteiros que podem ser alocados dependem da capacidade de memória da máquina. Quanto maior ou menor o número inteiro, mais bits são necessários para alocá-lo.

Exemplo 2.4.2.

O método Python sys.getsizeof retorna o tamanho de um objeto medido em bytes ( $1\leavevmode\nobreak\ \textit{byte}=8\leavevmode\nobreak\ \textit{bits}$ ).

⬇

1import sys

2print('0:',sys.getsizeof(0),'B')

3print('1:',sys.getsizeof(1),'B')

4print('100:',sys.getsizeof(100),'B')

5print('10**9:',sys.getsizeof(10**9),'B'))

6print('10**10:',sys.getsizeof(10**10),'B'))

7print('10**100:',sys.getsizeof(10**100),'B'))

0: 24 B
1: 28 B
100: 28 B
10**9: 28 B
10**10: 32 B
10**100: 72 B

O número googol $10^{100}$ é um número grande¹¹¹¹endnote: ¹¹Por exemplo, o número total de partículas elementares em todo o universo observável é estimado em $10^{80}$ . Fonte: Wikipedia: Eddington number., mas $72$ bytes não necessariamente. Um computador com $4$ Gbytes¹²¹²endnote: ¹² $1\leavevmode\nobreak\ \textit{Gbytes}=1024\leavevmode\nobreak\ \textit{Mbytes}$ , $1\leavevmode\nobreak\ \textit{Mbytes}=1024\leavevmode\nobreak\ \textit{Kbytes}$ , $1\leavevmode\nobreak\ \textit{Kbytes}=1024\leavevmode\nobreak\ \textit{bytes}$ . livres de memória, poderia armazenar um número inteiro que requer um registro de até $4,3\times 10^{9}\leavevmode\nobreak\ \textit{bytes}$ .

Observação 2.4.2.

O método Python type retorna o tipo de objeto alocado. Números inteiros são objetos da classe int.

⬇

1type(10)

<class ’int’>

2.4.2 Números Decimais

No Python, números decimais são alocados pelo padrão IEEE 774 de aritmética em ponto flutuante. Em geral, são usados $64\leavevmode\nobreak\ \textit{bits}=8\leavevmode\nobreak\ \textit{bytes}$ para alocar um número decimal. Um ponto flutuante tem a forma

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}x=\pm m\cdot 2% ^{c-1023},

(2.26)

onde $m\in[1,2)$ é chamada de mantissa e $c\in[0,2047]$ é um número inteiro chamado de característica do ponto flutuante. A mantissa usa $52\leavevmode\nobreak\ \textit{bits}$ , a característica $11\leavevmode\nobreak\ \text{bits}$ e $1\leavevmode\nobreak\ \textit{bit}$ é usado para o sinal do número.

⬇

1import sys

2sys.float_info

sys.float_info(max=1.7976931348623157e+308,
              max_exp=1024,
              max_10_exp=308,
              min=2.2250738585072014e-308,
              min_exp=-1021,
              min_10_exp=-307,
              dig=15,
              mant_dig=53,
              epsilon=2.220446049250313e-16,
              radix=2,
              rounds=1)

Vamos denotar fl(x) o número em ponto flutuante mais próximo do número decimal x dado. Quando digitamos

⬇

1x = 0.1

O valor alocado na memória da máquina não é 0.1, mas, sim, o valor de fl(x). Normalmente, o épsilon de máquina $\varepsilon=2,22\times 10^{-16}$ é uma boa aproximação para o erro¹³¹³endnote: ¹³Erro relativo. (de arredondamento) entre x e fl(x).

Notação Científica

A notação científica é a representação de um dado número na forma

d_{n}\ldots d_{2}d_{1}d_{0},d_{-1}d_{-2}d_{-3}\ldots\times 10^{E},

(2.27)

onde $d_{i}$ , $i=n,\ldots,1,0,-1,\ldots$ , são algarismos da base 10. A parte à esquerda do sinal $\times$ é chamada de mantissa do número e $E$ é chamado de expoente (ou ordem de grandeza).

Exemplo 2.4.3.

O número $31,415$ pode ser representado em notação científica das seguintes formas

$\displaystyle 31,415\times 10^{0}$	$\displaystyle=3,1415\times 10^{1}$	(2.28)
	$\displaystyle=314,15\times 10^{-1}$	(2.29)
	$\displaystyle=0,031415\times 10^{3},$	(2.30)

entre outras tantas possibilidades.

Em Python, usa-se a letra e para separar a mantissa do expoente na notação científica. Por exemplo

⬇

1# 31.415 X 10^0

231.415e0

  31.515

⬇

1# 314.15 X 10^-1

2314.15e-1

31.515

⬇

1# 0.031415 X 10^3

20.031415e3

31.515

No exemplo anterior (Exemplo 2.4.3), podemos observar que a representação em notação científica de um dado número não é única. Para contornar isto, introduzimos a notação científica normalizada, a qual tem a forma

d_{0},d_{-1}d_{-2}d_{-3}\ldots\times 10^{E},

(2.31)

com $d_{0}\neq 0$ ¹⁴¹⁴endnote: ¹⁴No caso do número zero, temos $d_{0}=0$ ..

Exemplo 2.4.4.

O número $31,415$ representado em notação científica normalizada é $3,1415\times 10^{1}$ .

Em Python, podemos usar de especificação de formatação¹⁵¹⁵endnote: ¹⁵Consulte Subseção 2.6.1 para mais informações. para imprimir um número em notação científica normalizada. Por exemplo, temos

⬇

1x = 31.415

2print(f'{x:e}')

3.141500e+01

2.4.3 Números Complexos

Python tem números complexos como uma classe básica da linguagem. O número imaginário $i:=\sqrt{-1}$ é representado por 1j. Temos

⬇

11j**2

(-1+0j)

Ou seja, $i^{2}=-1+0i$ . Aritmética de números completos está diretamente disponível na linguagem.

Exemplo 2.4.5.

Estudamos os seguintes casos:

a)

$-3i+2i=-i$

⬇

1-3j + 2j
```
-1j
```
b)

$(2-3i)+(4+i)=6-2i$

⬇

12-3j + 4+1j
```
(6-2j)
```
c)

$(2-3i)\cdot(4+i)=11-10i$

⬇

1(2-3j)*(4+1j)
```
(11-10j)
```

2.4.4 Exercícios

E. 2.4.1.

Complete as lacunas.

a)

** é o operador de potenciação.
b)

A computação 2+2*3 resulta 8.
c)

A computação 10-6/2 resulta 7.
d)

A computação 3**2*3 resulta 27.
e)

A computação 1-34/2*3 resulta 50.

Resposta.

a) **. b) 8. c) 7. d) 27. e) 50.

E. 2.4.2.

Desenvolva um código Python para computar a interseção com o eixo das abscissas da reta de equação

y=2ax-b.

(2.32)

Em seu código, aloque $a=2$ e $b=8$ e então compute o ponto de interseção $x$ . Em seguida, teste seu código com outros valores possíveis de $a$ e $b$ .

Resposta.

⬇

1a = 2

2b = 8

3x = b/(2*a)

4print("x = ", x)

E. 2.4.3.

Assuma que o seguinte código Python

⬇

1a = 2

2b = 8

3x = b/2*a

4print("x = ", x)

tenha sido desenvolvido para computar o ponto de interseção com o eixo das abscissas da reta de equação

y=2ax-b

(2.33)

com $a=2$ e $b=8$ . O código acima contém um erro, qual é? Identifique-o, corrija-o e justifique sua resposta.

Resposta.

Erro na linha 3. As operações não estão ocorrendo na precedência correta para fazer a computação desejada. Correção: x = b/(2*a).

E. 2.4.4.

Desenvolva um código Python para computar a média aritmética entre dois números $x$ e $y$ dados. Teste seu código para diferentes valores de $x$ e $y$ .

Resposta.

⬇

1x = 3

2y = 9

3media = (x + y)/2

4print('média = ', media)

E. 2.4.5.

Uma disciplina tem o seguinte critério de avaliação:

1.

Trabalho: nota com peso 3.
2.

Prova: nota com peso 7.

Desenvolva um código Python que compute a nota final, dadas as notas do trabalho e da prova (em escala de $0-10$ ) de um estudante. Teste seu código para diferentes valores de notas.

Resposta.

⬇

1notaTrabalho = 8.5

2notaProva = 7

3notaFinal = (notaTrabalho*3 + notaProva*7)/10

4print('Nota final = ', notaFinal)

E. 2.4.6.

Desenvolva um código Python para computar as raízes reais de uma equação quadrática

ax^{2}+bx+c=0.

(2.34)

Assuma dados os parâmetros $a=2$ , $b=-2$ e $c=-12$ . Em seguida, teste seu código para diferentes valores dos parâmetros $a$ , $b$ e $c$ .

Resposta.

⬇

1a = 2

2b = -2

3c = -12

4delta = b**2 - 4*a*c

5x1 = (-b - delta**(1/2))/(2*a)

6print('x1 = ', x1)

7x2 = (-b + delta**(1/2))/(2*a)

8print('x2 = ', x2)

E. 2.4.7.

Encontre a quantidade de memória disponível em seu computador. Quantos números decimais em ponto flutuante de $64$ -bits seu programa poderia alocar, caso conseguisse usar toda a memória disponível no momento?

Resposta.

Cada $1$ GBytes livre permite alocar aproximadamente $10^{8}$ números decimais.

E. 2.4.8.

Escreva os seguintes números em notação científica normalizada e entre com eles em um terminal Python:

a)

$700$
b)

$0,07$
c)

$2800000$
d)

$0,000019$

Resposta.

a) $7\times 10^{2}$ , 7e2; b) $7\times 10^{-2}$ , 7e-2; c) $2,8\times 10^{6}$ , 2.8e6; d) $1.9\times 10^{-5}$ , 1.9e-5

E. 2.4.9.

Escreva os seguintes números em notação decimal:

1.

$2,8\times 10^{-3}$
2.

$8,712\times 10^{4}$
3.

$3,\overline{3}\times 10^{-1}$

Resposta.

a) $0.0028$ ; b) $87120$ ; c) $0,\overline{3}$

E. 2.4.10.

Faça os seguintes cálculos e, então, verifique os resultados computando-os em Python:

1.

$5\times 10^{3}+3\times 10^{2}$
2.

$8,1\times 10^{-2}-1\times 10^{-3}$
3.

$\left(7\times 10^{4}\right)\cdot(2\times 10^{-2})$
4.

$\left(7\times 10^{-4}\right)\div(2\times 10^{2})$

Resposta.

a) $5,3\times 10^{3}$ ;

⬇

1x = 5e3 + 3e2

2print(f'{x:e}')

b) $8\times 10^{-2}$

⬇

1x = 8.1e-2 - 1e-3

2print(f'{x:e}')

c) $1,4\times 10^{3}$

⬇

1x = 7e4 * 2e-2

2print(f'{x:e}')

d) $3,5\times 10^{-6}$

⬇

1x = 7e-4 / 2e2

2print(f'{x:e}')

E. 2.4.11.

Faça os seguintes cálculos e verifique seus resultados computando-os em Python:

1.

$(2-3i)+(2-i)$
2.

$(1+2i)-(1-3i)$
3.

$(2-3i)\cdot(-4+2i)$
4.

$(1-i)^{3}$

Resposta.

a) $3+7i$

⬇

1(1+8j) + (2-1j)

b) $5i$

⬇

1(1+2j) - (1-3j)

c) $-2+16i$

⬇

1(2-3j) * (-4+2j)

d) $-2-2i$

⬇

1(1-1j)**3

E. 2.4.12.

Desenvolva um código Python que computa a área de um quadrado de lado $l$ dado. Teste-o com $l=0,575$ e assegure que seu código forneça o resultado usando notação científica.

Resposta.

⬇

1lado = 0.575

2area = lado**2

3print(f'área = {area:e}')

E. 2.4.13.

Desenvolva um código Python que computa o comprimento da diagonal de um quadrado de lado $l$ dado. Teste-o com $l=2$ e assegure que seu código forneça o resultado em notação científica normalizada.

Resposta.

⬇

1lado = 2

2diag = lado*2**(1/2)

3print(f'diagonal = {diag:e}')

E. 2.4.14.

Assumindo que $a_{1}\neq a_{2}$ , desenvolva um código Python que compute o ponto $(x_{i},y_{i})$ que corresponde a interseção das retas de equações

	$\displaystyle y=a_{1}x+b_{1}$		(2.35)
	$\displaystyle y=a_{2}x+b_{2},$		(2.36)

para $a_{1}$ , $a_{2}$ , $b_{1}$ e $b_{2}$ parâmetros dados. Teste-o para o caso em que $a_{1}=1$ , $a_{2}=-1$ , $b_{1}=1$ e $b_{2}=-1$ . Garanta que seu código forneça a solução usando notação científica normalizada.

Resposta.

⬇

1# parâmetros

2a1 = 1

3a2 = -1

4b1 = 1

5b2 = -1

6# ponto x de interseção

7x_intercep = (b2-b1)/(a1-a2)

8# ponto y de interceção

9y_intercep = a1*x_intercep + b1

10# imprime o resultado

11print(f'x_i = {x_intercep:e}')

12print(f'y_i = {y_intercep:e}')

Envie seu comentário

As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a Política de Uso de Dados para mais informações. Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

| | | |