PYTHON - Primeiros passos...¶

Operações elementares¶

In [1]:

print(2 + 3 - 1)
print(5 * 5 / 2) # Notar divisão inteira! (nota: Python 3 não é mais assim!)
print(5 * 5 / 2.0) # Notar divisão com valor float!
print(3**2) # nota: outras linguagens costumam usar o acento circunflexo ^
print( True * False)

Atribuição de valores¶

In [2]:

a = 'PI' # tipo string - aspas simples ou dupla
b = "D"
c = a + b
print(c)

PID

Estrutura de dados do tipo LISTA¶

In [3]:

d = [23, 'palavra', 4.5, 3]
print(type(d[0]))
print(type(d[1]))
print(type(d[2]))

<class 'int'>
<class 'str'>
<class 'float'>

Estrutura de dados do tipo TUPLA¶

In [4]:

e = (21.1234, 22.1234, 23.1234, 24.1234)
print('Valor na terceira posicao: {}'.format(e[2]))
print('Valor na terceira posicao: {0:.2f} \nValor na quarta: {1:.3f} '.format(e[2], e[3]))

Valor na terceira posicao: 23.1234
Valor na terceira posicao: 23.12 
Valor na quarta: 24.123

Estrutura de dados do tipo DICIONÁRIO¶

In [5]:

f = {'Cdef': 33, 'Abcd': 31, 'Bcde': 32}
print('Chaves: {}'.format(f.keys()))
print('Valores: {}'.format(f.values()))
print('Valor de Bcde: {}'.format(f['Bcde']))

Chaves: dict_keys(['Cdef', 'Abcd', 'Bcde'])
Valores: dict_values([33, 31, 32])
Valor de Bcde: 32

Tipo definido pelo usuário - CLASSE¶

In [6]:

# Definição da classe Quadrado
class Quadrado:
    """ Classe de formas poligonais.
    Cria objetos do tipo quadrado, recebendo como argumento o lado do quadrado.
    Função membro para cálculo da área.
    
    Argumentos:
    tamanho -- comprimento do lado do quadrado (default 1.0)
    """
    
    lado = 0.0
    def __init__(self, tamanho = 1.0):
        self.lado = tamanho

    def area(self):
        return self.lado**2

# solicitando o HELP da classe Quadrado
help(Quadrado)
# Criando um objeto do tipo Quadrado com lado igual a 3.5 u.m.
g = Quadrado(3.5)
# Executando o método do cálculo da área do quadrado
print('Área do quadrado: {}'.format(g.area()))

Help on class Quadrado in module __main__:

class Quadrado(builtins.object)
 |  Quadrado(tamanho=1.0)
 |  
 |  Classe de formas poligonais.
 |  Cria objetos do tipo quadrado, recebendo como argumento o lado do quadrado.
 |  Função membro para cálculo da área.
 |  
 |  Argumentos:
 |  tamanho -- comprimento do lado do quadrado (default 1.0)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, tamanho=1.0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  area(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  lado = 0.0

Área do quadrado: 12.25

Tipo datetime¶

In [7]:

import datetime
may1th2016 = datetime.datetime(2016, 5, 1) # a meia-noite
today = datetime.datetime.today()
delta = today - may1th2016
print('Formatando saída: {:%d/%m/%Y %H:%M:%S}'.format(today))
print('Diferença de "agora" e 1/5/16: {0} - {1} = {2}'.format(today, may1th2016, delta ) )

Formatando saída: 11/07/2019 10:14:42
Diferença de "agora" e 1/5/16: 2019-07-11 10:14:42.970959 - 2016-05-01 00:00:00 = 1166 days, 10:14:42.970959

Estruturas de Controle¶

In [8]:

# IF/ELIF/ELSE
a = input('Digite um numero do intervalo [0, 5): ')
ia = int(a)
if ia < 0:
    print('O número {0} é menor que zero!'.format(a))
elif ia >= 0 and ia < 5:
    print('O número {0} pertence ao intervalo!'.format(a))
elif ia == 5:
    print('Atenção: intervalo aberto em 5!')
else:
    print('O número {0} é maior que 5!'.format(a))

Digite um numero do intervalo [0, 5): 3
O número 3 pertence ao intervalo!

In [9]:

# FOR diretamente sobre uma lista
lista1 = ['a', 'b', 'c', 'd']
for letra in lista1:
    print(letra)

a
b
c
d

In [10]:

# FOR usando a função range para iterar sobre os índices da lista1
for i in range(len(lista1)):
    print ('Letra: {0}, posição: {1} '.format(lista1[i], i))

Letra: a, posição: 0 
Letra: b, posição: 1 
Letra: c, posição: 2 
Letra: d, posição: 3

In [11]:

# Criando uma lista usando o comando FOR
lista2 = [letra for letra in 'fghij']
print(lista2)
type(lista2)

['f', 'g', 'h', 'i', 'j']

Out[11]:

list

In [12]:

# WHILE
a = 1
while a != 0:
    ans = input('Digite 0 (zero) para encerrar: ')
    a = int(ans)
    if a == 999:
        print ('Número mágico!\nENCERRANDO... ')
        break
    if a == 0:
         print ('Zero digitado - saindo...')
    else:
        print ('O número {0} é diferente de zero! '.format(a))

Digite 0 (zero) para encerrar: 0
Zero digitado - saindo...

Visualizando o conteúdo da área de trabalho ou de Classes - comando DIR¶

In [13]:

dir()

Out[13]:

['In',
 'Out',
 'Quadrado',
 '_',
 '_11',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_i10',
 '_i11',
 '_i12',
 '_i13',
 '_i2',
 '_i3',
 '_i4',
 '_i5',
 '_i6',
 '_i7',
 '_i8',
 '_i9',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 'a',
 'ans',
 'b',
 'c',
 'd',
 'datetime',
 'delta',
 'e',
 'exit',
 'f',
 'g',
 'get_ipython',
 'i',
 'ia',
 'letra',
 'lista1',
 'lista2',
 'may1th2016',
 'quit',
 'today']

In [14]:

dir(Quadrado)

Out[14]:

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'area',
 'lado']

Carregando Módulos¶

import Nome_Modulo >> Nome_Modulo.funcao()
import Nome_Modulo as nm >> nm.funcao()
from Nome_Modulo import * >> funcao()
from Nome_Modulo import Nome_SubModulo >> Nome_SubModulo.funcao()

In [15]:

# Carregando os módulos NUPY e MATPLOTLLIB
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

In [16]:

# Exemplo da parábola
plt.style.use('ggplot') # define o estilo visual dos gráficos
x = np.arange(-10,11) # cria o vetor [-10, -9, ..., 9, 10]
y = x**2 -5*x + 6 # avalia elemento a elemento do vetor segundo a eq. da parábola
plt.plot(x,y) # cira um objeto de gráfico com o resultado
plt.ylim((-5,160)) # define os limites dos eixos do objeto gráfico
p = np.polynomial.Polynomial([6, -5, 1]) # cria um objeto POLINÔMIO do módulo NUMPY
print('Raízes: {}'.format(p.roots())) # calcula as raízes do polinômio e mostra na saída da tela

Raízes: [2. 3.]

PYTHON - Primeiros passos...¶

Operações elementares¶

Atribuição de valores¶

Estrutura de dados do tipo LISTA¶

Estrutura de dados do tipo TUPLA¶

Estrutura de dados do tipo DICIONÁRIO¶

Tipo definido pelo usuário - CLASSE¶

Tipo datetime¶

Estruturas de Controle¶

Visualizando o conteúdo da área de trabalho ou de Classes - comando DIR¶

Carregando Módulos¶

FIM dos exemplos ...¶

Retornar à apresentação¶