Trabalho sobre a linguagem Python

Python
Luan Ferreira Cardoso
Ricardo Solon Zalla
Trabalho para o curso de Linguagens de Programação do 9º período de Engenharia da Computação do IME
20 de maio de 2016

Sumário
1. Introdução
2. Python comparada à Java
3. O básico de Python
4. Variáveis e tipo de dados
5. Expressões e comandos
6. Modularização
7. Polimorfismo
8. Exceções
9. Concorre ̂ncia

O que é Python?
● Criado em 1990 por Guido Van Rossum
● Sobre o Pytho original, Van Rossum escreveu em 1996:
“Seis anos atrás, em Dezembro de 1989, eu estava procurando um hobbie
de programação que me manteria ocupado durante a semana de Natal. Meu
escritório estaria fechado … No entanto, eu tinha um computador em casa e
não tanta coisa a mais assim pra fazer. Eu decidi escrever um interpretador
para uma nova linguagem de script que eu estava pensando ultimamente: uma
descendente do ABC que seria endereçada para Unix/C hackers. Eu escolhi
Python com o título do projeto, me pareceu um título com um humor
irreverente (e de um grande fã de Monty Python’s Flying Circus).

Python é uma linguagem de script?
● Geralmente pensada com uma mas é principalmente uma questão de marketing
○ As pessoas pensam que linguagens de script são mais fáceis de
aprender e utilizar
● No entanto Python é uma linguagem de programação bem trabalhada,
dinâmica e coerente podendo ser utilizada numa gama muito grande de
aplicações.

Filosofia de Design
The Zen of Python, por Tim Peters tradução livre
Bonito é melhor que feia.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Linear é melhor aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o suficiente para quebrar regras
Embora praticabilidade seja melhor que pureza.
Erros nunca deverão passar em silêncio
A menos que explicitamente silenciados.
Caso ocorra ambiguidade, recuse a tentação de adivinhar.
Deveria existir um - e preferencialmente somente um - jeito óbvio de fazer.
Embora esse jeito possa ser não tão óbvio a menos que você seja Holandês.
Agora é melhor que nunca.
Embora nunca é melhor que exatamente agora.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces é uma grande ideia -- vamos fazer mais disso!

Por que Python?
● Design fácil de ser aprendido
○ Limpo
○ Muito poucas palavras chaves
● Altamente portátil
○ Roda quase em qualquer lugar - servidores e estações de trabalho
○ Utiliza byte-codes independente de máquina
● Extensível
○ Design pode ser extensível utilizando C/C++, permitindo acesso à
muitas bibliotecas externas

Características notórias
● Sintaxe limpa mais tipo de dados de alto nível
○ Isso leva a uma codificação rápida!
● Utiliza espaço em branco para delimitar blocos
○ Humanos geralmente fazem isso, por que não uma linguagem de
programação?
● Variáveis não necessitam de declaração
○ Muito embora não seja uma linguagem sem tipo.

Produtividade
● Tempo de desenvolvimento reduzido
○ tempo de codificação é de 2-10 vezes menor que C,C++, Java
● Manutenção de código melhorada
○ o código é extremamente legível
● Menor treinamento
○ linguagem é muito fácil de aprender

Para que ela é utilizada?
● rápida prototipação
● web script
● Aplicações científicas
● Linguagens de extensão
● Processamento XML
● Aplicações de banco de dados
● Aplicações de interface

Python vs. Java
● Código é de 5-10 mais conciso
● Desenvolvimento muito mais rápido
○ Sem fase de compilação
○ Menos codificação
● Sim, ela roda mais devagar
○ No entanto, desenvolvimento é muito mais rápido!
● Utilize Python com Java: Jython!

Programas em Python
● Programas em Python e módulos são escritos como arquivos texto com
tradicionalmente uma extensão .py
● Cada modulo Python tem o seu próprio namespace discreto
● Namespace dentro de um módulo Phyton é um namespace global
● Módulos Python e programas são diferenciados somente pelo jeito que eles
são chamados
○ arquivos .py executados diretamente são programas (geralmente
chamados scripts)
○ arquivos .py referenciados via declaração statement são módulos
● Portanto, o mesmo arquivo .py pode ser um programa/script ou um módulo

Python - Conceitos
● Python é uma linguagem
○ Interpretada
○ Multiparadigmas: orientadas a objeto, imperativa, funcional e
procedural
○ Fortemente tipada
○ Dinamicamente tipada

Váriaveis e Tipos
● Variáveis não precisam de declaração
○ >>> a=1
○ >>>
● Como uma atribuição de valor é uma declaração não há resultado impresso
na tela
○ >>>a
○ 1
● Um nome de variável sozinha é uma expressão. Portanto o resultado é
impresso na tela

Váriaveis e Tipos
● Variáveis devem ser criadas antes delas serem usadas
○ >>> b
○ Traceback (innermost last):
○ File “<interactive input>”, line
○ 1, in?
○ NameEroor: b
○ >>>
● Objetos sempre tem um tipo
○ >>>a=1
○ >>>type(a)
○ <type ‘int’>
○ >>> a=”Luan”
○ type(a)
○ <type ‘string’>

Tarefas vs Testes de Igualdade
● Tarefas são executadas com um simples =
● Testes de igualdade são realizados com um duplo = (==)
○ Promoções sensíveis de tipo são definidos
○ Testes de identidade com o operador is
● >>> 1==1
● 1
● >>> 1.0==1
● 1
● >>> “1”==1
● 0

Tipos de Dados
● Strings
○ Pode incluir qualquer tipo de dado, incluindo NULLs embutidos
○ Declarado incluindo single, double ou triple aspas
○ >>> s = “Hi there”
○ >>> s
○ ‘Hi there’
○ >>> s = “Embedded ‘quote’”
○ >>>s
○ “Embedded ‘quote’”

Tipos de Dados
● Aspas triplas úteis para strings multilinhas
○ >>> s = “““ uma string
○ … muito longa com “aspas” ou
○ qualquer outra coisa“““
○ >>> s
○ ‘uma string muito longa com “aspas” ou qualquer outra coisa’
○ >>> len(s)
○ 45

Tipos de Dados
● Inteiros implementados utilizando long C
○ Como C, divisão de inteiros retornam o floor
○ >>> 5/2
○ 2
● Tipos Floats implementados utilizando doubles C

Tipos de Dados
● Tipos de Dados de alto nível
○ Pode conter qualquer objeto
○ Declarado utilizando colchetes
○ >>> 1= []# An empty list
○ >>> l.append(1)
○ >>> l.append(“Hi there”)
○ >>> len(l)
○ 2
○ >>>l
○ [1, ‘Hi there’]

Listas e Strings
● Classes de sequências built-in
○ Fatiamento e ordenação
[begin : end : ordem]
>>> lista = [1, 'python', 4.3]
>>> lista[:2]
[1, 'python']
>>> lista[::-1]
[4.3, 'python', 1]
>>> len(lista)
>>> 3
>>> s = ‘551 arof’
>>> s[::-1]
>>> 155 fora

Tipos de Dados
● Tuplas são similares à listas
○ Sequencia de itens
○ A diferença chave é que são imutáveis
○ Frequentemente utilizado no lugar de estruturas simples
○ point = 2,3
○ >>> x,y = point
○ >>> x
○ 2
● Tuplas são particularmente utilizadas para retornar múltiplos valores de
uma função
○ >>> x,y = GetPoint()

Tipos de Dados
● Dicionários aceitam chave - par de valores
○ Frequentemente chamados maps ou hashes. Implementados utilizando
hash - tables
○ Chaves podem ser objetos imutáveis, valores podem ser qualquer
objeto
○ Declarados utilizando colchetes
○ >>> d={}
○ >>> d[0]= “ Olá ”
○ >>> d[“foo”] = 1
○ >>> len(d)
○ 2
○ >>> d[0]
○ ‘ Olá ‘

Expressões e Comandos
● Expressões
○ Instruções que o interpretador python executa
Atribuição não produz saída
>>> my_list = [‘LP’, 3, 3.14]
>>> print my_list
[‘LP’, 3, 3.14]
>>> print my_list[1]+my_list[2]
6.14
>>> 5892719 % 417
92
● Precedência de operadores
○ Acrônimo PEMDAS
● Expressões em curto circuito
○ Operadores and, or
○ Resultado: Booleano

Modularização
Não força a pensar em objetos mas
→ Todos os tipos são derivados de Object(): 3 é instância de int()
→ Todos os tipos são classes
Passagem de parâmetros
→ Somente por referência (sem necessidade de operadores)
TADs
→ Suporte a encapsulamento
Variáveis privadas
- Não existe modificador de acesso protected/private
- Convenção: Prefixo _ parte não pública
- Prefixo __ #__spam -> _nomeclasse__spam
→ Suporte a polimorfismo
Compilação separada
→ Não é compilado em etapa separada antes da execução
→ Compilação “on-the-fly”, código de bytes independente da plataforma

Modularização
Suporte a módulos
● fibonacci.py
○ Importar do shell
>>> import fibonacci
>>> fibonacci.fib_rec(30)
832040
○ >>> from fibonacci import fib_rec, fib_ite
>>> fib_rec(30)
832040
○ >>> from fibonacci import * as f
● Atribuição de nome local
○ >>> rec = fibonacci.fib_rec

Polimorfismo
● Oveload
○ Operadores
__add__, __mult__, …
def __add__(self, c):
return Complex(self.real + c.real, self.imag + c.imag)
>>> c+d*e
● Override
○ Classes derivadas podem sobrescrever classe base
→ Referenciar base (super) para chamar método dela
>>> class A(object):
... def who_is(self):
... print 'A'
>>> class B(A):
... def who_is(self):
... print 'B' ...
>>> x = B()
>>> x.who_is() # chama método da classe B
>>> super(B, x).who_is() # chama método da classe A

Polimorfismo
● -Herança
○ Sem modificadores de acesso
○ Herança múltipla
class NomeClasseDerivada(Base1, Base2, Base3):
● -Classe abstrata
○ Módulo Abstract Base Class (ABC)
__metaclass__ = ABCMeta #atributo
@abstractmethod #método
● Metaclasses
○ Derivadas de type
Instanciar classes: atributo # __metaclass__ = metaclasse

class Pessoa:
def __init__(self, nome ='', idade=0):
self.nome = nome
self.idade = idade
def getIdade(self):
return self.idade
class PessoaFisica(Pessoa):
def __init__(self, CPF, nome='', idade=0):
Pessoa.__init__(self, nome, idade)
self.CPF = CPF
class PessoaJuridica(Pessoa):
def __init__(self, CNPJ, nome='', idade=0):
Pessoa.__init__(self, nome, idade)
self.CNPJ = CNPJ
Polimorfismo

Polimorfismo
a = Pessoa()
Pessoa.__init__(a, 'Leonardo', 22)
b = PessoaFisica('122.333.332-1', nome='', idade=0)
banco = PessoaJuridica('00.000.000/0001-11', nome='Banco do Brasil', idade=435)
print a.nome # imprime Leonardo
print a.idade # imprime 22
print b.CPF # imprime 122.333.332-1
print banco.CNPJ # imprime 00.000.000/0001-11

Exceções
1. Erros de sintaxe
2. Exceções
- Sintaticamente correto
- Erro na execução

Built-in Exceptions
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> '2' + 2
TypeError: cannot concatenate 'str' and 'int' objects

Handling Exceptions
>>> while True:
... try:
... x = int(raw_input("Please enter a number: "))
... break
... except ValueError:
... print "Oops! That was no valid number. Try again..."

User-defined Exceptions
● Criar classes derivadas de Exception()
○ MinhaException(Exception) { … }
class Error(Exception):
"""Base class for exceptions in this module."""
pass
class Ex1(Error):
"""Base class for exception 1 in this module."""
pass
class Ex2(Error):
"""Base class for exception 2 in this module."""
pass

User-defined Exceptions
>>> class MyError(Exception):
... def __init__(self, value):
... self.value = value
... def __str__(self):
... return repr(self.value)
...
>>> try:
... raise MyError(2*2)
... except MyError as e:
... print 'My exception occurred, value:', e.value
...
My exception occurred, value: 4
>>> raise MyError('oops!')
__main__.MyError: 'oops!'

Clean-up Actions
finally
○ Clause do try que será executada em qualquer circunstância
○ Exceções não tratadas serão lançadas após o finally

Clean-up Actions
>>> def divide(x, y):
... try:
... result = x / y
... except ZeroDivisionError:
... print "division by zero!"
... else:
... print "result is", result
... finally:
... print "executing finally clause"
...
>>> divide(2, 1)
result is 2
executing finally clause
>>> divide(2, 0)
division by zero!
>>> divide("2", "1")
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Concorrência
● Módulos built-in
○ _thread: baixo nível, light-weight tasks
○ threading: alto nível, mais complexa
Controlar multiplas threads:
thread.start_new_thread(function, args[,kwargs])
Sincronização:
lock, Semaphore
-

Trabalho sobre a linguagem Python

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Trabalho sobre a linguagem Python (20)

Último (12)

Trabalho sobre a linguagem Python