Welcome to the Python tutorial !

In Python, variables are used to store data values. A variable is created when a value is assigned to it using the "=" operator. For example:

x = 5
y = "Hello, world!"

In this example, we've created two variables: "x" and "y". "x" is assigned the value of 5, which is an integer, and "y" is assigned the value of "Hello, world!", which is a string.

Python has several built-in data types, including integers, floating-point numbers, strings, booleans, and more. These data types can be combined using operators to perform operations on them. Some common operators include:

• Arithmetic operators: (+, -, *, /, %, **)
• Comparison operators: (==, !=, <, >, <=, >=)
• Logical operators: (and, or, not)
• Assignment operators: (=, +=, -=, *=, /=, %=, **)

Fere are some examples of using operators with variables:

x = 10

y = 5

print(not x) # Output: False
print(x > 3 and y < 6) # Output: true
print( x > 3 or y < 3) # Output: true

print(x + y) # Output: 15
print(x - y) # Output: 5
print(x * y) # Output: 50
print(x / y) # Output: 2.0
print(x % y) # Output: 0
print(x ** y) # Output: 100000

print(x == y) # Output: False
print(x != y) # Output: True
print(x > y) # Output: True
print(x < y ) # Output: False
print(x >= y) # Output: True
print(x <= y) # Output: False

x += 5
print(x) # Output: 15
x -= 5
print(x) # Output: 10
x *= 2
print(x) # Output: 20
x /= 2
print(x) # Output: 10.0
x %= 3
print(x) # Output: 1.0
x **= 2
print(x) # Output: 1.0

Conditional statements and loops are fundamental concepts in programming that allow you to control the flow of your code. They enable you to make decisions based on certain conditions and perform repetitive tasks efficiently.

Conditional Statements

Conditional statements are used to execute different blocks of code depending on whether a certain condition is true or false. In Python, we use the if, for, and while statements to create conditional statements.

1. the if statement

if condition1:   
 # execute code if condition1 is true  
elif condition2:  
 # execute code if condition2 is true  
else: 
 # execute code if none of the above conditions are true 

Here's an example that uses conditional statements to determine whether a number is positive, negative, or zero:

num = -5
if num > 0:  
 # print "Positive number" if num is greater than 0  
elif num ==  0: 
 # print "Zero" 
else: 
 # print "Negative number" 

2. the for statement

Here's an example that uses a for loop to iterate over a list and print each item:

fruits = ["apple", "banana", "cherry"]

# iterate through the fruits list
for fruit in fruits:
  print(fruit)

# list comprehension for printing fruits
[print(fruit) for fruit in fruits]

It is also possibe mix them as needed

fruits = ["apple", "banana", "cherry"]

# Iterate through the fruits list and print only if fruit is "cherry"

[print(fruit) for fruit in fruits if fruit == "cherry"]

# or
for fruit in fruits:
  if fruit == "cherry"
   print(fruits)

1. the while statement

Here's an example that uses a while loop to print the numbers from 1 to 5:

num = 1
while num < 5:
 print(num) num += 1

List Comprehensions

List comprehensions provide a concise way to create lists based on existing lists. They are a more Pythonic way of iterating over a list and transforming its elements.

# list comprehension example
original_list = [1, 2, 3, 4, 5]
new_list = [item * 2 for item in original_list]
print(newList) # [2, 4, 6, 8, 10]

In this example, we create a new list newList based on an existing list originalList. The new list is created using a list comprehension, which consists of the expression item * 2followed by a for statement that specifies how to iterate over the elements of the original list.

List comprehensions can also include conditional statements to filter the elements of the original list. Here's an example that creates a new list containing only the even numbers from the original list:

original_list = [1, 2, 3, 4, 5]
new_list = [item * 2 for item in original_list if item % 2 == 0]
print(newList) # [2, 4]

In this example, we add a conditional statement to the list comprehension using the if keyword. The conditional statement checks whether each element of the original list is even (item % 2 === 0), and only the even elements are included in the new list.

Dictionary Comprehensions

In addition to list comprehensions, Python also supports dictionary comprehensions, which provide a concise way to create dictionaries based on existing dictionaries.

original_dict = {"apple": 1, "banana": 2, "cherry": 3}
# Iterate through the original dictionary and multiply each value by 2

new_dict = {key: value * 2 for key, value in original_dict.items()}

# Print the new dictionary
print(new_dict) # {"apple": 2, "banana": 4, "cherry": 6}

In this example, we create a new dictionary newDict based on an existing dictionary originalDict. The new dictionary is created using a dictionary comprehension, which consists of the expression value * 2 followed by a for statement that specifies how to iterate over the key-value pairs of the original dictionary.

Dictionary comprehensions can also include conditional statements to filter the key-value pairs of the original dictionary. Here's an example:

original_dict =  {"apple": 1, "banana": 2, "cherry": 3}

# Iterate through the original dictionary and multiply each value by 2 if value is greater than 1

{key: value * 2 for key, value in original_dict.items() if value > 1}

# Print the new dictionary
print(new_dict) # {"banana": 4, "cherry": 6}

As you can see, dictionary comprehensions are similar to list comprehensions, but they produce dictionaries instead of lists. They can be a very powerful tool for manipulating dictionaries in a concise and readable way.

Functions and modules are essential building blocks of any Python program. They allow you to break down your code into smaller, reusable pieces that can be organized and maintained more easily. Here are some examples of functions and modules in Python:

Functions

A function is a block of code that performs a specific task. Functions help to make your code more modular and reusable, and can also take in inputs and return outputs.

To define a function in Python, use the def keyword followed by the function name and its arguments in parentheses. The code inside the function should be indented, and the function can optionally return a value using the return keyword.

Here's a basic example:

def add_numbers(x, y):
  return x + y

result = add_numbers(5, 10)
print(result) # Output: 15

In this example, we call the add_numbers function with the arguments 5 and 10, and store the result in a variable called result. Finally, we print the result using the print function, which outputs 15.

Here's an example of a function that takes in a list of numbers and returns the sum:

def sum_numbers(numbers):
  result = 0
  for num in numbers:
     result += num
  return result

my_numbers = [1, 2, 3, 4, 5]
total = sum_numbers(my_numbers)
print(total) # Output: 15

In this example, we define a function called sum_numbers that takes in a list of numbers called numbers, and returns their sum. We initialize a variable called result to 0, and then use a for loop to iterate through the list of numbers and add each one to the result. Finally, we return the result.

To call a function, simply use its name followed by its arguments in parentheses. In the example above, we call the sum_numbers function with the list of numbers [1, 2, 3, 4, 5] and store the result in a variable called total. We then print the result, which is 15.

Functions can also have optional arguments with default values. Here's an example:

def greet(name, greeting="Hello"): 
  print(greeting + ", " + name + "!") 

greet("Alice") # Output: "Hello, Alice!" 
greet("Bob", "Hi") # Output: "Hi, Bob!"

In this example, we define a function called greet that takes in two arguments, name and greeting, with a default value of "Hello". We then print out the greeting followed by the name.

When we call the function with just one argument (greet("Alice")), it uses the default value for greeting and prints "Hello, Alice!". When we call the function with both arguments (greet("Bob", "Hi")), it uses the provided value for greeting and prints "Hi, Bob!".

Modules

A module is a file that contains Python code, which can be imported and used in other Python files. Modules help to organize your code and keep related functionality together. Here's an example of a module calledmath_utils.py that defines some mathematical functions:

# math_utils.py 
def add_numbers(a, b): 
  return a + b 
def multiply_numbers(a, b): 
  return a * b 
def subtract_numbers(a, b): 
  return a - b

In this example, we define three functions for adding, multiplying, and subtracting numbers. We can then import this module into another Python file and use these functions. Here's an example of how we can use this module in a file called main.py:

# main.py 
import math_utils 
result1 = math_utils.add_numbers(5, 10) 
result2 = math_utils.multiply_numbers(5, 10) 
result3 = math_utils.subtract_numbers(5, 10) 
print(result1) # Output: 15 
print(result2) # Output: 50 
print(result3) # Output: -5

Object-Oriented Programming (OOP) is a programming paradigm that emphasizes the use of objects, which are instances of classes, to represent and manipulate data. Here are some of the key concepts in OOP:

• Classes: A class is a blueprint for creating objects that defines their properties and methods.
• Objects: An object is an instance of a class that contains data and methods.
• Attributes: Attributes are the data stored inside an object that define its state.
• Methods: Methods are functions that belong to a class and can modify the object's state or perform actions.
• Inheritance: Inheritance is a mechanism for creating new classes from existing ones by inheriting their attributes and methods.
• Polymorphism: Polymorphism is the ability of objects to take on different forms or have multiple behaviors depending on the context in which they are used.

Creating a Class

To create a class in Python, you use the class keyword followed by the name of the class. Here's an example of a simple class that represents a bank account:

class BankAccount: # Define a class called BankAccount
  def __init__(self, account_number, balance):# Constructor method to initialize account number and balance
   self.account_number = account_number # Set the account number
   self.balance = balance # Set the balance

  def deposit(self, amount): # Method to deposit money into the account
   self.balance += amount # Add the deposited amount to the balance

  def withdraw(self, amount): # Method to withdraw money from the account
   if amount <= self.balance: # Check if there are sufficient funds
     self.balance -= amount # Subtract the withdrawn amount from the balance
   else: # If there are insufficient funds, print a message
     print("Insufficient funds")

  def get_balance(self): # Method to retrieve the current balance
   return self.balance # Return the balance

my_account = BankAccount("123456789", 1000) # Create a new BankAccount object
my_account.deposit(500) # Deposit 500 into the account
my_account.withdraw(2000) # Withdraw 2000 from the account

print(my_account.get_balance()) # Output: 1500

In this example, we define a class called BankAccount that has four methods: __init__, deposit, withdraw, and get_balance. The __init__ method is a special method that is called when an object is created from the class and is used to initialize the object's attributes. The other three methods are used to modify the object's state by depositing or withdrawing money and getting the account balance.

Concepts :

Encapsulation

Encapsulation is the concept of hiding the internal details of an object from the outside world and providing a public interface for interacting with the object. This is achieved in OOP through the use of access modifiers, such as public, private, and protected. These access modifiers control which parts of an object can be accessed from outside the object's class. In Python, access modifiers are implemented using underscores before the attribute or method name.

class Dog: # Define a class called Dog
  def __init__(self, name, age): # Constructor method to initialize name and age
   self.name = name # Set the dog's name
   self.age = age # Set the dog's age

  def bark(self): # Method for the dog to bark
   print("Woof!") # Output: "Woof!"

my_dog = Dog("Rufus", 3) # Create a Dog instance with name "Rufus" and age 3
my_dog.bark() # Output: "Woof!"

Abstraction

Abstraction is the concept of simplifying complex systems by breaking them down into smaller, more manageable parts. In OOP, abstraction is achieved by defining abstract classes and interfaces. An abstract class is a class that cannot be instantiated on its own and must be subclassed to be used. An interface is a collection of abstract methods that define a contract for classes that implement the interface. Python does not have built-in support for interfaces, but they can be emulated using abstract base classes.

class Car: # Define a class called Car
  def start(self): # Method to start the car
    pass # Placeholder implementation
  def stop(self): # Method to stop the car
    pass # Placeholder implementation

class Honda(Car): # Define a class called Honda inheriting from Car
  def start(self): # Method to start a Honda
   print("Starting Honda") # Output: "Starting Honda"
  def stop(self): # Method to stop a Honda
   print("Stopping Honda") # Output: "Stopping Honda"

my_honda = Honda()
my_honda.start() # Output: "Starting Honda"
my_honda.stop() # Output: "Stopping Honda"

Polymorphism in Python

Polymorphism is the ability of objects to take on multiple forms or have multiple behaviors depending on the context in which they are used. In Python, polymorphism is achieved through the use of duck typing, which is a concept that allows objects to be used as if they are of a certain type based on their behavior, rather than their class. For example, if an object has a method called "quack", it can be used as if it were a duck object, even if it is not actually a duck.

class Animal: # Define a class called Animal
  def make_sound(self): # Method to make a sound
    pass # Placeholder implementation

class Cat(Animal): # Define a class called Cat inheriting from Animal
  def make_sound(self): # Method to make a cat sound
   print("Meow") # Output: "Meow"

class Dog(Animal): # Define a class called Dog inheriting from Animal
  def make_sound(self): # Method to make a dog sound
   print("Woof") # Output: "Woof"

def animal_sounds(animal): # Function to produce animal sounds
  animal.make_sound()

my_cat = Cat()
my_dog = Dog()
animal_sounds(my_cat) # Output: "Meow"
animal_sounds(my_dog) # Output: "Woof"

Inheritance in Python

Inheritance is the concept of creating a new class from an existing class by inheriting its attributes and methods. In Python, inheritance is implemented using the syntax class ChildClass(ParentClass):. The child class inherits all the attributes and methods of the parent class and can also define its own attributes and methods. Inheritance is useful for creating classes that share common functionality, such as different types of animals or vehicles.

class Vehicle: # Define a class called Vehicle
  def __init__(self, make, model, year): # Constructor method to initialize vehicle details
    self.make = make
    self.model = model
    self.year = year
  def start(self): # Method to start the vehicle
   print("Starting vehicle")

class Car(Vehicle): # Define a class called Car inheriting from Vehicle
  def stop(self): # Method to stop the car
   print("Stopping car")

my_car = Car("Honda","Civic", 2022)

print(my_car.make) print(my_car.model) # Output: "Civic"
print(my_car.year) # Output: 2022

my_car.start() # Output: "Starting vehicle"
my_car.stop() # Output: "Stopping car"

File input/output (I/O) is an important aspect of programming. It allows you to read from and write to files on your computer. Python provides many ways to work with files. In this section, we'll explore some of the basics of file I/O in Python.

Opening a File

The first step in working with a file is to open it. To do this, we use the built-in open() function. The open() function takes two arguments: the path to the file and the mode in which the file should be opened. The mode can be "r" for reading, "w" for writing, or "a" for appending. For example, to open a file called "example.txt" for reading, we would use the following code:

file = open("example.txt", "r") # you can use a path like '/Users/ProjectsFolder/example.txt'

Once the file is open, we can perform various operations on it such as reading or writing data.

const readFile = () => {
// Open the file in read mode
const file = open("/example.txt", "r");
// Read the contents of the file
const contents = file.read();
// Close the file
file.close();
// Print the contents of the file in the browser console
console.log(contents);
}