2 - TIPOS-DE-DADOS.sagews

TIPOS DE DADOS

String

Strings são seqüências de caracteres, sejam eles letras, números, espaços, caracteres especiais, e etc., e assim como os tipos numéricos vistos anteriormente, strings também são imutáveis. Strings podem ser delimitadas por aspas simples, duplas ou triplas.

string1 = "sagemath"
string2 = 'sagemath'
string3 = '''sagemath'''

string1 ; string2 ; string3

'sagemath' 'sagemath' 'sagemath'

Strings podem ser unidas (concatenadas) utilizando o operador de adição concatenação ( + ).

string4 = 'sage ' + "MATH"
string4

'sage MATH'

Assim como listas e tuplas, strings também são sequências, portanto, podemos utilizar as mesmas funcionalidades de indexação e fatiamento destes elementos.

# fatiamento
show(string4)

string4.split('sage') ; string4.split('ge')

sage MATH

['', ' MATH'] ['sa', ' MATH']

# Caixa alta e caixa baixa
show(string4)
string4.upper() ; string4.lower()

sage MATH

'SAGE MATH' 'sage math'

# troca de caixa entre as strings
string4.swapcase()

'SAGE math'

# elemento a partir do parametro indice passado como valor
string4[0] ; string4[1] ; string4[2] ; string4[3]

's' 'a' 'g' 'e'

Constantes

pi; e

pi e

Variáveis

O Python é uma linguagem de tipagem dinâmica, dessa form uma variável possui um valor associado enquanto durar o processamento e pode variar em tempo e execução. Para associar o valor a uma variável, basta utiliza "=". Para eliminar o valor de uma variável, use reset() para todas as variáveis ou reset("var1,var2...") para variáveis específicas.

x = 5

y = 10.1

z = 1/2

x ; y ; z

5 10.1000000000000 1/2

# OU

print(x, y, z)

(5, 10.1000000000000, 1/2)

x + y + z

15.6000000000000

• Verificar o tipo da variável criada

type(x) ; type(y) ; type(z)

<type 'sage.rings.integer.Integer'> <type 'sage.rings.real_mpfr.RealLiteral'> <type 'sage.rings.rational.Rational'>

#Verficar se um o valor de uma variável é primo
x.is_prime()

True

• Impressão de valores de variáveis com print e show semelhante ao fprint do MatLab

%d	Inteiro
%f	Ponto flutuante
%s	String
%r	Racionais
%e	Notação exponencial. Imprime o número em notação científica
%%	Porcentagem.

var = 10

print('valor de var é: %d' % var)

valor de var é: 10

var1 = 2/3
var2 = 0.3
var3 = 'texto'

print('valor de var1, var2 e var3 são: %r , %f e %s' % (var1,var2,var3))

valor de var1, var2 e var3 são: 2/3 , 0.300000 e texto

• ** Variáveis criadas**

ATENÇÃO! "==" siginifica IGUAL e não uma atribução! Dessa forma x==5 realiza um teste lógico perguntando se o valor da variável X é igual a 5. Se correto imprime true.

x  5

True

• Resetar variáveis

Para resetar apenas uma variável reset('variável')

var = 10

var + 2

12

reset('var')

Após resetar uma variável, qualquer operação com a variável var ocorrerá erro

var + 2

Error in lines 1-1 Traceback (most recent call last): File "/projects/sage/sage-6.10/local/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> File "sage/structure/element.pyx", line 1651, in sage.structure.element.RingElement.__add__ (/projects/sage/sage-6.10/src/build/cythonized/sage/structure/element.c:15852) return coercion_model.bin_op(left, right, add) File "sage/structure/coerce.pyx", line 1069, in sage.structure.coerce.CoercionModel_cache_maps.bin_op (/projects/sage/sage-6.10/src/build/cythonized/sage/structure/coerce.c:9736) raise TypeError(arith_error_message(x,y,op)) TypeError: unsupported operand parent(s) for '+': '<type 'function'>' and 'Integer Ring'

Listas

Método	Parâmetros	Descrição
append	item	Acrescenta um novo item no final da lista
insert	posição, item	Insere um novo item na posição dada
pop	nenhum	Remove e returno o último item
pop	posição	Remove e retorna o item da posição.
sort	nenhum	Ordena a lista
reverse	nenhum	Ord

• Criar uma lista

Para criar uma lista podemos usar os comandos:

varivel = [elementos/lista]

Sendo elementos o tipo de dados e lista uma lista de elementos de tipo de tados homogêneo ou heterogêneio

a = []                     # lista vazia

b = [1,'sage','math']    # lista heterogênea

c = [1,['a','b'],10]       # lista aninhada

a ; b ; c

[] [1, 'sage', 'math'] [1, ['a', 'b'], 10]

• Quantidade de elementos de uma lista ou tamanho da lista

Uma lista é um conjunto de elementos e dessa forma é possível obter o tamanho ou quantidade de elentos de uma lista com o comando:

len(lista)

len(a) ; len(b) ; len(c)

0 3 3

• Acesso e alteração de elementos de uma lista

Para acessar o valor de um emento de uma lista temos o comando:

lista[indice_lista]

Python/Sage utilizar indexação a partir de 0, logo a indexação dos elementos segue a lógica:

elementos lista: [1, 2, 3, 4 ]
indice elemento:  0, 1, 2, 3

o primeiro elemento será lista[0] o segundo lista[1] e assim por diante

# acessando o elemento 2 de cada lista. A lista "a" não pode, é vazia

b[1] ; c[1]

Error in lines 2-2 Traceback (most recent call last): File "/usr/local/lib/python2.7/dist-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> NameError: name 'b' is not defined

# alterando o valor do elemento 1 das listas b e c
print(b) ; print(c)   # antes

b[1] = 55
c[1] = 55

b ; c  # depois

Error in lines 2-2 Traceback (most recent call last): File "/usr/local/lib/python2.7/dist-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> NameError: name 'b' is not defined

%md
* **Adicionar e remover elementos de uma lista**

• Adicionar e remover elementos de uma lista

# adicionando o elemento 10 ao final da lista. Append só coloca um único elemento ao final do vetor
a.append(10)

a

[10]

# adiciona mais de um elemento ao final da lista
a.extend([-10,-100])

a

[10, -10, -100]

# retirando elemento do final da lista
a.pop()

a

-100 [10, -10]

# inserir um elemento em uma posição específica
a.insert(1,500)

a

[10, 500, -10]

# retirar elemento específico.
a.remove(500)

a

[10, -10]

• Busca de elementos e ordenação em uma lista

# retorna o numero de ocorrência da quantidade de vezes que aparece o valor na lista
a.count(10)

1

# Devolve a posição do primeiro valor procurado. Se não existir ocorre erro
a.index(-10)

1

# procura um item na lista e devolve true se existir e false se nao
1000 in a ; 10 in a

False True

# Inverte a ordem dos elementos na lista (sem gerar uma nova lista).
a.reverse()

a

[-10, 10]

a.sort()
a

[-10, 10]

# valor máximo da lista
max(a)

10

# valor minimo
min(a)

-10

# soma dos elementos de uma lista
show(a)
sum(a)

[$\displaystyle -10$, $\displaystyle 10$]

0

# formando pares ordenados
show(a)
show(b)

zip(a,b)

[$\displaystyle -10$, $\displaystyle 10$]

[$\displaystyle 1$, $\displaystyle 55$, math]

[(-10, 1), (10, 55)]

• Elementos aletórios

import random

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

# elemento aleatório
show(random.choice(aa))

$\displaystyle 5$

# escolhendo aleatoriamente 5 elementos da lista
(random.sample(aa, 5))

[5, 1, 9, 2, 6]

• Aplicar os elementos da lista à uma função anônima

dados = [10,20,30,40]

map(lambda x: x^2, dados)

[100, 400, 900, 1600]

• Fatiamento e concatenação de listas

lista = [1,2,3,4,5,6]

lista[1:3]

[2, 3]

lista[:4]

[1, 2, 3, 4]

lista[3:]

[4, 5, 6]

# Também podemos remover elementos de uma lista atribuindo a lista vazia a eles
lista[1:3] = []

lista

[1, 4, 5, 6]

# concatenação
L = ['mecanica','eletrica','computacao']

W = [1001,1002,1003 ]

W + L

[1001, 1002, 1003, 'mecanica', 'eletrica', 'computacao']

Sequencias

Uma sequencia é uma lista na forma sequencial na forma de numeros inteiros ou decimais (ponto flutuante) dada pelo comando range. Os comandos vistos (append, remove, ...) também valem para range

S = range(10)

type(S)

<type 'list'>

range(5,10)

[5, 6, 7, 8, 9]

range(0,50,10)

[0, 10, 20, 30, 40]

range(50,0,-10)

[50, 40, 30, 20, 10]

Listas do tipo sequencia formada por numeros Decimais (ponto flutuante)

srange(0,1,0.25)

[0.000000000000000, 0.250000000000000, 0.500000000000000, 0.750000000000000]

# Definindo o tipo RDF, SAGE ganha em velocidade de processamento, pois o RDF é optimiado para trabalhar com numeros reais e implementam uma excelente velocidade de processamento
SR = srange(0,1,0.25,universe=RDF, include_endpoint=true )

SR

[0.0, 0.25, 0.5, 0.75, 1.0]

SR.append(3)

SR

[0.0, 0.25, 0.5, 0.75, 1.0, 3]

# adicionando a string 'sage' ao final da sequencia
SR.append('sage')

SR

[0.0, 0.25, 0.5, 0.75, 1.0, 3, 'sage']

# removendo o termo de valor 3 da sequencia
SR.remove(3)

SR

[0.0, 0.25, 0.5, 0.75, 1.0, 'sage']

Sequencia aleatória

import random

# sequencia entre 0 a 100 de 10 elementos
random.sample(range(0, 100), 10)

[9, 57, 10, 25, 3, 62, 78, 16, 45, 67]

Listas como matrizes, ou melhor, como tabelas

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

lisTab

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

type(lisTab)

<type 'list'>

Formatação da lista como matriz

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

# lista[linha][coluna]
lisTab[0][0] ; lisTab[1][0] ; lisTab[2][1]; lisTab[2]

1 4 8 [7, 8, 9]

Tuplas

Uma tupla consiste de um número de valores separados por vírgulas. Tuplas ao contrário das listas são imutáveis - uma vez criadas não podem ser modificadas.

t = 12345,'bom dia', 54321, 'bom dia'
T = (10,20, 'bom domingo')
t ; T

(12345, 'bom dia', 54321, 'bom dia') (10, 20, 'bom domingo')

type(t); type(T)

<type 'tuple'> <type 'tuple'>

t[1] ; T[2]

'bom dia' 'bom domingo'

# não é possível alterar um valor de item em uma tupla

t[1] = 0

Error in lines 2-2 Traceback (most recent call last): File "/projects/sage/sage-6.10/local/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> TypeError: 'tuple' object does not support item assignment

# Associando cada elemento de uma tupla a variáveis
x, y, z = T

x ; y ; z

10 20 'bom domingo'

# Devolve o número de vezes que o valor x aparece na lista.
t.count('bom dia')

2

# Devolve a posição do primeiro valor procurado.
t.index('bom dia')

1

• Fatiamento e concatenação de Tuplas

tupla1 = ('a', 'b', 'c', 'd', 'e')
tupla2 = (1,2,3,4,5,6,'bola')

TP = tupla[1:3]
TP

Error in lines 1-1 Traceback (most recent call last): File "/projects/sage/sage-6.10/local/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> NameError: name 'tupla' is not defined

tupla1 + tupla2

('a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 6, 'bola')

Dicionários

Um dicionário é uma coleção de elementos onde é possível utilizar como índice qualquer tipo imutável, como strings, tuplas e tipos numéricos. O termo normalmente utilizado para descrever essa associação entre índice e elemento é key / value ou chave / valor. Dicionários2 são definidos entre chaves ( { e } ), as keys separadas dos values por dois-pontos ( : ) e os pares de keys e values separados por vírgulas.

forca_peso_A = {'aceleração': 9.8, 'massa': 80, 'não importa':00}

forca_peso_B = dict([('aceleração', 9.8), ('massa', 80), ('não importa',00 )])

forca_peso_C = dict(aceleracao=9.8, massa=80, nao_importa=00)

show(forca_peso_A)

show(forca_peso_B)

show(forca_peso_C)

{'acelera\xc3\xa7\xc3\xa3o': 9.80000000000000, 'n\xc3\xa3o importa': 0, 'massa': 80}

{'acelera\xc3\xa7\xc3\xa3o': 9.80000000000000, 'n\xc3\xa3o importa': 0, 'massa': 80}

{'aceleracao': 9.80000000000000, 'nao_importa': 0, 'massa': 80}

type(forca_peso_A); type(forca_peso_B); type(forca_peso_C)

<type 'dict'> <type 'dict'> <type 'dict'>

# itens do dicionário
show(forca_peso_A.items())

[(aceleração, $\displaystyle 9.80000000000000$), (não importa, $\displaystyle 0$), (massa, $\displaystyle 80$)]

# chaves
show(forca_peso_A.keys())

[aceleração, não importa, massa]

# valores
show(forca_peso_A.values())

[$\displaystyle 9.80000000000000$, $\displaystyle 0$, $\displaystyle 80$]

# acessando um valor correspondente a um valor
forca_peso_A['massa']

80

# atribuíndo as chaves a variáveis
a,b,c= forca_peso_A

show(a)
show(b)
show(c)

aceleração

não importa

massa

# atribuíndo os valores das chaves a variáveis

# apagar um elemento do dicinário
del forca_peso_A['não importa']

show(forca_peso_A)

{'acelera\xc3\xa7\xc3\xa3o': 9.80000000000000, 'massa': 80}

forca_peso_A.get('aceleração'['massa'])

Error in lines 1-1 Traceback (most recent call last): File "/projects/sage/sage-6.10/local/lib/python2.7/site-packages/smc_sagews/sage_server.py", line 947, in execute exec compile(block+'\n', '', 'single') in namespace, locals File "", line 1, in <module> TypeError: string indices must be integers, not str

Vetores e Matrizes

É importante estabelecer uma diferença entre vetores e listas. Vetores, na matemática, são entes matemáticos que possuem módulo, direção e sentido. Em programação, é uma estrutura lógica de tamanho fixo que contém elementos de um tipo definido. Listas em Python puro (sem NumPy ou SymPy) não são vetores matemáticos!

SAGE também utiliza o NumPy e o SymPy para trabalhar com vetores e matrizes, com a diferença que SAGE simplifica a operação, transformando listas em vetores e matrizes utilizano os comandos vector(lista) e matrix(lista)

Vetores no Python

import numpy as np

# criação de vetores

Vc1 = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])

Vc2 = np.array([9, 8, 7, 6, 5, 4, 3, 2, 1])

# criação de matrizes

Ma = np.array([(1,2), (4,5)])

Mb = np.array([(3,6),(7,9)])

Vc1; Vc2; Ma; Mb

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

Utilizando "array", podemos utilizar todas as funções do NumPy e SymPy

Vc1 + Vc2

array([9, 9, 9, 9, 9, 9, 9, 9, 9])

Ma + Ma

array([[ 2, 4], [ 8, 10]])

Vetores no SageMath

Matematicamente, Vetores são diferentes dos arrays ou listas.

• criação de vetores e acesso a dados em um vetor

# Criando um vetor
a = vector([1,2,3])
a

(1, 2, 3)

type(a)

<type 'sage.modules.vector_integer_dense.Vector_integer_dense'>

# quantidade de elementos de um vetor ou tamanho do vetor
len(a)

3

# alterando valor elemento. NAO USE ".SET(INDICE,VALOR)"! se nao existir o indice no vetor, sage entra em parafuso.
a[2] = 5
a

(1, 2, 5)

# valor maximo
max(a)

5

# valor minimo
min(a)

1

• Representação Gráfica de vetores 2D

Gráfico 2D

v = vector([1, 0])
u = vector([0, 1])
t = vector([-1,-2])

v;u;t

(1, 0) (0, 1) (-1, -2)

plot(v,color="red", figsize = (3,3),gridlines="minor") + plot(u) + plot(t,color="green")

• Gráfico de vetores 3D

t = vector([1, 0, 0])
r = vector([0,1, 0])
s = vector([0,0, 1])

t;r;s

(1, 0, 0) (0, 1, 0) (0, 0, 1)

plot(t,color="red", figsize = (3,3), mesh=true, thickness=3) + plot(r, thickness=3)+ plot(s,color="green",thickness=3)

3D rendering not yet implemented

• Vetor a partir de uma lista

L = [1,2,3]

Vl = vector(L)

Vl

(1, 2, 3)

type(Vl)

<type 'sage.modules.vector_integer_dense.Vector_integer_dense'>

• Vetor a partir de uma tupla

T = (1,2,3)

Vt = vector(T)

Vt

(1, 2, 3)

Matrizes no SagaMath

• criação de matrizes acessando dados em uma matriz

Ma = matrix([[1,2,3],[4,5,6],[7,8,9]])

Ma

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

type(Ma)

<type 'sage.matrix.matrix_integer_dense.Matrix_integer_dense'>

# dimensão da matrix (numero de colunas e numero de linhas)
Ma.dimensions()

(3, 3)

# quantidade de elementos da matriz
Ma.height()

9

# coluna indice
Ma.columns(); Ma.column(1); Ma.column(2)

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

# linha indice
Ma.rows(); Ma.row(1); Ma.row(2)

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

• Matriz criada por uma função anônima

M = matrix(5, 5, lambda i, j: i+(j*random()))

M

[ 0.0 0.6983980676462042 0.6376714068431804 1.4849273093439186 0.586836300579118] [ 1.0 1.0490247809109237 2.7310308242178682 2.5679844729949792 2.3368562771513233] [ 2.0 2.2449665551751217 3.2226374920666956 2.760588073339787 5.381825640048271] [ 3.0 3.8431159076544974 3.499805187324633 3.289714192417527 3.818596394535897] [ 4.0 4.302366394760218 5.080886625651207 5.335650516660635 5.485726306032028]

• ** Máximo e Mínimo**

# vetores de maior valor de cada coluna da matriz

min(M); max(M)

(0.0, 0.6983980676462042, 0.6376714068431804, 1.4849273093439186, 0.586836300579118) (4.0, 4.302366394760218, 5.080886625651207, 5.335650516660635, 5.485726306032028)

# valores maximos e mínimo da matrix

min(min(M)); max(max(M))

0.0 5.485726306032028

plot(M,cmap='Oranges', colorbar=True,vmin=min(min(M)), vmax=ceil(max(max(M))),figsize = (3,3))

M.plot(cmap='Reds',vmin=min(min(M)), vmax=ceil(max(max(M))), colorbar=true, figsize=(3,3))

• Criação de Matrizes a partir de Listas e Tubplas

# Criando uma matriz a partir de uma lista

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

Ml = matrix(L)

Ml ; Ml[0][2]

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

# Criando uma matriz a partir de uma tupla

T = ((1,2,3),(4,5,6),(7,8,9))

Mt = matrix(T)

Mt ; Mt[0][2]

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

Polinômios

reset()

iii
html
<p>Existem tr&ecirc;s formas de criar an&eacute;is de polin&ocirc;mios.<br /><br /></p>

Pol1

type(Pol1)

<class 'sage.rings.polynomial.polynomial_ring.PolynomialRing_field_with_category'>

Segunda forma

Pol2 = QQ['t']

Pol2

Univariate Polynomial Ring in t over Rational Field

Terceira forma

Pol3.<t> = PolynomialRing(QQ)
Pol_3.<t> = QQ['t']

Pol3 ; Pol_3

Univariate Polynomial Ring in t over Rational Field Univariate Polynomial Ring in t over Rational Field

ExPol = 2*t^2 + 3*t + 4

ExPol

2*t^2 + 3*t + 4

ExPol^2

4*t^4 + 12*t^3 + 25*t^2 + 24*t + 16

ExPol.factor()

(2) * (t^2 + 3/2*t + 2)

Tipos Definidos pelo Programador

%%% Fim Tipos de Dados %%%