#Notas de aula - minicurso de introdução à programação com Python - aula 1

Python 3.6.5 (default, Mar 31 2018, 19:45:04) [GCC] on linux
Type "help", "copyright", "credits" or "license" for more information.

#O caracter '#' (tralha) define um comentário de linha
>>> #isto é um comentário. 
#podemos usar o prompt do Python para fazer operações em geral para execução em tempo real
>>> 2 + 3
5
>>> 2 ** 10
1024
>>> 3**4
81

#Python não trabalha com declaração de variáveis. Assim, para trabalhar com uma variável, basta fazer uma atribuição
>>> valor = 7   # a partir desse ponto, passará a existir uma variável valor associada ao dado número inteiro 7
>>> valor
7
#Em python, as variáveis funcionam como ponteiros, no sentido de que toda variável aponta para um objeto. A atribuição anterior criou a variável valor e a fez apontar para um objeto número inteiro com o valor 7

>>> a = 10     # criando uma variável a e atribuindo-lhe o valor 10
>>> a
10

#variáveis em Pyhton não possuem tipo. O que possui tipo são os objetos apontados pelas mesmas. Assim, variáveis 
#podem apontar para objetos de qualquer tipo a qualquer momento. Podemos, por exemplo trocar o objeto apontado 
#pela variável a para #uma string (objeto textual)
>>> a = "jessica"
>>> a
'jessica'
>>> a
'jessica'

#o operador "del" serve para remover variáveis.
>>> del a		#remove a variável a.
>>> a			#note que ao nos referirmos à variável a, o interpretador nos dá um erro
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

#Todo o gerenciamento de memória é feito de forma automática em Python. Assim, quando um objeto fica sem qualquer apotamento
#para si, ele é automaticamente removido da memória

#Nada nos impede de reutilizar a variável a, mesmo após esssa ter sido deletada 
>>> a = 8

#quando fazemos uma atribuição do tipo <variável2> = <variável1>, não geramos cópia do objeto apontado por <variável1>
#apenas fazemos com que <variável2> passe a apontar para o mesmo objeto que <variável1> aponta.
>>> b = a		#não gera cópia. apenas faz b apontar para o mesmo objeto que a
>>> a
8
>>> b
8

#todavia, podemos mudar o apontamento da variável a, e isso não interferirá no apontamento de b:
>>> a = 2
>>> a
2
>>> b
8

>>> b = a
>>> b
2
>>> a
2
# números em python são objetos imutáveis, ou seja, não podem ser alterados na memória após a sua criação. Apenas podem ser 
# destruídos. Por essa razão, não há qualquer perigo quando duas ou mais variáveis apontam para um mesmo objeto imutável, pois
# não há o perigo desse objeto sofrer alteração.

#tipos de objetos imutáveis:

#booleano (bool): só pode assumir dois valores: False (falso) e True (verdadeiro):

>>> c = False
>>> d = True
>>> c
False
>>> d
True

#número inteiro (int):
... 
>>> e = 9
>>> f = -11
#a quantidade de bits usada no armazenamento é arbitrária, isto é, o tipo int em Python pode fazer uso de quantos bits forem necessários para representar o número sendo armazenado
# assim,em Python podemos trabalhar naturalmente com grandes números inteiros, por exemplo dois elevado a 1000:
>>> 2 ** 1000
10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376

#números reais racionais (float):
>>> g = 3.14
>>> h = 2.17
#float são armazenados sempre com 64 bits em Python. Por essa razão, não há um tipo double.

#números complexos (complex):
#o número imaginário (raiz quadrada de -1) é representado pela letrado pela letra j... 
>>> num = 2 + 3j
>>> num
(2+3j)
>>> 2 * num
(4+6j)
#nada nos impede de declarar também uma variável j. 
>>> j = 100
#ainda assim, o interpretador consegue entender os objetos número complexos da mesma forma (basta preceder o número 
#imaginário j por um número inteiro ou real sem operador entre ambos)
>>> p = 2-9j
>>> p
(2-9j)
#nesse caso, como usamos o operador * entre o 9 e j, o interpretador enetenderá que queremos fazer conta com a 
#variável j
>>> 2 - 9*j
-898
>>> 2 - 9j
(2-9j)
>>> 5 + 1j
(5+1j)
>>> #podemos fazer conversões entre os tipos
... 
>>> c
False
>>> e
9
>>> g
3.14
>>> 
>>> e2 = float(e) # "converte" e para float
>>> e
9
>>> e2
9.0
>>> e3 = bool(e) #"converte" e para booleano
>>> e3
True
>>> e
9
>>> g
3.14
>>> k = int(g)
>>> k
3
>>> g
3.14
>>> g = int(g)
>>> g
3
>>> h
2.17
>>> x = str(h)
>>> x
'2.17'
>>> #strings também são imutáveis em Python
... 
>>> nome = 'jessica'   #strings  podem ser declaradas com aspas simples ou duplas
>>> nome
'jessica'
>>> nome[0]  $acessa o caracter na posição 0 da string
  File "<stdin>", line 1
    nome[0]  $acessa o caracter na posição 0 da string
             ^
SyntaxError: invalid syntax
>>> nome[0] #acessa o caracter na posição 0 da string
'j'
>>> nome[0] = 'g'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
# não podemos mudar uma string porque elas são imutáveis

#python define a operação de fracionamento com [] e :

>>> nome[0:4]     #acessa da posição 0 até a posição 4 sem incluir a posição 4
'jess'
>>> nome2 = nome[0:4]
>>> nome2
'jess'
>>> texto = "universo"
>>> texto[0:3]
'uni'
>>> texto[0:8]
'universo'
>>> #o operador len é o operador de comprimento genérico do Python. ele sempre retorna o número
#de elementos dentro de um objeto sequencial (no caso das strings, o número de caracteres)

>>> len(nome)
7
>>> nome
'jessica'
>>> len(nome) #retorna o número de elementos do objeto apontado por nome (7 caracteres)

#não faz sentido usar o operador len em objetos que não tenham a ideia de sequência, container ou array,
#como números inteiros, por exemplo
>>> len(100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

>>> 
>>> nome[2: len(nome) ]
'ssica'
>>> nome[2: len(nome) ] #pega do caractere 2 até o final
'ssica'
>>> nome[2: ]
'ssica'
>>> nome[2: ] #se omitir o final, ele pega até o fim da sequência
'ssica'
>>> nome[ :5] #se omitir o início, ele pega a partir do começo da sequência 
'jessi'
>>> texto
'universo'
>>> texto[0:7:2] #pega a subsequência que vai da posição 0 até a 7, de dois em dois
'uies'
>>> texto[7: 0: -1]  #como o passo é negativo, percorre ao contrário
'osrevin'
>>> texto[7: :-1]
'osrevinu'
>>> texto[ : :-1]
'osrevinu'
>>> texto[7:-1:-1]
''
>>> nome
'jessica'
>>> nome == "jessica"
True
>>> 
>>> 
>>> 
>>> texto[4]
'e'
>>> texto[5]
'r'
>>> texto[-3]
'r'
>>> texto[-1]
'o'
>>> #python define índices negativos para as sequências ordenadas. Os índices negativos começam a contar a partir do fim
... 
>>> nome2 = nome  #não gera cópia
>>> nome3 = nome[ : ]  #gera cópia (rasa)
>>> nome
'jessica'
>>> nome2
'jessica'
>>> nome3
'jessica'
>>> nome is nome2
True
>>> nome is nome2 #retorna True se nome e nome2 apontam para o mesmo objeto
True
>>> nome3 is nome
True
>>> nome3 is nome2
True
>>> 
>>> nome
'jessica'
>>> nome4 = nome[:]
>>> nome4
'jessica'
>>> 
>>> # None: tipo imutável que serve para não representar nada
... 
>>> y = None
>>> y
>>> # type: objeto do tipo "tipo"
... 
>>> a
2
>>> type(a)
<class 'int'>
>>> type(nome)
<class 'str'>
>>> 
>>> type(c) == float  #retorna True se o tipo do objeto apontado por c for float
False
>>> c
False
>>> type(h) == float  #retorna True se o tipo do objeto apontado por c for float 
True
>>> h
2.17
>>> 
>>> lista = [1,2,3]
>>> lista2 = lista
>>> lista3 = lista[:]
>>> 
>>> lista is lista2
True
>>> lista3 is lista
False
>>> 
>>> 
>>> nome
'jessica'
>>> 
>>> 
>>> #o operador in verifica participação como membro de seqência
... 
>>> 
>>> 'a' in nome
True
>>> nome
'jessica'
>>> 'w' in nome
False
>>> "jes" in "jessica"
True
>>> "jes" not in "jessica"
False
>>> "mar" in "mariana"
True
>>> "mana" in "mariana"
False


>>> #o operador + serve para concatenação de sequência

>>> 
>>> m = "wendel" + "jessica"
>>> m
'wendeljessica'
>>> 
>>> #o operador * serve para repetição de sequência

>>> dado = "ai"*4
>>> dado
'aiaiaiai'
>>> 

#o operador % permite formatação de string. Através do código %s, podemos inserir valores externos em uma string
>>> nome = "jessica"
>>> idade = 27
>>> 
>>> texto = "%s tem %s anos"%(nome, idade)
>>> texto
'jessica tem 27 anos'
>>> texto
'jessica tem 27 anos'
>>> texto2 = nome + " tem " + str(idade) + " anos"
>>> texto2
'jessica tem 27 anos'
>>> 
>>> 
>>> texto = "minha string tem %s"
>>> texto
'minha string tem %s'
>>> 
>>> 
>>> 
>>> 
>>> 
>>> idade
27
>>> 
>>> idade <= 30
True
>>> idade >= 28 and idade <= 30
False
>>> not( idade <= 30 )
False
>>> idade <= 20  or nome == "jessica"
True
>>> 
>>> 
>>> idade >= 20 and idade <= 25
False
>>> 20 <= idade <= 25
False
>>> 26 <= idade <= 30
True
>>>