Você está na página 1de 376

Python

Sofiane Labidi, PhD.


 Introdução ........................................................................ 04
 Python? ........................................................................... 08
 Instalação ......................................................................... 17
 IDLE Python ..................................................................... 28
 Expressões Python ............................................................ 42
Roteiro  Tipagem ........................................................................... 56
 Strings ............................................................................. 76
 Atribuições ..................................................................... 112
 Saídas ............................................................................ 120
 Entradas ......................................................................... 150

2
 Controle Condicional ............................................................... 164
 Estruturas de Repetição ........................................................... 170
 Funções .................................................................................. 179
 Coleções ................................................................................. 191
 Arquivos ................................................................................. 300
 Matemática ............................................................................ 336
Roteiro  Classes .................................................................................... 344
 Utilitários ............................................................................... 346
 Gráficos .................................................................................. 351
 Exceções ................................................................................. 354
 Packages ................................................................................ 358
 Anaconda .............................................................................. 362
 Conclusão ............................................................................... 373

3
Introdução

4
Linguagem de
Programação

Linguagens de
Programação Permite às pessoas de expressarem o que eles desejam
que o computador faz.

Transmite ao computador como fazer isto!

5
 Programação Estruturada
C, Pascal, etc.

 Programação Orientada a Objeto


Java, C++, C#, SmallTalk, Eiffel, etc.

 Programação Funcional
Paradigmas de Lisp, Scheme ML, SML,etc.
Programação  Programação Lógica
Prologo, etc.

 Programação Visual
Delphi, JBuilder, C++Builder, etc.

 Programação Concorrente / Distribuída / Paralela


OCCAM, C*, Ada, SR, Linda, Orca, etc.

6
Paradigmas de
Programação  Podemos ter uma Linguagem Multiparadigmas ?
 Qual é a melhor linguagem de Programação?

7
Python?

8
• Python é uma linguagem criada por Guido van Rossum no
final de 1989, no Instituto Nacional de Matemática e Ciência
da Computação da Holanda –CWI.

• Criada a partir da linguagem ABC.

• Foco inicial: auxiliar os profissionais da física e das


A Linguagem engenharias.
Python
•É uma linguagem de programação livre, com
desenvolvimento comunitário.

• O nome é uma homenagem ao grupo humorístico britânico


Monty Python, criador do programa Monty Python's Flying
Circus.

9
• Empresas que usam Python: Google (aplicações web),
Yahoo (aplicações web), Microsoft (IronPython: Python
para .NET), Disney (animações 3D).

• Linguagem Python está na versão 3.6 quebrando a


A Linguagem
compatibilidade com as versões anteriores 2.6, etc. (o
Python
objetivo de corrigir falhas).

• Python usa simultaneamente um compilador e um


interpretador.

10
• Python usa simultaneamente um compilador e um
interpretador.

•O Compilador transforma as instruções python em


instruções de bytecode e salva em um arquivo (.pyc) .

A Linguagem • O arquivo .pyc é executado pelo interpretador apropriado.

Python • O Interpretador (Máquina Virtual Python - Python VM):


responsável por converter bytecode em linguagem de
máquina de baixo nível para execução direta no hardware.

• Bytecode Python é uma linguagem de máquina executada


pela Máquina Virtual Python.

11
• Python é uma linguagem simples e amigável,
com uma sintaxe clara, limpa e concisa.
• Não é necessário digitar ponto-e-vírgula no final de
cada linha de instruções – caso seja preciso
A Linguagem
continuar na linha seguinte basta colocar uma barra
Python
invertida.

• Não é necessário abrir e fechar blocos de código


com chaves, como o C, Pascal, Java, etc.

Os blocos são identificados por endentação.

12
•A identificação de blocos é feita por meio da
indentação:

>>> i=0

>>> while i<8:

A Linguagem print(i)

Python i=i+3

>>>

13
• Python é uma linguagem interpretada (como Perl,
Shell script, etc.).

• Os arquivos fontes são armazenado com a extensão py

A Linguagem • Eles podem ser executados diretamente pelo

Python interpretador, que os converte em byte codes


multiplataforma.
• O Python pode ser executado diretamente no terminal:
python (executa o python no modo interativo)
python teste.py (executa o programa teste.py)

14
• Python é uma linguagem Orientada a Objeto,
A Linguagem Tudo é objeto em Python, até mesmo os inteiros, e
Python até os tipos mais básicos possuem métodos
específicos.

15
• Python oferece também ferramentas para:
• Programação funcional

• Processamento de imagens
Python
• Interface gráfica
Multiparadigmas
• Processamento distribuído

• Integração com C e C# e linguagem de script e o


Blender.

16
Instalação

17
Interpretadores Online

www.codeskulptor.org/ (da Rice university)


Interpretador www.tutorialspoint.com/execute_python_online.php
Python http://mathcs.holycross.edu/~kwalsh/python/
Online

18
Outros Interpretadores Online (para várias linguagens)

Repl
https://repl.it/

Code, Compile & Run


Interpretadores
https://www.codechef.com/ide
Online
CodePad
http://codepad.org/

Outras 6 Plataformas
https://elias.praciano.com/2016/12/6-compiladores-online-
para-estudantes-de-programacao/

19
Instalando  Python para Android (mobile):
Python  Pydroid 3
QPython
 QPython

20
 IDLE Python (ou IDE) - Integrated Development Language
Environment:
Ambiente de desenvolvimento integrado para Python.

Instalando Python.org
Python
 Baixar:
 https://www.python.org/downloads/

última versão 3.6.5 (2017)

 https://docs.python.org/3/tutorial/index.html

Tutorial oficial Python.

21
Instalando
Python

22
 Automaticamente, o Python instala:
Instalando
Python  IDLE Shell Python

 IDLE Editor.

23
 IDLE / IDE (Integrated Development Environment)
(Integrated Development and Learning Environment)

 É o Ambiente de Desenvolvimento Integrado, contendo:


Instalando  Pacote de desenvolvimento de softwares, contendo o editor
Python de códigos.
IDE / IDLE
 Ferramentas de Automação do processo de construção.

 Depurador (Debugger),

 Plataforma Educacional.

24
 IDLEs Python:

 IDLE Python.org
Instalando
Python  Ninja IDE
IDE / IDLE

 PyCharm

 Outros.

25
 Ninja

IDLE http://ninja-ide.org/downloads/
Ninja

26
 PyCharm
da JetBrains

https://www.jetbrains.com/pycharm/download/#section=
IDLE
PyCharm windows

27
IDLE Python

28
IDLE  IDLE Python
Python
python.org

29
 Iniciar uma cessão

 Reiniciar uma cessão


IDLE
Python Para remover quaisquer alterações feitas ou então,
remover qualquer objeto criado em memória.

Menu Shell -> Restart Shell ou CTRL + F6.

30
Shell Python >>> # é o prompt de comandos Python
Prompt

31
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 16:07:46) [MSC v.1900
32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> 8*4
32
>>> print ('Olaa')
Olaa
Shell Python >>> print("bom dia")
1os Comandos
Bom dia # tanto faz aspas simples ou duplas
>>> print(5-2)
3
>>> 5-2
3
>>> 6
6

32
 Navegando nos comandos (avançar e retroceder):
 Alt P Comando Anterior

 Alt N Próximo comando


Shell Python
Atalhos  Observação:
 As teclas de atalho podem ser alteradas a vontade
usando a opção de menu Option -> Configure IDLE ->
Keys

33
34
 Atalhos dos comandos:
Shell Python >>> 4+6
Atalhos 10
>>> _ * 5
50
>>>

35
Atalhos dos comandos:
 Alt + P -> retorna última instrução
 Alt + N -> avança para a próxima instrução
 Crl+D fecha a janela / ShellPython
 Ctrl + F6 -> Reinicia o IDLE
Shell Python  Ctrl + N -> Abre o editor de Script´s de várias linhas
Atalhos
 Ctrl + Enter ->
 Ctrl + C -> interrompe a execução (Script em looping)
 Ctrl + Espaço -> abre o Code Complete
 Tab -> abre o Code Complete
 Ctrl + J -> adiciona linha e move o cursor para a mesma

36
 Um arquivo Python é um arquivo texto composto por comandos

Criando python e cuja extensão é PY.


Arquivos  É criado, no Idle, pela opção de meu:
Python
Editor File → New File - arquivo novo CTRL N

File → Save / Save as...- salvar com a extensão py

Run → Run Module - executar o arquivo python F5

37
 Exemplo, arquivo "teste.py"

a=2
b=3
print(a+b)
1º Arquivo
Python print(a-b) # um comando por linha

# Esse programa imprima a soma e a diferença


# de duas variáveis inteiras a e b na tela

-1

38
 O # é usado para os comentários em uma linha!
 ''' ... ''' comentário em várias linhas
 Temos um comando por linha.
 Não há cessão para declaração de variáveis.
Arquivo Python
Características  O tipo da variável é determinado pelo tipo do valor a
ela atribuído.

39
 Exemplo, arquivo "teste.py"

a=2
b=3

Arquivo Python print('A soma é: ',a+b)


print print('A diferença é: ',a-b)

A soma é: 5

A diferença é: -1

40
 Limpar a tela:

>>> import os

os.system('cls' if os.name == 'nt' else 'clear')


Arquivo Python
print

>>> from os import system


>>> system('cls')
0
>>>

41
Expressões Python

42
Expressões / • Expressões
Operadores • Lógicas
Lógicos e Aritméticos
• Aritméticas

43
>>> 8 -2*3
2

>>> (8 -2)*3
Operadores 18
Aritméticos
>>> 3**2
9 # potência

>>> pow(3,2)
9 # potência também

44
>>> 8/2 >>> -6//2
4.0 # divisão real -3.0 # divisão real

>>> 9/2 >>> 6//-2


Operadores 4.5 # divisão real -3.0 # divisão real
Aritméticos
>>> 9//2 >>> -6//-2
4 # divisão inteira 3 # divisão inteira

>>> 9%2 >>> 9%2/2


1 # resto da divisão inteira

45
•+ -
•* / // %
Operadores • divmod() (x//y,x%y)
Aritméticos • ** pow

abs valor absoluto

46
>>> divmod(9,2)
(4, 1)

>>> abs(-2)
Operadores
Aritméticos 2

>>> round(4.5) # arredonda uma float


4
>>> round(4.5)
5

47
Prioridade Operador
1 ()
2 **
3 * /
Operadores 4 + -
Aritméticos
Prioridades

48
Expressão Avaliação
a-c**2 ?
pow(b,2)-4*a*c ?
a-b*c-d ?
Operadores a-b*c-d ?
Aritméticos
Exercício
Variável Valor
a 12
b 4
c 2
d -3

49
Expressão Avaliação
a//c-3 ?
a-2*b%d ?
a/c%b ?
Operadores a**(a%d) ?
Aritméticos
Exercício
Variável Valor
a 12
b 4
c 2
d -3

50
Expressão Avaliação
a//c-3 ?
a-2*b%d ?
a/c%b ?
Operadores a**(a%d) ?
Aritméticos 18*b/a**(d-1) ?
Exercício
Variável Valor
a 6
b 4
c -2
d 3

51
> Maior que
>= Maior ou igual
Operadores < Menor que
Relacionais <= Menor ou igual
Expressões Lógicas
== Igualdade
!= Diferente de
in pertence

52
>>> 4!=5
True

>>> 6==5
False
Operadores
Relacionais >>> 'Maria'=='maria'
False # Python é uma linguagem Case Sensitive

>>> resp='s'
>>> resp in ('s','S')
True # resp in ['s','S']

53
 Bug/Imprecisão

>>> ((1.5)-(1.0))
0.5
>>> ((1.3)-(1.0))

Bug 0.30000000000000004
>>> ((1.1)-(1.0))
0.10000000000000009
>>> ((1.2)-(1.0))
0.19999999999999996
>>> print 1.2-1.0
0.2

54
 Bug/Imprecisão

>>> y = 1.0/3.0
>>> y
0.33333333333333331
>>> print y
Bug 0.333333333333
>>>
>>> y2 = round(y, 4)
>>> y2
0.33329999999999999
>>> print y2
0.3333

55
Tipagem

56
Tipagem no • É uma linguagem com tipagem:
Python • Forte, e

• Dinâmica.

57
• inteiro (int):
>>> a=10
# normalmente representados com 32 bits
# (de -231-1 a 232)
Tipos • ponto flutuante (float):
Tipos Numéricos
>>> a=2.453 (ou 24.53e-1)

• complexo (complex):
>>> a=3-2j

58
•Tipo lógico (bool):

Bool('')
False
>>> 2 < 4
Tipos True
Tipo bool (lógico) >>> 5 > 7
False
>>> 6 < 8 < 10
True
>>> 2 < 5 < 4
False

59
>>> a=-2+3j
>>> b= 5-1j
>>> a+b
3+2j

Tipos >>> complex(2,-1)


Tipo Complexo
(2-1j)

>>> c=2-1j
>>> c.conjugate()
(2+1j) # inverte o sinal da parte imaginária (j)

60
>>> (-2+3j)/(-2+3j) >>> (2-3j)*(1+j)
(1+0j) (5-1j)

>>> a=1j >>> (3-1j)-(2+4j)


>>> a**2 (1+3j)
Tipos
(-1+0j)
Tipo Complexo
>>> 3-1j/2+4j
>>> a**3 (3+3.5j)
(-0-1j)
>>> (3-1j)/(2+4j)
(-0.1-0.7j)

61
• A função type retorna o tipo de uma variável ou expressão.
print type(1) type(a==2)

<class 'int'> <class 'bool'>

type(2.0) type(4/2)

<class 'float'> <class 'float'>


Tipos
Extração do Tipo type(5//2) #ou %
Type("Alô")
<class 'str'> <class ‘int'>

type('Maria‘) type(2-4j)
<class ‘str'> <class ‘complex'>

62
• Tipo lógico (booleano): bool

• As expressões booleanas ou lógicas são expressões criadas a


partir do uso de:
• operadores lógicos (and, or, not) ou
Tipos
Tipo bool • operadores relacionais (>,>=,<,<=,==,!=)

e cujo o resultado é:
 verdadeiro (True) ou

 falso (False).

63
Operador Lógico Descrição
AND Conjunção
OR Disjunção
NOT Negação

>>> a=2
Tipo >>> b=6
Tipo bool
>>> (a>=b)
False
>>> (a!=b) or (b==2)
True
>>> not (a==a) or (b>=a+1) and (a<0)
True

64
• Notação científica:

>>> 2e1 # 2*10**1


20.0

Tipos >>> 2e3


2000.0
Notação Científica
>>> 2e-1
0.2

>>> 5e-3
0.005

65
a=1 # tipo inteiro
Tipos a = 'Maria' ou a="Maria" # string
Conversão de Tipos
a = 1.0 # float

66
>>> a=28
str(a) #converte para string
>>> str(a)
float(a) #converte para float
'28'
int (a) #converte para inteiro
>>> float(a)
Tipos
28.0
Conversão de Tipos

>>> int(3.14)
3

>>> int(3.9)
3

67
>>> a=2.0
>>> a+1 # ou print(a+1)
3.0
Tipos
Tipagem Dinâmica >>> a='São Paulo‘

# As variáveis podem mudar de tipo: a tipagem é dinâmica


# aqui a variável a mudou do tipo inteiro para string

68
>>> hex(15)
>>> bin(5) >>> oct(5)
'0xf'
'0b101' '0o5'
>>> hex(255)
>>> bin(10) >>> oct(10)
'0xff'
'0b1010' '0o1012'
>>> hex(100)
>>> oct(8)
Tipos >>> bin(200)
'0x64'
'0b11001000' '0o10'
Conversão de bases

bin converter decimal p binário


hex converter um decimal p hexa

69
>>> 0b111 >>> 0xA
7 10
>>> 0b10 >>> 0xFFF
2 4095
Tipos >>> 0b1010 >>> 0xA2
Conversão de bases 162
10
>>> >>>

0b converter binário p decimal


0x converter um hexa p decimal

70
>>> print int('01010101111',2)
687
>>> int('1010', 2)
10
>>>
>>> int('ff', 16)
Tipos
255
Conversão de bases
>>> int('b', 16)
11
>>>

Converter de qualquer base p decimal

71
2 8 10 16 b
2 0b
>>> 0b11
- 3

8 - 0o
>>> 0o10
8

Tipos 10 bin oct hex


>>> bin(101) >>> oct(9) - >>> hex(15)
Operadores de Conversão '0b1100101') '0o11' '0xf'
de bases
16 0x -
>>> 0x1F
31

b int
>>>
int('40',5)
20

72
 Python suporta o famoso calculo bits a bits.

 É a possibilidade de armazenar uma série de valores booleanos em bytes,


mas que precisam de operadores (bit a bit).

 Exemplo:

 Suponhamos que temos 8 informações booleanas representando o estado


Tipos de 8 lâmpadas. Ao invés de armazenar cada informação em sua variável
Operadores Bit a Bit booleana, é mais econômico usar 1 byte, que tem 8 bits, e armazenar os
estados das lâmpadas nesses bits.

 Se as lâmpadas 1, 3 e 4 estejam acesas, podemos armazenar o seu estado nos


bits 1, 3 e 4 do byte (10110000 em binário). Isso corresponde ao número
decimal 176 que passa a indicar o estado dessas luzes:

 luzes = 176 # 10110000

73
Operador Bit a Bit Descrição
>> Deslocamento de bits para direita
<< Deslocamento de bits para esquerda
& E bit a bit
| OU bit a bit
^ OU exclusivo bit a bit
Tipos ~ Complemento
Operadores Bits a Bits

74
bitsA 1 0 1 0
bitsB 1 0 1 1

>>> bitsA = int('1010', 2) ^ 1 0 1 0

10 | 1 0 1 1

>>> bitsB = int('1011', 2) ~ -1 0 1 1


Tipos 11 Exemplo Cálculo Bit a Bit
Operadores Bits a Bits bitsResultado = bitsA & bitsB
Exemplo de aplicação print(f'BitsA e bitsB = {bitsResultado:b})
bitsResultado = bitsA | bitsB
print(“bitsA ou bitsB = %s" % "{0:b}".format(bitsResultado))
bitsResultado = ~bitsA
print("Inversão dos bitsA = %s" % "{0:b}".format(bitsResultado))

75
Strings

76
 Concatenação de strings usando o +:
>>> a,b='São','Luís' # a='São' e b='Luís'

>>> a+b+'Cidade do Amor'


'SãoLuísCidade do Amor' # sem espaços entre as palavras.
Strings
Manipulação de Strings,
>>> a+' '+b+' '+'Cidade do Amor'
Concatenação usando o + >>> a+='\t\t‘
'São Luís Cidade do Amor' # equivalente a a=a+'\t\t'
>>> a
>>> print(a+' '+b+'\t'+'Cidade do Amor.') 'São \t\t'
>>> print(a,'Luís')
São Luís Cidade do Amor. São Luís

77
 Concatenação de strings usando o operador join:
>>> s1='Bom'
>>> s2='dia'
>>> ' '.join((s1,s2)) # as strings a concatenar são colocadas
'Bom dia' # em uma tupla: (str1,str2,str3,...)
>>> ''.join((s1,s2)) # pois o join aceita apenas 1 parâmetro
Strings 'Bomdia'
Manipulação de Strings,
>>> ','.join((s1,s2))
Concatenação usando o join # ''.join(('Ana','tem','um','filho.'))
'Bom,dia' # 'Anatemumfilhoo.'
# aqui o separador especificado é o vazio
>>> ' '.join((s1,s2,'.'))
'Bom dia .' >>> ','.join((s1,s2))
>>> ' '.join((s1,s2,'Maria.')) 'Ana tem um filho.‘
# aqui o separador especificado é o espaço
'Bom dia Maria.'

78
 Conversão Lista -> String usando join()
>>> ','.join(['a','b','c','d','e','f','gg','h'])
'a,b,c,d,e,f,gg,h' # converte uma lista em um string

>>> ','.join(['a','b','c']) # ou seja, concatenando os elementos


'a,b,c‘ # de uma lista.
Strings >>> ''.join(['a','b','c'])
Operadores de
Manipulação, 'abc'

Conversão de uma lista >>> ' '.join(['a','b','c'])


para uma string usando o 'a b c'
join
>>> ' '.join(['a','b','c'])
Ou seja, concatenando os
elementos de uma lista 'a b c'

79
 Conversão String <–> Lista

>>> l=['João','gosta','de','Música']
>>> s=' '.join(l) # criando um string tendo o espaço como
# separador
>>> s
Strings 'João gosta de Música'
Operadores de
Manipulação
>>> l=s.split() # divide o string em elementos, a cada espaço,
# formando uma lista
>>> l
['João', 'gosta', 'de', 'Música']

80
 Conversão String -> Lista usando o Split()

>>> s='São Luís' # A string s é convertida em uma lista l


>>> l=s.split() # pro default, a divisão é feita a cada espaço.
>>> l
['São', 'Luís']
Strings >>> s.split()[0] # Como o split retorna uma lista, então podemos
Operadores de 'São' # é l[0] # acessar seus elementos usando o índice.
Manipulação: split
>>> 'a,b,c'.split(',') # É possível fazer o split cortando em outros
['a', 'b', 'c'] # caracteres, por exemplo na virgule, basta
# especificá-lo como parâmetro do split.
>>> 'a*b*cde*f**g'.split('*')
['a', 'b', 'cde', 'f', '', 'g']

81
 Conversão String <–> Lista

>>> s='João gosta de Música'


>>> s.split() # retorna ['João', 'gosta', 'de', 'Música']
>>> ' '.join(s.split())João gosta de Música'
'João gosta de Música'
Strings
Operadores de
>>> s.Split('de') # retorna ['João gosta ', ' Música']
Manipulação
>>> 'de'.join(s.split('de'))
'João gosta de Música'

# O join pode anular o split e o split pode anular o join,


# pois os dois realizam operações inversas.

82
 Concatenação de strings usando o operador __add__ :
>>> s1='Boa'
>>> s2='Tarde.'
>>> s1.__add__(s2)
Strings 'BoaTarde.' # colocados juntos sem espaço no meio.
Manipulação de Strings
>>> (s1.__add__(' ')).__add__(s2)
'Boa Tarde.' # aqui um espaço é concatenado no meio
>>> s1.__add__('Tarde!')
'Boa Tarde!'

83
 Multiplicação de strings *:
>>> a*4
Strings 'São São São São'
Manipulação de Strings
>>> 'Aa'*3
AaAaAa

84
>>> len("abcdefg") # tamanho
7

>>> “Sami".startswith("S") # inicia por


True
>>> “Sami".startswith("s")
True
Strings
Manipulação de Strings >>> "Sami".endswith("d") # termina por
True

>>> "am" in "Sami“ # substring ?


True
>>> “im" in "Sami"
False

85
>>> 'Sofiane'.find('mar') # procura por ums substring dentro de uma string
-1 # retorna a sua posição (posição do 1o caractere)
>>> 'Sofiane'.find('s') # ou -1 se não estiver
-1
>>> 'Sofiane'.find(‘So') # o parametro do find deve ser uma string
0
Strings >>> 'Sofiane'.find('ane')
Manipulação de Strings 4

>>> "abcdefg".index("c") # é a mesmo coisa que o find


2 # apenas retorna erro qdo o substring não existe
>>> "abcdefg".index("x")
...

ValueError: substring not found

86
 Os strings são indexados a partir do 0 e podem ser fatiados:

>>> nome='Carla Bruni'


>>> nome[0] # 1° elemento do string
'C'
>>> nome[1] # 2° elemento do string
Strings 'a'
Slicing/Fatiamento de
>>> nome[2] # 3° elemento do string
Strings
'r'
>>> 'Carla Bruni'[-1] # último elemento do string
'i'
>>> 'Carla Bruni'[-2] # penultimo elemento do string
'n'

87
 Fatiando strings:

>>> nome='Carla Bruni'


>>> nome[2:4] # do 2° índice até o 4° índice (4° não incluso)
'rl'
Strings >>> nome[2:] # do 2° até o fim (último)
Slicing/Fatiamento de
Strings 'rla Bruni'
>>> nome[:2] # do início até o 2° elemento (2° não incluso)
'Ca‘
>>> 'Carla Bruni'[::] # imprime tudo
'Carla Bruni'

88
 Fatiando strings:

>>> 'Carla Bruni'[-2:] # do penúltimo até o fim


Strings 'ni'
Slicing/Fatiamento de
Strings >>> 'Carla Bruni'[:-2] # do início até o penultimo (este não incluso)
'Carla Bru'

89
 Fatiando strings:

>>> 'Carla Bruni'[::] # imprime tudo o string


'Carla Bruni'
>>> 'Carla Bruni'[::2] # imprime tudo o string com passo 2
'CraBui'
>>> 'Carla Bruni'[::3] # imprime tudo o string com passo 3
'ClBn'

Strings >>> 'Carla Bruni'[::-1] # imprime tudo o string de tras pra frente
'inurB alraC‘ # reverte o string (a ordem das letras)
Slicing/Fatiamento de
>>> 'Carla Bruni'[::-2] # imprime tudo o string com passo -2
Strings
'iuBarC‘
>>> 'Carla Bruni'[::-5] # retorna a lista de elementos de tras pra frente com passo
'i C‘ # retorna a lista de elementos com passe -5
>>> 'Carla Bruni'[1:8:-5] # não funciona
'‘
>>> 'Carla Bruni'[8:1:-5] # o 5° e o 3° elemento
'ul'

90
 Outras operações de strings:

>>> 'ABCD'.lower() # converte tudo para minúsculos


abcd
Strings
Operadores de >>> 'abcd'.upper() # converte tudo para maiúsculos
Manipulação
ABCD

>>> 'AbcD'.swapcase() # altera maiúsculos/minúsculos


aBCd

91
 Checar se uma palavra/texto é em maiúsculo ou minúsculo:

>>> 'SOFIANE'.isupper()
True
>>> 'Sofiane'.isupper()
False
Strings >>> 'Brasil'.islower()
Operadores de False
Manipulação
>>> 'brasil'.islower()
True
>>> 'São Luís, Ilha Do Amor!'.istitle() # verifica se é um title
True

92
 Checar o conteúdo de uma palavra/texto é alfanumérica:

>>> 'a5 abc 3'.isalnum() # não deve conter um caractere especial


# nem o espaço.
>>> 'a5abc3'.isalnum()
True
>>> '245'.isdigit() # verifica se a string contém apenas números
Strings True
Operadores de
>>> '24.5'.isdigit()
Manipulação
False
>>> 'abc21'.isalpha() # verifica se a string é composta por apenas letras
False
>>> 'abc'.isalpha()
True

93
 Checar se só há espaços na string:
>>> ‘>> >>> ''.isspace()
False
>>> ' '.isspace()
Strings True
Operadores de
Manipulação >>> ' '.isspace()
True
>>> ' e '.isspace()
False

94
 Adicionando espaços na string:
>>> ‘>> >>> 'Karen'.ljust(10) # alinhamento à esquerda
'Karen '
>>> 'Karen'.rjust(10) # alinhamento à direita
Strings
' Karen'
Operadores de
Manipulação >>> 'Karen'.center(10) # centraliza o texto
' Karen '

95
 Os espaços de alinhamento podem ser espalhados a direita e
esquerda da string:

Strings
>>> ‘>>

>>> 'Karen.'.rjust(15).strip()
Operadores de
'String.'
Manipulação
>>> 'Karen.'.ljust(15).rstrip()
'String.'

96
 Outras operações de strings: Eliminando caracteres brancos

>>> ' abcd e fgh '.lstrip() # Elimina os caracteres em branco


'abcd e fgh ' # do lado esquerdo
Strings >>> ' abcd e fgh '.rstrip() # Elimina os caracteres em branco
Operadores de ' abcd e fgh‘ # do lado direito
Manipulação
>>> ' abcd e fgh '.strip() # Elimina os caracteres em branco
'abcd e fgh‘ # dos lados direitro e esquerdo

97
 Outras operações de strings:

>>> s='PARIS cApital da frança'

>>> s.lower()
'paris capital da frança'
Strings >>> s
Operadores de
Manipulação 'PARIS cApital da frança'
>>> s.lower().capitalize() # coloca a 1ª letra em maiúsculo
'Paris capital da frança‘
>>> s.title() # transforma a 1ª letra de cada
'Paris Capital Da França' # palavra em maiúsciulo

98
 Outras operações de strings:

>>> 'Carla Bruni'.replace(' ',' - ')

Strings 'Carla - Bruni'


Operadores de
Manipulação >>> s='Olá Carla!'
>>> s.replace('Carla','Lucas')
'Olá Lucas!'

99
 Strings são imutáveis:
>>> nome='Caren'
Imagina que digitamos o nome de Caren com C e que precisamos
corrigir para Karen (trocando C por K).
Intuitivamente, íamos executar o seguinte comando:
Strings >>> nome[0]='K'
Operadores de
mas isto gera erro, pos as strings no python são imutáveis.
Manipulação
A solução é de criar uma nova string:
>>> novonome='K'+nome[1:]
>>> novonome
'Karen'

100
 Strings são imutáveis:

>>> a = '20' # o string é um conjunto imutável


>>> id(a) # ao mudar o seu conteúdo, o identificador
103936544 # muda também.
Strings >>> a= 'Olá'
Operadores de
Manipulação >>> id(a)
1868623968
>>> a='Maria'
>>> id(a)
103937920

101
 Comparando Strings

>>> 'Fortaleza'<'Salvador'
True

>>> 'Bahia'!='Pernambuco'
Strings True
Operadores de
Manipulação
>>> 'Maranhão'>='Maranhão'
True

if Cidade_Nascimento'== 'São Luís' :


print(' Você é Ludovicense')

102
 Iterando/Percorrendo um String

>>> for letra in 'Lucas':


print(letra)

Strings L
Operadores de
Manipulação u
c
a
s
>>>

103
 Iterando/Percorrendo um String

>>> s='Lucas'
>>> for letra in s:
print(letra)
Strings
Operadores de L
Manipulação
u
c
a
s
>>>

104
 Iterando/Percorrendo um String

>>> s='Fruta'
>>> i=0
>>> while i<len(s):
c=s[i]
Strings print(c)
Operadores de i+=1
Manipulação
F
r
u
t
a

105
 O comando chr imprime o caractere correspondente ao código ascii
passado como parâmetro:

>>> chr(42)
'*'
>>> chr(97)
Strings 'a'
chr >>> chr(123)
'z'
>>> chr(65)
'A‘
>>> chr(91)
' Z'

106
 Imprime as letras do alfabeto:

>>> for i in range(97,123): # 97=a 123=z


print(chr(i),end=' ')

Strings abcdefghijklmnopqrstuvwxyz
chr

>>> for i in range(65,91): # 65=A 91=Z


print(chr(i),end=' ')

A B C D E F G H I J K L M N O P Q R S T U V W XY Z

107
 Imprime as letras do alfabeto (outro método):

>>> [chr(x) for x in range(97,123)]


['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
'r','s','t','u','v','w','x','y','z']
Strings # gerar uma lista
chr

>>> {chr(x) for x in range(97,123)}


{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
'r','s','t','u','v','w','x','y','z‘}
# gerar um set (conjunto)

108
 Imprime as letras do alfabeto (mais um método):

>>> l=map(chr,list(range(65,91)))
Strings >>> for i in l:
chr print(i,end=' ')

A B C D E F G H I J K L M N O P Q R S T U V W XY Z

109
 Tipos simples - constituídos por simples blocos, como int() e float().

 Tipos de contêiner - objetos capazes de conter outros objetos.

Tipos  Tipos de código - objetos encapsuladores de elementos dos


Classificação programas.

 Tipos internos - tipos que serão utilizados durante a execução dos


programas.

110
 Outros tipos:

lista - para agrupar um conjunto de elementos, mas que tem


ordem.

Tipos tupla - semelhante ao tipo list, porém, imutável.


conjuntos
dic - para agrupar elementos que serão recuperados usando
uma chave. E

set - conjunto de valores.

111
Atribuições

112
>>> a=3.0 # A atribuição é feita usando o símbolo =
>>> a
3.0
Atribuições
Variáveis >>> b=a-1
>>> b
2.0

113
>>> nome="Lucas" # os strings devem ser colocados
>>> nome # entre aspas simples ou duplas
'Lucas'
Atribuições
Strings >>> bairro='Calhau'
>>> bairro
'Calhau'

114
>>> a,b,c=3,2,4 # A atribuição pode ser feita em série
# I.e. Atribuição de valores a várias
# variáveis de uma vez só
# isto é feito de forma sequencial
>>> a
3
Atribuições
Atribuição em série >>> b
2
>>> c
4

>>> a,b,c
(3,2,4)

115
Uma Reflexão:
>>> a=2
>>> a,b=4,a+1
# Qual será o valor de a (2 ou 4) e de b (3 ou 5) ?
Atribuições
Variáveis >>> a
?
>>> b
?

116
 Exercício
Faça o programa swap de troca entre duas variáveis.

>>> a,b=4,6
>>> a,b
Atribuições (4,6)
Exercício de Swap

>>> a,b=b,a
>>> a,b
(6,4)

117
a=a+b
a+=b

Atribuições a*=6
Abreviações
A=a*6
Essas duas expressões são equivalentes!

118
None é o equivalente ao valor nulo (null)
Uma variável pode ser iniciada a um valor nulo

Atribuições >>> nome=None (N em maiúsculo e sem aspas)


None
>>> nome

>>>

119
Saídas

120
a=2
b=3
print('A soma de ',a,' com ',b,' é: ',a+b)
Saídas
Comando print

A soma de 2 com 3 é: 5

121
a=2
b=3
print(a,b)

Saídas # é possível ter duas ou mais saídas no mesmo print


print

2 3

122
a=8
b=6
print('A soma é: \n',a+b)

Print(‘\n\n') # pula duas linhas


Saídas print('A diferença é: ',a-b)
\n

A soma é:
14

A diferença é: 2

123
>>> idade=28
>>> nome="Lucas"
>>> print("Seu nome é %s e sua idade é %d"%(nome,idade))

Saídas Seu nome é Lucas e você tem 28 anos.


Formatação com o %

%s é uma lacuna que é preenchida por cada variável da lista na


ordem que elas nela se apresentam.
O % é usado para separar a mensagem com a máscara dos valores
que são colocados entre parênteses.

124
 Impressão por formatação:
>>> nome='João'

Saídas >>> sobrenome= 'Alberto'


Formatação com o % >>> print("%s %s"%(nome,sobrenome))
João Alberto

125
 Impressão por formatação:

Expressão Significado
%s String
Saídas %c Caractere
Formatação com o % %d Inteiro
%f Real (float)
%e Notação Científica (e)
%% um %

126
 Formatação de número (%d %f %e):

>>> '%6d'%25
' 25'
>>> '%-6d'%25 # com um número negativo, os caracteres brancos
'25 ' # são adicionados do lado direito.
>>> '%13f'%25
>>> '%5.2f'%20
' 25.000000'
Saídas >>> '%10.2f'%25
'20.00'
Formatação com o % ' 25.00' >>> '%10.2f'%20
>>> '%-10.2f'%25 ' 20.00'
'25.00 '
>>> '%-10.2e'%25 >>> '%-10.2f'%20
'2.50e+01 ' '20.00 '
>>> '%10.2e'%25
>>> '%-10.2e'%20
' 2.50e+01‘/ '2.00e+01 '

127
 Impressão por formatação:
>>> pi=3.141592653589793

>>> print("%f"%pi) # Os () são opcionais no caso


>>> print("%f"%(pi)) # onde há apenas uma variável
3.141593
Saídas
Formatação com o % >>> print("%6.3f"%pi)
Uso das () 3.142

>>> print("%6.2f"%pi)
3.14

128
 Formatação usando a notação científica:
>>> x = 300000
>>> y = 0.00003
Saídas
Formatação com o % print('Número grande %.2e\nNumero pequeno %.2e'%(x, y))
%e
# Numero grande 3.00e+05
# Numero pequeno 3.00e-05

129
 Formatação usando a notação científica:

>>> print("%e"%10000)
1.000000e+04
>>> print("%e"%(10000))

Saídas 1.000000e+04
Formatação com o % >>> print("%2e"%(10000))
%e 1.000000e+04
>>> print("%.2e"%(10000))
1.00e+04
>>> print("%.0e"%(10000))
1e+04

130
 Caracteres não imprimíveis:

Simbolo Efeito
\n New line
Saídas \t Tab
\ \\ \
\x41 'A' (caractere com código hexadecimal é 41)
\’ ’
\” “

131
 Caracteres não imprimíveis:

print('Sofiane\tLabidi\nCarla\tBrune')
print('Cesar\tMaia')

Saídas Print('\\')
\
Sofiane Labidi
Carla Brune
Cesar Maia
\

132
 Caracteres não imprimíveis:

>>> print('\x27')
'
>>> print('\x28')
Saídas (
\x
>>> print('\x29')
)
>>> print('\x30')
0
>>>

133
 É possível desabilitar os efeitos da \ colocando na frente da
expressão a letra r:

>>> print(r'Sofiane\nLabidi')
Saídas
Sofiane\nLabidi
r
>>>

134
 É possível escrever um texto comprido em várias linhas desde
que se coloque uma barra invertida no final de cada linha:

>>> print('São Luis\tCaxias\n\


Imperatriz\n\
Saídas
Balsas')
\

São Luís Caxias


Imperatriz
Balsas
>>>

135
 É possível fazer a mesma coisa delimitando o texto em três aspas (simples ou
duplas)

 A saída imprime tudo igual!

print("""
Maria
Maria
Saídas Joao Joao
Carlos Carlos # afastado
’’’ ’’’
Roberta\n""") Roberta
3 aspas (duplas ou
simples)
print(''' Maria
Maria Joao
Joao Carlos # afastado
Carlos Roberta
>>>
Roberta\n''')

136
 Usamos as aspas triplas também para poder imprimir aspas:

>>> print(''' ' ''')


'

Saídas >>> print('''a ' b''')


’’’ ’’’ a ' b
3 aspas (duplas ou >>>
simples)

137
 Testando se uma string é vazia ou preenchida?

Se a string é vazia o operador bool retorna falso.

>>> bool('aabb')
True

Saídas >>> bool('a') s='aaabbb'


Vazia ou Preenchida? True If s:
print(‘String preenchido')
>>> bool('')
If not s:
False
print(‘String vazio!')

>>> bool("")
False

138
 .format()
 Formatação moderna, usada a partir da versão Python 2.6

 O uso do operador % para formatação de saídas deve deixar de existir nas


próximas versões do Python.

 O % é substituído por {}
Saídas
Formatação Moderna: >>> a,b=4,5
.format >>> a,b
(4, 5)

>>> print('O valor de a é {} e o valor de b é {}'.format(a,b))


O valor de a é 4 e o valor de b é 5

139
 format()
A lista das variáveis no .format é indexada, a partir do zero. Portanto,
podemos usar os índices para indicar as variáveis nas lacunas (as {})

Saídas >>> print('{0} gosta de {1}.'.format('Maria','Lucas'))


.format (usando os Maria gosta de Lucas. # usando índices
índices)
# Maria tem índice 0 e Lucas tem índice 1

>>> print('{1} e {0}.'.format('Maria','Lucas'))


Lucas gosta de Maria. # observe que aqui a ordem foi alterada

140
 .format()
É possível usar referentes (apelidos) dentro da formatação e
usá-los em lugar dos índices.

Saídas
.format usando >>> print('Este {objeto} é {adjetivo}.'.format(objeto='Relógio',
referentes ou apelidos adjetivo='muito caro')
Este Relógio é muito caro. # usando referentes (apelidos)

141
 .format()

>>> a,b=2,4

>>> print('A soma de {0} com {1} é {2}'.format(a,b,a+b))


A soma de 2 com 4 é 6 # usando a posição na sequencia

Saídas >>> print('A soma de {a} com {b} é {sm}'.format(a=a,b=b,sm=a+b))


.format usando A soma de 2 com 4 é 6 # usando os apelidos
referentes ou apelidos
>>> print('A soma de {a} com {b} é {sm}'.format(a=a,b=b,sm=a+b))
A soma de 2 com 4 é 6 # podemos trocar a posição dos apelidos no .format

>>> print('A soma de {e} com {f} é {sm}'.format(e=a,f=b,sm=a+b))


A soma de 2 com 4 é 6 # usando nomes de apelidos diferentes
# dos nomes das variáveis
142
 A formatação pode ser separada (colocada em uma variável de tipo
string)
Saídas
.format >>> s= 'O filme {0} do autor {1} merece {2} estrelas'
>>> s.format('O Fugitivo','Harrsisson Ford', 4)
'O filme O Fugitivo do autor Harrisson Ford merece 4 estrelas'

143
>>> import math
>>> math.pi
3.141592653589793

Saídas
Os f-strings >>> print('O valor de PI é aproximadamente {0:.3f}.'.format(math.pi))
O valor de PI é aproximadamente 3.142. # indica 3 dígitos após a vírgula

>>> print(f'O valor de PI é aproximadamente {math.pi:.3f}.')

144
>>> idade=28
>>> nome="Carla"
>>> print("{0:10} - {1:5}".format(nome,idade))
Carla - 28
Saídas
# 10 caracteres p Carla e 5 dígitos p 28
.format

>>> >>> print("{0:10} - {1:5.2f}".format(nome,idade))


# f para saída flutuante, e para saída em notação científica
(2.8e+01), e d para decimal (inteiro: sem vírgula)

145
 Outro recurso para Formatação
f

Saídas >>> a=10


f-strings
>>> f 'O dobro de {a} é {2*a}' # aspa simples ou dupla
O dobro de 5 é 10 # pode usar o print

146
Interpolação de strings
nome='João'
peso=48.5 # escreve na tela: João você pesa 48.50 kilos.

print(nome,'você pesa',peso,'kilos.') #1º formato de saída

print('%s você pesa %f kilos.'%(nome,peso)) #2º formato de saída: %


Saídas print('%s você pesa %.2f kilos.'%(nome,peso))
exemplo
print('{} você pesa {} kilos.'.format(nome,peso)) #3º formato de saída: .format
print('{0} você pesa {1} kilos.'.format(nome,peso))
print('{0} você pesa {1:.2f} kilos.'.format(nome,peso))
#print('{1} você pesa {0} kilos.'.format(nome,peso))
print(f'{nome} você tem {peso:.2f} kilo.') #4º formato de saída: f
print(f'{nome:20} você tem {peso:.2f} kilo.')
147
sep O valor padrão de sep é um espaço em branco, quando dois ou mais
argumentos são passados para a função print sep coloca entre eles um
espaço em branco ou um outro valor que podemos passar para sep.
end O valor padrão de end é uma nova linha “\n” e por isso que sempre a função
print adiciona uma nova linha depois de imprimir tudo que lhe foi passado,
mas, podemos definir outro valor com uma tabulação “\t” por exemplo.
file Este é o padrão que define onde será impresso os argumentos passados
Saídas para print. Seu valor padrão é definido por sys.stdout, o fluxo de saída
padrão que normalmente é o terminal. Podemos alterar esse valor para
Configurações end sep e especificar um arquivo por exemplo.
file

# o print tem 3 parâmetros:


# sep (o separador, por default é o espaço),
# end (o fim da linha, por default é o \n) e
# file (o arquivo de saída, por default é o stdout).
# mas isto pode ser alterado a critério!

148
>>> a,b,c=10,20,30

>>> print(a,b,c,sep='***',end='...\n')
10***20***30...
Saídas
Configurações end sep e
file >>>

149
Entradas

150
 Para leitura de dados a partir do teclado, usaremos a função input.

>>> nome= input("Digite seu nome: ")


Digite seu nome: Sofiane

Entradas >>> nome


input
'Sofiane'
>>>

151
• A função input retorna um string.
• Para leitura de uma inteiro ou real, é preciso fazer uma conversão
usando o int ou o flaot.

>>> idade= int(input("Digite sua idade: "))


Entradas
Digite sua idade: 28
input

>>> idade
28

152
• A função eval permite de avaliar uma expressão dada como
entarada.

>>> eval(input("Digite uma expressão: "))


Entradas
eval Digite uma expressão: 8+3
11
>>>

Muito cuidado com o uso do comando eval!

153
• Observação:
Na versão 2, o Python usa a função raw_input para entrada de
dados.
Na sua versão 3 o Python usa o input.

Há uma forma de detectar a versão do python que está sendo


Entradas usada:
version_info.major >>> import sys
>>> sys.version_info.major
3

154
• Observação:
import sys

Entradas
if sys.version_info.major == 2:
Input / raw_input ?
usuario = raw_input('Insira seu login: ')
elif sys.version_info.major == 3:
usuario = input('Insira seu login: ')

155
 É possível ler várias variáveis na mesma linha, graças ao
comando split: input().split()
>>> e,f=input("Entra com dois números: ").split()
Entra com dois números: 25 10

Entradas >>> e
split '25'
>>> f
'10'
>>> e,f
('25','10 ')

156
 Por default, o separador é o espaço, mas isto pode ser alterado
(especificado):

>>> a,b,c=input("Entra com três nomes: ").split('--')


Entradas Entra com três nomes: Carlos--Maria--Lucas
split
>>> a
'Carlos'
>>> b,c
('Maria', 'Lucas')

157
 # Quando a entrada não é de tipo string, é preciso fazer a
conversão!

>>> idade=int(input("Qual é sua idade: "))


Entradas
split
>>> peso=float(input("Qual é seu peso: "))

158
• Exercício 1:

Faça o programa Python que leia a temperatura ambiente


em graus Celsius e a converte em graus Fahrenheit, e
Entradas vice versa.
Exercício

159
Celsius Fahrenheit
0 32
15 59
-8.89 16

Entradas C/5 = (F-32)/9


Exercício

Usa a calculadora do Windows para verificar as conversões de temperaturas


Ou este site:
https://www.metric-conversions.org/pt-br/temperatura/celsius-em-fahrenheit.htm

160
• Exercício 2:

Faça o programa Python que resolve uma equação de 1º grau.

ax+b=0
Entradas
Exercício

ax+b=0

161
# C/5 = (F-32)/9
# Celsius para Fahrenheit
C=float(input("Qual é a temperatura (em graus Celsius): "))
F=9/5*C+32
print(F)

Entradas print() # pula uma linha

# Fahrenheit para Celsius


F=float(input("Qual é a temperatura (em graus Fahrenheit): "))
C=5/9*(F-32)
print(C)

Print(f)
print('A temperatura %5.2f em graus Celsius é equivalente a %5.2f em
graus Fahrenheit'%(C,F))
162
#a,b=input().split()
a,b=input('Entra com dois número: ').split() # na mesma linha, separados
# por um espaço

a=float(a)
b=float(b)
Entradas
split print('Raiz da equação {0:.2f}x+{1:.2f}=0 é {2:.2f}'.format(a,b,-b/a))
print(f'Raiz da equação {a:.2f}x+{b:.2f}=0 é {-b/a:.2e}')
# de dois formatos f e .format()
Entra com dois número: 2 -1
Raiz da equação 2.00x+-1.00=0 é 0.50
Raiz da equação 2.0x+-1.0=0 é 5.00e-01 # e para notação científica

163
Controle Condicional

164
• A construção if de controle condicional:
if <condição>:
Controle <expressão 1>
Condicional elif <condição 2>:
if <expressão 2>
else:
<expressão 3>

165
# idade=18
idade=int(input('Informa sua idade: '))
if
if idade<20:
print("Você é jovem! ")

166
idade=int(input('Informa sua idade: '))

If-else if idade>=18:
print("Você é Maior de Idade! ")
else:
print("Você é Menor de Idade! ")

167
hora=int(input('Informa a hora: '))

if hora<11:

If-elif-else print('Bom dia! ')


elif hora<17:
print('Boa tarde')
else:
print('Boa noite! ')

168
idade=int(input("Informa sua idade pfvr: "))

if idade<12:
print("Criaca!")
elif idade<15:
print("Pre Adolescente")
If-elif-else elif idade<17:
print("Adolescente")
elif idade<25:
print("Jovem")
elif idade<60:
print("Adulto")
else:
print("Idoso")

169
Estruturas de Repetição

170
• A expressão for é utilizada para percorrer listas,
sequencias e realizar processos iterativos:
for <referência> in <sequencia>:
<bolco de expressões>
Repetição continue
for break
else:
<bolco de expressões>

171
for <thing> in <list of things>:
#

for i in range(3):
print(i)

Repetição
for 0
1
2
3

172
• Exp:
>>> lista=[1,2,3]
>>> for i in lista:
Print(i)
Repetição
for 1
2
3
>

173
• A função range(m, n, p) define uma sequencia de inteiros
iniciada em m, menor do que n (ou maior, depende da
direção da sequencia), a um passo p (podendo ser
negativo):
>>> for i in range(1,10,2):
Repetição ... print i
range ...
1
3
5
7
9

174
• While

while<condição>:
<bloco de expressões>
Repetição
continue
while
break
else:
<bloco de expressões>

175
• Exemplo:
>>> a=0
>>> while a<5:
... print(a)
Repetição ... a+=2
while
...
0
2
4

176
• Exercício:
• Imprima a série de fibionacci até 50.

Fib(0)=1

Repetição Fib(1)=1
Exercício Fib(n)=fib(n-1)+fib(n-2)

1 1 2 3 5 8 13 21 34 55 88 143 231 …

177
• Fibionacci

>>> a,b = 0,1


>>> while b < 50:
Repetição print(b,end=' - ')
Exercício
a, b = b, a+b

1 - 1 - 2 - 3 - 5 - 8 - 13 - 21 - 34 -

178
Funções

179
import math

def areacirculo(raio):
return math.pi*raio**2

Funções
>>> areacirculo(10)
314

180
import math

def areac(r):
return math.pi*r**2

raio=int(input('Qual é o raio do círculo: '))


Funções
print(f'Área do círculo de raio {raio} é {areac(raio):.2f}')

Qual é o raio do círculo: 10


Área do círculo de raio 10 é 314.16

181
 Sempre que o compilador encontra uma atribuição a um

Funções nome/variável dentro de uma função, ele assume que tal


Variáveis locais vs globais nome/variável é local em toda a função, não importando
onde a atribuição ocorre.

182
def f1():
x=10
print(x) # ok (global) 10
f1() # 10
def f2():
print(x) # erro (local)
#f2() # erro
x=1
# essa atribuição a torna local
f3() # 1
print(x) # 10 (não foi alterado)
def f3():
Funções x=1
f4() # 10
Variáveis locais vs globais print(x) # ok (local) 1
print(x) # 10 global
def f4():
f5() # 1
global x
print(x) # 1
print(x) # ok 10
# saídas: 10 1 10 10 10 1 1
def f5():
global x
x=1
print(x) # ok 1
183
 Variáveis globais não são aconselhados no Python, pois tornam o
código mais difícil de ler e modificar podendo levar a bugs difíceis
Funções de serem encontrados.
Variáveis locais vs globais
 É por isso que o Python força o programador a explicitar suas
variáveis globais quando quiser alterá-la fora do escopo global. .

184
Função que procura um caractere em uma string:

def achar(c,s):
i=0
Funções
while i < len(s):
Exercícios >>> achar('a','Sofiane')
if s[i] == c:
True
return i
>>> achar('b','Sofiane')
i+=1
False
return -1

185
Função que procura um caractere em uma string:

def achar (c,s):


i=0 # p é a posição da 1ª ocorrência do caractere c na string s
p=-1 # retorna -1 e falso se não existe.
achei=False
Funções while (i<len(s)) and (not achei):
if s[i]==c:
Exercícios
achei=True
>>> achar('a','Sofiane')
p=i
(True,4)
i+=1 >>> achar('b','Sofiane')
(False,-1)
return(achei,p)

186
Função que retorna o número de ocorrências de um caractere
em uma string:

def contar(c,s):
contador = 0
Funções for letra in s:
Exercícios if letra == c: >>> fruta = 'banana'
contador +=1 >>> contar('n',fruta)

return(contador) 2

187
Procedimento que retorna número de letras e de palavras em uma

frase de tipo string:

def frase(f):
Funções cc,cp=0,0 >>> frase('Maria Adora Cinema e
Futebol.')
Exercícios for palavra in f.split():
cp+=1 Palavras: 5 Caracteres: 25
for letra in palavra:
cc+=1
print(f'Palavras: {cp} Caracteres: {cc}')
# return(cp,cc) # a,b=frase('Boa noite') # (2,8)

188
Função que verifica se um caractere é minúsculo ou não:

Há várias formas de fazer:


Funções
def eMinusculo(ch):
Exercícios >>> eMinusculo('B')
return 'a' <= ch <= 'z'
False
>>> eMinusculo('a')
True

189
 As rotinas Python podem ou não retornar um valor. É o
que faz a diferença entre procedimento e funções.
Funções
Procedimento
 Diferentemente de várias linguagens, as funções Python
podem retornar vários valores.

190
Coleções de Dados
Coleções Sequenciais de Objetos

191
 Listas. Os elementos de uma lista são colocados em sequência e para cada um
deles é determinado um índice numérico.

a = [] b=[5,3,6,1] # estrutura homogênea

 Tuplas. Funciona da mesma forma que listas, mas os elementos são imutáveis
Strings, Listas, (seus elementos não podem ser alterados).

tuplas, Sets e a = (1,2,3) # estrutura heterogênea

Dicionários  Dicionários. Os índices dos dicionários não precisam ser numéricos.

a {‘teste’ : ‘teste_cont’}

 Listas e Tuplas são estruturas indexadas.

 Dicionários e Sets são estruturas não indexadas.

192
 Coleções são estruturas de dados sequenciais de objeto:
 No Python destacamos os:
 Strings. Compostas por caracteres, e

Coleções de s=[2,'b,4,56,'cde']

Dados  Listas formados por elementos de qualquer tipo.


Strings, Listas, Tuplas, lst=[2,'b',4,56,'cde']
Sets e Dicionários
 A diferença é que as listas são mutáveis (seus elementos podem ser
alterados) e os strings são imutáveis (os caracteres de uma string não
podem ser alterados).

193
# É um conjunto de elementos heterogêneos e ordenados.

>>> lista1=[] # lista vazia


>>> lista1
[]

>>> lista2=[6,8,'Carla',10.5,False] # estrutura heterogênea


Listas >>> lista2
Construção [6,8,'Carla',10.5,False]

>>> lista=list(range(5))
[0,1,2,3,4]

>>> lista = [x*2 for x in range(8)]


[0,2,4,6,8,10,12,14]

194
 O comando list cria uma lista a partir de uma série de
argumentos:

>>> lista1=list(range(5)) # 5 elementos (de 0 a 4)


Listas [0,1,2,3,4]
Operador list
>>> lista2=list(range(1,10,2)) # de 1 a 10 com passo 2
[1,3,5,7,9]

195
 Listas aninhadas:

Listas >>> lista=[6,'d',[10,8],5]


Listas aninhadas
>>> lista=[[5,4,8],[1,6,10,2,5,5,7]]

196
# Acessando os elementos de uma lista usando o índice:

>>> lista=[25, 10, 2, 34]


>>> lista
[25, 10, 2, 34]

>>> lista[0] # 1º elemento da lista.


25
Listas
Acessando pelo índice >>> lista[1] # 2º elemento da lista.
[10]

>>> lista[2]*4
8

>>> lista[-1] # último elemento da lista


[10]

197
 Podemos gerar cópias (clones) de uma lista de várias formas. O
comando is verifica se duas listas são equivalentes (mesma
referência e portanto o mesmo conteúdo) i.e. com o mesmo id:

>>> l1=[1,2,3,4,5,6] >>> l1=[1,2,3,4,5,6]

Listas >>> l2 = l1 >>> l3 = l1[:] # cria um clone l3 de l1


Cópia de Lista: clone >>> l2 >>> l3 is l1
[1, 2, 3, 4, 5, 6] False
Operador is
>>> l2 is l1 >>> l1 is l3
True False
>>> l1 is l2
# listas com mesmo conteúdo, porém
True
# com referências diferentes
# listas equivalentes

198
 Podemos também gerar clones de uma lista copiando uma fatia
da lista original:

>>> a=[20,21,22,23,24]
>>> b=a[:] # cria um clone (b) da lista toda.
Listas >>> b
Cópia de Lista: clone [20,21,22,23,24]
Operador is >>> a==b # b e a são iguais (de conteúdo).
True
>>> a is b # mas não são idênticos (de endereço/referência).
False # elas têm um id diferente.

199
>>> a=[20, 21, 22, 23, 24]
>>> b=a[:]
[20, 21, 22, 23, 24]
>>> a[1]=31 # a alteração de um elemento na lista
>>> a # original não se repercute na lista clone.
[20, 31, 22, 23, 24] # as duas listas têm ids diferentes.
Listas
Cópia de Lista: clone >>> b

Operador is [20, 21, 22, 23, 24]


>>> a==b
False
>>> a is b
False

200
 Mas:
>>> a=[20, 21, 22, 23, 24]
>>> b=a # e não b=a[:]
[20, 21, 22, 23, 24]
>>> a[1]=31 # a alteração na lista original se repercute
>>> a # na nova lista.
Listas [20, 31, 22, 23, 24] # as duas listas têm ids iguais.
Cópia de Lista: clone
>>> b
Operador is
[20, 31, 22, 23, 24]
>>> a==b
True
>>> a is b
True

201
>>> a=[1,2,3,4]

>>> b=['a','b']

Listas >>> a[2]=b


Cópia de Lista: clone
Operador is >>> a

[1, 2, ['a', 'b'], 4]

202
>>> a=[1,2,3,4]
>>> a=[1,2,3,4]
>>> a[2:5]=b
>>> b=['a','b']
>>> a
>>> a[2:2]=b [1, 2, 'a', 'b']
>>> a
[1, 2, 'a', 'b', 3, 4] >>> a=[1,2,3,4]
>>> a[2:6]=b
Listas >>> a=[1,2,3,4]
>>> a[2:3]=b >>> a
Cópia de Lista: clone
>>> a [1, 2, 'a', 'b']
Operador is
[1, 2, 'a', 'b', 4]
>>> a=[1,2,3,4]
>>> a=[1,2,3,4]
>>> a[2:]=b
>>> a[2:4]=b
>>> a >>> a
[1, 2, 'a', 'b'] [1, 2, 'a', 'b']

203
>>> x = [1, 2, 3]

>>> y = [4, 5, 6]

>>> x[:0] = y # inserção/concatenação a esquerda

>>> x
[4, 5, 6, 1, 2, 3]
Listas
Cópia de Lista: clone
>>> x=[1,2,3]
Operador is
>>> x[0:]=y

>>> x

[4, 5, 6]

204
>>> x[:] = []
Listas
Cópia de Lista: clone # apaga o conteúdo de uma lista
Operador is

205
>>> x=[1,2,3]

>>> id(x)

103175032 >>> id(z)


>>> y=x # clone 103318112
Listas >>> id(y) >>> z is x
Cópia de Lista: clone False
103175032
Operador is >>> y is x
>>> z=x[:] # clone
True
>>> z
# y é uma copia idêntica
[1, 2, 3] # z não é (apenas de conteúdo)

206
>>> x = [1, 2, 3]
>>> y=x
>>> id(x)
101864432
>>> x[:]=[]
Listas >>> x
Cópia de Lista: clone
[]
Operador is
>>> y >>> x is y
[] True

>>> id(x) >>> y is x


101864432 True

207
>>> a=list(range(10,14)) >>> a=list(range(10,14))
>>> a >>> a

[10, 11, 12, 13] [10, 11, 12, 13]


Listas >>> a[2:]=['a','b','c']
>>> a.insert(2,['a','b','c'])
Cópia de Lista: clone >>> a
>>> a
Operador is
[10, 11, ['a', 'b', 'c'], 12, 13]
[10, 11, 'a', 'b', 'c']

posição 2

208
>>> a=list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=2*['bola']
>>> b
Listas ['bola', 'bola']
Cópia de Lista: clone
>>> a[::3]=b # em toda lista do início até o fim com
>>> a # passo 3
['bola', 1, 2, 'bola', 4, 5, 'bola', 7, 8, 'bola']
# irá dar erro se o tamanho da sequencia (aqui 4) for diferente
# do tamanho do fatiamento (4)

209
>>> a=[45,76,34,55] # lista original
>>> b=3*a # lista nova (* é o operador de repetição)
>>> b
[45,76,34,55,45,76,34,55,45,76,34,55]
# Na realidade, a nova lista (b) é uma lista que contém 3 referências à lista original a.

b
Listas
Operador de repetição *

210
 O que acontece se modificamos o valor de um elemento da lista
original a:?

>>> a[1]=200
>>> a
Listas [45, 200, 34, 55]
>>> a=[45,76,34,55]
Operador de repetição * >>> b
>>> b=3*[a]
[45, 200, 34, 55, 45, 200, 34, 55, 45,
>>> a
200, 34, 55]
[45, 76, 34, 55]
>>> b
[45, 76, 34, 55, 45, 76, 34, 55, 45, 76, 34, 55]

211
 O comando copy e deepcopy cria uma nova lista (cópia) a partir
de uma lista original:

import copy >>> l1=[1,[2,3],4,5,[6],7]


>>> l5=copy.deepcopy(l1)
>>> l1=[1,2,3,4,5,6]
Listas >>> l5
[1, [2, 3], 4, 5, [6], 7]
Cópia de Lista: copy e >>> l4 = copy.copy(l1)
deepcopy >>> l4 >>> l5 is l1
[1, 2, 3, 4, 5, 6] False
>>> l4 is l1 >>> l1 is l5
False False
>>> l1 is l4 # com a cópia profunda, as
False sublistas são copiadas e não
referenciadas
212
 O comando shuffle permite de embaralhar uma lista (altera
a ordem dos elementos):

import random
>>> l1=[1,2,3,4,5,6]
Listas >>> random.shuffle(l1)
Embaralhar uma lista: >>> l1
shuffle
[5, 3, 1, 4, 2, 6]
>>> random.shuffle(l1)
>>> l1
[5, 4, 3, 2, 6, 1]

213
 O comando sample permite de gerar uma amostra aleatória
de n elementos a parti de uma dada lista:

import random
>>> l1=[1,2,3,4,5,6]
>>> l6=random.sample(l1,3) # gera uma sublista de 3 elemtnos de l1
Listas [2, 1, 4]
Gerar amostra a partir de
>>> l6=random.sample(l1,3)
uma lista: sample
[1, 4, 6]
>>> l6=random.sample(l1,5) # gera uma sublista de 5 elemtnos de l1
[1, 6, 4, 3, 5]
>>> l6=random.sample(l1,5)
[1, 6, 4, 5, 3]

214
import random
>>> l1=[1,2,3,4,5,6]
>>> l7=random.sample(range(0,100,2),4)
>>> l7
[66, 30, 46, 60]

>>> l7=random.sample(range(0,100,2),4)
Listas >>> l7
[64, 42, 56, 44]
Gerar amostra a partir de
uma lista: sample >>> l7=random.sample(range(1,100,2),10)
>>> l7 # gera uma lista aleatória de 10 números impares entre 1 e 100
[83, 77, 73, 47, 43, 99, 3, 71, 91, 51]

>>> l7=random.sample(range(80),10)
>>> l7
[33, 58, 63, 2, 20, 4, 23, 5, 57, 1]

215
 O comando choice retorna um elemento aleatório a parti de
uma dada lista:

import random

>>> l1=[1,2,3,4,5,6]
Listas >>> random.choice(l1)
Gerar amostra: choise 3
>>> random.choice(l1)
2
>>> random.choice(l1)
2

216
 O comando zip permite de juntar duas listas, formando pares
de elementos: :

import random

>>> l8=zip(range(0,3),range(5,10))
>>> for e in l8:
Listas e
Gerar amostra a partir de
uma lista: zip (0, 5)
(1, 6)
(2, 7)

217
 Criar uma lista intercalada a partir de outras:

import random

>>> l1=[1,2,3,4,5,6]
>>> l2=list(range(10,20))
>>> l2
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
Listas
>>> l10=l1[::2],l2[3:],l1[1::2]
Gerar listas intercaladas
>>> l10
([5, 3, 6], [13, 14, 15, 16, 17, 18, 19], [4, 2, 1]) # contém 3 sublistas

>>> l10=l1[::2],l2[3:]
>>> l10
([1, 3, 5], [13, 14, 15, 16, 17, 18, 19]) # contém 2 sublitas

218
 O comando map permite de aplicar uma função (anônima ou não)
a todos os elementos de uma lista:

import random

>>> l1=[1,2,3,4,5,6]
Listas
map: aplica uma função >>> l11=map(lambda x: x*-1,l1)
anônima ou não em cima >>> l11
de cada elemento da lista

219
 Tornar todos elementos de uma lista positivos:

def positiva(lst):
return (map(lambda x: abs(x), lst))

l1=[-3,-2,-1,0,1,2,3]
Listas l2=positiva(l1)

map: aplica uma função for e in l2:


anônima ou não em cima print(e,end=' ')
de cada elemento da lista

220
 O comando filter permite de filtrar os elementos de uma lista
baseando-se em um critério:
import random
>>> l1=[1,2,3,4,5,6]

>>> def criterio(x): return x>=0


Listas >>> criterio(-2)
False
Filtrando elementos de
>>> criterio(5)
uma lista: filter
True
>>> filter(criterio,l1)
>>> filter(criterio,range(-6,6))
>>> filter(None,range(-3,3)) % [-3,-2,-1,0,1,2]

# retira da lista os elementos que não vereficamo critério


# no caso a1uiu, os elemtndso negativos.

221
# O slicing (fatiamento) é o acesso a sublistas usando o operador :

>>> uma_lista = ['a', 'b', 'c', 'd', 'e','f']


>>> uma_lista[1:3] # (índice_início:índice_fim) não incluso (aqui o 3)
['b', 'c']
>>> uma_lista[:4] # até a posição 4 (não inclusa)
['a', 'b', 'c', 'd']
Listas >>> uma_lista[3:] # da posição 3 até o final
Acessando: slicing ['d', 'e', 'f']
>>> uma_lista[:] # todos os elementos
['a', 'b', 'c', 'd', 'e', 'f']
>>> uma_lista[-1] # último elemento, -2 é o penúltimo
'f'
>>> >>> l[-len(uma_lista)] # retorna o 1º elemento da lista
'a'
>>>

222
# O slicing (fatiamento):

>>> ll=list(range(10))
>>> ll
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> ll[0]
0
Listas >>> ll[1::2] # inicia no 1 (2º) vai até o fim com passo 2
Acessando: slicing : [1, 3, 5, 7, 9] # índices impares
>>> >>> ll[0::2] # inicia no 0 (1º) vai até o fim com passo 2
[0, 2, 4, 6, 8] # índices pares
>>> ll[2:8:3] # inicia no 2 (3º) vai até o 8 (9º) com passo 3
[2, 5]
>>> ll[::4] # inicia no 1º vai até o fim com passo 4
[0, 4, 8]

223
# O slicing (fatiamento):

>>> a=list(range(3))
>>> a
[0, 1, 2]
>>> a[0]=9
Listas >>> a
Acessando: slicing : [9, 1, 2]
>>> a[1:3]
[1, 2]
>>> a[1:3]=[4,5,6]
>>> a
[9, 4, 5, 6]
>>>

224
#
>>> lista=list(range(2))
>>> print(lista)
[0, 1]
Listas
Criação de Listas >>> lista = [x*2 for x in list(range(5))]
>>> lista
[0, 2, 4, 6, 8]
>>>

225
#
>>> range(10)
range(0, 10)

Listas >>> lista=list(range(10))


Criação de Listas
>>> lista
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

226
# Percorrendo uma lista usando o for

>>> lista=[0,6,1,2,4,3]
>>> for x in lista:
print(x) # faça algo com a lista

Listas 0
Percorrendo uma Lista 6
1
2
4
3

227
# Percorrendo uma lista usando o for

>>> lista=[0,6,1,2,4,3]
>>> s=0
>>> for x in lista:
s+=x # s=s+x # faça algo com a lista
Listas
Percorrendo uma Lista >>> print(s)
16

# isto é equivalente a:
>>> sum(lista)
16

228
# Criando uma lista de números em sequencia
>>> lista=[1, 2, 3, 4]
>>> for indice,valor in enumerate(lista):
print(f'lista[{indice}] = {valor}')
# print("lista[%d] = %d" % (indice, valor))

Lista[0] = 1
Listas Lista[1] = 2
Percorrendo uma Lista:
Lista[2] = 3
enumerate
Lista[3] = 4

>>> l=2,4,5]
>>> for x,v in enumerate(l):
l[x]=l[x]*2
[4, 8, 16]

229
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[3:6]: # o incremento é 1 por defaut

Listas print(x)
Percorrendo uma Lista 3
4
5
>>>

230
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[7:4:-1]:
print(x)
Listas
Percorrendo uma Lista
7
6
5
>>>

231
# Percorrendo uma lista usando o for:
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[7:4:-2]:

Listas print(x)
Percorrendo uma Lista
7
5
>>>

232
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]:
print(x)

9
8
Listas 7
Percorrendo uma Lista 6
5
4
3
2
1
>>>

233
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]:
print(x)

9
8
Listas 7
Percorrendo uma Lista 6
5
4
3
2
1
>>>

234
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in lista[::-1]: # equivalente a for x in reversed(lista)
print(x)
>>> for x in reversed(lista):

Listas print(x)
Percorrendo uma Lista 9
8
7
...
1
>>>

235
# Percorrendo uma lista usando o for
>>> lista= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for x in sorted(lista):
print(x)

Listas 9
Percorrendo uma Lista 8
7
...
1
>>>

236
import random

>>> lista=list(range(10))

Listas
Acesso aleatório >>> random.choice(lista)
7
>>> random.choice(lista)
2

237
>>> lista= ['b',8,45,'k',3]
>>> lista
['b',8,45,'k',3]
>>> nova_lista=['Maria',lista,28,'bbb']

Listas >>> nova_lista # ['Maria',['b',8,45,'k',3],28,'bbb']


Listas Compostas >>> nova_lista[0] # 'Maria'
>>> nova_lista[1] # ['b',8,45,'k',3]
>>> nova_lista[2] # 28
>>> nova_lista[3] # 'bbb'
>>> nova_lista[1][0] # 'b' (1º elemento da sublista)

238
# Tamanho de uma lista
>>> lista=[25,8,-3,12]
>>> lista
Listas [25, 8, -3, 12]
len

>>> len(lista)
4

239
>>> lista=['a','b','c']
>>> lista[0]= 'A'

Listas >>> lista


Alterando elementos da ['A','b','c']
Lista >>> lista[2]=30
[’A','b',30]

240
>>> l1=['a','b','c']
>>> l2=[1,2,3,4]

>>> print(l1+l2)
Listas ['a', 'b', 'c', 1, 2, 3, 4]
Concatenação

>>> print(l2*3) # concatena 3 vezes a mesma lista


[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

241
# verificar se um elemento/símbolo pertence a uma lista

Lista=[45,23,12,8,22,0,15]
>>> 8 in lista
Listas True
in

>>> 'gato' in lista


False

242
# Operadores

l2=[1,2,3,4]

Listas >>> print(min(l2))


sum min max 1
>>> print(max(l2))
4
>>> print(sum(l2))
10

243
# Operadores

>>> livros = ['Java','C','Python']

>>> livros.append('C++') # o append é o operador de


# concatenação das listas,
Listas # e o + é operador de concatenação
Concatenação: append
# das strings
>>> livros
['Java','C','Python','C++']

244
EM STRINGS EM LISTAS

>>> s = 'Bom ' >>> l=[]


>>> s += 'dia' >>> l.append('Bom ')
>>> s >>> l
' Bom dia ' ['Bom ']
>>> l.append('dia')
# strings não >>> l
Listas # suportam o append ['Bom ', 'dia']
Concatenação
# observação
>>> l=[]
>>> l+='Bom'
>>> l
['B', 'o', 'm']

245
>>> lst=[]
>>> for i in range(10):
lst.append('a')
>>> lst
Listas ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']
Convertindo lista para
String
>>> lst=''.join(lst)
>>> lst
'aaaaaaaaaa'

246
# Operadores

>>> livros = ['Java','C','Python']


Listas
insert >>> livros.insert(0,'Arduino') # insere um elemento na posição zero

>>> livros
['Arduino','Java','C','Python']

247
# retirar elementos

>>> livros = ['Java','C','Python,'C++']

>>> livros.pop() # retira o último elemento


'C++'
Listas >>> livros
pop
['Java','C','Python']

>>> livros.pop(1) # retira o 2º elemento (índice 1)


'C'
>>> livros
['Java','Python']

248
# retirar elementos da lista:

>>> livros = ['Java','C','Python,'C++']


= ['Java','C','Python
>>> livros.remove('C++') # retira apenas a 1ª ocorrência
>>> livros # do elemento
Listas
['Java','C','Python']
remove

# outra forma de deletar elementos em uma lista:


>>> livros[3:4]=[] # ou livros[3:]=[]
>>> livros
['Java', 'C', 'Python']

249
# reverter

>>> livros = ['Java','C','Python,'C++']


Listas
reverse >>> livros.reverse() # muda a lista original
>>> livros
['C++','Python','C','Java']

250
# ordenar

>>> livros = ['Java','C','Python,'C++']


Listas
sort >>> livros.sort() # muda a lista original
>>> livros
['C','C++','Java','Python']

251
# contar ocorrência

Listas >>> l2=[3,4,5,3,2,8,10,6]


count
>>> l2.count(3)
2

252
# retornar o índice da 1ª ocorrência de um elemento na lista:

>>> l2=[3,4,5,3,2,8,10,6]

Listas >>> print(l2.index(2))


index
4

>>> l2.index(3)
0

253
 Representação de matrizes, sob forma de lista composta:

>>> matriz=[[1,2,3],[4,5,6],[7,8,9]]

Listas >>> matriz[1]


Matrizes [4,5,6]
>> matriz[1][2]
6

254
list.append → adiciona ao final.
list.count → conta a quantidade de determinado elemento em uma lista
list.index → mostra a posição de um determinado elemento na lista
list.insert → enquanto append adiciona ao final, aqui especificamos a posição
Listas:
list.pop → retira e exibe algum elemento, por padrão o último
Métodos
list.remove → similar ao pop, mas sem exibir a posição do elemento a retirar
list.reverse → inverte a ordem dos itens
list.sort → ordena os elementos, o método de ordenamento usado é o
TimSort: https://pt.wikipedia.org/wiki/Timsort

255
 Python tem duas outras estruturas de dados muito importantes: as
tuplas e os Dicionários.

 Tuplas:
É um sequência de itens de qualquer tipo e que são imutáveis.
Tais itens são separadas por uma vírgula e normalmente
Tuplas colocados entre parênteses.
Tuplas Tuplas são semelhantes aos records de outras linguagens.
c=('Caneta',2.50,'Escolar',300)
As tuplas permitem, portanto, de agrupar várias informações heterogêneas
em um único objeto.

As tuplas permitem os mesmos operadores que as listas e strings


têm.

256
 Tupla simples:
>>> t=(2,3,4,5,6)

Tuplas >>> type(t)


Tuplas <class 'tuple'>

>>> len(t)
5

257
 Tupla composta: Lista dentro de uma tuple.
>>> t=(2,3,[4,5,6])

Tuplas >>> type(t)


Tuplas compostas <class 'tuple'>

>>> len(t)
3

258
 Tupla composta: lista dentro de uma tupla:
>>> t=(2,3,[4,5,6])
t[2]=10
TypeError: 'tuple' object does not support item assignment

>>> t[-1][1]
Tuplas 5
Tuplas compostas
>>> t[-1][1]=88
>>> t
(2, 3, [4, 88, 6])
# É possivel alterar uma lista dentro de uma tupla mas nunca
# se consegue alterar uma tupla diretamente.

259
 Tupla composta: Tupla dentro de uma tupla:
>>> t2=(2,3,(4,5))
>>> t2
(2, 3, (4, 5))
Tuplas >>> type(t2)
Tuplas compostas <class 'tuple'>
>>> t2[-1]
(4, 5)
>>> t2[-1][0]=10
TypeError: 'tuple' object does not support item assignment

260
 Para alterar uma tupla, pode-se criar um clone dela (cópia) i.e.
criar uma varável que referência uma nova tupla com os
elementos desejados, usando as técnicas de fatiamento
(slicing) e de concatenação.
Tuplas  Para alterar o preço do produto caneta:
Tuplas
c=('Caneta',2.50,'Escolar',300)

261
Tuplas  Tuplas só têm dois métodos: count e index
Tuplas

262
Tuplas  Dicionário é uma estrutura que
Dicionários

263
 Se enquanto nos objetos indexáveis os objetos que inseríamos
estavam relacionados a uma posição,

 Em um dicionário não temos índices mas apenas uma


associação de chaves e valores.
Tuplas
Dicionários  Em vez de chamarmos um índice, chamamos a chave e
obtemos um valor:
>>> d = {"chave":"valor"}
>>> print(d["chave"])
valor

264
 Percorrer um dicionário:

for i in op:
print(op[i](100, 50))
Tuplas
Dicionários # ou

for i in op.values():
print(i(100, 50))

265
 Sets ou conjuntos são estruturas disponíveis do Python
(Python builtins) utilizadas para representar coleções desordenadas
Coleções de de elementos únicos.
Dados  Conjuntos têm duas características principais:
Sets
 Não tem ordem {2,3,4} = {3,2,4}
Por isso, conjuntos não suportam indexação e nem slicing
(fatiamento)
 Não tem redundância (não contém elementos repetidos).

266
>>> s={1,3,2,5,0}

>>> type(s)
<class 'set'>
Sets
Sets >>> s
{0, 1, 2, 3, 5}

>>> len(s)
5

267
 Conjunto vazio
>>> s={} # Conjunto vazio
>>> s
Sets {}
Sets >>> len(s)
0
>>> len({})
0

268
>>> a={2,1,0,2} # há redundância
>>> a # Python elimina as redundâncias
{0, 1, 2} # automaticamente

Sets >>> b={1,1,1,1,1,0,-1,-1} # há redundância


Sets >>> b
{0, 1, -1}

>>> len({2,2,2,2}) # há redundância


1

269
 Um set pode ser criada a partir de um outro tipo de dados:

>>> set([1, 2, 3, 4]) # a partir de uma lista

{1, 2, 3, 4}

>>> set(('a','b','c')) # a partir de uma tupla


Sets {'b', 'a', 'c'}
Sets: criação
>>> set('Amor.') # a partir de uma string

{'r', 'o', 'm', 'A', '.'}

 Observa-se que conjunto não tem ordem.


 A ordem colocada aqui depende do interpretador Python.

270
 Observação: as vezes é possível usar as parênteses como
delimitadores de tuplas:
>>> t1=(1,2,3,4)
Sets >>> t1
Sets: criação (1, 2, 3, 4)
>>> type(t1)
<class 'tuple'>

271
 Criar uma lista de apenas u elemento no caso do uso das parênteses
como delimitadores de tuples:
>>> tp=(8)
>>> tp
8
Sets >>> type(tp)
Sets: criação <class 'int'>
>>> tp=(8,) # acrescentando uma virgule
>>> tp
(8,)
>>> type(tp)
<class 'tuple'>

272
 Funções podem ter tuplas como valores retorno:

def circulo(r):
""" (numero) -> (float,float)
Recebe um numero r e retorna o comprimento da
Sets circunferência de raio r e a área do circulo de raio r.
Sets: criação
"""
p = 2 * 3.14159 * r
>>> circulo(10)
a = 3.14159 * r **2
(62.8318, 314.159)
return (c, a)

273
 Intercessão

 União
Sets
Sets: Operações de
conjunto

 Diferença

274
 Intercessão
>>> a={'A','m','o','r'}
>>> a
{'A', 'o', 'm', 'r'}
>>> a
{'A', 'o', 'm', 'r'}
Sets >>> b={'R','o','m','a'}
Sets: Operações de
conjunto >>> b
{'o', 'a', 'R', 'm'}
>>> a.intersection(b) # lembre-se que Python é uma linguagem case

{'o', 'm'} # sensitive.


>>> b.intersection(a)
{'o', 'm'}

275
 Intercessão vazia

Sets >>> {2,1,3,4}.intersection({7,5,6})


Sets: Operações de set() # conjunto vazio porém set() != {}
conjunto
>>>

276
 Observação: O operando esquerdo da operação deve ser um conjunto,
mas o operando direito pode ser qualquer data collection (tupla, lista,
string,...)
>>> set([1,2,3,4]).intersection({4,1})
{1, 4}

>>> set([1,2,3,4]).intersection(set([4,1]))
Sets {1, 4}
Sets: Operações de
conjunto >>> set([1,2,3,4]).intersection([4,1]) # com lista
{1, 4}

>>> set([1,2,3,4]).intersection((4,1)) # com tupla


{1, 4}

>>> set([1,2,3,4]).intersection('134') # com string


set()

277
 Esses métodos não alteram os conjuntos originais.
 Para mudar o primeiro conjunto usaremos o intersection_update():
>>> a={1,2,3,4,5} # a original

>>> b={2,4,6,8,10,12}

>>> a.intersection(b)
Sets {2, 4}
Sets: Operações de
conjunto >>> a

{1, 2, 3, 4, 5}

>>> a.intersection_update(b) # a é alterada para receber

>>> a # o resultado da operação

{2, 4}

278
 União
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}

>>> a.union(b)
Sets {'r', 'o', 'R', 'm', 'a', 'A'}
Sets: Operações de
conjunto >>> b.union(a)
{'r', 'o', 'R', 'm', 'a', 'A'}
>>>

279
 Diferença
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}

Sets >>> a.difference(b)


Sets: Operações de
conjunto {'A', 'r'}

>>> b.difference(a)
{'a', 'R'}

280
 Diferença Simétrica
>>> a={'A', 'o', 'm', 'r'}
>>> b= {'o', 'a', 'R', 'm'}

Sets >>> a.symmetric_difference(b)


Sets: Operações de
conjunto {'r', 'R', 'a', 'A'}
>>> b.symmetric_difference(a)
{'r', 'R', 'a', 'A'}

281
 A Diferença Simétrica é a união das duas diferenças:
>>> d1=a.difference(b)
>>> d1
>>> a={'A', 'o', 'm', 'r'}
{'A', 'r'}
>>> b= {'o', 'a', 'R', 'm'}
>>> d2=b.difference(a)
>>> d2
{'a', 'R'}
Sets >>> d1.union(d2)
Sets: Operações de {'A', 'a', 'R', 'r'}
conjunto
>>> a.symmetric_difference(b)
{'r', 'R', 'a', 'A'}
>>> a.symmetric_difference(b)==d1.union(d2)
True
>>> a.symmetric_difference(b)==d2.union(d1)
True

282
 Para alterar o conjunto original usamos o difference_update():
>>> a={1,2,3,4,5}
>>> b={2,4,6,8,10,12}
>>> a.difference(b)

Sets {1, 3, 5}
Sets: Operações de >>> a
conjunto
{1, 2, 3, 4, 5}
>>> a.difference_update(b) # muda o conjunto original
>>> a # recebendo o resultado
{1, 3, 5} # da operação

283
 Além desses operadores de interseção, união e diferença, há
também o operador de pertinência in que verifica se um
elemento pertence ao conjunto:

Sets >>> a={1,2,3,4,5}


Sets: Operações de >>> 3 in a
conjunto
True
>>> 8 in a
False

284
 O operador issubset verifica se um subconjunto pertence a um
conjunto:
>>> a={1,2,3,4}
>>> b={2,3}
>>> b.issubset(a)
Sets True
Sets: Operações de >>> {1}.issubset(a)
conjunto True
>>> {4,3}.issubset(a)
True
>>> a.issubset(b)
False

285
 O operador issuperset verifica se um conjunto é superconjunto
de um outro (é o contrário de issubset):

>>> a={1,2,3,4,5,6} >>> {3,1,2,6}.issuperset({2,3})


>>> b={3,5,1} True
Sets a.issubset(a)
>>> {'a'}.issuperset({'a','b','c'})
Sets: Operações de False
conjunto True
>>> {'a','b','c'}.issuperset({'a'})
>>> a.issuperset(a)
True
True

286
 O operador isdisjoint verifica se dois conjuntos são disjuntos ou seja, se
eles tiverem uma interseção nula:
>>> {2}.isdisjoint({1,2})
False
>>> A={2,3,4}

Sets >>> B={'a','b','c'}

Sets: Operações de >>> A.isdisjoint(B)


conjunto
True
>>> A.intersection(B)
set()
>>> A.isdisjoint(B) == (A.intersection(B)==set())
True

287
 List versus set:
>>> lista=[2,1,3,6]
>>> set(lista)
{1, 2, 3, 6}
>>> list(set(lista))
Sets
Sets: Operações de [1, 2, 3, 6]
conjunto

# O probelema é que o comando set pode alterar a ordem


# original da lista.

288
 Esse mecanismo de tuple assignment: é também utilizado para
fazer sawp entre variáveis:

>>> (a,b)=(b,a) # normalmente: x=a a=b b=x


Sets >>> nome
'Karine'
Sets: Operações de
conjunto >>> idade
22
>>> peso
60.5

289
 Python possui um mecanismo muito forte de atribuição de
valores às tuplas chamado tuple assignment:

>>> (nome,idade,peso)=('Karine',22,60.5) # com parênteses


Sets >>> nome
'Karine'
Sets: Operações de
conjunto >>> idade
22
>>> peso
60.5

290
 Dicionário é um conjunto de chaves e seus valores associados:
Coleções de >>> d1={'nome':'Marina','idade':20}
Dados
>>> type(d1)
Dicionários
<class 'dict'>

291
 Para acessar os valores do dicionário, usaremos as chaves m lugar
dos índices:

>>> d1={'nome':'Marina','idade':20}

>>> d1['nome'] # basta colocar o nome da chave


Dicionários 'Marina' # que o python retorna o valor associado
Dicionários: acesso
>>> d1['idade']

20

292
 Podemos testar se uma chave pertence ao dicionário ou não
usando o operador de pertinência in:

>>> d1={'nome':'Marina','idade':20}

>>> 'profissão' in d1
Dicionários False
Dicionários: in
>>> 'idade' in d1

True

293
 Para adicionar um elemento ao dicionário:
>>> produtos= {'Caneta': 20,'Caderno': 12, 'Lápis': 6}
>>> len(produtos)
3
>>> >>> produtos
Dicionários {'Caneta': 20, 'Caderno': 12, 'Lápis': 6}
Dicionários: adicionar >>> produtos['Tesoura']=8
>>> produtos
{'Caneta': 20, 'Caderno': 12, 'Lápis': 6, 'Tesoura': 8}
>>> len(produtos)
4

294
 Podemos deletar uma chave usando o comando del:
>>> produtos= {'Caneta': 20, 'Burracha': 4, 'Caderno': 12, 'Lápis': 6}
>>> len(produtos)
4
>>> 'Burracha' in produtos
Dicionários True
Dicionários: deletar >>> del(produtos['Burracha'])
>>> len(produtos)
3
>>> produtos
{'Caneta': 20, 'Caderno': 12, 'Lápis': 6}

295
 A alteração de um valor no dicionário é feita por uma atribuição
direta:
>>> produtos= {'Caneta': 20,'Caderno': 12, 'Lápis': 6}

Dicionários >>> produtos['Lápis']=4.50


Dicionários: alterar >>> produtos
{'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5}

296
 Para saber todas as chaves de um dicionário usamos o método keys:

>>> d1={'nome': 'Marina', 'idade': 20}

>>> d1.keys()

dict_keys(['nome', 'idade'])

Dicionários
Dicionários: keys >>> produtos={'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5, 'Tesoura': 8}

>>> produtos.keys()

dict_keys(['Caneta', 'Caderno', 'Lápis', 'Tesoura'])

297
 Da mesma dorma, para saber todos os valores de um dicionário
usamos o método values:

>>> d1={'nome': 'Marina', 'idade': 20}

>>> d1.valuess()

Dicionários dict_values(['Marina', 20])


Dicionários: values
>>> produtos={'Caneta': 20, 'Caderno': 12, 'Lápis': 4.5, 'Tesoura': 8}

>>> produtos.values()

dict_values([20, 12, 4.5, 8])

298
 Portanto, para descompactar um dicionário em duas listas de
chaves e de valores:

>>> k,v = d1.keys(), d1.values()

>>> k
Dicionários
Dicionários: dict_keys(['nome', 'idade'])
descompactar em lista
>>> v

dict_values(['Marina', 20])

299
Arquivos

300
 Um Programa comunica com o mundo externo usando operações
de entrada e saída.

 Isto é feito por meio de arquivos que são associados aos


dispositivo: Monitor, Teclado, Disco, Impressora, etc.
Arquivo?
 Geralmente, os arquivos são usados para armazenar dados, pós a
memória do computador é volátil.

 Os arquivos são organizados em um Diretório (Pastas/Folders) do


Disco.

301
 Arquivos são estruturas de dados armazenadas em disco.

 Cada arquivo tem um nome que o identifica.

 Em Python, um arquivo pode ser lido/escrito através de um objeto

Arquivo? da classe file.

 Os arquivos permitem duas operações básicas: a leitura e a


escrita.

 Mas para tal, ele precisa ser aberto e fechado logo quando
terminamos de usá-lo.

302
• Em Python, utiliza-se a função open para abrir um arquivo.

F = open(nome_do_arquivo, modo)

 Exemplo:

Arquivos >>> f = open('teste.dat','w')


Abertura: open
# abertura de um arquivo chamado teste.dat no modo escrita
# para poder armazenar/escrever dados nele.

A função open retorna um objeto da classe file.


Esse objeto representa o arquivo a ser manipulado.

303
• A função open recebe dois argumentos:
• o nome do arquivo, e

• o modo em que pretendemos usar o arquivo:


Arquivos
• modo w (write): i.e. estamos abrindo o arquivo para
Abertura: open
escrita (gravação de dados).

• modo r (read): i.e. estamos abrindo o arquivo apenas


para leitura dos dados armazenados.

304
• O arquivo é referenciado por dois nomes:

• Um nome lógico que será usado dentro do programa


a cada vez que se quer referenciar o arquivo.
Arquivos É o objeto da classe file do Python.
Abertura: open
• Um nome físico que é nome do arquivo no disco.

Geralmente o nome é precedido pelo diretório que é o caminho do


arquivo: por exemplo "/usr/share/dict/exemplos"

305
• Observação muito importante:

Arquivos • Se o arquivo especificado no comando open não existe (no


Abertura: open caso aqui 'teste.dat') então um novo arquivo com este nome
será automaticamente criado.

306
 Caminho do arquivo
 Se o arquivo e o programa estão no mesmo diretório, podemos usar

Arquivos apenas o nome do arquivo (“caminho relativo”).

Especificando o caminho f = open('teste.dat','w')


do arquivo?
 Se o arquivo e o programa estão em pastas (diretórios) diferentes,
usamos o “caminho absoluto”.

f = open('C:\Users\Labidi\Arquivos\teste.dat','w')

307
 O open retorna um objeto instancia da classe file:

>>> f = open('Arq2.dat','r')
Arquivos
Objeto da classe file >>> print(f)

<_io.TextIOWrapper name='Arq2.dat' mode='r' encoding='cp1252'>

308
Arquivos >>> f.write('Primeira frase de meu arquivo texto.')
Escrita: write

309
# abertura do arquivo no modo escrita (w)

Arquivos f=open('teste.dat','w')
Escrita: write f.write('Primeira frase de meu arquivo texto.\n')
f.write('Segunda frase de meu arquivo texto.\n')
f.close()

310
f.close()
Arquivos
Fechament0: close
 Todo arquivo aberto deve ser fechado quando terminar de
usá-lo com a chamada do close.

311
print (f.read())

 O read permite de ler todo o conteúdo do arquivo de só uma vez.

f.read(n)
Arquivos
Leitura: read  Para fazer uma leitura parcial, o read pode receber um inteiro n como
parâmetro indicando a quantidade dos caracteres que desejamos ler.

 A leitura de n caracteres a partir da posição atual do cursor.

312
# escrita
f=open('Arq.txt','w')
f.write('linha1\nlinha2\nlinha3') # escreva no arquivo
f.close()

Arquivos
read/write: exemplo
# leitura
f=open('Arq.txt','r')
txt=f.read() # ler todo o conteúdo de só uma vez
print(txt)
f.close()

313
# é possível delimitar o número de caracteres
# a serem lidos.
Arquivos >>> f=open('teste.dat','r')
Leitura parcial: read(n)
>>> print(f.readl(10))
'Primeira f‘ # leitura de apenas 10 caracteres
>>> f.close()

314
>>> import os

Arquivos >>> os.path.getsize ('c:Arq1.dat')


Tamanho de um arquivo: 48
getsize >>>

315
print (f.readline())

Usamos o comando readline para ler a linha atual do


Arquivos
Leitura: readline arquivo.

Para isto, o arquivo dever ser aberto no modo leitura, o


modo read (r)

316
# abertura do arquivo no modo escrita (w)
f=open('teste.dat','r')
Arquivos
print(f.readline()) # leitura de apenas 1ª linha
Leitura: readline
print(f.readline()) # leitura de apenas 2ª linha
f.close()

317
# leitura de todo o conteúdo, linha a linha
# usando readline:

f=open('Arq.txt','r')
linha='.'
while linha !='':
Arquivos
Leitura: readline linha=f.readline()
print(linha)
f.close()

# ao atingir o fim do arquivo, o readline retorna vazio ''


# e provoca a saída do while.

318
print (f.readlines())

Arquivos
Leitura: readlines Leia todo o conteúdo do arquivo.

Retorna todas as linhas, tudo em uma lista.

319
# leitura de todo o conteúdo,
# usando readlines:

f=open('Arq.txt','r')
Arquivos linhas=f.readlines()
readlines
for linha in linhas:
print(linha,end='')
f.close()

320
# leitura de todo o conteúdo, caractere a caractere,
# usando read(1) e getsize() 1º método
# read(1) leia uma caractere

f=open('Arq.txt','r')
Arquivos n=os.path.getsize('Arq.txt')
read(n)
for i in range(n):
c=f.read(1) # leia apenas 1 caractere.
print(c,end='')
f.close()

321
# Impressão caractere a caractere, 2º método:

f=open('Arq.txt','r')
c=f.read(1)
Arquivos
while c:
read(n)
print(c,end='')
c=f.read(1)
f.close()

322
Modo Função
Arquivos r Leitura
Modos de abertura w Escrita
a Abre para adicionar ao final (append)
r+ Leitura e escrita
b Indica modo binário

323
read(n) Retorna uma string única com todo o conteúdo do arquivo. Se n é
especificado, retorna o n carcateres.
readline() Retorna a próxima linha do arquivo, e incrementa a posição atual.

readlines() Retorna todo o conteúdo do arquivo em uma lista, uma linha do


arquivo por elemento da lista.
Arquivos
write(data) Escreve a string data no arquivo, na posição atual ou ao final do
Operações arquivo, dependendo do modo de abertura. Esta função falha se o
arquivo foi aberto com modo leitura "r“ (modo leitura).
writelines() Escreve várias linhas de só uma vez no arquivo.

seek(n) Muda a posição atual do arquivo para o valor indicado em n.

tell() Retorna a posição atual do cursos no arquivo..


close() Fecha o arquivo. Sempre utilizado no final da manipulação do
arquivo.
324
 Cria a função que copia um arquivo texto em um outro.
def copiararquivo(arq1,arq2):
f1 = open(arq1,'r')
f2 = open(arq2,'w')

while 1:
Arquivos
texto = f1.read(20)
Exercício
if not texto: # texto==''
break # chamada da função:
f2.write(texto) copiararquivo('teste.dat','teste2.dat')
f1.close() f=open('teste2.dat','r')
print(f.readlines())
f2.close() close(f) # impressão do arquivo cópia (f2)

325
Exemplo:

>>> f=open('Arq1.dat','w')
>>> f.write('1a linha do arquivo.\n')
21
Arquivos >>> f.write('2a linha do arquivo.\n')
Exemplo: Escrita
21
>>> f.write('fim.')
4
>>> f.close()

326
>>> f=open('Arq1.dat','r')
>>> f.readline() # leia uma linha do arquivo (aqui, a 1ª).
'1a linha do arquivo.\n'
>>> f.readline() # leia uma linha do arquivo (aqui, a 2ª).
'2a linha do arquivo.\n'
Arquivos
Exemplo: Leitura >>> f.readline() # leia uma linha do arquivo (aqui, a 3ª).
'fim.'
>>> f.readline() # leia uma linha do arquivo (aqui, a 4ª).
'' # mas como o arquivo chegou no fim
# retorna vazio.

327
>>> f.seek(0) # posiciona novamente o cursor no início do arquivo.
0
>>> f.readlines() # leia todo o conteúdo do arquivo e retorna uma lista.
['1a linha do arquivo.\n', '2a linha do arquivo.\n', 'fim.']
'1a linha do arquivo.\n2a linha do arquivo.\nfim.'
>>> f.read() # leia uma linha do arquivo.
Arquivos '' # já que o arquivo tá no fim, nada a ler,
Exemplo: Leitura # retorna vazio.
>>> f.seek(0) # posiciona o cursor no início do arquivo.
0
>>> f.read() # leia uma linha do arquivo (aqui a 1ª linha).
'1a linha do arquivo.\n2a linha do arquivo.\nfim.'
>>> f.close()

328
Escreva o arquivo caractere a caractere:

import os

arquivo='c:Arq1.dat'

f=open(arquivo,'r')
Arquivos
n=os.path.getsize(arquivo)
Exercício
for i in range(n):
c=f.read(1) # leia apenas 1 caractere.
print(c,end='')

f.close()

329
Escreva o arquivo linha a linha:

import os

arquivo='c:Arq1.dat'

f=open(arquivo,'r')
Arquivos
Exercício f.seek(0)
texto=f.read() # leia todo o conteúdo do dor arquivo texto.

for linha in texto:


print(linha,end='')

f.close()

330
 Escrevendo dados em um arquivo de só uma vez.
Arquivos  Usando writelines()
writelines

331
# Escrevendo dados em um arquivo de só uma vez (writelines).
f=open('Arq.txt','w')
linha=''
lista=[]
ok=True
while ok:
Arquivos linha=input('Digita a linha para gravar (vazio para sair): ')
writelines
lista.append(linha)
ok=linha # qdo linha é vazia seu valor lógico torna-se False
frase=''.join(lista) # converte a lista de strings em uma string
f.writelines(frase) # Texto gravado no arquivo!
f.close()

332
1. Crie um arquivo onde cada linha armazena o nome do
aluno, suas duas notas dos bimestres além da média:

Maria Sousa, 10.0, 8.0


Arquivos João Carlos, 5.0, 4.0
Exercícios
Zenira Maranhão, 2.5, 9.0
 Escreva uma função que receba o nome do arquivo como parâmetro e
que retorna a relação dos alunos aprovados (média>=7).

333
2. Desenvolva um algoritmo que escreve em disco um arquivo
com números ordenados crescentemente de 1 a 100
separado por “;”.
Arquivos
Exercícios
3. Desenvolva um algoritmo que escreve em disco um arquivo
com números ordenados decrescentemente de 100 a 1.
Cada número deve estar em uma linha..

334
4. Desenvolva um programa que cadastra produtos. O programa
deve registrar nome, preço e valor do estoque do produto. O

Arquivos usuário deve ter as seguintes opções de menu: Cadastrar novo


Exercícios produto; Listar os produtos cadastrados; Buscar um produto;
Alterar o preço ou estoque de um produto e Remover um
produto

335
Matemática

336
import math
x = math.sqrt(y)

Matemática import math as m


math x = m.sqrt(y)

from math import pi

337
pi Aproximação de π

Matemática
math

338
>>> print(f'Seno 30 = {M.sin(30*M.pi/180):.4f}')
Seno 30 = 0.5000
>>> print(f'Coseno 30 = {M.cos(30*M.pi/180):.4f}')
Coseno 30 = 0.8660
>>> print("$Log_{10}$ 100 = %.4f" % math.log10(100))
Log10 100 = 2.0000
Matemática
>>> print("Raiz Quadrada de 4 = %d " % math.sqrt(4)) 10 print("\n")
Exemplos
Raiz Quadrada de 4 = 2

>>> print("Menor inteiro 2.56 = %d " % math.floor(2.56))


Menor inteiro 2.56 = 2

>>> print("\n") 13 print("Maior inteiro 2.56 = %d " % math.ceil(2.56))


Maior inteiro 2.56 = 3

339
>>> import time
>>> th = time.localtime()

>>> print(f'Dia: {th.tm_mday}')


Matemática Dia: 30
Tempo - Horário
>>> print(f'Mês: {th.tm_mon}')
Mês: 5
>>> print(f'Ano: {th.tm_year}')
Ano: 2018

340
>>> print(f'Hora: {tempohorario.tm_hour}')
Hora: 20
>>> print(f'Minutos: {tempohorario.tm_min}')
Minutos: 52
>>> print(f'Segundos: {tempohorario.tm_sec}')
Segundos: 7
>>> print(f'Dia da semana: {tempohorario.tm_wday}')
Matemática Dia da semana: 2
Tempo - Horário >>> dias=['Segunda-feira','Terça-feira','Quarta-feira','Quinta-feira','Sexta-
feira','Sábado','Domingo']
>>> print(f'Dia da semana: {dias[tempohorario.tm_wday]}')
Dia da semana: Quarta-feira
>>> print(f'Dia do ano: {tempohorario.tm_yday}')
Dia do ano: 150
>>> print(f'Horário de verão: {tempohorario.tm_isdst}')
Horário de verão: 0

341
 Outra forma de fazer:
>>> import datetime
>>> hoje = datetime.datetime.now()
>>> hoje
datetime.datetime(2018, 6, 3, 23, 25, 27, 531139)
>>> str(hoje)
'2018-06-03 23:25:27.531139'
Matemática >>> repr(hoje)
Tempo - Horário
'datetime.datetime(2018, 6, 3, 23, 25, 27, 531139)‘
>>> hoje.day
3
>>> hoje.hour
23
>>> hoje.minute
25
342
 Criação de uma data:
>>> d1=date(2018,6,1)
>>> d2=date(1995,10,2)
>>> type(d1)
<class 'datetime.date'>

Matemática
 Diferença entre duas datas:
Tempo – Horário: days
>>> delta = d2-d1
datetime.timedelta(8278)
>>> delta.days
8278

343
Classes

344
Classes Python é uma linguagem Orientada a Objeto.
Orientação a Objeto

345
Utilitários

346
 Para colocar um delay de tempo entre os comandos:

>>> import time


Utilitários >>> time.sleep(5) # delay de 5 segundos
Delay de tempo: sleep
>>> time.sleep(60) # delay de 1 minuto

347
 Para executar um comando do sistema operacional (cmd):

Utilitários >>> import subprocess


O comando: check_output >>> subprocess.check_output(['notepad']) # abre o editor notepad
>>> subprocess.check_output(['ipconfig']) # configurações ip
>>> subprocess.check_output(['ipconfig‘,‘/all']) # atributos são separados

348
import turtle

t = turtle.Turtle()
t.shape("turtle")
t.forward(100)
t.right(90)
Utilitários t.forward(100)
t.right(90)
t.forward(100)
t.right(90)
t.color("red")
t.forward(100)
t.right(90)
349
import turtle

t = turtle.Turtle()

Criando t.shape("turtle")

t.forward(100)
Arquivos t.right(90)
Python t.forward(100)

t.right(90)

t.forward(100)

t.right(90)

t.color("red")

t.forward(100)

t.right(90)

350
Gráficos

351
Gráficos
Tratamento - Bibliotecas

352
 Em Python, utiliza-se RGB (Red, Green, Blue) para
definirmos as cores.

Cores (255, 0, 0) Vermelho


(0, 255, 0) Verde
(0, 0, 255) Azul
(255,255,0) Amarelo
(255,255,255) Branco
(0,0,0) Preto

353
Exceções

354
bFim = False
while not bFim:
try:
iNumero1 = 10
iNumero2 = 0
fResultado = iNumero1/iNumero2
Exceção print('Resultado = %.2f' % fResultado)
exemplo bFim = True
except ZeroDivisionError:
print("Você tentou dividir por zero.")
break
except TypeError:
print("Você usou um valor não numérico.")
break

355
 Muitas funções em Python fazem o programa terminar em caso
de erro.
 Isto acontece porque uma exceção foi gerada.
Exceções  Exceções não tratadas causam o fim do programa.
try:
programa
except:
tratamento

356
 Interpretador Dinâmico
dir( objeto ) #lista todos os métodos do objeto
Exceções
help( objeto.metodo ) #retorna o docstring do objeto,
função, método, modulo, etc...

357
Pacotes

358
Packages

359
 Para cálculo especial
Numpy  Álgebra linear
 Matrizes

360
Panda

361
Anaconda

362
 Integra o conda que é uma plataforma de gerenciamento de
pacotes e sistema de desenvolvimento.

 Dedicada os desenvolvedores Python e R.


AnaConda
 O Anaconda tem por intuito facilitar a instalação de pacote e
portanto a tarefa do desenvolvedor.

 Principalmente, os pacotes científicos, com foco no


processamento e análise de dados.

363
 Para instalação de Pacotes em Conda:
conda install nome_pacote

 Exemplo:
AnaConda conda install numpy
Instalação de Pacotes
 Para instalar vários pacotes de só uma vez, basta coloca-los
em uma lista separados por um espaço:
conda install numpy pandas

364
 Para remover um Pacotes em Conda:
conda remove nome_pacote
AnaConda
Remoção de Pacotes  Exemplo:
conda remove numpy

365
AnaConda  Para checar a relação dos Pacotes instalados:
Lista de Pacotes conda list

366
 É aconselhado criar ambientes específicos para cada
projetos, com seus pacotes específicos, etc.

AnaConda  Para tal, usamos o comando create:


Gerenciamento de conda create –n nome_ambiente lista dos pacotes
Ambientes: criação
 Exemplo:
conda create –n t este_arquivos numpy panda

367
 Para acessar um ambiente, usamos o comando activate no
windows:
AnaConda activate nome_ambiente
Gerenciamento de
Ambientes: aceso  No linux:
source activate nome_ambiente

368
 Para sair do ambiente, usamos o comando desactivate no
windows:
AnaConda desactivate nome_ambiente
Gerenciamento de
Ambientes: aceso  No linux:
source desactivate nome_ambiente

369
 AnaConda é uma distribuição relativamente pesada. Um
MinConda opção mais leve é usar o MiniConda que pssui apenas o
Conda e o Python.

370
 Site Oficial do AnaConda:
https://www.anaconda.com/

https://www.anaconda.com/download/
AnaConda
Instalação
Precisa de 3GB de HD para ser instalado.

371
AnaConda
Instalação

372
Conclusão

373
Conclusão  Python é uma linguagem muito poderosa.

374
Referências Bibliográficas

375
 HETLAND, Magnus Lie. Beginning Python From Novice to
Professional. Nova York: Apress. 2015.

 Python para desenvolvedores – Luis Eduardo Borges.

 Tutorial Python. Release 2.4.2 – Guido Van Rossum , Fred L.


Referências Drake, Jr.

 Por que as pessoas usam... Python? - Emerson Henrique,


Thiago Paiva, I Jornada de Iniciação Científica da ASPER
- Ciências da Computação e Processamento de Dados.

 Computação Gráfica em Python – Luís Eduardo Borges.

376

Você também pode gostar