Introdução A Linguagem Python

14/05/2016 Minicurso
Python
Introdução à Linguagem Python
http://localhost:8888/nbconvert/html/Minicurso%20Python.ipynb?download=false 1/27
14/05/2016 Minicurso Python
Sobre o Autor
Tales Moreira
Formado em Sistemas para Internet pelo Instituto Federal Minas Gerais
Mestrando em Modelagem Matemática e Computacional pelo CEFETMG
Iniciou no mundo da programação em 2006 com Pascal e Delphi
Programador python desde 2011
Conecimento em outras linguagens, como Java, PHP, Javascript (clientside)
Larga experiencia em frameworks de desenvolvimento, como:
PHP
Laravel
Zend
CakePHP
Javascript Frontend
ReactJS desenvolvido e utilizado em produção pela equipe do Facebook
AngularJS desenvolvido pela equipe do Google
KnockoutJS
JQuery
Bootstrap desenvolvido pela equipe do Twitter
Python para Web
Django
Flask
Projetos atuais voltados para Web estão sendo desenvolvidos Com Django, Bootstrap,
JQuery e ReactJS
História do Python
Monty Python! Grupo de humoristas ingleses;
Criada por Guido van Rossum em 1989;
Publicada em 1991 versão 0.9.0;
Criada para substituir a linguagem ABC, usada no Amoeba OS (SO distribuído criado por
Andrew Tanenbaum);
Baseada na linguagem ABC, com parte da sintaxe derivada do C, Haskell, Icon, Modula3,
e Perl;
Linguagem de propósito geral de alto nível (OO, imperativo, funcional, prodedural);
Uma das linguagens mais utilizadas no mundo;
Instalação
Linux: Python já vem préinstalado nas distribuições Linux;
Windows: Basta realizar o download e instalar, lembrando de adicionar o path nas variáveis de
ambiente do SO;
Como executar os primeiros comandos em Python? Basta abrir o terminal e digitar o comando
$ python
Posteriormente, o programa será codigicado em arquivos com extensão ".py" e executado através
do comando "python". Exemplo:
$ python main.py
Como o computador entende a linguagem?
$ python programa.py
Executa o interpretador Python que lê todas instruções do arquivo (script) passado por parâmetro,
compila e gera um arquivo .pyc ou .pyo (otimizado), e executa o programa. O programa é
executado em ordem (fluxo de execução), de cima para baixo, linha a linha, instrução por
instrução.
Python – Hashbang (shebang)
#!/usr/bin/env python3
print('Olá mundo!')
O hashbang é respeitado somente se o programa for executado sem informar o interpretador
explicitamente. Por exemplo:
./script.py # Ao invés de: python script.py
Python – Encoding dos arquivos
No Python 3 o encoding padrão é UTF8. No Python 2, era necessário adicionar uma linha
chamada magic comment informando o encoding.
O interpretador identifica ela nas 2 primeiras linhas do arquivo. Por exemplo:
#!/usr/bin/env python
# ‐*‐ coding: utf‐8 ‐*‐
Python – Comentários
#!/usr/bin/env python3
# Comentário
"""
Outro comentário
"""
''' Mais um comentário '''
Python – Variáveis
Reserva um espaço na memória para armazenar um dado/valor de um determinado tipo, e o
associa a um nome.
In [1]:
var1 = 5
var2 = 10
var3 = var1 * var2
print (var3)
50
Restrições de nomenclatura
Somente letras, números, underscore;
Não pode iniciar com número;
Não pode ser uma palavra reservada:
and, as, assert, break, class, continue, def, del, elif, else, exce
pt, exec, finally, for, from, global, if, import, in, is, lambda, n
ot, or, pass, print, raise, return, try, while, with, yield
Alguns tipos importantes
‐ str (‐ing) 'Texto entre aspas', 'palavra'
‐ bool (‐ean) True ou False
‐ int (‐eger) 1, 2, 10, 5000
‐ float 3.1415, 9.8, 1.61803398875
‐ list [ 'palavra', True, 1, 3.1415 ]
‐ dict { 'prop':'nome', 'tem':True }
‐ tuple ( 'palavra', True, 1, 3.1415 )
‐ type Tipo dos tipos :‐)
Tipagem forte e dinâmica
O último valor atribuído à variável indicará o tipo dela.
In [2]:
var1 = "valor" # atribuição de string
var2 = 'valor' # atribuição de string
var1 = 5 # atribuição de inteiro
var2 = 3.1337 # atribuição de float
print(var2, type(var2))
print()
# múltiplas atribuições
a, b, c = 1, 2.5, 'teste'
print(a, b, c)
print(type(a), type(b), type(c))
3.1337 <class 'float'>
1 2.5 teste
<class 'int'> <class 'float'> <class 'str'>
str
– Tipo composto por um conjunto imutável de caracteres, texto.
In [36]:
fruta = "banana"
marca = """Tesla"""
str1 = 'abc'
str2 = '''teste'''
print(len(fruta)) # retorna o comprimento, 6
print(fruta[0]) # retorna 'b'
print(fruta[2:5]) # retorna 'nan'
print(fruta.upper()) # retorna 'BANANA'
print(fruta.find('n', 3))
print(fruta.split('n'))
6
b
nan
BANANA
4
['ba', 'a', 'a']
bool
– Verdadeiro ou falso.
George Boole? Matemático Inglês autodidata que definiu o primeiro sistema de lógica algébrica na
metade do século XIX, nomeado álgebra booliana, ou de Boole.
In [4]:
var1 = True # verdadeiro
var2 = False # falso
print(var1, var2)
True False
int
– Números inteiros sem limite de bits!
NOTA: int e long eram diferentes antes do Python 3 – a PEP 237 unificou. * PEP: Python
Enhancement Proposal
In [5]:
var1 = 1991
var2 = 2016
print(var1, var2)
1991 2016
float
– Números decimais (double).
In [6]:
var1 = 1.2345
var2 = 3.141592
print(var1, var2)
1.2345 3.141592
constantes
– ”Variáveis” não mutáveis.
Não são formalmente definidas pela linguagem, mas a convenção é nomear variáveis utilizando
apenas letras maiúsculas.
OBS: Podemos contornar utilizando class properties.
In [7]:
PI = 3.141592
MAX_LENGTH = 255
print(PI, MAX_LENGTH)
PI = 3.14
print(PI)
3.141592 255
3.14
Objetos e valores
No exemplo abaixo, a e b apontam para a mesma string?
a = 'banana'
b = 'banana'
No primeiro caso, a e b se referem a duas coisas diferentes com o mesmo valor. No segundo caso,
elas se referem à mesma coisa.
Todo objeto possui um identificador único que pode ser obtido com a função id().
Se 2 objetos possuem o mesmo identificador, significa que apontam para (referenciam) o mesmo
valor.
print(id(a)) #135044008
print(id(b)) #135044008
Exemplo com Listas
In [8]:
a = [1, 2, 3]
b = [1, 2, 3]
print(id(a), id(b))
189958878984 189958880200
Referências, apelidos (aliases)
In [9]:
a = [1, 2, 3]
b = a
print(id(a), id(b))
189958902024 189958902024
Escopos
Escopo Global: Variáveis criadas fora do escopo de qualquer função/classe são criadas no
escopo global. O valor das variáveis globais é "esquecido" quando o programa termina.
Escopo Local Variáveis criadas dentro do escopo de funções ou classes tem escopo local.
O valor das variáveis locais é "esquecido” automaticamente quando a função termina, ou
quando o interpretador identifica que o objeto em questão não está mais sendo utilizado
neste caso, pode ser forçado via gc.collect().
Indentação
Recuo do texto em relação a margem. No caso específico do Python, é determinante para a
definição do escopo de um bloco de código.
In [10]:
def teste():
'''retorna um número'''
my_int = 12
return my_int
print(teste())
File "<ipython‐input‐10‐64f8a593a4cd>", line 2
'''retorna um número'''
^
IndentationError: expected an indented block
Operadores
Operadores são utilizados em expressões. Os tipos são:
Aritméticos
Atribuição
Lógicos
Bitwise
Comparação
Membership (filiação?)
Identity (identidade)
Aritméticos
# Soma
a + b, a + 2, 100 + 20
# Subtração
a – b, a ‐ 2, 100 ‐ 20
# Multiplicação
a * b, a * 2, 100 * 20
# Divisão
a / b, a / 2, 100 / 20
# Módulo*
a % b, a % 2, 100 % 2
# Divisão floor*
a // b, a // 2, 100 // 2
# Exponenciação
a ** b, a ** 2, 100 ** 3
"""
* Módulo é o resto da divisão. Exemplo: 3 % 2 == 1.
* Divisão floor é o quociente inteiro da divisão, sem decimais. Exemplo: 9
// 2 == 4
"""
Os operadores de soma (+) e ”módulo” (%) podem ser utilizados com strings
também. O operador de módulo para strings tem outro nome, operador de
formatação de string.
In [11]:
var1 = 'abc' + 'def' # soma de 2 strings literais
print(var1)
var2 = var1 + var1 # soma de 2 variáveis do tipo str
print(var2)
var3 = 'Teste ' + var1 # soma de 1 variável do tipo str e uma string literal.
var3 = 'Teste %d' % 123 # formata a string. Como o tipo str é imutável, uma nova s
tr é criada em cada operação.
print(var3)
data_formatada = "Hoje é %d de %s" % (14, 'Maio')
print(data_formatada)
abcdef
abcdefabcdef
Teste 123
Hoje é 14 de Maio
Atribuição
Como armazenar um valor em uma variável?
a = b
Atribui o valor do operando da direita ao operando da esquerda. O operador de atribuição requer
que o operando da esquerda seja uma variável.
No Python, especificamente, é possível realizar múltiplas atribuições utilizando um único operador
de atribuição:
a, b = x, y
(a, b) = x, y
a, b, c = x, y, z
a, (b, c) = [x, [y, z]]
Atribuição Existem outros operadores de atribuição:
a = a + b
a += b
a /= b
a //= b
a ‐= b
a %= b
a *= b
a **= b
Lógicos
Lembram do tipo bool? True e False?
Tabela verdade (1922);
a and b # and
a or b # or
not a # not
Comparação
< # menor que
> # maior que
<= # menor ou igual a
>= # maior ou igual a
== # igual a
!= # diferente de
Membership?
in # True se o valor está presente numa sequência, False caso contrário (x
in y)
not in # False se o valor está presente numa sequência, True caso contrári
o (x not in y)
Identity
is # True se os operandos referenciam o mesmo objeto, False caso contrário
(x is y, id(x) equals id(y))
is not # False se os operandos referenciam o mesmo objeto, True caso contr
ário (x is not y, id(x) not equal id(y))
Conversões
str(10) integer > string
str(10.1) float > string
str({'v':True}) object > string
int('10') string > integer
float('10.1') string > float
int(10.1) float >
int float(10) int > float
Formatadores de string
In [12]:
nome = input('Qual é o seu nome?n')
idade = int(input('Qual é o sua idade?n'))
print('Olá %s!' % nome)
print('%s, %d anos' % (nome, idade))
print('{0}, {1} anos'.format(nome, idade))
print('{}, {} anos'.format(nome, idade))
frase = '{a}, {b} anos'.format(a=nome, b=idade)
print(frase)
Qual é o seu nome?nTales
Qual é o sua idade?n28
Olá Tales!
Tales, 28 anos
Tales, 28 anos
Tales, 28 anos
Tales, 28 anos
Listas
Conjunto mutável de valores (elementos) de qualquer tipo, com índices de 0 a N.
In [13]:
# Criando
# vazia
lista = []
lista = list()
print(lista)
# contendo números de 0 a 29
lista = list(range(30))
print(lista)
# contendo números de 5 a 29
lista = list(range(5, 30))
print(lista)
# contendo números múltiplos de 5 entre 0 e 29
lista = list(range(0, 30, 5))
print(lista)
# Clonando
lista2 = list(lista)
print(id(lista), id(lista2))
[]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 1
9, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 2
3, 24, 25, 26, 27, 28, 29]
[0, 5, 10, 15, 20, 25]
189974783240 189974783688
In [14]:
print(lista)
# Adicionando itens
lista.append(12)
print(lista)
# Removendo itens
lista.remove(5)
print(lista)
i = 2
lista.pop(i)
print(lista)
del lista[0]
print(lista)
del lista[2:4]
print(lista)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12]
[0, 1, 2, 3, 4, 6, 7, 8, 9, 12]
[0, 1, 3, 4, 6, 7, 8, 9, 12]
[1, 3, 4, 6, 7, 8, 9, 12]
[1, 3, 7, 8, 9, 12]
In [15]:
print(lista)
# Acessando itens
print(lista[0])
print(lista[1])
print(lista[4‐2]) # Qual índice será acessado?
print(lista[‐1]) # Qual índice será acessado?
print(lista[‐2]) # Qual índice será acessado?
# Alterando itens
lista[0] = 1000
print(lista)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
2
9
8
[1000, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [16]:
print(lista)
# Tamanho, comprimento
len(lista) # retorna o # de itens na lista
#inverso
lista.reverse()
print(lista)
# Ordenando
print(sorted(lista)) # retorna uma nova lista ordenada
print(lista)
lista.sort() # muda a própria lista
print(lista)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [17]:
# Testando existência do item
print(10 in lista) # retorna True ou False
# Repartindo
start = 2
end = 5
print(lista[start:end]) # items de start até end‐1
print(lista[start:]) # items de start até o fim
print(lista[:end]) # items do início até end‐1
print(lista[:]) # uma cópia da lista inteira
False
[2, 3, 4]
[2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [18]:
# Matrizes Representadas por listas aninhadas (lista de listas, ou array de array
s).
m3x2 = [[1, 7, 9],[8, 4, 2]]
m3x2[0] == [1, 7, 9]
m3x2[1] == [8, 4, 2]
print(m3x2)
m3x2[0][0] == 1
m3x2[1][1] == 4
m3x3 = [
[1,0,0],
[0,1,0],
[0,0,1]
]
print(m3x3)
[[1, 7, 9], [8, 4, 2]]
[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
Dicionários
Tipo composto que utiliza qualquer tipo como índice.
In [19]:
# Criando
# vazio
d = dict()
d = {}
# contendo propriedades
d = {'name': 'value'}
print(d)
d = {'x': 1, 'y': 2}
print(d)
# usando uma lista de tuples
d = dict([('x', 1), ('y', 2)])
print(d)
# Clonando
d2 = d.copy()
# Adicionando propriedades
d = {}
d['nome'] = 'Bruce Lee'
d['ano'] = 1940
print(d)
# Removendo propriedades
del d['nome']
print(d)
d['nome'] = 'Bruce Lee'
#Outras operações:
print(len(d)) # Retorna tamanho, compimento
print(d.keys()) # Retorna chaves (nome das propriedades)
print(d.values()) # Retorna valores (das propriedades)
print(d.items()) # Retorna lista de tuplas de chave‐valor
print('nome' in d) # A propriedade existe? True ou False
{'name': 'value'}
{'x': 1, 'y': 2}
{'x': 1, 'y': 2}
{'ano': 1940, 'nome': 'Bruce Lee'}
{'ano': 1940}
2
dict_keys(['ano', 'nome'])
dict_values([1940, 'Bruce Lee'])
dict_items([('ano', 1940), ('nome', 'Bruce Lee')])
True
Tuplas
Lista de valores separados por vírgula, similar a lista, porém imutável.
In [20]:
# Criando
t = 'a', 'b', 'c', 'd', 'e'
print(t)
t = ('a', 'b', 'c', 'd', 'e')
print(t)
t = ('a',) # Note a vírgula no final Sem a vírgula, o interpretador entenderá que
é apenas uma string entre parênteses.
print(t)
# Tamanho, comprimento
print(len(t)) # retorna o # de itens na tupla
('a', 'b', 'c', 'd', 'e')
('a', 'b', 'c', 'd', 'e')
('a',)
1
In [21]:
# Alterando elementos
t[0] = 'x'
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐
TypeError Traceback (most recent call
last)
<ipython‐input‐21‐e00e67af15c8> in <module>()
1 # Alterando elementos
‐‐‐‐> 2 t[0] = 'x'
TypeError: 'tuple' object does not support item assignment
In [ ]:
# Removendo elementos
del t[0]
In [ ]:
# Testando existência do item
print('a' in t) # retorna True ou False
# Repartindo
t = ('a', 'b', 'c', 'd', 'e')
start = 2
end = 4
print(t[start:end]) # items de start até end‐1
print(t[start:]) # items de start até o fim
print(t[:end]) # items do início até end‐1
print(t[:]) # uma cópia da lista inteira
In [ ]:
# Trocando valores (sem tupla)
a = ('a',)
b = ('b',)
print(a, b)
temp = a
a = b
b = temp
print(a, b)
In [22]:
# Trocando valores usando atribuição de tupla
a = ('a',)
b = ('b',)
print(a, b)
a, b = b, a
print(a, b)
('a',) ('b',)
('b',) ('a',)
Condições e condicionais
Condições podem ser verdadeiras ou falsas. Por exemplo: A expressão x > 10 é verdadeira se o
valor da variável x for maior que 10, caso contrário a expressão é falsa.
Condicionais dependem de condições, portanto elas permitem que você faça uma coisa ou outra,
dependendo do resultado da condição.
A condicional mais comum é a palavrachave if. Por exemplo:
if x > 10: print('maior que 10')
As vezes você quer fazer uma coisa quando a condição é verdadeira, e outra coisa quando ela é
falsa. A palavrachave else permite que você faça isto. Exemplo:
if x > 10: print('maior que 10') else: print('menor que 10')
Condicionais aninhados:
In [23]:
x = 1
y = 2
if x == y:
print(x, 'e', y, 'são iguais')
else:
if x < y:
print(x, 'é menor que', y)
else: print(x, 'é maior que', y)
1 é menor que 2
Também é possível testar várias condições, e fazer uma coisa somente para a primeira condição
que for verdadeira. Para isto usamos a palavrachave elif (abrev de else if). Exemplo:
In [24]:
x = 1
y = 2
if x == y:
print(x, 'e', y, 'são iguais')
elif x < y:
print(x, 'é menor que', y)
else:
print(x, 'é maior que', y)
1 é menor que 2
Operador ternário (desde Python 2.5)
a if cond else b
Testa a condição cond, e retorna a ou b, dependendo do resultado da condição.
In [25]:
resultado = 'maior' if x > 10 else 'menor'
print('x é %s que 10' % resultado)
x é menor que 10
In [26]:
import time
agora = time.localtime()
hora = agora.tm_hour
if hora < 7:
print('dormindo')
elif hora < 8:
print('indo trabalhar')
elif hora < 13 and hora > 12:
print('almoçando')
elif hora < 18:
print('trabalhando')
elif hora < 19:
print('voltando pra casa')
elif hora < 20:
print('jantando')
elif hora < 22:
print('descansando')
else:
print('dormindo')
trabalhando
Loops (laços)
É comum a necessidade de repetir uma ou mais instruções um determinado número de vezes.
Para isto, podemos usar a palavrachave while. Exemplo:
In [27]:
lista = [0,10,20,30,40,50]
indice = 0
while indice < len(lista):
print('num = %d' % lista[indice])
indice += 1
num = 0
num = 10
num = 20
num = 30
num = 40
num = 50
Utilizar um índice para percorrer um conjunto de valores é tão comum que o Python oferece uma
alternativa simplificada, as palavraschave forin. Exemplo:
In [28]:
lista = [0,10,20,30,40,50]
for num in lista:
print('num = %d' % num)
for i, num in enumerate(lista):
print('lista[%d] = %d' % (i, num))
num = 0
num = 10
num = 20
num = 30
num = 40
num = 50
lista[0] = 0
lista[1] = 10
lista[2] = 20
lista[3] = 30
lista[4] = 40
lista[5] = 50
Outro exemplo:
In [29]:
prefixos = 'JKLMNOPQ'
sufixo = 'ython'
for letra in prefixos:
print(letra + sufixo)
Jython
Kython
Lython
Mython
Nython
Oython
Python
Qython
Funções
Função é uma sequência nomeada de instruções ou comandos que realizam uma operação
desejada.
Deve ser definida/declarada ANTES de ser utilizada, chamada, invocada;
Pode ser chamada repetidamente;
Pode chamar outra função (composição), inclusive a si mesma (recursividade);
Pode receber argumentos (parâmetros) ou não;
Pode retornar um resultado ou não;
A definição de uma função não altera o fluxo de execução do programa;
Os comandos dentro da função não são executados até a função ser chamada;
Chamadas de função são como um desvio no fluxo de execução. Em vez de ir para o
próximo comando, o fluxo salta para a primeira linha da função chamada, executa todos
os comandos lá e então volta atrás para retomar de onde havia deixado.
Como declarar uma função?
def NOME():
COMANDOS # corpo da função, function’s body
def NOME():
pass # função vazia, sem implementação
In [30]:
def OlaMundo():
texto = 'Olá mundo!'
print(texto)

def OlaNovamente():
texto = 'Olá novamente!'
print(texto)

# Como chamar (invocar, executar) uma função?
OlaMundo()
OlaNovamente()
Olá mundo!
Olá novamente!
Argumentos
Argumentos são valores passados para a função, e podem influenciar no fluxo de execução, ou
comportamento, da função. Argumentos tem escopo LOCAL.
Como declarar uma função com argumentos?
def NOME(ARGUMENTOS):
pass
def NOME(arg1, arg2, arg3):
pass
In [31]:
def nome1(arg1):
print('Olá', arg1)
def nome2(arg1, arg2):
print('Olá', arg1, arg2)
nome1('Tales')
nome2('Tales', 'Moreira')
Olá Tales
Olá Tales Moreira
In [32]:
nome1('Tales', 'Moreira')
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐
last)
<ipython‐input‐32‐1985d3af6032> in <module>()
‐‐‐‐> 1 nome1('Tales', 'Moreira')
TypeError: nome1() takes 1 positional argument but 2 were given
In [33]:
nome2('Tales')
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
‐‐‐‐‐‐
last)
<ipython‐input‐33‐9a96a51352b4> in <module>()
‐‐‐‐> 1 nome2('Tales')
TypeError: nome2() missing 1 required positional argument: 'arg2'
Retorno
O resultado de uma função é chamado de valor de retorno. A palavra chave return permite que
uma função retorne valores, e também permite terminar a execução de uma função antes de ela
alcançar seu fim. Um uso comum para isto é ao detectar uma condição de erro.
Exemplo de retorno precoce (antecipado):
In [34]:
def calculaPotencia(num, pot):
if num <= 0 or pot <= 0:
print('Somente números positivos')
return
return num ** pot
print(calculaPotencia(‐1, 2))
print(calculaPotencia(2, 2))
Somente números positivos
None
4
def nada():
return # ou return None
def potencia(valor, potencia):
return valor ** potencia
def fatorial(num):
import math
return math.factorial(num)
def tupla():
return True, 'Teste'
Objetos
In [38]:
class Nome(object):

nome = None

def __init__(self, nome):
self.nome = nome
obj = Nome("Tales")
print(obj.nome)
Tales
In [ ]:


Introdução A Linguagem Python

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Introdução A Linguagem Python

Enviado por

Direitos autorais:

Formatos disponíveis

14/05/2016 Minicurso

Você também pode gostar