python_intro_scGenomics.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nunososorio/bhs/blob/main/python_intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "# Bioinformatics in Health Science Course - Python Fundamentals\n",
        "## School of Medicine, University of Minho, Braga, Portugal"
      ],
      "metadata": {
        "id": "-zABU3vfJCG_"
      },
      "id": "-zABU3vfJCG_"
    },
    {
      "cell_type": "markdown",
      "id": "e2069ee8",
      "metadata": {
        "id": "e2069ee8"
      },
      "source": [
        "Welcome to our Python Fundamentals practical class! This session will help you with the basics of Python programming.\n",
        "In the end, you will have the opportunity to apply your knowledge through a hands-on coding playground to build your skills and confidence as a future Python programmer 🚀\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Why?"
      ],
      "metadata": {
        "id": "e5tRFtdQRvga"
      },
      "id": "e5tRFtdQRvga"
    },
    {
      "cell_type": "markdown",
      "source": [
        "🤖 Even in the age of AI, learning Python is definitely worth it! 🐍\n",
        "\n",
        "1. **Understanding**: To effectively use and understand the code generated by AI, you need to have a basic understanding of the programming language being used.\n",
        "\n",
        "2. **Customization**: AI can generate code based on prompts, but for more complex, specific, or novel tasks, you might need to write or modify the code yourself.\n",
        "\n",
        "3. **Debugging**: If there's an issue with the code, understanding Python will allow you to debug it.\n",
        "\n",
        "4. **Career Opportunities**: Python is one of the most popular and in-demand programming languages. Knowing Python opens up many opportunities in fields like web development, data science, machine learning, etc.\n",
        "\n",
        "5. **Versatility**: Python is used in many areas of software development and data analysis. It's a great tool for building web applications, analyzing data, automating tasks, and much more."
      ],
      "metadata": {
        "id": "cTGV6SuRQFUF"
      },
      "id": "cTGV6SuRQFUF"
    },
    {
      "cell_type": "markdown",
      "id": "bc3c1317",
      "metadata": {
        "id": "bc3c1317"
      },
      "source": [
        "# 1. Variables and print statements\n",
        "🐍 In Python, a variable is like a container used to store data. It's given a unique name (the variable name) that can be used to retrieve the stored data. Data stored in a variable can be of different types, the most common being:\n",
        "\n",
        "- **Numbers**: These can be integers (`int`), which are whole numbers, or floats (`float`), which are numbers with a decimal point¹.\n",
        "- **Text strings (`str`)**: In Python, the string data type is used to represent text data. It is a sequence of characters enclosed in single quotes, double quotes, or triple quotes. Strings are immutable in Python, which means that once a string is created, it cannot be modified.\n",
        "\n",
        "The `print` function is a built-in function in Python that is used to output text or variables to the console. You can use the `print` function to print strings, numbers, or variables.\n",
        "\n",
        "⏭ In the examples provided, the first variable that is defined is named `genename1`, which stores the string value `\"DMD\"`. This means that `genename1` acts as a label for the text `\"DMD\"`, and you can use this label to refer to the text in your code. This is a common practice in programming and is a fundamental concept in Python.\n",
        "\n",
        "❎\"Code preceded by `#` is ignored.\"\n",
        " any text, even valid code, following the `#` symbol on a line is considered a comment and is ignored by the Python interpreter. This is useful for adding notes or explanations within your code.\n",
        "\n",
        " Lets start coding! 🐍"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "0d7004d8",
      "metadata": {
        "id": "0d7004d8"
      },
      "outputs": [],
      "source": [
        "genename1 = \"DMD\"\n",
        "gene1description = \"gene that codes for the protein dystrophin, which is involved in muscle function. The DMD gene is located on the X chromosome, and it is the largest known gene in the human genome, spanning about 2.3 million base pairs.\"\n",
        "print(genename1, \":\", gene1description)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "59b5fcef",
      "metadata": {
        "id": "59b5fcef"
      },
      "source": [
        "❓ Create new variables for the gene \"BRCA1\" and use print to write a description of the gene. Similar to what was done above for \"DMD\" ⚠"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8599fe27",
      "metadata": {
        "id": "8599fe27"
      },
      "outputs": [],
      "source": [
        "# please fix the error(s)\n",
        "genename1\n",
        "gene1description = \"gene that codes for a protein that acts as a tumor suppressor. The BRCA1 gene is located on chromosome 17 and spans about 81,000 base pairs. It plays a critical role in maintaining the stability of a cell's genetic information by repairing damaged DNA.\"\n",
        "print(, \":\",)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6097d59b",
      "metadata": {
        "id": "6097d59b"
      },
      "source": [
        "- You can also interpolate you variables inside a text, for a more complex output and print out the result. For this you precede the text with f' and then add the variables to be printed inside {} (don't forget to close the text by adding ' at the end):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5dd28226",
      "metadata": {
        "id": "5dd28226"
      },
      "outputs": [],
      "source": [
        "print(f'Our lab studies {genename1}, which is a {gene1description}')"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b602714c",
      "metadata": {
        "id": "b602714c"
      },
      "source": [
        "❓ Now try here adding your text for the BRCA1 gene variables you created above: ⚠"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7be7d8ce",
      "metadata": {
        "id": "7be7d8ce"
      },
      "outputs": [],
      "source": [
        "# please fix the error(s)\n",
        "print(fOur lab studies {genename1}, which is a {gene1description})"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🎁 Bonus"
      ],
      "metadata": {
        "id": "XmbpB_sBfLDC"
      },
      "id": "XmbpB_sBfLDC"
    },
    {
      "cell_type": "markdown",
      "id": "5f8bdf63",
      "metadata": {
        "id": "5f8bdf63"
      },
      "source": [
        "The text you create can also be stored in a variable:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "5b3cb3dc",
      "metadata": {
        "id": "5b3cb3dc"
      },
      "outputs": [],
      "source": [
        "general_lab_desc= f'Our lab studies {genename1}, which is a {gene1description}'\n",
        "print (general_lab_desc)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "a7b6f864",
      "metadata": {
        "id": "a7b6f864"
      },
      "source": [
        "# 2. Basic arithmetic operations\n",
        "\n",
        "📝 In Python, basic arithmetic operations include addition `+`, subtraction `-`, multiplication `*`, division `/`, floor division `//`, and modulus `%`.\n",
        "- These operations can be performed on **numbers** (integers and floats) and can be used to perform mathematical calculations in your code.\n",
        "- Python supports the use of parentheses to control the order of operations and the use of shorthand operators such as `+=`, `-=`, `*=`, and `/=` to perform arithmetic operations and assign the result back to a variable in a single step.  \n",
        "\n",
        "📌 These basic arithmetic operations are fundamental building blocks in any mathematical computation and are widely used in various programming fields, this is why a good understanding of these operations is crucial for any Python developer or advanced user.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7fbd77d4",
      "metadata": {
        "id": "7fbd77d4",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "DMD = 2.3  # Million base-pairs\n",
        "BRCA1 = 0.08 # Million base-pairs\n",
        "GENOME = 3000 # Million base-pairs\n",
        "\n",
        "# DMD represents what % of the human genome?\n",
        "print(\"The DMD gene represents\", DMD / GENOME * 100, \"% of the human genome\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7227c5b8",
      "metadata": {
        "id": "7227c5b8"
      },
      "source": [
        "❓What fraction of the human genome does BRCA1 represent? ⚠"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9eb72331",
      "metadata": {
        "id": "9eb72331"
      },
      "outputs": [],
      "source": [
        "# please fix the error(s)\n",
        "print(\"The BRCA1 gene represents\",  / GENOME * 100, \"% of the human genome\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "96ed3a34",
      "metadata": {
        "id": "96ed3a34"
      },
      "source": [
        "# 3. Conditional statements\n",
        "\n",
        "📝 Conditional statements are used to control the flow of a program based on certain conditions.\n",
        "- They allow you to check if a certain condition is true or false, and execute different code depending on the result.\n",
        "- The most common conditional statements are the `if`-`elif`-`else` statements.\n",
        "\n",
        "📌 Conditional statements are a fundamental concept in programming, they provide a way to control the flow of the program, and they are widely used in various programming fields.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "1e8bd61b",
      "metadata": {
        "id": "1e8bd61b",
        "scrolled": true
      },
      "outputs": [],
      "source": [
        "if DMD > BRCA1:\n",
        "    print(f\"DMD gene ({DMD} mb) is larger than BRCA1 ({BRCA1} mb)\")\n",
        "elif DMD == BRCA1:\n",
        "    print(f\"DMD gene ({DMD} mb) is equal in size to BRCA1 ({BRCA1} mb)\")\n",
        "else:\n",
        "    print(f\"DMD gene ({DMD} mb) is smaller than BRCA1 ({BRCA1} mb)\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "898b34da",
      "metadata": {
        "id": "898b34da"
      },
      "source": [
        "# 4. Functions:\n",
        "\n",
        "📝Functions are blocks of reusable code that can be called by name.\n",
        "- They are used to organize and structure your code, make it more readable, and promote code reusability.\n",
        "- In Python, A function is defined using the `def` keyword, followed by the function name, and a set of parentheses that may contain parameters.\n",
        "- The code block inside the function is indented, this block of code will be executed every time the function is called. Functions can also return a value using the `return` statement.\n",
        "- They can be used to encapsulate complex logic, and make it easier to test and debug your code.  \n",
        "\n",
        "📌Functions are a fundamental concept in Python, and they are widely used in various programming fields."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "ce245b61",
      "metadata": {
        "id": "ce245b61"
      },
      "outputs": [],
      "source": [
        "def calculate_genome_percentage(gene_size):\n",
        "    percentage = gene_size / GENOME * 100\n",
        "    return percentage\n",
        "\n",
        "# Example usage for DMD and BRCA1 genes\n",
        "\n",
        "print(f\"The DMD gene represents {calculate_genome_percentage(DMD)}% of the human genome\")\n",
        "print(f\"The BRCA gene represents {calculate_genome_percentage(BRCA1)}% of the human genome\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1904c6a9",
      "metadata": {
        "id": "1904c6a9"
      },
      "source": [
        "❓ What is the percentage of the genome is represented by an hypothetical gene with 90 million base pairs? ⚠"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "248ad9bf",
      "metadata": {
        "id": "248ad9bf"
      },
      "outputs": [],
      "source": [
        "#please complete the code and fix the error\n",
        "hip_gene = 90\n",
        "\n",
        "print(f\"The hypothetical gene has {calculate_genome_percentage()}% of the human genome\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🎁 Bonus"
      ],
      "metadata": {
        "id": "ESKr7vyke_iW"
      },
      "id": "ESKr7vyke_iW"
    },
    {
      "cell_type": "markdown",
      "id": "83ea2539",
      "metadata": {
        "id": "83ea2539"
      },
      "source": [
        "Numbers can be rounded to a chosen number of decimal places by using the round function and indicating the variable and number of decimals inside the brackets:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bba2f5bc",
      "metadata": {
        "id": "bba2f5bc"
      },
      "outputs": [],
      "source": [
        "def calculate_genome_percentage(gene_size):\n",
        "    percentage = gene_size / GENOME * 100\n",
        "    return round(percentage, 3)\n",
        "\n",
        "# Example usage for DMD and BRCA1 genes\n",
        "\n",
        "print(f\"The DMD gene represents {calculate_genome_percentage(DMD)}% of the human genome\")\n",
        "print(f\"The BRCA1 gene represents {calculate_genome_percentage(BRCA1)}% of the human genome\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "41db5514",
      "metadata": {
        "id": "41db5514"
      },
      "source": [
        "# 5. Lists and list manipulation:\n",
        "\n",
        "📝In Python, lists are a built-in data structure that allow you to store and organize collections of items.\n",
        "- Lists are defined using square brackets and items within the list are separated by commas. Lists can store any type of data, such as numbers, strings, and even other lists.\n",
        "- List manipulation is the act of modifying or manipulating lists in various ways. This can include adding, removing, or updating items in a list, as well as sorting, reversing or slicing a list.\n",
        "- Python provides a variety of built-in methods and functions that can be used to manipulate lists. For example, the `append()` method can be used to add an item to the end of a list, the `remove()` method can be used to remove an item from a list, the `sort()` method can be used to sort the items in a list in ascending or descending order. To slice a list and create a new one with a specific part of the original list you can use the `:` operator.\n",
        "\n",
        "📌List manipulation is an important concept in Python, as lists are widely used in various programming fields. Understanding how to manipulate lists is crucial for any Python user as it allows you to organize and manage data in an efficient and flexible way. With the knowledge of list manipulation, you will be able to work with large sets of data and perform complex operations on them in a powerful and efficient way.\n",
        "\n",
        "✋Remember that Python 🐍 uses zero-based indexing, so the first element is at index 0.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "7aed7095",
      "metadata": {
        "id": "7aed7095"
      },
      "outputs": [],
      "source": [
        "# create list\n",
        "genes = [\"DMD\", \"BRCA\", \"Hypothetical\"]\n",
        "\n",
        "# access elements\n",
        "print(genes[0])\n",
        "\n",
        "# modify elements\n",
        "genes [2] = \"IRF1\"\n",
        "print(genes)\n",
        "\n",
        "# add elements\n",
        "genes.append(\"Hypothetical\")\n",
        "print(genes)\n",
        "\n",
        "# remove elements\n",
        "genes.remove(\"Hypothetical\")\n",
        "print(genes)\n",
        "\n",
        "# sort elements\n",
        "genes.sort()\n",
        "print(genes)\n",
        "\n",
        "# slice genes to include elements 0 and 1\n",
        "genes_slice = genes[0:2]\n",
        "print(genes_slice)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🎁 Bonus"
      ],
      "metadata": {
        "id": "Av0eLpwgePQv"
      },
      "id": "Av0eLpwgePQv"
    },
    {
      "cell_type": "markdown",
      "source": [
        "What is the difference between a list, a tuple and an array?\n",
        "\n",
        "- **Lists** are mutable, which means you can change their content (add, remove or modify items) after they are created. Lists are defined by enclosing the elements in square brackets `[]`. For example: `my_list = [1, 2, 3]`.\n",
        "\n",
        "- **Tuples** are immutable, which means once they are created, you cannot change their content. This can be useful in situations where you want to ensure that certain values do not change. Tuples are defined by enclosing the elements in parentheses `()`. For example: `my_tuple = (1, 2, 3)`. You might choose to use a tuple when you have a collection of items that should not be changed.\n",
        "\n",
        "- **Arrays**: An array is also a collection of elements like a list but it can only store items of the same data type. Arrays are used when you need to perform mathematical operations on collections of numerical data, using less memory and having more functionality. In Python's standard library there's an array module that provides basic array functionality. However, for scientific computing tasks (like data analysis or machine learning), people often use arrays from the NumPy library instead. NumPy arrays have more features than basic Python arrays and are more efficient for numerical operations."
      ],
      "metadata": {
        "id": "7PC6C_OQdyo3"
      },
      "id": "7PC6C_OQdyo3"
    },
    {
      "cell_type": "code",
      "source": [
        "# To perform element-wise operation you can use NumPy arrays\n",
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3])\n",
        "b = np.array([4, 5, 6])\n",
        "\n",
        "c = a + b  # This will give array([5, 7, 9])\n",
        "\n",
        "# Standard python lists do not support element-wise operations directly.\n",
        "list1 = [1, 2, 3]\n",
        "list2 = [4, 5, 6]\n",
        "\n",
        "concatlists = list1 + list2 # This will give [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "print(c)\n",
        "print(concatlists)"
      ],
      "metadata": {
        "id": "8XCemcAjg49A"
      },
      "id": "8XCemcAjg49A",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "f339ec02",
      "metadata": {
        "id": "f339ec02"
      },
      "source": [
        "# 6. Dictionaries:\n",
        "\n",
        "📝In Python, dictionaries are a built-in data structure that allow you to store and organize collections of items in a key-value format.\n",
        "- Dictionaries are defined using curly braces {} and items within the dictionary are separated by commas.\n",
        "- Each item in a dictionary is made up of a key-value pair, where the key is a unique identifier for the value. Dictionaries can store any type of data, such as numbers, strings, and even other dictionaries.\n",
        "\n",
        "📌Dictionaries are very useful as they provide a way to store and retrieve data in a very efficient way. They are widely used in various programming fields. Python provides a variety of built-in methods and functions that can be used to manipulate dictionaries. With the knowledge of dictionaries, you will be able to work with large sets of data and perform complex operations on them, making your code more powerful and efficient.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "af4dae2c",
      "metadata": {
        "id": "af4dae2c"
      },
      "outputs": [],
      "source": [
        "# create dictionary\n",
        "genesizes = {\n",
        "  \"DMD\": 2.3,\n",
        "  \"BRCA\": 0.1,\n",
        "  \"IRF1\": 0.03\n",
        "}\n",
        "print(genesizes)\n",
        "\n",
        "# access elements\n",
        "print(genesizes[\"IRF1\"])\n",
        "print(genesizes.keys())\n",
        "print(genesizes.values())\n",
        "print(genesizes.get(\"IRF1\"))\n",
        "\n",
        "# modify elements\n",
        "genesizes[\"IRF1\"] = 0.0333\n",
        "print(genesizes)\n",
        "\n",
        "# add elements\n",
        "genesizes[\"Hypothetical\"] = 99\n",
        "print(genesizes)\n",
        "\n",
        "# remove elements\n",
        "del genesizes[\"Hypothetical\"]\n",
        "print(genesizes)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🎁 Bonus"
      ],
      "metadata": {
        "id": "fy9UUHUHbNYD"
      },
      "id": "fy9UUHUHbNYD"
    },
    {
      "cell_type": "markdown",
      "source": [
        "In previous code, the lines `print(genesizes[\"IRF1\"])` and `print(genesizes.get(\"IRF1\"))` are giving the same result. Here's why:\n",
        "\n",
        "- `genesizes[\"IRF1\"]` uses the bracket notation to access the value of the key `\"IRF1\"` in the `genesizes` dictionary. If the key is in the dictionary, it will return its value.\n",
        "\n",
        "- `genesizes.get(\"IRF1\")` uses the `get` method to achieve the same thing. The `get` method is a built-in Python method for dictionaries that returns the value for a given key if it exists in the dictionary.\n",
        "\n",
        "So, both lines are accessing the value of `\"IRF1\"` in the `genesizes` dictionary, which is why they return the same result.\n",
        "\n",
        "However, there's a subtle difference between these two methods:\n",
        "- If you try to access a key that does not exist in the dictionary, `genesizes[\"nonexistent_key\"]` will raise a `KeyError`.\n",
        "- On the other hand, `genesizes.get(\"nonexistent_key\")` will return `None` and will not raise an error.\n",
        "\n",
        "So while they function the same with existing keys, their behavior differs when dealing with keys that don't exist in the dictionary."
      ],
      "metadata": {
        "id": "k8DqHHZibiuN"
      },
      "id": "k8DqHHZibiuN"
    },
    {
      "cell_type": "code",
      "source": [
        "print(genesizes[\"IRF2\"])"
      ],
      "metadata": {
        "id": "Fztj9KVCZ4iR"
      },
      "id": "Fztj9KVCZ4iR",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(genesizes.get(\"IRF2\"))"
      ],
      "metadata": {
        "id": "-yjBCvHZaCP1"
      },
      "id": "-yjBCvHZaCP1",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "🤯 So what?\n",
        "\n",
        "A `KeyError` that is raised when you try to access a key that does not exist can disrupt the flow of your program and cause it to stop.\n",
        "\n",
        "On the other hand, when you use the `get` method on a dictionary and the key does not exist, it returns `None`. This does not cause your program to stop or raise an error. Instead, it allows your program to continue running, which can be beneficial in many cases.\n",
        "\n",
        "However, if your program logic expects a certain value (other than `None`) and it gets `None`, it might lead to unexpected behavior or bugs in other parts of your program."
      ],
      "metadata": {
        "id": "sVvDuFircaok"
      },
      "id": "sVvDuFircaok"
    },
    {
      "cell_type": "markdown",
      "id": "214c5abc",
      "metadata": {
        "id": "214c5abc"
      },
      "source": [
        "# 7. Loops:\n",
        "\n",
        "📝 Loops are used to execute a block of code repeatedly. The most common type of loop is the **\"for\"** loop:\n",
        "- A **\"for\"** loop is used to iterate over a sequence of items, such as a list or a range of numbers. The general syntax is \"for variable in sequence:\", where the variable takes on each value in the sequence, one at a time, and the code block following the \"for\" statement is executed for each value."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3ced495a",
      "metadata": {
        "id": "3ced495a"
      },
      "outputs": [],
      "source": [
        "for gene, gene_size in genesizes.items():\n",
        "    print(f\"The {gene} gene represents {calculate_genome_percentage(gene_size)}% of the human genome.\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4f91eacc",
      "metadata": {
        "id": "4f91eacc"
      },
      "source": [
        "# 8. Importing modules:\n",
        "\n",
        "📝 A module is a collection of code that can be imported and used in other code.\n",
        "- Importing modules allows you to access pre-existing code and functionality, which can save you time and effort when writing your own code.\n",
        "- Python has a large number of built-in modules that can be imported, as well as a vast number of third-party modules that can be installed using package managers such as pip.\n",
        "\n",
        "To import a module, you use `import`  followed by the name of the module. Once a module is imported, you can access the functions and variables defined in the module by prefixing them with the name of the module.\n",
        "\n",
        "There are several popular collections of modules (libraries) in bioinformatics that are widely used in the field. Some of the most popular ones are:\n",
        "- **Pandas**: A powerful data manipulation library in Python. It provides data structures and functions needed to manipulate structured data, including functions for reading and writing data in a variety of formats. It is particularly well-suited for working with numerical tables and time series data.\n",
        "- **Seaborn**: A Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics. Seaborn helps you explore and understand your data. Its plotting functions operate on dataframes and arrays containing whole datasets and internally perform the necessary semantic mapping and statistical aggregation to produce informative plots.\n",
        "- **Scanpy**: A scalable toolkit for analyzing single-cell gene expression data built jointly with anndata. It includes preprocessing, visualization, clustering, trajectory inference, and differential expression testing. The Python-based implementation efficiently deals with datasets of more than one million cells.\n",
        "- **Biopython**: a collection of modules for bioinformatics, including tools for sequence analysis, structure analysis, and biological data parsing.\n",
        "- **scikit-allel**: A Python package for exploratory analysis of large-scale genetic variation data. It is particularly useful for working with structured arrays of data, like Variant Call Format (VCF) files, which are often used in bioinformatics to store gene sequence variations.\n",
        "- **PyBioMed**: A module that provides various bioinformatics tools, such as protein and DNA sequence analysis, molecular docking, and pharmacological prediction.\n",
        "- **PyMOL**: A molecular visualization system that can be used to create high-quality images of molecules and visualize protein structures.\n",
        "- **scikit-learn**: A machine learning module that has been widely used in bioinformatics, it contains a variety of tools for classification, regression, clustering and feature selection.\n",
        "\n",
        "📌These are just a few examples of the many libraries available for bioinformatics, and new ones are constantly being developed. These provide powerful tools and functionality that can be used to analyze and visualize biological data, making it easier for bioinformaticians to work with large and complex datasets.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load the Iris dataset\n",
        "iris = sns.load_dataset('iris')\n",
        "\n",
        "# Create a pair plot\n",
        "sns.pairplot(iris, hue='species')\n",
        "\n",
        "# Display the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "46e-_PbkHoq1"
      },
      "id": "46e-_PbkHoq1",
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "id": "888ea903",
      "metadata": {
        "id": "888ea903"
      },
      "source": [
        "MIT License\n",
        "\n",
        "Copyright (c) 2023 Nuno S. Osório\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "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.9.7"
    },
    "vscode": {
      "interpreter": {
        "hash": "92d1c8824dd9ed58f2e2fe7d35df9188f2132fcf69312c535170a29d4fbf29a8"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}