FP 2022-10-17

Bom dia!
FP  2022-10-17

Instalador de Jetbrains PyCharm
Há duas versões do produto
- "académica"
- "professional" => modelo de negócio subscrição
$ = { comércio, subscrição, donativos, venda de pub, venda de info}

Para ter acesso à versão "professional" sem ter que pagar a subscrição, teremos q ter uma conta JB
Essa conta deveria ter sido criada com o email escolar,
[email protected]

Python.org

Passo 1 para termos as ferramentas que utilizaremos em sessão:
ter a "linguagem"
https://www.python.org/ftp/python/3.10.8/python-3.10.8-amd64.exe

********

# 1.py # single-line comment

""" # grammar switch-off
multiple-line comment 1
second line
third line
4th line
"""

def leny():
    pass

leny("Artur")

****************

# 2.py
"""
input => computação => output

Objetivo: fazer um programa que
receba/faça input de um número inteiro
de um utilizador e, recebido o número,
responda se é par, ou não é par
(se não for par será ímpar)

p1
fazer entrada de um nº inteiro
- pensar numa pergunta a fazer

p2
computar sobre o nº recebido para
determinar se é par, ou não

p3
responder: se for par, responder "SIM";
caso contrário, responder "NÃO"
"""

"""
pensar em PT
resposta <--- input de um nº inteiro
av <-- avaliar_se_resposta_é_num_par(resposta)
se av for sim, responder SIM; c.c. responder NÃO
"""

*************


# 3.py

"""
pensar em PT
resposta <--- input de um nº inteiro
av <-- avaliar_se_resposta_é_num_par(resposta)
se av for sim, responder SIM; c.c. responder NÃO
"""

"""
entrada -> computação -> saída(s)
frango => micro-ondas para aquecimento => frango quente
argumentos => function/computa/processa => return saída

como usar:
nome-de-função(lista-de-argumentos)
C, C++, C#, PHP, Java, JavaScript, Python
LISP
(nome arg1 arg2 arg3)
"""

"""
Operador atribuição
sintaxe / forma / notação
= lê-se "torna-se", "becomes", "is assigned"
expressões que se escrevem são da forma
operando-esquerdo = operando-direito
este é um operador binário
um operador é binário quando tem EXATAMENTE
dois operandos
"""

"""
notação SUGESTIVA para constantes:
ESCREVER_AOS_GRITOS
"""
# plicas ' single-quotes
# aspas " double-quotes
QUESTAO_A_FAZER = 'P.f., escreve um inteiro: '
#QUESTAO_A_FAZER = "Please, enter an int"

"""
uma entidade que PODE mudar de valor
é uma variável
"""
n = 2
n = 3
n = 4

"""
em qualquer linguagem há regras para os nomes
que damos aos identificadores
já conhecemos 3 tipos de "criaturas" que podem
viver num programas:
CONSTANTES
variáveis
functions

<id>::= <l>|<l><loua>
<loua>::=<l>|<a>|<l><loua>|a<loua>
<l>::=a|b|...|A|Z|_
<a>::=0|...|9
"""


"""
+ é operador "concatenação" / junção / colagem
de frases
neste contexto é a concatenação
porque os operandos são frases
"""
resposta1 = input(QUESTAO_A_FAZER)
print("A tua resposta foi "+resposta1)

resposta2 = input(QUESTAO_A_FAZER)
print("A tua resposta foi "+resposta2)

soma = resposta1+resposta2
print("O resultado da soma é "+soma)

**********************************************************

# 3.py

"""
pensar em PT
resposta <--- input de um nº inteiro
av <-- avaliar_se_resposta_é_num_par(resposta)
se av for sim, responder SIM; c.c. responder NÃO
"""

"""
entrada -> computação -> saída(s)
frango => micro-ondas para aquecimento => frango quente
argumentos => function/computa/processa => return saída

como usar:
nome-de-função(lista-de-argumentos)
C, C++, C#, PHP, Java, JavaScript, Python
LISP
(nome arg1 arg2 arg3)
"""

"""
Operador atribuição
sintaxe / forma / notação
= lê-se "torna-se", "becomes", "is assigned"
expressões que se escrevem são da forma
operando-esquerdo = operando-direito
este é um operador binário
um operador é binário quando tem EXATAMENTE
dois operandos
"""

"""
notação SUGESTIVA para constantes:
ESCREVER_AOS_GRITOS
"""
# plicas ' single-quotes
# aspas " double-quotes
QUESTAO_A_FAZER = 'P.f., escreve um inteiro: '
#QUESTAO_A_FAZER = "Please, enter an int"

"""
uma entidade que PODE mudar de valor
é uma variável
"""
n = 2
n = 3
n = 4

"""
em qualquer linguagem há regras para os nomes
que damos aos identificadores
já conhecemos 3 tipos de "criaturas" que podem
viver num programas:
CONSTANTES
variáveis
functions

<id>::= <l>|<l><loua>
<loua>::=<l>|<a>|<l><loua>|a<loua>
<l>::=a|b|...|A|Z|_
<a>::=0|...|9
"""


"""
+ é operador "concatenação" / junção / colagem
de frases
neste contexto é a concatenação
porque os operandos são frases
"""
#n = 3+4 # adição aritmética
resposta1 = input(QUESTAO_A_FAZER)
print("A tua resposta foi "+resposta1)

resposta2 = input(QUESTAO_A_FAZER)
print("A tua resposta foi "+resposta2)

# cast de str para int
#print (type(resposta1)) # str
soma = int(resposta1)+int(resposta2)
print (type(soma)) #int
print("O resultado da soma é "+str(soma))

n1 = int(input("n1:"))
n2 = int(input("n2:"))
soma = n1+n2
print("soma = "+str(soma))

*****************************************************************

# 4.py

# documentação interna

# QUESTAO_A_FAZER representa a frase com que o utilizador vai ser questionado
# pedir um inteiro
QUESTAO_A_FAZER:str = \
    "pf, escreve um inteiro: "

# strResposta - para representar a resposta do utilizador
strResposta:str=""
strResposta =\
    input(QUESTAO_A_FAZER) # input retorna sempre uma str
iResposta:int = int(strResposta)

# já tenho um inteiro que corresponde
# à resposta do utilizador

"""
+
+
=

resto da divisão inteira
%
ope % opd
resto da divisão inteira de ope por opd

4/2
"""

#print (4%2) #0
#print (5%2) #1


"""
operadores novos de seguida
% operador binário aritmético
resto da divisão inteira

== operador binário relacional
ope == opd
True se o ope tiver mesmo valor que opd
False se ope tive diferente valor que opd
"""
bRespostaEPar:bool = (iResposta%2)==0

print\
("Sim é par" if bRespostaEPar else "Não é par")