04 - Programação Básica.ipynb

Kernel: SageMath (system-wide)

Programação Básica

A sintaxe do Sage é baseada na linguagem do Python e, assim, herda o estilo compacto e muito legível do Python. Neste tutorial, vamos apresentar a sintaxe para o essencial da programação.

3.1 Estruturas Básicas

Listas

Uma lista é uma coleção ordenada de objetos. Os elementos de uma lista são indexados pelos inteiros, começando por 0 . Aqui está um exemplo rápido de como construir uma lista e acessar seus elementos.

L = [ 1,2 ,3,4, 5, 6, 7,8,9]; L

[1, 2, 3, 4, 5, 6, 7, 8, 9]

L[0] # primeiro elemento

1

L[1] # segundo elemento

2

L[-1] # ultimo elemento

9

Como dissemos acima, listas são listas de objetos, logo podemos ter listas de listas:

LL = [ [ 1,2], [2, 3], [4, 5]]
LL[0]

[1, 2]

LL[0][0] # primeiro da primeira lista

1

LL[-1][-1] # ultimo elemento da ultima lista

5

Sublistas

Uma caracteristica das listas em Python é a possibilidade de obter sublistas um por fatiamento (slice).

L[0: 3]    # L[inicial: final + 1]

[1, 2, 3]

L[3:]      # Todos a partir do indice 3

[4, 5, 6, 7, 8, 9]

L[3:7]    # L[inicial: final + 1]

[4, 5, 6, 7]

Gerando Listas

Como eles são usados com bastante freqüência, Sage oferece uma maneira conveniente de criar listas de números consecutivos.

[0..9]   # inteiros

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[0,1/4..1] # racionais

[0, 1/4, 1/2, 3/4, 1]

[0,0.2..1] # floats

[0.000000000000000,
 0.200000000000000,
 0.400000000000000,
 0.600000000000000,
 0.800000000000000,
 1.00000000000000]

Outras outras possibilidades:

range(9)      # lista de inteiros

[0, 1, 2, 3, 4, 5, 6, 7, 8]

srange(0, 1, 1/4, include_endpoint=True)   # lista de QQ or RR

[0, 1/4, 1/2, 3/4, 1]

srange(0,1, 0.2)

[0.000000000000000,
 0.200000000000000,
 0.400000000000000,
 0.600000000000000,
 0.800000000000000]

3.2 Condicionais

Uma declaração condicional é o que usamos quando queremos que nosso código tome decisões. Por exemplo, suponha que queremos dividir um número por 2 apenas se for par. Nós podemos fazer isso em Sage usando uma instrução $\textbf{if}$.

n=44
if n%2==0:
    print n/2

22

n=35
if n%2==0:
    print n/2

Às vezes, é necessário verificar se a nossa expressão satisfaz mais de uma condição. Para fazer isso, use a declaração $\textbf{elif}$ , que é uma abrevição do if-else.

k=35
if k%3==0:
    print k/3
elif k%5==0:
    print k/5

7

Os testes são avaliados em ordem e, uma vez que o primeiro é cumprido, o código associado é executado e o Sage encerra a execução.

k=6
if k%2==0:
    print k/2
elif k%3==0:
    print k/3
elif k%5==0:
    print k/5

3

Note acima que para k=6, as consições 1 e 2 são atendidas mas o Sage executa o código contido apenas na primeira condição.

3.3 Laço for

Um laço $\textbf{for}$, repetidamente, executa um bloco de código um número fixo de vezes. Veja um simples exemplo.

for n in [0..10]:
    print n

0
1
2
3
4
5
6
7
8
9
10

A seguir vamos imprimir números contidos em uma lista que são primos:

for n in range(100):
    if is_prime(n):
        print n

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

Agora vamos somar todos os primos de 0 até 100.

soma = 0
for n in range(100):
    if is_prime(n):
        soma = soma + n
print soma

1060

3.4 Laço While

Essencialmente, um loço $\textbf{while}$ executa um bloco de código enquanto uma condição ainda está satisfeita. Para exemplificar vamos calcular a soma dos primos entre 0 e 100.

n = 0
while n <100:
    if is_prime(n):
        print n
    n=n+1

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

soma = 0
n = 0
while n <100:
    if is_prime(n):
            soma = soma + n
    n+=1
print soma

1060

Exemplos Avançados

Calcula a soma dos primos menores que 100, até que a soma seja menor que 700.

soma = 0
for n in range(100):
     if is_prime(n):
            if soma+n < 700:            
                
                soma= soma + n
                
                
print soma

639

Quais são os primos menores que 100 cuja soma é menor que 700?

soma = 0
primos = [] # lista vazia
for n in range(100):
     if is_prime(n):
            if soma+n < 700:
                soma= soma + n
                primos.append(n)
            
              
print soma
print primos

639
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]

3.5 Compreensão de lista ( Laços em listas)

Uma técnica particularmente útil em python (e Sage por extensão) é a construção de listas usando compreensões de lista . Esse recurso é muito parecido com a notação do construtor definido que usamos em matemática. Por exemplo, o conjunto de inteiros pares pode ser escrito como: $$\{2\cdot k \,\,|\,\,\, k \in \mathbb{Z}\}$$. Com o Sage podemos contruir parte desse conjunto usando uma sintaxe similar. A seguir contruimos a lista com inteiros pares de 0 até 20.

[ 2*k for k in [0..10]]

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Agora, vamos voltar aos números primos e obter, usando compreensão, a lista dos prmos menos que 100. Os passos a seguir é chamado de filtro de lista.

[n for n in [0..100] if is_prime(n)]

Obterndo a soma de todos os primos menores que 100.

sum([n for n in [0..100] if is_prime(n)])

Para construir a lista de todos os números naturais que são menores do que 20 tais que $mdc(k,20)=1$.

[k for k in [1..19] if gcd(k,20)==1]

Pareando listas obtidas por compreensão.

A = srange(0,2*pi, pi/4)
B = [sin(i) for i in A]
AxB = zip(A,B) # pareamento de listas
show(AxB)

3.6 Criando suas Funções

Uma vez que seus cálculos se complicarem o suficiente, talvez queiramos esconder parte dessa complexidade criando seu próprio comando que possa ser facilmente reutilizado, como os comandos internos da Sage. Esses comandos definidos pelo usuário são comumente chamados de funções , embora diferem das funções matemáticas.

def soma_quadrados(a,b):
    
    c = a^2 + b^2
    
    return c

soma_quadrados(3,4)

Sequência de Fibonacci definada recursivamente por $$F_n = F_{n-1} + F_{n-2}, \quad F_1=F_2=1.$$

Para obter seus elementos podemos fazer:

def fib(n):
    if n==0:
        return 0
    elif n<=2:
        return 1
    else:
        return fib(n-1)+ fib(n-2)

fib(3)

fib(20)

Gerando uma lista com 10 temos da sequência de fibonacci:

[fib(n) for n in [0..10]]

3.7 Exercícios

1. Escreva um procedimento que retorne o sinal de um número real. Ou seja, use O Sage para representar a função $$\mathrm{sgn}(x)=\begin{cases}

   • 1 & \quad \text{se } x> 0,\ 0 & \quad \text{se } x=0,\

   • 1 & \quad \text{se} ,x<0.\ \end{cases} $$

2. Usando um laço, calcule o somatório: $\displaystyle\sum_{n=1}^{10}\displaystyle\frac{1}{n^2}$.

3. O fatorial de um número natural $n$ é definido recursivamente por: $$F_n = n \cdot F_{n - 1} , \qquad F(0) = 1 \quad e \quad F(1) = 1.$$ Crie uma função que calcule o fatorial de um número natural n.

4. Crie lista para representar o conjunto $$A=\{x^2,\forall x \in \mathbb{N};\, 100< x^2< 1000\}.$$

5. Vamos criar uma função para calcular uma aproximação para a função seno usando a Série de Taylor: $x - \frac{x^{3}}{3!} + \frac{x^{5}}{5!} - \frac{x^{7}}{7!}+ \dots$ Incluindo todos os termos da série até que $$\left|\displaystyle \frac{\left(-1\right)^{n} x^{2 \, n + 1}}{\left(2n + 1\right)!}\right|<\epsilon .$$ A constante $\epsilon$ é o erro de aproximação predefinido.

def seno_taylor(x, epsilon= 0.000001):
    x = RR(x)
    soma = 0
    n = 0
    while True:
        parcela = (-1)^n*x^(2*n+1)/ factorial(2*n+1)
        soma = soma + parcela
        if abs(parcela)< epsilon:
            break
        n=n+1
    return round(soma, 4)

seno_taylor(2)

N(sin(2))