Python_basics_Lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "fe3a68c0-9851-4fbc-bc57-db913a3783d6",
   "metadata": {},
   "source": [
    "## 1- Python Basics\n",
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "#### Introduction to Python Syntax and Semantics\\*\\*\n",
    "\n",
    "-   Python is known for its readability and simplicity.\n",
    "-   Uses indentation (spaces or tabs) to define code blocks, unlike\n",
    "    curly braces in other languages.\n",
    "-   Dynamic typing: no need to declare variable types explicitly.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6704253f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: Indentation and block structure in Python\n",
    "x = 5\n",
    "if x > 3:\n",
    "    print(\"x is greater than 3\")  # Correct indentation\n",
    "# print(\"This will cause an error\")  # Incorrect indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f8986c6",
   "metadata": {},
   "source": [
    "#### Variables and Data Types\n",
    "\n",
    "-   Python supports multiple data types: `int`, `float`, `str`, `bool`.\n",
    "-   Variables are created when they are first assigned.\n",
    "-   No need to declare the data type explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34e9840c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Examples of different data types in Python\n",
    "name = \"Alice\"    # String\n",
    "age = 25          # Integer\n",
    "height = 5.6      # Float\n",
    "is_student = True # Boolean\n",
    "\n",
    "print(type(name))  # Output: <class 'str'>\n",
    "print(type(age))   # Output: <class 'int'>\n",
    "print(type(height))  # Output: <class 'float'>\n",
    "print(type(is_student))  # Output: <class 'bool'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0cf38f2",
   "metadata": {},
   "source": [
    "#### Basic Operators\n",
    "\n",
    "-   Arithmetic Operators: `+`, `-`, `*`, `/`, `//` (floor division), `%`\n",
    "    (modulus), `**` (exponentiation)\n",
    "-   Comparison Operators: `==`, `!=`, `>`, `<`, `>=`, `<=`\n",
    "-   Logical Operators: `and`, `or`, `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e138777",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arithmetic Operations\n",
    "a = 10\n",
    "b = 3\n",
    "print(a + b)  # Addition: 13\n",
    "print(a - b)  # Subtraction: 7\n",
    "print(a * b)  # Multiplication: 30\n",
    "print(a / b)  # Division: 3.333\n",
    "print(a // b)  # Floor division: 3\n",
    "print(a % b)  # Modulus: 1\n",
    "print(a ** b)  # Exponentiation: 1000\n",
    "\n",
    "# Comparison Operations\n",
    "print(a > b)  # True\n",
    "print(a == b)  # False\n",
    "\n",
    "# Logical Operations\n",
    "x = True\n",
    "y = False\n",
    "print(x and y)  # False\n",
    "print(x or y)   # True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a82cbdd",
   "metadata": {},
   "source": [
    "#### Expressions and Precedence\n",
    "\n",
    "-   Operator precedence defines the order in which operations are\n",
    "    performed.\n",
    "-   Use parentheses to control the order of operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8892572d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Operator precedence\n",
    "result = 10 + 3 * 2  # Multiplication is evaluated first: result = 16\n",
    "print(result)\n",
    "\n",
    "# Using parentheses to change precedence\n",
    "result = (10 + 3) * 2  # Parentheses first: result = 26\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3667fb11",
   "metadata": {},
   "source": [
    "#### Example: Writing Simple Python Scripts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd8311a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables and data types\n",
    "name = \"John\"\n",
    "age = 30\n",
    "height = 6.1\n",
    "\n",
    "print(f\"My name is {name}, I am {age} years old, and I am {height} feet tall.\")\n",
    "\n",
    "# Calculating area of a rectangle\n",
    "length = 5\n",
    "width = 3\n",
    "area = length * width\n",
    "print(f\"The area of the rectangle is: {area}\")\n",
    "\n",
    "# Comparing two numbers\n",
    "num1 = 8\n",
    "num2 = 10\n",
    "if num1 > num2:\n",
    "    print(f\"{num1} is greater than {num2}\")\n",
    "elif num1 == num2:\n",
    "    print(f\"{num1} is equal to {num2}\")\n",
    "else:\n",
    "    print(f\"{num1} is smaller than {num2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39388e4d",
   "metadata": {},
   "source": [
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "## 2- Functions and Modular Code\n",
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "#### **Introduction to Functions**\n",
    "\n",
    "-   Functions allow for code reusability and modularity.\n",
    "-   Functions are defined using the `def` keyword.\n",
    "-   Functions can take parameters and return values.\n",
    "\n",
    "**Key Points:** - Syntax: `def function_name(parameters):` - Use\n",
    "`return` to get a result from the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "559b2a04",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a simple function\n",
    "def greet(name):\n",
    "    return f\"Hello, {name}!\"\n",
    "\n",
    "# Calling the function\n",
    "print(greet(\"Alice\"))  # Output: Hello, Alice!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "905cb374",
   "metadata": {},
   "source": [
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "#### **Parameters and Arguments**\n",
    "\n",
    "-   Functions can take multiple parameters.\n",
    "-   Parameters are placeholders that accept values when the function is\n",
    "    called.\n",
    "-   Default values can be set for parameters.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f1a6ba9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function with multiple parameters\n",
    "def calculate_area(length, width=5):\n",
    "    return length * width\n",
    "\n",
    "# Calling the function with and without default parameter\n",
    "print(calculate_area(10, 3))  # Output: 30\n",
    "print(calculate_area(10))     # Output: 50"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "681a1878",
   "metadata": {},
   "source": [
    "\n",
    "#### **Variable Scope in Functions**\n",
    "\n",
    "-   Variables defined inside a function are local to that function.\n",
    "-   Variables outside the function are global variables and can be\n",
    "    accessed inside unless overwritten.\n",
    "-   `global` keyword to modify global variables inside functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa8488d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of variable scope\n",
    "x = 10  # Global variable\n",
    "\n",
    "def update_value():\n",
    "    global x\n",
    "    x = 20  # Modifies the global variable\n",
    "    print(f\"Inside function: x = {x}\")\n",
    "\n",
    "update_value()  # Output: Inside function: x = 20\n",
    "print(f\"Outside function: x = {x}\")  # Output: Outside function: x = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1f78f85",
   "metadata": {},
   "source": [
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "#### **Lambda Functions**\n",
    "\n",
    "-   Lambda functions are anonymous, single-line functions.\n",
    "-   Often used for small tasks, passed as arguments to functions.\n",
    "-   Best used for short, simple operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "966d431f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lambda function for addition\n",
    "add = lambda x, y: x + y\n",
    "print(add(2, 3))  # Output: 5\n",
    "\n",
    "# Using lambda in a list operation\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "squared_numbers = list(map(lambda x: x ** 2, numbers))\n",
    "print(squared_numbers)  # Output: [1, 4, 9, 16, 25]\n",
    "\n",
    "# Lab Exercise 2: Lambda function and list comprehension\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "squares = [lambda x: x ** 2 for x in numbers]\n",
    "print([square(2) for square in squares])  # Output: [4, 4, 4, 4, 4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0eda493",
   "metadata": {},
   "source": [
    "\n",
    "------------------------------------------------------------------------\n",
    "\n",
    "#### **Modular Programming in Python**\n",
    "\n",
    "-   **Content:**\n",
    "    -   Modular programming involves dividing a program into separate\n",
    "        modules.\n",
    "\n",
    "    -   Each module can be imported into other scripts using the\n",
    "        `import` statement.\n",
    "\n",
    "    -   Modules help organize code and improve maintainability.\n",
    "\n",
    "    -   Python files (ending in `.py`) are treated as modules.\n",
    "\n",
    "    -   Use `import module_name` to import functionality from other\n",
    "        files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "664a620c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import mymodule\n",
    "\n",
    "result = mymodule.multiply(4, 5)\n",
    "print(result)  # Output: 20\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cac454ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "numbers = [1, 2, 3, 4, 5, 6]\n",
    "print(mymodule.sum_even_numbers(numbers))  # Output: 12\n",
    "print(mymodule.add(10, 5))  # Output: 15\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "729d05e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a string text  and save it in sample.txt:\n",
    "\n",
    "import mymodule\n",
    "\n",
    "mymodule.write_file(\"sample.txt\", \"This is a sample text.\") \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2cb47beb",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mymodule.read_file(\"sample.txt\"))  # Output: Contents of sample.txt"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}