{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"source": [
"#**Química Computacional - Aula Prática 1**\n",
"\n",
"**Introdução ao [Google Colab](https://https://colab.google/) e programação básica em Python**\n",
"\n",
"\\\\\n",
"\n",
"---\n",
"Bibliografia de Suporte:\n",
"\n",
"Javier Heras-Domingo and Diego Garay-Ruiz, *J. Chem. Educ.* **2024**, 101, 11, 4883–4891 [LINK](https://doi.org/10.1021/acs.jchemed.4c00840)\n",
"\n",
"Pythonic Chemistry: The Beginner's Guide to Digital Chemistry: https://github.com/jherasdo/pythonic-chemistry\n",
"\n",
"---\n",
"\n",
"\\\\\n",
"#**O que é o Google Colab?**\n",
"\n",
"\n",
" \n",
"\n",
"\n",
"\"Colab\" é uma abreviatura para \"Colaboratory\", um produto da Google Research, que pode ser usado para executar código na linguagem Python (ou R) usando um *browser*. Trata-se de um Jupyter notebook (mais informações [aqui](https://jupyter.org/)) que não necessita de instalação e permite o acesso grátis a recursos computacionais, incluíndo GPUs.\n",
"\n",
"\\\\\n",
"#**Porquê Python**\n",
"\\\\\n",
"\n",
" \n",
"\n",
"\n",
"A linguagem [Python](https://www.python.org/) é uma linguagem de alto nível que possui um conjunto muito grande e diversificado de bibliotecas que permitem automatizar tarefas como iremos ver ao longo deste curso. Apesar de permitir aplicações muito avançadas, a linguagem Python tem uma sintaxe simples e directa. Por conseguinte, é uma linguagem de fácil aprendizagem para iniciantes.\n",
"\n"
],
"metadata": {
"id": "KqADZfYeHzHd"
}
},
{
"cell_type": "markdown",
"source": [
"**1 . Variaveis e tipos de dados**\n",
"\n",
"O que são ***variáveis*** em Python? Como o nome indica, e em suma, são valores que podem variar. Em linguagens de programação, as variáveis são um local/posição na memória onde se encontra armazenada um valor. Esse valor armazenado **pode ser alterado** de acordo com instruções posteriores.\n",
"\n",
"Em Python, uma variável é criada assim que é inicializadas e/ou atribuídas. Vamos ver algun exemplos.\n",
"\n",
"Nota: em Python, os comentários podem ser escritos usando o caracter \"#\".\n",
"\n",
"`# isto é um comentário`\n",
"\n",
"Os comentários não são interpretados/executados e servem muitas vezes para auxiliar o programador/utilizador do programa"
],
"metadata": {
"id": "qOmhVPiRtmA8"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#\n",
"# Vamos declarar umas variáveis!\n",
"\n",
"# isto é um comentário!\n",
"\n",
"# o número pi\n",
"pi = 3.14\n",
"\n",
"# uma cor\n",
"cor = \"Vermelho\"\n",
"\n",
"# número de alunos\n",
"numero_alunos = 10\n",
"\n",
"# Uma condição\n",
"python_is_cool = True\n"
],
"metadata": {
"id": "YTFyvSUxK8nX"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**Exercício 1**\n",
"\n",
"Escreva um programa para imprimir os valores armazenados nas nossas variáveis. A sintaxe é\n",
"\n",
"`print(f\"escrever um mensagem aqui {var}\")`\n",
"\n",
"por exemplo\n",
"\n",
"`print(f\"A variável pi é igual a {pi}\")`"
],
"metadata": {
"id": "yzRZ8TXbnN1o"
}
},
{
"cell_type": "code",
"source": [
"print(f\"A variável pi é igual a {pi}\")\n",
"\n",
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#\n"
],
"metadata": {
"id": "VjeBeBM2rOIY"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Como reparou, as variáveis podem conter dados de diversos tipos.\n",
"\n",
"\n",
" \n",
" Source: https://pynative.com\n",
"\n",
"\n",
"**Exercício 2**\n",
"\n",
"Indique o tipo de dados das variáveis anteriores.\n",
"\n",
"**Exercício 3**\n",
"\n",
"Adapte o programa anterior e escreva um programa que indique o tipo de dados.\n",
"\n",
"Nota: A função `type(variableName)` retorna o tipo de dados."
],
"metadata": {
"id": "H8q_5BA2u9Zn"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "a7MiK8FBwyK_"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Uma das vantagens da linguagem Python é o facto de permitir que o tipo de dados seja dinâmico, isto é, uma variável contendo um tipo de dados e ser alterada para conter outro outro tipo\n",
"\n",
"**Exercício 4**\n",
"\n",
"No seguinte código\n",
"\n",
"```\n",
"chemical_formula = \"H2O\"\n",
"molecular_weight = 18.01528\n",
"\n",
"# mudança\n",
"\n",
"molecular_weight = \"dezoito\"\n",
"\n",
"```\n",
"\n",
"indique o tipo de dados em cada variável e indique se existiu alguma alteração.\n",
"Pode usar a caixa em baixo para escrever um código que auxilie nessa atribuição."
],
"metadata": {
"id": "ofoE6vzEhfPb"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "T0JamKwa28Ji"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**2 . Operações**\n",
"\n",
"Agora que sabemos o que são variáveis e como atribuir valores às mesmas, podemos fazer operações usando operadores.\n",
"\n",
"Operadores Aritméticos\n",
"\n",
"|Operador | Nome | Exemplo|\n",
"|-------------------|------------------|------------------|\n",
"|+\t|adição\t|x + y|\n",
"|-\t|subtracção\t|x - y|\n",
"|*\t|multiplicação\t|x * y|\n",
"|/\t|divisão\t|x / y|\n",
"|%\t|operação módulo (resto da divisão)\t|x % y|\n",
"|**\t|Exponenciação ou potenciação\t|x ** y|\n",
"|//\t|quociente da divisão exata (arredondamento)|x // y|\n",
"\n",
"Operadores de Atribuição\n",
"\n",
"|Operador | Exemplo | Igual a |\n",
"|-------------------|------------------|------------------|\n",
"|=\t |x = 5\t |x = 5|\n",
"|+=\t |x += 3\t |x = x + 3|\n",
"|-=\t |x -= 3\t |x = x - 3|\n",
"|*=\t |x *= 3\t |x = x * 3|\n",
"|/=\t |x /= 3\t |x = x / 3|\n",
"|%=\t |x %= 3\t |x = x % 3|\n",
"|//=\t|x //= 3\t|x = x // 3|\n",
"|**=\t|x **= 3\t|x = x ** 3|\n",
"\n",
"**Exercício 5**\n",
"\n",
"Na caixa de código seguinte, exemplifique todas as operações das tabelas anteriores."
],
"metadata": {
"id": "44bVoQkQz-NT"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "wBUYSdwsipRh"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Para além dos anteriores, existem também operadores de comparação\n",
"\n",
"|Operador | Nome | Exemplo |\n",
"|-------------------|------------------|------------------|\n",
"|== |\tIgual\t |x == y |\n",
"|!= |\tDiferente de\t |x != y |\n",
"|>\t| Maior\t|x > y |\n",
"|<\t| Menor\t |x < y |\n",
"|>= |\tMaior ou igual\t| x >= y |\n",
"|<= |\tMenor ou igual\t| x <= y |\n",
"\n",
"e lógicos\n",
"\n",
"|Operador | Nome | Exemplo |\n",
"|-------------------|------------------|------------------|\n",
"|and|\tDevolve True se ambos forem verdade\t|x < 5 and x < 10|\n",
"|or\t| Devolve True se uma for verdade\t|x < 5 or x < 4|\n",
"|not|\tReverte o resultado, devolve False se o resultado for verdadeiro | not(x < 5 and x < 10)|\n",
"\n",
"\\\n",
"**Exercício 6**\n",
"\n",
"Na caixa de código seguinte, exemplifique todas as operações das tabelas anteriores. Sugestão: Comece por atribuir valores a variáveis `x` e `y`. Depois, aplique um operador e verifique o resultado."
],
"metadata": {
"id": "zUt6pxGmmEvI"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "NBHmOlZHpym3"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**3. Objectos iteráveis e declarações condicionais**\n",
"\n",
"Existem vários objectos iteráveis na linguagem Python, por exemplo, `Lists`, `Dictionaries`e `Tuples`.\n",
"\n",
"`uma_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`\n",
"\n",
"```\n",
"dicionario_peso_molecular = {\n",
" \"H\": 1.0079,\n",
" \"C\": 12.0107,\n",
" \"O\": 15.999,\n",
" \"Na\": 22.9898,\n",
" \"Cl\": 35.453\n",
"}\n",
"```\n",
"\n",
"`um_tuple = (\"ronaldo\", \"messi\", \"tozé\")`\n",
"\n",
"Podemos percorrer estes objectos iteráveis ou aceder a um determinado elemento.\n",
"\n",
"**Exercício 7**\n",
"\n",
"Verifique o significado de cada uma das linhas de código assinaladas comentando as mesmas. Para facilitar, vá descomentando as linhas de código uma a uma.\n",
"\n"
],
"metadata": {
"id": "K0v7Z3RRpz-2"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#\n",
"\n",
"uma_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"\n",
"# LINHA 1 - significado?\n",
"#\n",
"#print(uma_lista)\n",
"\n",
"# LINHA 2 - significado?\n",
"#print(uma_lista[2])\n",
"\n",
"# LINHA 3 - significado?\n",
"#print(uma_lista[-2])\n",
"\n",
"# LINHA 4 - significado?\n",
"#print(len(uma_lista))\n",
"\n",
"dicionario_peso_molecular = {\n",
" \"H\": 1.0079,\n",
" \"C\": 12.0107,\n",
" \"O\": 15.999,\n",
" \"Na\": 22.9898,\n",
" \"Cl\": 35.453\n",
"}\n",
"\n",
"# LINHA 5 - significado?\n",
"#print(dicionario_peso_molecular)\n",
"\n",
"# LINHA 6 - significado?\n",
"#print(dicionario_peso_molecular[\"Na\"])\n",
"\n",
"um_tuple = (\"ronaldo\", \"messi\", \"tozé\")\n",
"\n",
"# LINHA 7 - significado?\n",
"#print(um_tuple)\n",
"\n",
"# LINHA 8 - significado?\n",
"#print(len(um_tuple))\n",
"\n",
"# LINHA 9 - significado?\n",
"#print(um_tuple[1])\n"
],
"metadata": {
"id": "RFFeluCGIQBQ"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Podemos usar declarações condicionais para processos de tomada de decisão. Podemos realizar estas condições usando `if`, `elif` and `else`. A sintaxe é a seguinte:\n",
"\n",
"```\n",
"if condição:\n",
" expressão\n",
"elif condição:\n",
" expressão\n",
"else:\n",
" expressão\n",
"```\n",
"\n",
"Por exemplo, podemos verificar se um determinado valor foi atingido para realizar uma tarefa, e.g.\n",
"\n",
"```\n",
"temperatura_ambiente = 40.5\n",
"\n",
"if temperatura_ambiente <= 25:\n",
" print(f\"Está tudo OK! A temperatura é {temperatura_ambiente}\")\n",
"elif temperatura_ambiente <= 35:\n",
" print(f\"Cuidado! A temperatura atingiu valores preocupantes: {temperatura_ambiente}\")\n",
"else:\n",
" print(f\"Atingimos a temperatura crítica, vamos falecer! {temperatura_ambiente}\")\n",
"```\n",
"\n",
"Nota 1: podemos adicionar váias condições usando `elif` ou nenhuma.\n",
"\n",
"Nota 2: a indentação é obrigatória (tab)!\n",
"\n",
"**Exercício 8**\n",
"\n",
"Corra as linhas de código acima para vários valores de `temperatura_ambiente`. Usando essas linhas como inspiração, modifique o programa para que verifique se a variável `rendimento_reax` é maior que 80%, menor que 80% ou zero. Em cada caso, deverá imprimir uma mensagem apropriada."
],
"metadata": {
"id": "SmGDpxwvLw_d"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "pvHikgEunzO9"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**4. Laços de repetição (loops)**\n",
"\n",
"As estruturas denominadas de loops permitem repetir uma ou mais tarefas até que uma determinada condição se torne verdadeira.\n",
"\n",
"\\\\\n",
"\n",
" \n",
" Source: Javier Heras-Domingo and Diego Garay-Ruiz, J. Chem. Educ. 2024, 101, 11, 4883–4891 (https://github.com/jherasdo/pythonic-chemistry)\n",
"\n",
"\n",
"\n",
"Exemplos\n",
"\n",
"```\n",
"# While loop\n",
"contador = 0\n",
"\n",
"while contador < 5:\n",
" print(f\"O contador está em: {contador}\")\n",
" contador += 1\n",
"```\n",
"\n",
"\n",
"```\n",
"# For loop\n",
"\n",
"uma_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"\n",
"for item uma_lista:\n",
" print(item)\n",
"```\n",
"\n",
"**Exercício 9**\n",
"\n",
"Corra as linhas de código anterior. Posteriormente, e usando-as como base, construa um programa para\n",
"\n",
"\n",
"* Converter todos os valores de temperatura em Celsius (partindo de `celsius = 10`) para Kelvin, até ao limite de `celsius = 100`. \n",
"* Identificar se uma solução é ácida, alcalina ou neutra usando os seguintes valores de pH numa lista: 2.0, 4.5, 6.8, 7.0, 7.2, 8.0, 9.3.\n",
"\n",
"\n",
"\n"
],
"metadata": {
"id": "-8S7cEh1B84Y"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#\n",
"\n",
"# While loop\n",
"contador = 0\n",
"\n",
"while contador < 5:\n",
" print(f\"O contador está em: {contador}\")\n",
" contador += 1\n",
"\n",
"# For loop\n",
"uma_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"\n",
"for item in uma_lista:\n",
" print(item)\n",
"\n",
"# Escreva o seu programa de conversão de C para K\n",
"\n",
"\n",
"# Escreva aqui o seu programa para identificar o carácter ácido, alcalina ou neutro"
],
"metadata": {
"id": "s3GqqL43Mta9"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"**Exercício Avaliação (Casa)**\n",
"\n",
"Vamos tentar juntar os vários conceitos.\n",
"Imagine que possui uma base de dados de compostos organizados sob a forma de `dictionary`, por exemplo:\n",
"\n",
"```\n",
"# The aspirin dict\n",
"aspirin_info = {\n",
" \"IUPAC_name\": \"2-acetoxybenzoic acid\",\n",
" \"common_name\": \"Aspirin\",\n",
" \"molecular_formula\": \"C9H8O4\",\n",
" \"molar_mass\": 180.16,\n",
" \"structure\": \"O=C(C)Oc1ccccc1C(=O)O\",\n",
" \"melting_point_celsius\": 138,\n",
" \"boiling_point\": \"Decomposes\",\n",
" \"solubility\": \"Slightly soluble in water, soluble in ethanol, chloroform, and ether\",\n",
" \"side_effects\": [\"Stomach upset\", \"Tinnitus\", \"Bleeding\"],\n",
" \"mechanism_of_action\": \"Inhibition of COX enzymes, which are involved in the production of prostaglandins.\"\n",
"}\n",
"```\n",
"\n",
"Na caixa seguinte, escreva um programa que verifique se a massa molar do composto é inferior a 500 e o ponto de fusão é superior a 100 Celsius.\n",
"\n",
"Em caso afirmativo, deverá imprimir a mensagem \"O composto cumpre os requisitos: a massa molar é X e o ponto de fusão é Y\" (com X e Y igual aos valores)\n",
"\n",
"Em caso de apenas critério ser cumprido, deverá imprimir a mensagem \"O composto apenas cumpre um dos requisitos: \"a massa molar é X \" ou \"ponto de fusão é Y\" (com X e Y igual aos valores, dependendo do caso).\n",
"\n",
"Em caso de nenhum critério ser cumprido, deverá imprimir a mensagem \"O composto apenas não cumpre os requisitos\""
],
"metadata": {
"id": "ZqaEupj7ZHJp"
}
},
{
"cell_type": "code",
"source": [
"# Coloque aqui o seu código e faça as modificações necessárias\n",
"#\n",
"#"
],
"metadata": {
"id": "QUvoVyZmaJmr"
},
"execution_count": null,
"outputs": []
}
]
}