Semana3_Exercícios(Gabarito).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Semana3_Exercícios(Gabarito).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNLIL3cJV4dfOHy9L099CyX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/CharlesPrado23/Notebooks/blob/main/Semana3_Exerc%C3%ADcios(Gabarito).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VASoC4nNmAI9"
      },
      "source": [
        "## Semana 3 \n",
        "## Exercícios (FOR, IF, WHILE) "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wqFIo-c2mOYV"
      },
      "source": [
        "1) Dado a lista, abaixo, de temperaturas da cidade de Boulder em Fahrenheit (F):\n",
        "\n",
        " 1.1) Crie uma lista convertendo para Celsius (C). Para converter use a fórmula C = (F-32)*(5/9); Print os valores na tela. \n",
        " \n",
        " 1.2) Crie uma função que receba a lista de temperaturas em Fahrenheit e retorna uma lista em graus Celsius. Print a lista na tela. \n",
        "\n",
        " 1.3) **(Desafio)** Generalize a função criada em 1.2 usando *args para que a função receba uma lista de tamanho variável.\n",
        " \n",
        "\n",
        " F = [47,49,57,64,72,83,89,87,79,67,55,47]; (Temperaturas em F da cidade de Boulder)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zvElfdL68jW7"
      },
      "source": [
        "boulder_avg_high_temp_f = [\n",
        "    47,\n",
        "    49,\n",
        "    57,\n",
        "    64,\n",
        "    72,\n",
        "    83,\n",
        "    89,\n",
        "    87,\n",
        "    79,\n",
        "    67,\n",
        "    55,\n",
        "    47\n",
        "]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Sn6F9Wb8_1P",
        "outputId": "2bbf7eb8-ef28-4d0e-a3b9-d9795c26309c"
      },
      "source": [
        "boulder_avg_high_temp_celsius_2 = []\n",
        "for temperature in boulder_avg_high_temp_f:\n",
        "    celsius = (temperature-32)*(5/9)\n",
        "    boulder_avg_high_temp_celsius_2.append(celsius)\n",
        "    \n",
        "\n",
        "print(boulder_avg_high_temp_celsius_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8.333333333333334, 9.444444444444445, 13.88888888888889, 17.77777777777778, 22.22222222222222, 28.333333333333336, 31.666666666666668, 30.555555555555557, 26.11111111111111, 19.444444444444446, 12.777777777777779, 8.333333333333334]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1d9qZDelDxwZ"
      },
      "source": [
        "def convert_F_to_C(F_Temperatures):\n",
        "  boulder_avg_high_temp_celsius_2 = []\n",
        "  for idx in range(len(F_Temperatures)):\n",
        "    celsius = (F_Temperatures[idx]-32)*(5/9)\n",
        "    boulder_avg_high_temp_celsius_2.append(celsius)\n",
        "  return boulder_avg_high_temp_celsius_2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rFa_k_63EBMq",
        "outputId": "1fdfd0b7-2f3f-4ae8-9741-a7036f2c1a98"
      },
      "source": [
        "List_C = convert_F_to_C(boulder_avg_high_temp_f)\n",
        "print(List_C)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[8.333333333333334, 9.444444444444445, 13.88888888888889, 17.77777777777778, 22.22222222222222, 28.333333333333336, 31.666666666666668, 30.555555555555557, 26.11111111111111, 19.444444444444446, 12.777777777777779, 8.333333333333334]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_KTw0L539r4u"
      },
      "source": [
        "def F_to_C(*args):\n",
        "  boulder_avg_high_temp_celsius_2 = []\n",
        "  for idx in range(len(args[0])):\n",
        "    celsius = (args[0][idx]-32)*(5/9)\n",
        "    boulder_avg_high_temp_celsius_2.append(celsius)\n",
        "  return boulder_avg_high_temp_celsius_2\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o2RWPYvT-Ta4"
      },
      "source": [
        "List_C = F_to_C([32,-32])\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FkqNAqEtDnd8",
        "outputId": "6074de1f-485d-48d4-faf8-433d8d4a657d"
      },
      "source": [
        "print(List_C)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.0, -35.55555555555556]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ClQPuqarsW9_"
      },
      "source": [
        "2)Passe por todos os números até 99 (começando em 1). Imprima 'fizz' para cada número que é divisível por 7, imprima 'buzz' para cada número divisível por 5 e imprima 'fizzbuzz' para cada número divisível por 7 e 5! Se o número não for divisível por 7 ou 5, imprima um travessão (‘-‘)! \n",
        "\n",
        " Para descubrir se um número x é divisível por y use operador (%): \n",
        "\n",
        "    x % y retorna True se x é divísel por y, False se não for. \n",
        "\n",
        "Dica : use  FOR , IF, ELIF, ELSE \n",
        "   "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tGVUsD6G9hzc",
        "outputId": "a4f2ce36-260d-46f5-fbe4-6d5eacf91722"
      },
      "source": [
        "for i in range(100):\n",
        "    if i % 7 == 0 and i % 5 == 0:\n",
        "        print('fizzbuzz')\n",
        "    elif i % 7 == 0:\n",
        "        print('fizz')\n",
        "    elif i % 5 == 0:\n",
        "        print('buzz')\n",
        "    else:\n",
        "        print('-')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "fizzbuzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "fizz\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "fizz\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "fizz\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "fizz\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "fizzbuzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "fizz\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "fizz\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "fizz\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "fizz\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "fizzbuzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "fizz\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "fizz\n",
            "buzz\n",
            "-\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "fizz\n",
            "-\n",
            "-\n",
            "-\n",
            "buzz\n",
            "-\n",
            "-\n",
            "fizz\n",
            "-\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pE2jEaxFnsJ8"
      },
      "source": [
        "3) Os filmes/séries podem ser classificados conforme o seu genero (ação,comédia, drama, terror etc). Considerando as classificações abaixo: \n",
        "\n",
        "   a) Ação = Jumanji, Projeto Gemini,The old guard,WandaVision.\n",
        "\n",
        "   b) Comédia = Jumanji,How I Met Your Mother,Friends, Amigos para sempre.\n",
        "\n",
        "   c)  Drama = Amigos para sempre, After,Game of Thrones, WandaVision.\n",
        "\n",
        " Tarefas: \n",
        "\n",
        "   3.1 - Cria uma lista de listas para representar cada um dos conjuntos acima. \n",
        "\n",
        "   3.2 - Usando a lista criada em 3.1, escreva um programa que \"print\" na tela a quantidade de caracteres de cada título.    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B2ex-slo9l6a",
        "outputId": "244cfd47-1191-4b88-d1b8-d4bf2aaeae63"
      },
      "source": [
        "my_movies = [['Jumanji', 'Projeto Gemini','The old guard','WandaVision'],\n",
        "    ['Jumanji','How I Met Your Mother','Friends','Amigos para sempre'],\n",
        "    ['Amigos para sempre','After','Game of Thrones','WandaVision']]\n",
        "for sublist in my_movies:\n",
        "    for movie_name in sublist:\n",
        "        char_num = len(movie_name)\n",
        "        print(\"The title \" + movie_name + \" is \" + str(char_num) + \" characters long.\")    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The title Jumanji is 7 characters long.\n",
            "The title Projeto Gemini is 14 characters long.\n",
            "The title The old guard is 13 characters long.\n",
            "The title WandaVision is 11 characters long.\n",
            "The title Jumanji is 7 characters long.\n",
            "The title How I Met Your Mother is 21 characters long.\n",
            "The title Friends is 7 characters long.\n",
            "The title Amigos para sempre is 18 characters long.\n",
            "The title Amigos para sempre is 18 characters long.\n",
            "The title After is 5 characters long.\n",
            "The title Game of Thrones is 15 characters long.\n",
            "The title WandaVision is 11 characters long.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rqdZUmi2vTJt"
      },
      "source": [
        "4) Escreva um programa que calcule o fatorial de um número (entre com o número usando input). Sabendo que: \n",
        "\n",
        "  a) n! = n*(n-1)*(n-2)*...*1 \n",
        "\n",
        "  b) 1! = 1\n",
        "\n",
        "  c) 0! = 1\n",
        "  \n",
        "  Dica: Use While  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-xb-slIFE38B",
        "outputId": "6ec6b705-98c3-413a-b42a-748ce609ba43"
      },
      "source": [
        "\n",
        "number = int(input(\"Enter number:\"))\n",
        "x=number\n",
        "fac = 1\n",
        "if number == 0:\n",
        "  print(1)\n",
        "else:\n",
        "  while number>=1:\n",
        "    fac = fac*number\n",
        "    number = number-1\n",
        "  print(\"Fatoria de {} é igual = {}\".format(x,fac))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter number:4\n",
            "Fatoria de 4 é igual = 24\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uCYFCuBvsIN8"
      },
      "source": [
        "**5) Desafio**\n",
        "\n",
        "Considerando o problema 3): \n",
        "\n",
        " 5.1) Crie um dicionário no qual cada chave representa o genero do filme; \n",
        "\n",
        " 5.2) Em um sistema de recomendação baseado em conteúdos, deseja-se saber as classificações (generos) de cada filme. Faça um programa que usando o dicionário criado em 5.1, retorne os generos associados a cada filme. (Dica: use um outro dicionário).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ALomF0a8AjE"
      },
      "source": [
        "my_movies_Dict = {'Acao':['Jumanji', 'Projeto Gemini','The old guard','WandaVision'],'Comedia':\n",
        "    ['Jumanji','How I Met Your Mother','Friends','Amigos para sempre'],'Drama':\n",
        "    ['Amigos para sempre','After','Game of Thrones','WandaVision']}\n",
        "\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UzyGAO0UG4dT",
        "outputId": "23429eec-2b09-41d5-fca1-a337a2a6d5aa"
      },
      "source": [
        "rev_Dict = {}\n",
        "for k, v in my_movies_Dict.items():\n",
        "    for e in v:\n",
        "        if e in rev_Dict:\n",
        "            rev_Dict[e].add(k)\n",
        "        else:\n",
        "            rev_Dict[e] = {k}\n",
        "print(rev_Dict)            "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'Jumanji': {'Acao', 'Comedia'}, 'Projeto Gemini': {'Acao'}, 'The old guard': {'Acao'}, 'WandaVision': {'Acao', 'Drama'}, 'How I Met Your Mother': {'Comedia'}, 'Friends': {'Comedia'}, 'Amigos para sempre': {'Drama', 'Comedia'}, 'After': {'Drama'}, 'Game of Thrones': {'Drama'}}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G7x5Wph8xXrU"
      },
      "source": [
        "1.\n",
        " \n",
        "(a) Make a class called User. \n",
        "\n",
        "(b) Create two attributes called first_name and last_name, and then create several other attributes that are typically stored in a user profile. \n",
        "\n",
        "(c) Make a method called describe_user() that prints a summary of the user’s information. \n",
        "\n",
        "(d) Make another method called greet_user() that prints a personalized greeting to the user."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oiBl4HjMxYlk"
      },
      "source": [
        "class User:\n",
        "\n",
        "  def __init__(self,first_name, last_name,**kwargs): \n",
        "    \n",
        "    self.first_name = first_name\n",
        "    self.last_name = last_name\n",
        "    self.login_attempt = 0\n",
        "  \n",
        "    for key, value in kwargs.items():\n",
        "            setattr(self, key, value)  \n",
        "\n",
        "  def describe_user(self):\n",
        "    print(self.__dict__)  \n",
        "  \n",
        "  def greet_user(self): \n",
        "    print(f'Hello, {self.first_name} {self.last_name}')\n",
        "  \n",
        "  \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rJN1hFgu3rSC",
        "outputId": "08f7ea30-abf9-41de-fd2b-848d8a13e8c2"
      },
      "source": [
        "user1 = User(\"Charles\",\"Prado\",location = 'BR',age = 47)\n",
        "user1.describe_user()\n",
        "user1.greet_user()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'first_name': 'Charles', 'last_name': 'Prado', 'login_attempt': 0, 'location': 'BR', 'age': 47}\n",
            "Hello, Charles Prado\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mWlXunh5G32H"
      },
      "source": [
        "(a) Add an attribute called login_attempts to your User class from Exercise. \n",
        "\n",
        "(b) Write a method called increment_login_attempts() that increments the value of login_attempts by 1. \n",
        "\n",
        "(c) Write another method called reset_login_attempts() that resets the value of login_attempts to 0.\n",
        "\n",
        "(d) Make an instance of the User class and call increment_login_attempts() several times. \n",
        "\n",
        "(e) Print the value of login_attempts to make sure it was incremented properly, and then call reset_login_attempts(). \n",
        "\n",
        "(f) Print login_attempts again to make sure it was reset to 0."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1vjkmrelHTGQ"
      },
      "source": [
        "class User:\n",
        "\n",
        "  def __init__(self,first_name, last_name,**kwargs): \n",
        "    \n",
        "    self.first_name = first_name\n",
        "    self.last_name = last_name\n",
        "    self.login_attempt = 0\n",
        "  \n",
        "    for key, value in kwargs.items():\n",
        "            setattr(self, key, value)  \n",
        "\n",
        "  def describe_user(self):\n",
        "    print(self.__dict__)  \n",
        "  \n",
        "  def greet_user(self): \n",
        "    print(f'Hello, {self.first_name} {self.last_name}')\n",
        "  \n",
        "  def increment_login_attempts(self):\n",
        "    self.login_attempt+=1\n",
        "\n",
        "  def reset_login_attempts(self):\n",
        "    self.login_attempt = 0     "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "52aOI6lTANYm",
        "outputId": "12e89f34-b7b9-41fc-a22a-26ade68fe6e2"
      },
      "source": [
        "user1 = User(\"Charles\",\"Prado\",location = 'BR',age = 47)\n",
        "for x in range(10):\n",
        "  user1.increment_login_attempts()\n",
        "print(user1.login_attempt)  \n",
        "user1.reset_login_attempts()\n",
        "print(user1.login_attempt) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CusIUSCpH3TG"
      },
      "source": [
        "Admin: An administrator is a special kind of user. \n",
        "(a) Write a class called Admin that inherits from the User class you wrote . \n",
        "\n",
        "(b) Add an attribute, privileges, that stores a list of strings like \"can add post\", \"can delete post\", \"can ban user\", and so on. \n",
        "\n",
        "(C) Write a method called show_privileges() that lists the administrator’s set of privileges. \n",
        "\n",
        "(d) Create an instance of Admin, and call your method."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxPGKS7jBKUc"
      },
      "source": [
        "class Admin(User):\n",
        "\n",
        "  def __init__(self,first_name, last_name,**kwargs):\n",
        "\n",
        "    super().__init__(first_name, last_name,**kwargs)\n",
        "\n",
        "    self.privileges = [\"can add post\", \"can delete post\", \"can ban user\"]\n",
        "  \n",
        "  def show_privileges(self):\n",
        "    print(f'The admin privileges are: {self.privileges}')     \n",
        "\n",
        "    \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IQIBSH6QDZyr",
        "outputId": "27619f7a-12e2-43af-9d47-984b7657419d"
      },
      "source": [
        "admin = Admin('Charles','Prado')\n",
        "admin.show_privileges()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The admin privileges are: ['can add post', 'can delete post', 'can ban user']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JiYWuR3eIL0r"
      },
      "source": [
        "(a) Write a separate Privileges class. The class should have one attribute, privileges, that stores a list of strings as described in previous Exercise. \n",
        "\n",
        "(b) Move the show_privileges() method to this class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GyMlqwYCDutN"
      },
      "source": [
        "class Privileges():\n",
        "\n",
        "  def __init__(self,*args):\n",
        "    self.privileges = args[0]\n",
        "\n",
        "  def show_privileges(self):\n",
        "    print(f'The admin privileges are: {self.privileges}')\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0Ur_DcFyEZ90",
        "outputId": "c2fb65cf-a5fd-49b5-d356-4333f731ce90"
      },
      "source": [
        "privileges = Privileges([\"can add post\", \"can delete post\", \"can ban user\"])\n",
        "privileges.show_privileges()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The admin privileges are: ['can add post', 'can delete post', 'can ban user']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uAGBZdChIgzp"
      },
      "source": [
        "(a) Make a Privileges instance as an attribute in the Admin class. \n",
        "\n",
        "(b) Create a new instance of Admin and use your method to show its privileges."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a6dRN0qLEsp0"
      },
      "source": [
        "class Admin(User):\n",
        "\n",
        "  def __init__(self,first_name, last_name,**kwargs):\n",
        "\n",
        "    super().__init__(first_name, last_name,**kwargs)\n",
        "\n",
        "    self.privileges = Privileges([\"can add post\", \"can delete post\", \"can ban user\"])\n",
        "  \n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "J09-y3ruFC_m",
        "outputId": "658bd8fe-5e4e-481a-9fbc-cb2ce5880d91"
      },
      "source": [
        "admin = Admin(\"Charles\",\"Prado\")\n",
        "admin.privileges.show_privileges()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The admin privileges are: ['can add post', 'can delete post', 'can ban user']\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}