O que são dados, variáveis e o que podemos fazer com eles? - Dicas, Aprenda Como fazer, Tutorial e Livros.

Tutomania - Dicas, Aprenda Como fazer, Tutorial...

Login:
Senha:
Salvar |  Cadastre-se

 

Home | Arquivo | Envio | Jogos Online | Política de Privacidade | Contato

Informática / Programação

O que são dados, variáveis e o que podemos fazer com eles?


DOCUMENTO:


ESTATÍSTICAS:

Comentários: 0 (Comentar)
Nota: (Dar Nota)
Valor: 10 crédito(s)
Enviado por: cerejinha (1164)
Publicado em: 28/02/05 12:11hs.

LINKS PATROCINADOS:

DOCUMENTO:

A matéria-prima

O que iremos cobrir?

  • o que são dados
  • O que são variáveis
  • Tipos de dados, e o que podemos fazer com eles

Introdução

Em qualquer actividade criativa, nós precisamos de 3 coisas básicas, são elas, ferramentas, materiais e técnicas. Por exemplo, quando estou a pintar as minhas ferramentas são os pincéis e os lápis, técnicas são 'washes', 'wet on wet', spraying, etc... E finalmente os materiais são as tintas, a tela, etc.... De uma forma muito semelhante quando estou a programar as minhas ferramentas são, as linguagens de programação, o hardware e os sistemas operativos. As técnicas são, pelo menos algumas, aquelas que estivemos a ver até aqui. E o material são os dados que manipula-mos. Este capitulo vai ser centrado na matéria-prima da programação.

Isto vai ser uma secção muito longa, por vezes podes mesmo acha-la um tanto ou quanto seco, isto para não dizer chato. Mas as boas noticias são que não iras precisar de ler tudo de uma assentada. Este capitulo vai começar aso tipos de dados mais básicos que podemos encontrar, depois fala-nos como havemos de lidar com bibliotecas de dados e finalmente por fim falamos de uns conceitos já mais avançados. Em caso que queiras saltar do barco (nem que seja para ir tomar um café), recomendo que o faças depois da secção sobre as bibliotecas, e se quiseres podes mesmo ler o capitulo seguinte do tutorial, mas não te esqueças que tens que aqui voltar, porque os conceitos mais avançados precisam que saibas isto.

Data (dados)

Dados ou data, é um daqueles termos que toda a gente usa, mas poucos são o qual o seu significado. O meu dicionário diz o seguinte:

"factos ou números, dos quais conclusões podem ser tiradas; informação"

Não sei se ficaste muito mais elucidado, mas pelo menos já tens um ponto de partida. Vamos ver se conseguimos clarificar as coisas olhando para como os dados são encarados do ponto de vista programacional. Dados são os ingredientes, a informação nua e crua, que o teu programa mais tarde irá manipular por forma a torna-lo algo de interessante. Mas sem dados para manipular os programas também não fazem nada de interessante. Programas podem manipular dados de varias formas, muitas das vezes dependendo apenas do tipo de dados. Cada tipo de dados por sua vez tem um número de operações - ou seja formas que se pode manipular - por exemplo já vimos que podemos adicionar números, então a adição é um operador de um tipo de dados que são os números. Dados têm vários tipos, o que nos nos vamos propor a fazer é analisar as mais comuns e os operadores que podemos usar nesse tipo de dados:

Variáveis

Os dados são guardados na memória do computador, podes ver isso como sendo uma sala dos correios cheia de caixas para separar o correio, agora imagina as variáveis como sendo o rotulo dessas caixas, sim porque se essas caixas não tivessem rotulo, ai seria a confusão geral. Então as variáveis são os rótulos na memória na do computador, indicando onde dados estão guardadas.

Para podermos manipular os dados, nós iremos precisar de acede-la, e para isso é que servem as variáveis. Em termos nós criamos instances (é como tirar uma fotografia) dos vários tipos de dados e depois usamos variáveis para os rotular. Uma variável é uma referência para uma aérea especifica na memória do computador onde os dados estão guardados. Em algumas linguagens de programação existem vários tipos de variáveis, como vários tipos de dados, fazendo que um determinado tipo de variável só possa ser usado com determinado tipo de dados, e qualquer tentativa de mudar essas regras do jogo resultam em erro. Existem alguns programadores que preferem este sistema, conhecido como static typing (escrita estática) porque ajuda a prevenir os bugs mais subtis, que são os mais difíceis de detectar.

Mas no Python isso não acontece, uma variável aceita qualquer tipo de dado que lhe destines, mas avisa-te quando já estás a misturar dados de uma forma estranha - como quereres adicionar um número a uma string. Podemos mudar o tipo dado para a qual a variável esta apontar, simplesmente redireccionando a variável para um outro tipo de dado.

>>> q = 7         # atribuímos o q a um número
>>> print q
7
>>> q = "Sete"   # agora atribuímos o q a uma string
>>> print q
Sete

Como podes ver o q estava a apontar para o número 7 inicialmente, até que nós o mandamos apontar para a string 'sete'. confirmando o que foi dito acima que para mudar o tipo de dado a que uma variável esta a apontar, basta redirecciona-la. Quando esse redireccionamento acontece, o dado inicial é 'perdido' e o Python apaga-o da memória (a não ser que existam 2 variáveis a apontar para o mesmo dado) isto é conhecido como Garbage collecction (a colecção do lixo - a colecção que vai para o lixo, seria uma tradução melhor).

Garbage collecction pode ser associado com o empregado dos correios, que aparece de vez em quando e, tira todos as cartas que não tem morada, pois para ele se uma carta não tem morada, não serve para nada, então, lixo. Agora vamos dar uma olhadela a alguns tipos de dados para ver como tudo isto funciona.

Tipos primitivos de dados

Os tipos de dados primitivos, são assim chamados porque de todos os tipos de dados que podemos manipular estes são sem duvida os mais básicos. Os outros tipos de dados mais complexos, são apenas combinações do tipo primitivo. Podemos dizer que são a fundação onde os outros dados podem ser construídos. Neste tipo de dados podemos incluir as letras, os números e uma outra categoria a que chamaremos de Boolean.

Caracteres

Estes já foram vistos. Neste grupo incluímos todos os caracteres ou sequência de caracteres, desde que possam ser dispostos no ecrã ( mas, nesta categoria, ainda podemos incluir alguns caracteres que não podem ser impressos os chamados control characters).

No Python as strings podem ser representadas de varias maneiras:

com aspas simples:

'Aqui esta uma string'

Com aspas duplas:

"Aqui esta uma outra string muito semelhante"

Com triplas aspas:

""" Aqui esta uma string muito, mais longa que
    que as anteriores, e pode ser disposta com todas as linhas que escrevemos
    preservando a forma como elas foram escritas..."""

Um uso especial para este último é a construção da documentação das funções do Python que nós mesmos criamos - mas isso veremos mais tarde.

É-nos permitido aceder aos caracteres de uma string individualmente, tratando-as como uma array . Normalmente existe sempre um determinado número de operadores, fornecidos pela linguagem de programação, que nos ajudam a manipular melhor as strings - como por exemplo ajudam-nos a encontrar sub strings, juntar duas string, copiar de uma string para outra etc....

Operadores de strings

< Sequências das secção na sys com fizemos qu foi (como importa-los terás portanto módulos dos dentro existem outros muitos mas, Python, proprio pelo fornecidos são operadores desses alguns strings, nas executar podemos operações número>

Operadores de strings

Operador

Descrição

S1 + S2

Concatenação de S1 e S2

S1 * N

N repetições de S1

Agora vamos vê-los em acção:

>>> print 'Vezes' + 'sem conta'    # concatenação de string
Vezes sem conta
>>> print 'Repete ' * 3                       # repetição de string
Repete Repete Repete
>>> print 'Sem conta' + ('vezes e vezes' * 3)  # combine '+' and '*'
Sem conta vezes e vezes vezes e vezes vezes e vezes

Também podemos atribuir uma variável a uma string, assim:

>>> s1 = 'Sem conta '
>>> s2 = 'vezes e vezes'
>>> print s1 + (s2 * 3)
Sem conta vezes e vezes vezes e vezes vezes e vezes

Repara que os dois últimos exemplos produziram o mesmo resultado.

AS strings no BASIC

No BASIC, se uma variável é uma variável para strings terá que terminar com o símbolo $. Uma vez feito não poderás atribui um número a essa variável. De uma forma semelhante o mesmo acontece quando falamos de números, quando atribuís uma variável a um número ela terá que terminar com o símbolo %, e não poderás atribuir uma string a essa variável. O BASIC no entanto, permite que criemos variáveis anónimas, ou seja variáveis que não tem nenhum símbolo como finalização, mas essas variáveis só podem ser atribuídas a números, sejam inteiros ou fraccionários. Aqui ficam alguns exemplos de variáveis no BASIC:

DIM MyString$
 
MyString$ = "Olá Mundo!"
 
PRINT MyString$

Strings no Tcl

O Tcl usa as strings de uma forma interna, do ponto de vista do utilizador, isso nem sempre é assim tão obvio. Quando queres criar uma string, uma forma de o fazeres é pô-la entre aspas. Para atribuíres uma variável tens que usar o comando set e para teres acesso a essa variável, simplesmente terás que por o símbolo $ a frente do nome da variável, ora vê:

% set Mystring "Olá Mundo"
% put $Mystring

Nota: Tanto no Tcl como no BASIC somente aspas duplas podem ser usadas nas strings.

Integras

Integras são números inteiros que vão desde um determinado valor negativo até a um determinado valor positivo, isto que acabei de dizer é algo que que vocês decorem pois é muito importante, vamos em frente. Normalmente não pensamos números como estando restritos a um tamanho ou a um valor se quiserem, mas como estamos a falar de computadores, têm que existir limites. Limite para o número mais baixo e um limite para o número mais alto. O limite para o número mais alto que se pode utilizar chama-se de MAXINT e depende do número de bits que o teu computador usa para representar um número. Na maioria dos computadores são 32 bits, o que faz com que o MAXINT seja volta dos 2 bilhões..

Números com valores positivos e números com valores negativos são conhecidos como signed integers. Também podemos obter uma outra coisa chamada de unassigned values, ou seja um grupo de números, mas apenas com valores positivos neste grupo incluímos o zero. Isto significa que imediatamente ficamos com um novo um limite para o número mais alto que será de 2* MAXINT ou 4 bilhões, num computador de 32 bits, isto porque agora podemos utilizar o espaço anteriormente reservado para números negativos para guardar mais números positivos.

Mas como as integras estão restritas em tamanho pelo MAXINT, a adição entre duas integras e onde o resultado dessa adição resulte um número maior que o MAXINT irá dar erro. Normalmente quando é causado um erro, das duas uma, ou o programa tenta lidar com ele, ou então o programa fecha. No Python esta última e a opção adoptada, enquanto no Tcl a primeira opção foi a escolhida. o BASIC, diz-nos que existe um erro, mas não nos indica como 'caça-lo' (pelo que eu saiba)

Operadores aritméticos

Nos já vimos todos os quase todos operadores aritméticos na secção das Sequências Simples, mas façamos uma recapitulação:

Operadores aritméticos e de bits

Exemplo

Descrição

M + N

Adição de M e N

M - N

Subtracção de N do M

M * N

Multiplicação de M pelo N

M / N

Divisão de integras ou números fraccionários.

M % N

Modulo: encontra o resto na divisão M pelo N

M ** N

Potências: M elevado a potência de N

Como ainda não vimos o último operador em acção, vamos por isso a um exemplo para que possamos ver como utiliza-lo melhor:

>>> i1 = 2     # criamos a integra 2 a qual atribuímos a variável i1
>>> i2 = 4
>>> i3 = 2 ** 4  # atribuímos o resultado de 2 elevado a 4 a variável i3
>>> print i3
16
 

Integras no BASIC

O BASIC já contém mais algumas regras que o Python para lidar com integras. já foi dito que se quisermos atribuir uma integra a uma variável no BASIC, podemos utilizar um texto simples, ou então usar um nome terminando com o símbolo % (pessoalmente recomendo, porque penso que o interprete reconhece as coisas mais rapidamente assim):

FOO = 8   REM podemos atribuir a variável FOO a qualquer tipo de número
BAR% = 9  REM só nós é permitido atribuir integras a variável BAR 

Uma última coisa relativamente as integras no BASIC:

i% = 7
PRINT 2 * i%
i% = 4.5
PRINT 2 * i%

Repara que quando atribuímos o 4.5 ao i, nada de estranho pareceu acontecer, mas na realidade só a parte inteira do número fica atribuída a variável, isto provavelmente te faz lembrar a divisão com números decimais no Python. Como te foi dito na altura, todas as linguagens de programação têm estas pequenas particularidades.

Os números no Tcl

Como acima mencionado, o Tcl guarda tudo internamente como strings, contudo isso não faz muita diferença ao utilizador porque quando se acede aos números o Tcl faz a conversão, por detrás das cortinas, sem que nós nos aperceba-mos disso. Mas as restrições relativas ao valores mais altos e mais baixos, ainda se aplicam.

O uso de números no Tcl, é ligeiramente mais complicado do que em outras linguagens, uma vez que para poderes fazer cálculos, tens que dizer ao interprete que vais fazer um calculo. Uma forma de avisar o interprete é usando o comando expr:

% put [expr 6 + 5]
11

Tudo que é colocado dentro de parêntesis rectos no Tcl é avaliado e executado em primeiro lugar, como se tivesse sido colocado na linha de comandos. Ao fazer isso o Tcl vê o comando expr, e faz o calculo. O resultado depois "posto" no ecrã através Em caso que tentes executar o calculo sem o expr, usando somente o comando put, o Tcl imprimiria, neste caso "6+5":

% put 6 + 5
6 + 5

Números reais

Estes são fracções. Representam números de grande magnitude, muito maiores que o MAXINT, mas com menos precisão. Isto para dizer que 2 números reais, que supostamente deveriam ser iguais, podem não o ser quando comparados por um computador. Isto porque o computador faz os arredondamentos a partir de um certo grau. Por exemplo o 4.0 poderia ser representado por um computador como sendo 3.99999999... ou então 4.00000...01. Estes arredondamentos no entanto não interferem com a maior parte das nossas aplicações, mas ocasionalmente podem tornar-se num grande sarilho. Portanto se algum dia obtiveres resultados não esperados quando estiveres a usar números reais, mantém o isto em mente.

Os números fraccionários ou floating point numbers têm os mesmos operadores que as integras, com a capacidade extra de criar um valor que é uma integra.

Números Complexos ou imaginários

Em caso que tenhas um background cientifico ou matemático, poderás estar a pensar, então e os números complexos? Em caso que não tenhas um background desses, provavelmente então nem sequer ouviste alguma vez falar de tal coisa. De qualquer das maneiras existem algumas linguagens de programação que fornecem funções built-ins para trabalhar com números complexos, nessas linguagens podemos incluir o Python e antes que perguntes o mesmo se aplica a matrizes.

No Python um número complexo é representado da seguinte forma:

(real + imaginário)

Para fazer uma adição será assim:

>>> M = (2+4j)
>>> N = (7+6j)
>>> print M + N
(9+10j)

Todos os operadores usado nas integras podem aplicar-se aos números complexos..

Boolean - Verdadeiro ou falso

Tal como diz no titulo, este tipo suporta apenas 2 valores - ou verdadeiro ou falso. Algumas linguagens têm um suporte directo para valores Boolean, enquanto outras usam uma convenção, onde normalmente um valor numérico (na maior parte da vezes o 0) representa falso enquanto outro valor numérico (usualmente o 1) representa verdadeiro.

Os valores de Boolean são por vezes conhecidos como os valores verdade, isto porque eles são usados para testar se algo é verdadeiro ou falso. Por exemplo imagina que crias um programa que faz um back up de todos os ficheiros numa determinada directoria, esse programa funcionaria da seguinte forma, fazia um back up de um ficheiro e depois perguntava ao sistema operativo pelo nome do próximo ficheiro. Quando não houvesse mais ficheiros para guardar o sistema operativo respondia com uma string vazia. Então o que o teu programa faria era testar para ver se o nome era uma string vazia ou não, guardando o resultado (verdadeiro em caso que a string seja vazia). Mais a frente verás como usar esse resultado.

Operadores de Boolean (ou operadores lógicos)

Exemplo

Descrição

Efeito

A and B

AND

Verdadeiro se ambos A, B forem verdadeiros, doutra forma falso.

A or B

OR

verdadeiro se um ou ambos forem A, B verdade, falso se A e B falsos

A == B

Igualdade

verdadeiro se A for igual a B

A != B
ou
A <> B

Diferente

Verdadeiro se A é diferente B.

not B

Negação

Verdadeiro se B não for verdadeiro

Nota: que o último operador funciona somente para um dos valores, enquanto os outros operam sobre os 2 valores.

Colecções

As Ciências computacionais desenvolveram uma complexa disciplina de estudo a volta das colecções e dos seus comportamentos. Por vezes estas as colecções podem ter o nome de contentores. Nesta secção vamos ver os tipos de colecções existentes no Python e só depois iremos fazer um pequeno sumário sobre os tipos de colecções que se pode encontrar nas outras linguagens.

Colecções no Python

Listas

Uma lista, é simplesmente uma sequência de itens. O que a faz diferente de uma array é que a nas lista pode-se continuamente ir-se adicionado mais itens. Como o lado mau disso, é que as listas não contém uma forma de índice, portanto quando queres encontrar um dos itens, tens que ir a procura, verificando item por item. Tanto o Python como o Tcl têm módulos de listas que já vêem como parte da linguagem. No BASIC o caso já é diferente, e obriga-nos a ter que fazer programação muito complicada por forma a podermos simular uma. Os programadores de BASIC na maior parte das vezes acabam é por criar array muito grandes. A grande vantagem que o Python leva as outras linguagens é que ele cria um ince das suas listas, o que como veremos mais adiante, é uma coisa muito útil.

Operações com listas

O Python tem muitos operadores que trabalham com colecções, e quase todos eles com listas. Ainda existe um outro grupo de operadores que trabalham somente com alguns tipo de listas como as strings, que no fundo são uma lista de caracteres. Para criar e aceder uma lista no Python usa-se parêntesis rectos. Podes criar uma lista vazia, usando um par de parêntesis rectos sem nada lá dentro, mas em caso que queiras lá colocar vários elementos podes separa-los usando uma virgula:

>>> aLista = []
>>> outra = [1,2,3]
>>> print outra
[1, 2, 3]

Podemos aceder aos vários elementos de uma lista, usando um índice numerário, onde o 0 equivale ao primeiro elemento da lista, o número do valor a aceder deve estar dentro de parêntesis rectos:

>>> print outra[2]
3

< lista valores os mudar>

>>> outra[2] = 7
>>> print outra
[1, 2, 7]

E também podemos usar números negativos para aceder a lista, isto tem como regra que o -1 é sempre o último valor da lista:

>>> print outra[-1]
7

Uma forma de adicionar valores a lista é usando o operador append():

>>> aLista.append(42)
>>> print aLista
[42]

Até podemos colocar uma lista dentro de uma outra lista:

>>> aLista.append(outra)
>>> print aLista
[42, [1, 2, 7]]

Repara em como o resultado é uma lista de 2 elementos, e o segundo elemento apresenta-se como uma lista (ou seja dentro de []) Isto é útil uma vez que nos permite criar representações de tabelas e grelhas usando listas dentro de listas. Podemos aceder aos elementos da segunda lista usando uma forma de duplo índice::

>>> print aLista[1][2]
7

O primeiro elemento do índice extrai o segundo elemento da, que por sua vez também é uma lista, o segundo índice extrai o terceiro elemento da sub lista.

O oposto de adicionar elementos, é remove-los, como é claro, para fazer isso usamos o comando del:

>>> del aLista[1]
>>> print aLista
[42]

Em caso que queiras juntar duas listas podes usar o operador da concatenação '+', tal qual como fizemos com as strings:

>>> novaLista = aLista + outra
>>> print novaLista
[42, [1, 2, 7], 1, 2, 7]

Da mesma forma podes usar o operador * para criar múltiplos do mesmo valor dentro da mesma lista:

>>> zeroLista = [0] * 5
>>> print zeroLista
[0, 0, 0, 0, 0]

E finalmente, para determinar o tamanho de uma lista podes a usar a função len():

>>> print len(aLista)
2
>>> print len(zeroLista)
5

Listas do Tcl

O Tcl também tem já vem com um módulo built In de listas, e junto com uma variedade de comandos para trabalhar nessas listas. Esses comandos são identificados pelo prefixo 'l' como por exemplo linsert, lappend, lindex, etc. Aqui esta um exemplo de como criar uma lista e aceder a uma lista no Tcl:

% set L [list 1 2 3]
% put [lindex $L 2]
3

Tuple

É uma função que não existe em todas as linguagens, mas naquelas em que se pode encontrar, é extraordinariamente útil. Um tuple não é mais que uma colecção de valores que são tratadas como uma só. Tuple e listas são semelhantes em muitos aspectos, com a grande excepção de Tuple são imutáveis, que é o mesmo quer dizer que são se pode alterar os seus constituintes, nem adicionar-lhe novos valores uma vez criado. No Python Tuple são simplesmente representados por um par de parêntesis, e os valores são separados por virgulas, assim:

>>> aTuple = (1,3,5)
>>> print aTuple[1]    # o índice funciona como nas listas
3
>> aTuple[2] = 7       # erro, não podes alterar os elementos de um tuple
Traceback (innermost last):
  File "", line 1, in ?
        aTuple[2] = 7
TypeError: object doesn't support item assignment

O principal a manter em mente, pelo menos neste nível, 'e que um tuple é criado usando parêntesis normais. e é acedido usando-se parêntesis rectos. O acesso aos itens funciona da mesma forma como nas listas, usando-se um índice numerário. Mais uma vez repito que dos Tuple são imutáveis uma vez criados, de outra forma são tal e qual as listas. A maioria dos operadores das listas, também se aplicam aos Tuple.

Dicionários ou Hash

Um dicionário, tal como o nome sugere contem um valor associado a uma chave, da mesma forma que um dicionário associa um determinado significado, a um determinado nome. os valores podem ser acedidos usando essa chave. As chaves podem ser desde string como qualquer outro objecto, desde que possa ser considerado um objecto imutável, como números e tuple. Ou seja quase todos os tipos de data que o Python usa. O dicionários normalmente são utilizados internamente, através de uma avançada técnica de programação chamada tabela hash. Por essa razão por vezes pode-se referir-se a dicionários usando a palavra hash. Lamento informa que não tem nada a haver com drogas!

Porque o acesso a dicionários é através de uma chave, tens que te certificar que cada valor tem um chave e essa chave é única. Os dicionários são imensamente úteis, no diz respeito as estruturas do código, e no Python já vêem como um módulo built In, mas em outras linguagens terás que ser tu a aceder a esse módulo, ou as vezes terás que ser tu a criar um. Dicionários podem ser usados em diversas coisas, e estou certo que teremos muitas mais adiante, mas por agora deixo-vos com este simples exemplo:

>>> dict = {}
>>> dict['boolean'] = "um valor que só pode ser verdadeiro ou falso"
>>> dict['integer'] = "um número inteiro"
>>> print dict['boolean']
um valor que só pode ser verdadeiro ou falso

Repara em como iniciamos um dicionário braces, mas depois utilizamos os parêntesis rectos que aceder e adicionar valores.

Devido a estrutura interna dos dicionários, muitos dos operadores que já estudamos não são utilizados. Nada de concatenação, repetição e outros operadores. Existe uma função especifica para se aceder as chaves de um dicionário, função essa que é o Keys() (chaves), que uma vez digitada imprime todas as chaves validas de um dicionário.

Em caso que comeces a ficar um bocado cansado, podes passar para o próximo capitulo aqui Mas não te esqueças de voltar porque nos capítulos mais avançados iremos fazer uso de alguns tipos de data com tu ainda não estas familiarizado.

Outros tipos de colecções.

Array ou Vectores

Uma lista de itens que usam um índice que permite um acesso fácil e rápido. Normalmente nestes casos já tens que saber de antemão quantos itens vão fazer parte do array ou vector. Por exemplo imagina que tens um array chamado A, quando quiseres aceder a um dos itens, por simplesmente digitas A[3]. Arrays são uma parte fundamental do BASIC, visto que são o único tipo de colecção que o BASIC suporta. No Python os array podem simulados com as listas, e no Tcl é com o uso de dicionários.

Um exemplo de um Array no BASIC, há-de ser assim:

DIM Myarray(20) REM cria uma array para 20 elementos
 
MyArray(1) = 27
MyArray(2) = 50
FOR i =1 TO 5 
   PRINT MyArray(i)
NEXT i

Repara que no BASIC o índice numerário começa no 1, o que é muito pouco usual, visto na maior parte das outras linguagens o índice começa sempre no 0. Bom e é tudo quanto a array, não existem operadores, nem mais nada, tudo que és permitido fazer é cria-los, atribuir-lhes valores e depois aceder a esses valores.

Stack

Isto seria traduzido (como já devem ter reparado detesto traduzir nomes) qualquer coisa como uma pilha. Imaginem uma pilha de bandejas num restaurante o empregado de mesa coloca uma pilha de bandejas limpas num determinado sitio, onde os clientes as vão retirando. Como é obvio os clientes vão tirando as de cima primeiro, o que faz com que as debaixo sejam tiradas por último. Bom com os dados exactamente a mesma coisa, colocas um item num stack ou podes tirar um. O item tirado é sempre o último que foi lá colocado (a mesma analogia que as bandejas). A esta propriedade das Stack dá-se o nome de LIFO - Last In First Out (Último a chegar, primeiro a sair - O empregado ideal). Uma outra propriedade dos stacks é que sempre que quiseres podes inverter a ordem dos itens. Os Stack não vêem coo módulos built In, nem no Python, BASIC ou Tcl. Tens fazer um bocado de programação para implementar esse comportamento nessa linguagens. Mas as listas são um melhor ponto de começo visto que tal como os stacks, podem crescer conforme as necessidades.

Bags (sacos)

Bags são apenas de itens sem nenhuma ordenação especifica, e podem conter itens duplicados. Os bags normalmente tem operadores próprios que os permitem adicionar, remover, adicionar o encontrar itens. No caso do Python e do Tcl são são apenas Listas, no BASIC terás de as construir a partir de array muito grande.

Set

Os sets ao contrario dos bags não podem conter duplicados, existem operadores que nos permitem testar para verificar se um determinado itens já faz parte de um set ou não. Nenhuma das nossas linguagens tem o módulo de set built In mas podemos facilmente simula-las tanto no Python como no Tcl através do uso de dicionários.

Queue (fila)

Os Queue são tal como os Stack, excepto que o primeiro item a entrar é o primeiro a sair (tal como numa fila, o primeiro a chegar é o primeiro a ser atendido), a isto dá-se o nome de FIFO First in First Out.

Existem muitos outros tipos de colecções, mas estes são os principais e os que irás encontrar mais frequentemente (na realidade nós nem vamos lidar com todos eles, neste tutorial)

Ficheiros

Como um utilizador de computadores, deves saber tudo que precisas de saber - os ficheiros são a base de quase tudo que fazemos com computadores, portanto não vais ser surpresa nenhuma em saberes que a maioria das linguagens e programação tem um tipo de próprio de ficheiros para guardar dados. Contudo o processamento de ficheiros é tão importante que irei deixar isso para mais tarde, onde irei dedicar uma secção inteira a esse facto.

Datas e horas

Datas e horas normalmente são um tipo de dados muito específicos, em qualquer que seja a linguagem. Mas muitas outras vezes são simplesmente representados como um número muito grande (na maior parte das vezes como sendo um número de segundos de uma determinada data). Noutros casos é um tipo de dado que é conhecido como o o tipo complexo que é descrito na próxima secção. Quando é com este tipo de dados, normalmente fica mais fácil de extrair o mês, dia, horas, etc..

Tipos complexo/Definido pelo Utilizador

Em algumas ocasiões os tipos básicos de dados descritos nas secções anteriores, por e simplesmente são inadequados para certas operações, mesmo quando esse tipos são combinados em colecções. O que por vezes queremos é juntar várias peças de informação de trata-las como se fossem uma peça só. como exemplo vamos usar uma morada. Onde existe um número de porta, o nome da rua, o nome da cidade, etc...

A maior parte das linguagens permitem-nos agrupar toda esta informação numa estrutura ou record.

No BASIC esse record teria mais ou menos este aspecto:

Type Morada
     Hs_Porta AS INTEGER
     Rua AS STRING
     Cidade AS STRING
     codigo_postal AS STRING
End Type

No Python sseria ligeiramente diferente:

class Morada:
    def __init__(self, P, Rua, Cidade, Codigo):
        self.Hs_Porta = p
        self.Rua = rua
        self.Cidade = Cidade
        self.Codigo_postal = Codigo           

Isto pode-te parecer um tanto ou quanto estranho, mas não te preocupes, eu irei explicar o significado do def __init(...) e do self  na secção sobre programação orientada a objectos. Em caso que tenhas tentado introduzir o exemplo acima no Python certifica-te que também copias a indentação como deve ser, porque não sei se já reparaste que o Python é muito exigente quanto a isso.. <

VEJA TAMBÉM:

COMENTÁRIOS:

Este documento não possui comentários. Prestigie quem o enviou e comente.

Comentar:

Título:
Autor:   Anônimo (Efetue login para comentar identificado)
Comentário:    

OPÇÕES

ENTRE COM SEU LOGIN E SENHA

Olá visitante! Para interagir com este documento, você precisa estar logado.

Login:
Senha:  
Salvar Dados  |  Cadastre-se!

O cadastro é gratis! É muito fácil e rápido fazer o seu cadastro.

Home | Termos de Uso | Sobre o Tutomania | Publicidade | Contato
2005 - 2013 ® Tutomania.