{ "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 - 2025-2026**\n", "\n", "**Aula Prática 1 - Introdução ao [Google Colab](https://https://colab.google/) e 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://pubs.acs.org/doi/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", "\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", "\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": [ "#**Introdução à linguagem Python**\n", "\n", "**1 . Variaveis e tipos de dados**\n", "\n", "O que são ***variáveis*** em Python?\n", "\n", "Em linguagens de programação, as variáveis são um local/posição na memória onde se encontra armazenado um valor. Então, como o nome indica, é um nome simbólico que armazena dados que podem **variar**. Esse valor armazenado **pode ser alterado** de acordo com instruções posteriores.\n", "\n", "Em Python, uma ***variável*** é criada assim que é inicializada e/ou atribuída. Vamos ver algun exemplos.\n", "\n", "Nota: em Python, os comentários podem ser escritos usando o caracter \"#\" antes do comentário.\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. É uma boa prática comentarmos as linhas de código, explicando o que elas fazem.\n", "\n", "

 

\n", "\n", "**Exercício 1**\n", "\n", "Vamos declarar variáveis na caixa de código seguinte:" ], "metadata": { "id": "qOmhVPiRtmA8" } }, { "cell_type": "code", "source": [ "# Programa 1\n", "# 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.14159265\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": [ "

 

\n", "\n", "**Exercício 2**\n", "\n", "Escreva um programa para imprimir os valores armazenados nas variáveis. A sintaxe é:\n", "\n", "`print(f\"escreva uma mensagem aqui {var}\")`\n", "\n", "por exemplo\n", "\n", "`print(f\"A variável pi é igual a {pi}\")`\n", "\n", "Varie o formato do que é impresso (ver notas abaixo)\n", "\n", "Nota: Nesta sintaxe estamos a indicar que o Python deve avaliar as expressões/variáveis/funções dentro de {} e substituí-las pelo seu valor.\n", "\n", "O `f` antes das aspas indica uma *f-string* (formatted string). Permitem entre outras coisas, controlar o formato do que é escrito\n", "\n", "```\n", "x = 3.14159265\n", "print(f\"x = {x:.2f}\")\n", "```\n", "\n", "em que `.2f` significa: número em formato decimal fixo (f) com 2 casas decimais. Verifique por exemplo o que fazem os formatos `.2e` e `8.2f`" ], "metadata": { "id": "yzRZ8TXbnN1o" } }, { "cell_type": "code", "source": [ "# Programa 2\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n" ], "metadata": { "id": "VjeBeBM2rOIY" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "

 

\n", "\n", "**Exercício 3**\n", "\n", "Como reparou, as variáveis podem conter dados de diversos tipos.\n", "\n", "
\n", " \n", "
Source: https://pynative.com
\n", "
\n", "\n", "Indique o tipo das seguintes variáveis (usadas no exercício anterior).\n", "\n", "```\n", "# o número pi\n", "pi = 3.14159265\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", "```\n", "\n" ], "metadata": { "id": "H8q_5BA2u9Zn" } }, { "cell_type": "markdown", "source": [ "

 

\n", "\n", "**Exercício 4**\n", "\n", "A função `type()` pode ser usada para saber o tipo de uma variável. A sintaxe é\n", "\n", "```\n", "type(variavel)\n", "```\n", "\n", "Adapte o programa anterior (Programa 2) para que indique, além da variável, o seu tipo\n", "\n", "```\n", "print(f\"a variável var é igual a {var} e é do tipo {type(var)}\")\n", "```" ], "metadata": { "id": "iVq5MbkeXeOO" } }, { "cell_type": "code", "source": [ "# Programa 3\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n" ], "metadata": { "id": "a7MiK8FBwyK_" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "\n", "\n", "

 

\n", "\n", "**Exercício 5**\n", "\n", "Uma das vantagens da linguagem Python é permitir que o tipo de dados seja dinâmico, isto é, uma variável pode conter um tipo de dados e posteriormente ser alterada para conter outro tipo\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", "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": [ "# Programa 4\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n", "chemical_formula = \"H2O\"\n", "molecular_weight = 18.01528\n" ], "metadata": { "id": "T0JamKwa28Ji" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "

 

\n", "\n", "**2 . Operações**\n", "\n", "Agora que sabemos o que são variáveis e como atribuir valores às mesmas, podemos fazer operações. Para isso usamos ***operadores***.\n", "\n", "

 

\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", "\n", "

 

\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", "\n", "

 

\n", "\n", "**Exercício 6**\n", "\n", "Na seguinte caixa de código (Programa 6), exemplifique todas as operações das tabelas anteriores. Por exemplo\n", "\n", "```\n", "# Exemplo de adição\n", "soma = 3 + 5\n", "print(f\"{soma}\")\n", "\n", "# Outra forma de realizar a adição\n", "print(f\"{3+5}\")\n", "\n", "# Outra forma de realizar a adição, use a imaginação\n", "a=3\n", "b=5\n", "add=a+b\n", "print(f\"O resultado da adição de {a} com {b} é {add}\")\n", "\n", "```\n", "\n", "\n" ], "metadata": { "id": "44bVoQkQz-NT" } }, { "cell_type": "code", "source": [ "# Programa 5\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n", "###################################################\n", "# Teste os Operadores Aritméticos\n", "\n", "\n", "\n", "###################################################\n", "# Teste os Operadores de Atribuição\n", "\n", "\n" ], "metadata": { "id": "wBUYSdwsipRh" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "**Exercício 7**\n", "\n", "Para além dos anteriores, existem também\n", "\n", "*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", "

 

\n", "\n", "*Operadores 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", "\n", "Na caixa de código seguinte (Programa 6), exemplifique 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. Por exemplo\n", "\n", "```\n", "# Definição das variáveis x e y\n", "x = 5\n", "y = 10\n", "\n", "# aplicação do operador ==\n", "# à variável \"res\", atribuímos o valor x == x\n", "res = x == x\n", "print(f\"{res}\")\n", "```" ], "metadata": { "id": "zUt6pxGmmEvI" } }, { "cell_type": "code", "source": [ "# Programa 6\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n" ], "metadata": { "id": "NBHmOlZHpym3" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "

 

\n", "\n", "**3. Objectos iteráveis e declarações condicionais**\n", "\n", "Existem também objectos iteráveis na linguagem Python, como 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 e escreva 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": [ "# Programa 7\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n", "uma_lista = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100]\n", "\n", "# LINHA 1 - significado?\n", "#\n", "# print(uma_lista)\n", "# Significado:\n", "\n", "# LINHA 2 - significado?\n", "# print(uma_lista[2])\n", "# Significado\n", "\n", "# LINHA 3 - significado?\n", "# print(uma_lista[-2])\n", "# Significado\n", "\n", "# LINHA 4 - significado?\n", "#print(len(uma_lista))\n", "#Significado\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": [ "

 

\n", "\n", "**Exercício 8**\n", "\n", "Podemos usar declarações condicionais para definir processos de tomada de decisão 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", "# Atribuímoos o valor de 40.5 à variável \"temperatura_ambiente\"\n", "temperatura_ambiente = 40.5\n", "\n", "# Definimos as condições:\n", "# Se a variável \"temperatura ambiente for menor ou igual que 25, imprimimos a mensagem \"Está tudo OK! Etc ...\"\n", "# Se a variável \"temperatura ambiente for menor ou igual a 35, imprimimos a mensagem \"Cuidado! A temperatura atingiu valores preocupantes\"\n", "# Em todos os outros casos, imprimimos a mensagem \"Atingimos a temperatura crítica, vamos falecer!\"\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árias condições usando `elif` ou nenhuma.\n", "\n", "Nota 2: a indentação é obrigatória (tab)!\n", "\n", "Copie as linhas de código para a caixa abaixo (Programa 8), experimentando atribuir vários valores de `temperatura_ambiente`. Em seguida, usando as linhas anteriores como \"template\" escreva um programa que verifique se a variável `rendimento_reax` é maior que 80%, menor que 80% ou zero. Em cada caso, deverá imprimir uma mensagem apropriada. Teste usando vários valores para `rendimento_reax`" ], "metadata": { "id": "SmGDpxwvLw_d" } }, { "cell_type": "code", "source": [ "# Programa 8\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n", "# copie as linhas anteriores e teste\n", "\n", "\n", "\n", "#\n", "# Escreva em seguida o seu código relativo à variável \"rendimento_reax\"\n", "#\n", "\n" ], "metadata": { "id": "pvHikgEunzO9" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "

 

\n", "\n", "**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", " \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", "\n", "**Exercício 9**\n", "\n", "Os loops `while` e `for` são bastante úteis para, por exemplo, implementar contadoes ou iterar listas. Exemplos\n", "\n", "```\n", "# Exemplo de um loop \"while\"\n", "\n", "# Atribuímos à variável \"contador\" o valor de 0\n", "contador = 0\n", "\n", "# Vamos iniciar o loop; o loop é mantido enquanto a variável \"contador\" for < 5;\n", "# Na primeira iteração a variável contador é 0, então, como a condição é verificada\n", "# O programa imprime a mensagem e faz \"contador += 1\": a variável contador toma agora o valor de 1\n", "# O programa volta a avaliar a condição, e assim sucessivamente\n", "\n", "while contador < 5:\n", " print(f\"O contador está em: {contador}\")\n", " contador += 1\n", "```\n", "\n", "\n", "```\n", "# Exemplo de um loop \"for\"\n", "\n", "# Atribuição da lista à variável \"uma_lista\"\n", "uma_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "# Para cada elemento da lista (a que demos o nome/variável \"item\"), imprime o valor da variável \"item\"\n", "\n", "for item uma_lista:\n", " print(item)\n", "```\n", "\n", "Copie as linhas de código anterior para a caixa seguinte (Programa 9). Posteriormenre, e usando-as como base, construa um programa para\n", "\n", "\n", "* Converter uma lista valores de temperatura em Celsius para Kelvin (0 C = 273.15 K). Para essa lista para de `celsius = 10` até `celsius = 100`, somando de 1 em 1.\n", "\n", "\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": [ "# Programa 9\n", "# Coloque aqui o seu código e faça as modificações necessárias\n", "#\n", "#\n", "\n", "# copie as linhas anteriores e teste\n", "\n", "\n", "\n", "#################################\n", "# Escreva o seu programa de conversão de C para K\n", "\n", "\n", "\n", "#################################\n", "# Escreva aqui o seu programa para identificar o carácter ácido, alcalina ou neutro\n", "\n" ], "metadata": { "id": "s3GqqL43Mta9" }, "execution_count": null, "outputs": [] } ] }