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.6 Sequência de Caracteres 3 Programação Estruturada

2.7 Coleção de Dados

Compre o e-book deste material aqui!

Objetos da classe de dados inte floatpermitem a alocação de um valor numérico por variável. Já, string é um coleção (sequência) de caracteres. Nesta seção, vamos estudar sobre classes de dados básicos que permitem a alocação de uma coleção de dados em uma única variável.

2.7.1 Conjuntos set

Em Python, set é uma classe de dados para a alocação de um conjunto de objetos. Assim como na matemática, um set é uma coleção de itens não indexada, imutável e não admite itens duplicados.

A alocação de um set pode ser feita como no seguinte exemplo:

⬇

1>>> a = {1, -3.7, 'amarelo'}

2>>> type(a)

3<class 'set'>

4>>> a

5{'amarelo', 1, -3.7}

Observamos que a ordem dos elementos é arbitrária, uma vez que set é uma coleção de itens não indexada.

O método set() também pode ser usado para criar um conjunto. Por exemplo, o conjunto vazio pode ser criado como segue:

⬇

1>>> b = set()

2>>> type(b)

3<class 'set'>

4>>> b

5set()

O método len pode ser usado para obtermos o tamanho (número de elementos) de um set:

⬇

1>>> len(a)

3>>> len(b)

Operadores de Comparação

Os seguintes operadores de comparação estão disponíveis para sets:

•

x in a pertencimento

Verifica se $x\in a$ .

⬇

1>>> a = {1, -3.7, 'amarelo'}

2>>> 1 in a

3True

4>>> 'mar' in a

5False
•

a == b igualdade

Verifica se $a=b$ .

⬇

1>>> a == a

2True
•

a != b diferente

Verifica se $a\neq b$ .

⬇

1>>> b = {'amarelo', -3.7}

2>>> a != b

3True
•

a <= b contido em ou igual a (subconjunto)

Verifica se $a\subseteq b$ .

⬇

1>>> b <= a

2True
•

< contido em e não igual a (subconjunto próprio)

Verifica se $a\subsetneq b$ .

⬇

1>>> a < a

2False

3>>> b < a

4True
•

>= contém ou é igual a (subconjunto)

Verifica se $a\supset b$ .

⬇

1>>> a >= b

2True
•

> contém e não é igual a (subconjunto próprio)

Verifica se $a\supsetneq b$ .

⬇

1>>> a > b

2True

3>>> b > b

4False

Operações com Conjuntos

Em Python, as seguintes operações com conjuntos estão disponíveis:

•

a | b união

Retorna o setequivalente a

$a\cup b:=\{x:\leavevmode\nobreak\ x\in a\lor x\in b\}$ (2.44)

⬇

1>>> a = {1, -3.7, 'amarelo'}

2>>> b = {'mar', -5}

3>>> a | b

4{1, 'amarelo', 'mar', -5, -3.7}
•

a & b interseção

Retorna o setequivalente a

$a\cap b:=\{x:\leavevmode\nobreak\ x\in a\land x\in b\}$ (2.45)

⬇

1>>> a = {1, -3.7, 'amarelo'}

2>>> b = {'mar', 1, -3.7, -5}

3>>> a & b

4{1, -3.7}
•

- diferença

Retorna o setequivalente a

$a\setminus b:=\{x:\leavevmode\nobreak\ x\in a\land x\not\in b\}$ (2.46)

⬇

1>>> a - b

2{'amarelo'}
•

^ diferença simétrica

Retorna o setequivalente a

$a\Delta b:=(a\setminus b)\cup(b\setminus a)$ (2.47)

⬇

1>>> a ^ b

2{'amarelo', 'mar', -5}

2.7.2 N-uplas tuple

Em Python, tuple é uma sequência de objetos, indexada e imutável. São similares as $n$ -uplas²⁶²⁶endnote: ²⁶Pares (duplas), triplas, quadruplas ordenadas, etc. em matemática. A alocação é feita com uso de parênteses e os elementos separados por vírgula, por exemplo,

⬇

1>>> a = (1, -3.7, 'amarelo', -5)

2>>> type(a)

3<class 'tuple'>

Indexação e Fatiamento

O tamanho de um tuple é sua quantidade de objetos e pode ser obtido com o método len(), por exemplo,

⬇

1>>> a = (1, -3.7, 'amarelo', -5, {-3,1})

2>>> len(a)

Os itens são indexados como segue

(\underset{\underset{-5}{0}}{1},\underset{\underset{-4}{1}}{-3.7},\underset{% \underset{-3}{2}}{\text{'amarelo'}},\underset{\underset{-2}{3}}{-5},\underset{% \underset{-1}{4}}{\{-3,1\}})

(2.48)

A referência a um objeto do tuple pode ser feita com

⬇

1>>> a[2]

2'amarelo'

3>>> a[-1]

4{1, -3}

Analogamente a strings, pode-se fazer o fatiamento de tuples usando-se o operador :. Por exemplo,

⬇

1>>> a[:2]

2(1, -3.7)

3>>> a[1:5:2]

4(-3.7, -5)

5>>> a[::-1]

6({1, -3}, -5, 'amarelo', -3.7, 1)

Operações com tuples

Os mesmos operadores de comparação para sets estão disponíveis para tuples (consulte a Subseção 2.7.1). Por exemplo,

⬇

1>>> -5 in a

2True

3>>> a[::-1] == a[-1:-6:-1]

4True

5>>> a != a[::-1]

6True

7>>> a[:2] < a

8True

Observação 2.7.1.

(Igualdade entre tuples). Dois tuples são iguais quando contém os mesmos elementos e na mesma ordem.

Há, também, operadores para a concatenação e repetição:

•

+ concatenação

⬇

1>>> a = (1,2)

2>>> b = (3,4,5)

3>>> a+b

4(1, 2, 3, 4, 5)
•

* : repetição

⬇

1>>> a*3

2(1, 2, 1, 2, 1, 2)

Observação 2.7.2.

(Permutação de variáveis.) Dizemos que um código é pythônico quando explora a linguagem para escrevê-lo de forma sucinta e de fácil compreensão. Por exemplo, a permutação de variáveis é classicamente feita como segue

⬇

1>>> x = 1

2>>> y = 2

3>>> z = x

4>>> x = y

5>>> y = z

6>>> x, y

7(2, 1)

Note que na última linha, um tuple foi criado. Ou seja, a criação de tuples não requer o uso de parênteses, basta colocar os objetos separados por vírgulas. Podemos explorar isso e escrevermos o seguinte código pythônico para a permutação de variáveis:

⬇

1>>> x, y = y, x

2>>> x, y

3(1, 2)

2.7.3 Listas list

Em Python, list é uma classe de objetos do tipo lista, é uma coleção de objetos indexada e mutável. Para a criação de uma lista, usamos colchetes:

⬇

1>>> a = [1, -3.7, 'amarelo', -5, (-3,1)]

2>>> type(a)

3<class 'list'>

4>>> a[2]

5'amarelo'

6>>> a[1::2]

7[-3.7, -5]

Exemplo 2.7.1.

(Vetores alocados como lists.) Sejam dados dois vetores

	$\displaystyle v$	$\displaystyle=(v_{1}.v_{2},v_{3}),$		(2.49)
	$\displaystyle w$	$\displaystyle=(w_{1},w_{2},w_{3}).$		(2.50)

O produto interno $v\cdot w$ é calculado por

v\cdot w:=v_{1}w_{1}+v_{2}w_{2}+v_{3}w_{3}.

(2.51)

O seguinte código, aloca os vetores

	$\displaystyle v$	$\displaystyle=(-1,2,1),$		(2.52)
	$\displaystyle w$	$\displaystyle=(3,-1,4)$		(2.53)

usando lists, computa o produto interno $v\cdot w$ e imprime o resultado.

⬇

1v = [-1, 2, 1]

2w = [3, -1, 4]

3p = v[0]*w[0] \

4 + v[1]*w[1] \

5 + v[2]*w[2]

6print(f'v.w = {p}')

Exemplo 2.7.2.

(Matrizes e listas encadeadas.) Consideramos a matriz

A=\begin{bmatrix}-1&1\\ 1&3\end{bmatrix}

(2.54)

Podemos alocá-la por linhas pelo encadeamento de lists, i.e.

⬇

1>>> A = [[-1,1],[1,3]]

2>>> A

3[[-1, 1], [1, 3]]

Com isso, podemos obter a segunda linha da matriz com

⬇

1>>> A[1]

2[1, 3]

Ou ainda, podemos obter o elemento da segunda linha e primeira coluna com

⬇

1>>> A[1][0]

Observação 2.7.3.

(Operadores.) Os operadores envolvendo tuple são análogos para lists. Por exemplo,

⬇

1>>> a = [1,2]

2>>> b = [3,4]

3>>> a + b

4[1, 2, 3, 4]

5>>> 2*a

6[1, 2, 1, 2]

7>>> a <= a

8True

Modificações em lists

list é uma classe de objetos mutável, i.e. permite que a coleção de objetos que a constituem seja alterada. Pode-se fazer a alteração de itens usando-se suas posições, por exemplo

⬇

1>>> a = [1, -3.7, 'amarelo', -5, (-3,1)]

2>>> a[1] = 7.5

3>>> a

4[1, 7.5, 'amarelo', -5, (-3, 1)]

5>>> a[1:3] = ['mar', -2.47]

6>>> a

7[1, 'mar', -2.47, -5, (-3, 1)]

8>>> a[:2] = 7

Tem-se disponíveis os seguintes métodos para a modificação de lists:

•

del deleta elemento(s)

⬇

1>>> del a[:2]

2>>> a

3[-2.47, -5, (-3, 1)]
•

list.insert inserção de elemento(s)

⬇

1>>> a.insert(1, 'azul')

2>>> a

3[-2.47, 'azul', -5, (-3, 1)]
•

list.append anexa um novo elemento

⬇

1>>> a.append([2,1])

2>>> a

3[-2.47, 'azul', -5, (-3, 1), [2, 1]]
•

list.extend estende com novos elementos dados

⬇

1>>> del a[-1]

2>>> a.extend([2,1])

3>>> a

4[-2.47, 'azul', -5, (-3, 1), 2, 1]

5>>> a += [3]

6>>> a

7[-2.47, 'azul', -5, (-3, 1), 2, 1, 3]

Observação 2.7.4.

(Cópia de objetos.) Em Python, dados têm um único identificador, por isso temos

⬇

1>>> a = [1,2,3]

2>>> b = a

3>>> b[1] = 4

4>>> a

5[1, 4, 3]

Para fazermos uma cópia de uma list, podemos usar o método list.copy. Com isso, temos

⬇

1>>> a = [1,2,3]

2>>> b = a.copy()

3>>> b[1] = 4

4>>> a

5[1, 2, 3]

6>>> b

7[1, 4, 3]

2.7.4 Dicionários dict

Em Python, um dicionário dict é uma coleção de objetos em que cada elemento está associado a uma chave. Como chave podemos usar qualquer dado imutável (int, float, str, etc.). Criamos um dict ao alocarmos um conjunto de chaves:valores:

⬇

1>>> x = {'nome': 'Fulane', 'idade': 19}

2>>> x

3{'nome': 'Fulane', 'idade': 19}

4>>> y = {3: 'número inteiro', 3.14: 'pi', 2.71: 2}

5>>> y

6{3: 'número inteiro', 3.14: 'pi', 2.71: 2}

7>>> d = {}

8>>> type(d)

9<class 'dict'>

Observamos que {} cria um dicionário vazio. Acessamos um valor no dict referenciando-se sua chave, por exemplo

⬇

1>>> x['idade']

219

3>>> y[3]

4'número inteiro'

Podemos obter a lista de chaves de um dict da seguinte forma

⬇

1>>> list(x)

2['nome', 'idade']

3>>> list(y)

4[3, 3.14, 2.71]

Exemplo 2.7.3.

Consideramos o triângulo de vértices $\{(0,0),(1,0),(0,1)\}$ . Alocamos um dicionário contendo os vértices do triangulo

⬇

1>>> tria = {'A': (0,0), 'B': (1,0), 'C': (0,1)}

2>>> tria

3{'A': (0, 0), 'B': (1, 0), 'C': (0, 1)}

Para recuperarmos o valor do segundo vértice, por exemplo, digitamos

⬇

1>>> tria['B']

2(1, 0)

Em um dict, valores podem ser modificados, por exemplo,

⬇

1>>> x['nome'] = 'Fulana'

2>>> x

3{'nome': 'Fulana', 'idade': 19}

Podemos estender um dict pela inserção de uma nova associação chave:valor, por exemplo

⬇

1>>> x['altura'] = 171

2>>> x

3{'nome': 'Fulana', 'idade': 19, 'altura': 171}

Exemplo 2.7.4.

No Exemplo 2.7.3, alocamos o dicionário tria contendo os vértices de um dado triângulo. Agora, vamos computar o comprimento de cada uma de suas arestas e alocar o resultado no próprio dict. A distância entre dois pontos $A=(a_{1},a_{2})$ e $B=(b_{1},b_{2})$ pode ser calculada por

d(A,b):=\sqrt{(b_{1}-a_{1})^{2}+(a_{2}-b_{2})^{2}}

(2.55)

Segue nosso código:

⬇

1# vértices do triangulo

2tria = {'A': (0,0), 'B': (1,0), 'C': (0,1)}

3# aresta AB

4tria['AB'] = ((tria['B'][0] - tria['A'][0])**2 \

5 + (tria['B'][1] - tria['A'][1])**2)**0.5

6# aresta BC

7tria['BC'] = ((tria['C'][0] - tria['B'][0])**2 \

8 + (tria['C'][1] - tria['B'][1])**2)**0.5

9# aresta AC

10tria['AC'] = ((tria['C'][0] - tria['A'][0])**2 \

11 + (tria['C'][1] - tria['A'][1])**2)**0.5

12# novo dicionário

13print(tria)

2.7.5 Exercícios

E. 2.7.1.

Crie um código que aloque os seguintes conjuntos

	$\displaystyle A$	$\displaystyle=\{1,4,7\}$		(2.56)
	$\displaystyle B$	$\displaystyle=\{1,3,4,5,7,8\}$		(2.57)

e verifique as seguintes afirmações:

a)

$A\supset B$
b)

$A\subset B$
c)

$B\not\supset A$
d)

$A\subsetneq B$

Resposta.

⬇

1A = {1,4,7}

2B = {1,3,4,5,7,8}

3# a)

4a = A >= B

5print(f"a) A>=B: {a}")

6# b)

7b = A <= B

8print(f"b) A<=B: {b}")

9# c)

10c = not(B >= A)

11print(f"c) not(A>=B): {c}")

12# d)

13d = A < B

14print(f"d) A<B: {d}")

E. 2.7.2.

Crie um código que aloque os seguintes conjuntos

$\displaystyle A$	$\displaystyle=\{-3,-1,0,1,6,7\}$	(2.58)
$\displaystyle B$	$\displaystyle=\{-4,1,3,5,6,7\}$	(2.59)
$\displaystyle C$	$\displaystyle=\{-5,-3,1,2,3,5\}$	(2.60)

e, então, compute as seguintes operações:

a)

$A\cap B$
b)

$C\cup B$
c)

$C\setminus A$
d)

$B\cap(A\cup C)$

Resposta.

⬇

1A = {-3,-1,0,1,6,7}

2B = {-4,1,3,5,6,7}

3C = {-5,-3,1,2,3,5}

4# a)

5a = A & B

6print(f"a)\n A&B = {a}")

7# b)

8b = C | B

9print(f"b)\n A|B = {b}")

10# c)

11c = C - A

12print(f"c)\n C-A = {c}")

13# d)

14d = B & (A | C)

15print(f"d)\n B&(A|C) = {d}")

E. 2.7.3.

O produto cartesiano²⁷²⁷endnote: ²⁷René Descartes, 1596 - 1650, matemático e filósofo francês. Fonte: Wikipédia: René Descartes. de um conjunto $X$ com um conjunto $Y$ é o seguinte conjunto de pares ordenados

X\times Y:=\{(x,y):\leavevmode\nobreak\ x\in X\land y\in Y\}.

(2.61)

Crie um código que aloque os conjuntos

X=\{-2,1,3\},Y=\{5,-1,2\}

(2.62)

e $X\times Y$ . Por fim, fornece a quantidade de elementos de $X\times Y$ .

Resposta.

⬇

1X = {-2,1,3}

2Y = {5,-1,2}

3XxY = {(-2,5), (-2,-1), (-2,2), \

4 (1,5), (1,-1), (1,2), \

5 (3,5), (3,-1), (3,2)}

6print(f'#(X x Y) = {len(XxY)}')

E. 2.7.4.

A sequência de Fibonacci²⁸²⁸endnote: ²⁸Leonardo Fibonacci, 1170 - 1250, matemático italiano. Fonte: Wikipédia: Leonardo Fibonacci. $(f_{n})_{n\in\mathcal{N}}$ é definida por

f_{n}:=\left\{\begin{array}[]{ll}0&,n=0,\\ 1&,n=1,\\ f_{n-2}+f_{n-1}&,n\geq 2\end{array}\right.

(2.63)

Crie um código que aloque os $6$ primeiros elementos da sequência em uma list e imprima-o.

Resposta.

⬇

1a = [0,1]

2a.append(a[0]+a[1])

3a.append(a[1]+a[2])

4a.append(a[2]+a[3])

5a.append(a[3]+a[4])

6print(a)

E. 2.7.5.

Crie um código que usa de lists para alocar os seguintes vetores

	$\displaystyle\boldsymbol{v}=(-1,0,2),$		(2.64)
	$\displaystyle\boldsymbol{w}=(3,1,2)$		(2.65)

e computar:

a)

$\boldsymbol{v}+\boldsymbol{w}$
b)

$\boldsymbol{v}-\boldsymbol{w}$
c)

$\boldsymbol{v}\cdot\boldsymbol{w}$
d)

$\|\boldsymbol{v}\|$
e)

$\|\boldsymbol{v}-\boldsymbol{w}\|$

Resposta.

⬇

1v = [-1, 0, 2]

2w = [3, 1, 2]

3# a)

4vpw = [v[0] + w[0],

5 v[1] + w[1],

6 v[2] + w[2]]

7print(f'a) v+w = {vpw}')

8# b)

9vmw = [v[0] - w[0],

10 v[1] - w[1],

11 v[2] - w[2]]

12print(f'b) v-w = {vmw}')

13# c)

14vdw = v[0]*w[0] + \

15 v[1]*w[1] + \

16 v[2]*w[2]

17print(f'c) v.w = {vdw}')

18# d)

19norm_v = (v[0]**2 + \

20 v[1]**2 + \

21 v[2]**2)**0.5

22print(f'd) ||v|| = {norm_v:.2f}')

23# e)

24norm_vmw = (vmw[0]**2 + \

25 vmw[1]**2 + \

26 vmw[2]**2)**0.5

27print(f'e) ||v-w|| = {norm_vmw:.2f}')

E. 2.7.6.

Crie um código que usa de listas encadeadas para alocar a matriz

A=\begin{bmatrix}1&-1\\ 2&3\end{bmatrix}

(2.66)

e imprima o determinante de $A$ , i.e.

|A|:=a_{1,1}a_{2,2}-a_{1,2}a_{2,1}.

(2.67)

Resposta.

⬇

1A = [[1, -1],

2 [2, 3]]

3detA = A[0][0]*A[1][1] \

4 - A[0][1]*A[1][0]

5print(f'|A| = {detA}')

E. 2.7.7.

Crie um código que use de listas para alocar a matriz

A=\begin{bmatrix}1&-1&2\\ 2&0&-3\\ 3&1&-2\end{bmatrix}

(2.68)

e o vetor

\boldsymbol{x}=(-1,2,1).

(2.69)

Na sequência, compute $A\boldsymbol{x}$ e imprime o resultado.

Resposta.

⬇

1A = [[1, -1, 2],

2 [2, 0, -3],

3 [3, 1, -2]]

4x = [-1, 2, 1]

5Ax = [A[0][0]*x[0] + A[0][1]*x[1] + A[0][2]*x[2],

6 A[1][0]*x[0] + A[1][1]*x[1] + A[1][2]*x[2],

7 A[2][0]*x[0] + A[2][1]*x[1] + A[2][2]*x[2]]

8print(f'Ax = {Ax}')

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!

| | | |