3- Tkinter em Ação.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Função no Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma função é definida para executar uma tarefa. Geralemente pega uma variavel como argumento e faz uma operação sob esse argumento e retorna o resultado. Iguel as funções que a gente ve no calculo. Uma função é definida na seguinte forma\n",
    "\n",
    "```python\n",
    "def my_func():\n",
    "    blah\n",
    "    blah\n",
    "    return foo\n",
    "```\n",
    "Vamos ver duas funções simples. A função a seguir pega um `string`, printa uma frase mas retorna nada. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prestam atenção que o argumento da função tem que ser inserido como um string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumprimentar1(name):\n",
    "    print(f\"oi {name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oi vahid\n"
     ]
    }
   ],
   "source": [
    "cumprimentar1(\"vahid\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos ver uma função que pega um argumento e retorna um resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube(numero):\n",
    "    n = numero**3\n",
    "    return n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na função acima, `numero**3` significa \"numero\" levado ao cubo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cube(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos montar um função para modificar os elementos de uma lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modify_elements(items):\n",
    "\n",
    " #multiplicar todos os elementos por 2\n",
    "\n",
    "    for i in range(len(items)):\n",
    "\n",
    "        items[i] *= 2\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "modify_elements([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções de `lambda`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: 2*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `list comprehension`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse é um jeito phytonico de fazer uma operação sob elementos de uma lista. No inicio parrece complicado mas quando se acustumar nunca vai querer montar uma função para fazer isso! kkk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1,2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [2*x for x in list1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10, 12]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tkinter: Widget em ação!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As funções de ligação (Binding) ou comando (Command) são aquelas que são chamadas quando um evento ocorre (por exemplo clicar um botão) ou é acionado (trigger)(por exemplo, mouse passado por cima de uma janela).\n",
    "Vamos dar um exemplo para entender as funções de ligação.\n",
    "Vamos definir um botão que, quando clicado, chama uma função chamada `python_uerj`. Além disso, a função `python_uerj` criará um novo rótulo com o texto `A FAT é linda` ! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter\n",
    "# vamos criar uma janela\n",
    "window = tkinter.Tk()\n",
    "window.title(\"GUI\")\n",
    "\n",
    "# vamos definir uma função chamada python_uerj()\n",
    "def python_uerj():\n",
    "    tkinter.Label(window, text = \"A FAT é linda!\").pack()\n",
    "\n",
    "tkinter.Button(window, text = \"Click Me!\", command = python_uerj).pack()\n",
    "window.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Clica varias vezes no botão!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver outro exemplo de binding. Agora vamos criar um contador que conta quantas vezes clicams em um botão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "\n",
    "window = tk.Tk()\n",
    "\n",
    "x = tk.IntVar()\n",
    "x.set(1)\n",
    "def add():\n",
    "    x.set(x.get() + 1)\n",
    "\n",
    "label = tk.Label(window, textvariable=x)\n",
    "label.pack()\n",
    "\n",
    "button = tk.Button(window, text=\"Incremento\", command=add)\n",
    "button.pack()\n",
    "\n",
    "win.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de chamar funções de ligação (binding) com um clique do mouse, os eventos podem ser chamados com um movimento do mouse, mouse sobre, clique, rolagem, etc (trigger).<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora estamos capacitados para construir a interface grafica para o nosso jogo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tkinter as tk\n",
    "import random\n",
    "\n",
    "max = 10\n",
    "num = random.randint(0,max)\n",
    "chances = 3\n",
    "\n",
    "def verificar():\n",
    "    global num, chances\n",
    "    if chances >0:\n",
    "        \n",
    "        if int(y.get())== num:\n",
    "            x.set(\"YOU WIN\")\n",
    "            chances = 0\n",
    "        else:\n",
    "            x.set(f\"voce ainda tem {chances} chances\")\n",
    "            \n",
    "    else:\n",
    "        x.set(\"YOU LOST\")\n",
    "        \n",
    "        \n",
    "    chances -= 1    #chances = chances - 1\n",
    "            \n",
    "        \n",
    "    \n",
    "#vamos construir a interface grafica\n",
    "\n",
    "window = tk.Tk()\n",
    "window.title(\"Experiente a sua sorte!\")\n",
    "window.geometry(\"300x150\")\n",
    "\n",
    "# vamos precisar de uma variavel para registrar quantas vez ainda podemos escolher um numero e o resultado do sorteio\n",
    "\n",
    "x = tk.StringVar()\n",
    "x.set(f\"voce ainda tem {chances} chances\")\n",
    "\n",
    "y = tk.IntVar()\n",
    "y.set(\"\")\n",
    "\n",
    "\n",
    "#gerar um numero aleatorio\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "label1 = tk.Label(window, text = f\"escolhe um numero entre 0 e {max}\").pack()\n",
    "\n",
    "label2 = tk.Label(window, textvariable = x).pack()\n",
    "\n",
    "text = tk.Entry(window, textvariable=y).pack()\n",
    "\n",
    "button = tk.Button(window, text = \"verifique\", command = verificar).pack()\n",
    "\n",
    "\n",
    "window.mainloop()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Executar um programa fora do Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois de montar um programa em Python a gente não quer entrar no Jupyter ou outro ambiente de programação para executar o programa. É muito chato fazer isso o tempo todo! Para resolver esse problema temos varias opções. Aqui vamos ver duas opções mais comuns.\n",
    "- Executar o .py no terminal\n",
    "- Criar um arquivo executavel\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Executar o .py no terminal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para executar um programa de Python diretamente no terminal temos que o salvar como `.py`. Para fazer isso temos que copiar o codigo inteiro e usando um editor de texto qualquer criar um arquivo de texto, mas com a enxentção `.py`. Depois disso, na pasta do arquivo, podemos executa-lo com o comando\n",
    "```\n",
    "python <nome_do_arquivo>.py\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Criar um arquivo executavel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro caminho é construir um arquivo executavel. Tem varios pacotes por este fim. Um dos melhores é `pyinstaller` [documentação](https://www.pyinstaller.org/). Temos que instalar esse pacote para puder usar mas esse pacote não está disponivel no repositorio de `conda` e temos que instalar usando o comando `pip`. A instalação é feito no terminal mas o dentro do Jupyter tambem podemos executar os comandos do terminal, basta inserir o sinal `exclamação` no inicio do comando na celula. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pyinstaller in /home/vahid/miniconda3/lib/python3.7/site-packages (3.6)\r\n",
      "Requirement already satisfied: altgraph in /home/vahid/miniconda3/lib/python3.7/site-packages (from pyinstaller) (0.17)\r\n",
      "Requirement already satisfied: setuptools in /home/vahid/miniconda3/lib/python3.7/site-packages (from pyinstaller) (46.1.3.post20200330)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install pyinstaller"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O resto é simples! Primeiro, igual a seção anterior, temos que criar um arquivo `.py`, depois dentro da pasta do arquivo `.py` executamos o comando \n",
    "```\n",
    "pyinstaller <nome_do_arquivo>.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E acabou! Na mesma pasta, o `pyinstaller` vai criar varias pastas. A pasta que nos intressa é `dist`. Podemos apagar o resto. Dentro dessa pasta `dist` vai ter outra pasta com nome do nosso arquivo. Aí, dentro dessa pasta a gente consegue achar o arquivo  **<nome_do_arquivo>.exe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para os arquivos que tem interface grafica é melhor adicionar alguns `flags` na hora de criação do executavel,\n",
    "```\n",
    "pyinstaller --onefile --noconsole <nome_do_arquivo>.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim o `pyinstaller` vai criar um arquivo unico. Alem disso na hora de executar o arquivo executavel não vai a janela do terminal. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}