Python Tutorial
Learn python Tutorial here!
Welcome to the Introduction to Python tutorial! Python is a high-level, interpreted programming language known for its simplicity and readability. Let's get started!
Python is a high-level programming language that was created by Guido van Rossum and first released in 1991. It emphasizes code readability and simplicity, making it a great language for beginners and experienced developers alike.
There are several reasons to learn Python:
# This is a simple Python program
print("Hello, world!")
Above is a simple Python program that prints "Hello, world!" to the console.
To install Python, follow these steps:
Go to the Python Downloads page and download the installer for your operating system.
Run the downloaded installer and follow the on-screen instructions.
To verify that Python is installed correctly, open a command prompt (or terminal) and type python --version
.
$ python --version
Python 3.10.1
To set up your Python environment, follow these steps:
Virtualenv is a tool to create isolated Python environments. You can install it via pip:
$ pip install virtualenv
Create a new virtual environment for your project:
$ virtualenv myenv
Activate the virtual environment:
$ source myenv/bin/activate (for Linux/Mac)
C:\> myenv\Scripts\activate (for Windows)
In Python, comments start with the hash symbol (#) and continue until the end of the line.
# This is a single-line comment
"""
This is a multi-line comment.
It can span multiple lines.
"""
Variables in Python are dynamically typed, meaning you don't need to declare their type explicitly.
# Variable assignment
x = 10
name = "Alice"
Indentation is significant in Python and is used to define blocks of code.
if x > 5:
print("x is greater than 5")
else:
print("x is not greater than 5")
Python supports various data types such as integers, floats, strings, lists, tuples, dictionaries, etc.
# Example of different data types
num = 10
pi = 3.14
name = "John"
my_list = [1, 2, 3]
my_tuple = (4, 5, 6)
my_dict = {"name": "Alice", "age": 30}
Variables in Python are used to store data values. They do not need to be explicitly declared and their type can change dynamically.
# Variable assignment
x = 10
name = "Alice"
Python supports various numeric data types including integers, floats, and complex numbers.
# Integer
num_int = 10
# Float
num_float = 3.14
# Complex
num_complex = 2 + 3j
Strings are sequences of characters, enclosed within either single quotes (' ') or double quotes (" ").
# Single-line string
name = 'Alice'
# Multi-line string
address = """
123 Main Street
City, State, ZIP
"""
Boolean data type represents truth values, either True or False.
is_true = True
is_false = False
The None data type represents the absence of a value or a null value.
value = None
Python supports various arithmetic operators:
# Addition
x = 10 + 5
# Subtraction
y = 10 - 5
# Multiplication
z = 10 * 5
# Division
a = 10 / 5
# Modulus
b = 10 % 3
# Exponentiation
c = 2 ** 3
Python supports comparison operators to compare values:
# Equal to
x == y
# Not equal to
x != y
# Greater than
x > y
# Less than
x < y
# Greater than or equal to
x >= y
# Less than or equal to
x <= y
Python supports logical operators to combine conditional statements:
# AND
x > 0 and y < 10
# OR
x > 0 or y < 0
# NOT
not x > 0
The if statement is used to execute a block of code only if a condition is true:
x = 10
if x > 5:
print("x is greater than 5")
The if-else statement is used to execute one block of code if the condition is true, and another block of code if the condition is false:
x = 3
if x > 5:
print("x is greater than 5")
else:
print("x is not greater than 5")
The if-elif-else statement is used to execute different blocks of code based on multiple conditions:
x = 3
if x > 5:
print("x is greater than 5")
elif x == 5:
print("x is equal to 5")
else:
print("x is less than 5")
The while loop is used to repeatedly execute a block of code as long as a condition is true:
x = 0
while x < 5:
print(x)
x += 1
The for loop is used to iterate over a sequence (such as a list, tuple, or string) and execute a block of code for each element:
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
A list is a collection of items, ordered and mutable:
# Creating a list
my_list = [1, 2, 3, 4, 5]
# Accessing elements
print(my_list[0]) # Output: 1
# Modifying elements
my_list[0] = 10
print(my_list) # Output: [10, 2, 3, 4, 5]
# Adding elements
my_list.append(6)
print(my_list) # Output: [10, 2, 3, 4, 5, 6]
# Removing elements
my_list.remove(3)
print(my_list) # Output: [10, 2, 4, 5, 6]
A tuple is a collection of items, ordered and immutable:
# Creating a tuple
my_tuple = (1, 2, 3, 4, 5)
# Accessing elements
print(my_tuple[0]) # Output: 1
# Cannot modify elements
# my_tuple[0] = 10 # This will raise an error
A dictionary is a collection of key-value pairs, unordered and mutable:
# Creating a dictionary
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
# Accessing elements
print(my_dict["name"]) # Output: Alice
# Modifying elements
my_dict["age"] = 35
print(my_dict) # Output: {'name': 'Alice', 'age': 35, 'city': 'New York'}
# Adding elements
my_dict["gender"] = "female"
print(my_dict) # Output: {'name': 'Alice', 'age': 35, 'city': 'New York', 'gender': 'female'}
# Removing elements
del my_dict["city"]
print(my_dict) # Output: {'name': 'Alice', 'age': 35, 'gender': 'female'}
A set is a collection of unique elements, unordered and mutable:
# Creating a set
my_set = {1, 2, 3, 4, 5}
# Adding elements
my_set.add(6)
print(my_set) # Output: {1, 2, 3, 4, 5, 6}
# Removing elements
my_set.remove(3)
print(my_set) # Output: {1, 2, 4, 5, 6}
To define a function in Python, you can use the def
keyword followed by the function name and parameters:
def greet():
print("Hello, world!")
# Calling the function
greet()
You can pass parameters to a function by placing them within the parentheses:
def greet(name):
print("Hello, " + name + "!")
# Calling the function with a parameter
greet("Alice")
A function can return a value using the return
statement:
def add(x, y):
return x + y
# Calling the function and storing the result
result = add(3, 5)
print(result) # Output: 8
You can specify default parameter values in a function:
def greet(name="world"):
print("Hello, " + name + "!")
# Calling the function with and without parameter
greet() # Output: Hello, world!
greet("Alice") # Output: Hello, Alice!
A function can accept a variable number of arguments using the asterisk (*) syntax:
def sum(*args):
total = 0
for num in args:
total += num
return total
# Calling the function with different number of arguments
print(sum(1, 2, 3)) # Output: 6
print(sum(1, 2, 3, 4, 5)) # Output: 15
A module is a file containing Python code. It can define functions, classes, and variables. To use a module in your code, you can import it:
# Importing a module
import math
# Using functions from the module
print(math.sqrt(16)) # Output: 4.0
A package is a collection of modules organized in directories. Each package directory contains an __init__.py
file to indicate that it is a package. To import modules from a package, you can use dot notation:
# Importing modules from a package
import mypackage.mymodule
# Using functions from the module
mypackage.mymodule.my_function()
To create your own module, simply save your Python code in a file with a .py
extension. You can then import this module in other Python scripts:
# mymodule.py
def my_function():
print("This is my function")
# main.py
import mymodule
mymodule.my_function()
To create a package, organize your modules into directories and include an __init__.py
file in each directory. This file can be empty or can contain initialization code:
# mypackage/__init__.py
# Empty file or initialization code
# mypackage/mymodule.py
def my_function():
print("This is my function")
# main.py
import mypackage.mymodule
mypackage.mymodule.my_function()
You can use the input()
function to get input from the user, and print()
function to output data to the console:
# Getting input from the user
name = input("Enter your name: ")
# Outputting data to the console
print("Hello, " + name + "!")
You can read from and write to files using Python's built-in file objects:
# Writing to a file
with open("output.txt", "w") as file:
file.write("Hello, world!")
# Reading from a file
with open("input.txt", "r") as file:
data = file.read()
print(data)
You can format output using the format()
method or formatted string literals (f-strings):
name = "Alice"
age = 30
# Using format() method
print("Name: {}, Age: {}".format(name, age))
# Using f-strings (Python 3.6+)
print(f"Name: {name}, Age: {age}")
You can use string formatting methods or regular expressions to parse input:
# Using string formatting methods
data = "Alice 30"
name, age = data.split()
print("Name:", name)
print("Age:", age)
# Using regular expressions
import re
data = "Alice 30"
match = re.match(r"(\w+) (\d+)", data)
if match:
print("Name:", match.group(1))
print("Age:", match.group(2))
You can use a try-except
block to handle exceptions:
try:
# Code that may raise an exception
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
You can handle different types of exceptions using multiple except
blocks:
try:
# Code that may raise an exception
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
except ValueError:
print("Invalid input!")
You can use an else
block to execute code when no exceptions occur:
try:
# Code that may raise an exception
result = 10 / 2
except ZeroDivisionError:
print("Cannot divide by zero!")
else:
print("Division successful. Result:", result)
You can use a finally
block to execute code regardless of whether an exception occurs:
try:
# Code that may raise an exception
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
finally:
print("This code always executes.")
You can open a file using the open()
function:
# Open a file in read mode
file = open("example.txt", "r")
You can read from a file using various methods like read()
, readline()
, or readlines()
:
# Read the entire contents of the file
content = file.read()
print(content)
# Read one line from the file
line = file.readline()
print(line)
# Read all lines into a list
lines = file.readlines()
print(lines)
You can write to a file using the write()
method:
# Open a file in write mode
file = open("example.txt", "w")
# Write to the file
file.write("Hello, world!")
Always close a file after reading or writing:
# Close the file
file.close()
Using the with
statement ensures that the file is properly closed:
# Open and automatically close the file using "with" statement
with open("example.txt", "r") as file:
content = file.read()
print(content)
A class is a blueprint for creating objects. An object is an instance of a class:
# Defining a class
class Dog:
# Constructor method
def __init__(self, name):
self.name = name
# Instance method
def bark(self):
print(f"{self.name} says woof!")
# Creating objects
dog1 = Dog("Buddy")
dog2 = Dog("Max")
# Calling methods
dog1.bark() # Output: Buddy says woof!
dog2.bark() # Output: Max says woof!
Attributes are variables associated with a class and methods are functions associated with a class:
class Car:
def __init__(self, make, model):
self.make = make
self.model = model
def drive(self):
print(f"Driving {self.make} {self.model}")
# Creating objects
car1 = Car("Toyota", "Camry")
# Accessing attributes
print(car1.make) # Output: Toyota
print(car1.model) # Output: Camry
# Calling methods
car1.drive() # Output: Driving Toyota Camry
Inheritance allows a class to inherit attributes and methods from another class:
# Parent class
class Animal:
def speak(self):
pass
# Child class
class Dog(Animal):
def speak(self):
print("Woof!")
# Creating objects
dog = Dog()
# Calling method
dog.speak() # Output: Woof!
Encapsulation is the bundling of data with the methods that operate on that data:
class BankAccount:
def __init__(self):
self.balance = 0
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
def get_balance(self):
return self.balance
# Creating objects
account = BankAccount()
# Accessing methods
account.deposit(100)
account.withdraw(50)
print(account.get_balance()) # Output: 50
Polymorphism allows methods to be used with objects of different classes:
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("Woof!")
class Cat(Animal):
def speak(self):
print("Meow!")
# Polymorphism
def make_sound(animal):
animal.speak()
# Creating objects
dog = Dog()
cat = Cat()
# Calling function
make_sound(dog) # Output: Woof!
make_sound(cat) # Output: Meow!
A class is a blueprint for creating objects. It defines the attributes and methods that objects of the class will have:
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def drive(self):
print(f"Driving {self.year} {self.make} {self.model}")
# Creating an object of the class Car
my_car = Car("Toyota", "Camry", 2022)
An object is an instance of a class. It represents a unique instance of the class with its own set of attributes and methods:
# Accessing attributes of the object
print(my_car.make) # Output: Toyota
print(my_car.model) # Output: Camry
print(my_car.year) # Output: 2022
# Calling methods of the object
my_car.drive() # Output: Driving 2022 Toyota Camry
The __init__()
method is a special method used to initialize objects. It is called automatically when a new object is created:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# Creating an object of the class Person
person = Person("Alice", 30)
Instance methods are functions defined within a class that can access and modify the object's attributes:
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius ** 2
# Creating an object of the class Circle
circle = Circle(5)
# Calling an instance method
print(circle.area()) # Output: 78.5
Class attributes are variables shared by all instances of a class. Class methods are methods that are called on the class itself rather than on instances of the class:
class Employee:
raise_amount = 1.05 # Class attribute
def __init__(self, name, salary):
self.name = name
self.salary = salary
def apply_raise(self):
self.salary *= self.raise_amount
# Creating an object of the class Employee
employee = Employee("Bob", 50000)
# Accessing class attribute
print(Employee.raise_amount) # Output: 1.05
# Calling class method
employee.apply_raise()
print(employee.salary) # Output: 52500.0
A parent class, also known as a base class, is the class being inherited from:
class Animal:
def speak(self):
print("Animal speaks")
# Creating an object of the parent class
animal = Animal()
animal.speak() # Output: Animal speaks
A child class, also known as a derived class, inherits attributes and methods from the parent class:
class Dog(Animal): # Dog class inherits from Animal class
def bark(self):
print("Dog barks")
# Creating an object of the child class
dog = Dog()
dog.bark() # Output: Dog barks
dog.speak() # Output: Animal speaks (inherited from parent class)
You can override methods of the parent class in the child class:
class Cat(Animal): # Cat class inherits from Animal class
def speak(self): # Overriding the speak method
print("Cat meows")
# Creating an object of the child class
cat = Cat()
cat.speak() # Output: Cat meows
You can call methods of the parent class from the child class:
class Bird(Animal): # Bird class inherits from Animal class
def speak(self):
super().speak() # Calling the speak method of the parent class
print("Bird chirps")
# Creating an object of the child class
bird = Bird()
bird.speak()
A class can inherit from multiple parent classes, allowing it to inherit attributes and methods from all parent classes:
class A:
def method_a(self):
print("Method A")
class B:
def method_b(self):
print("Method B")
class C(A, B): # C inherits from both A and B
def method_c(self):
print("Method C")
# Creating an object of the child class
c = C()
c.method_a() # Output: Method A
c.method_b() # Output: Method B
c.method_c() # Output: Method C
Encapsulation is the bundling of data (attributes) and methods that operate on the data within a single unit or class. It restricts access to some of the object's components, preventing the direct modification of its internal state:
class Car:
def __init__(self, make, model, year):
self._make = make # Protected attribute
self._model = model # Protected attribute
self._year = year # Protected attribute
def drive(self):
print(f"Driving {self._year} {self._make} {self._model}")
# Creating an object of the class Car
my_car = Car("Toyota", "Camry", 2022)
# Accessing attributes (should ideally be done using getters and setters)
print(my_car._make) # Output: Toyota
print(my_car._model) # Output: Camry
print(my_car._year) # Output: 2022
# Calling methods
my_car.drive() # Output: Driving 2022 Toyota Camry
Access modifiers in Python can be used to restrict the access to attributes and methods. There are three types of access modifiers:
class BankAccount:
def __init__(self):
self.__balance = 0 # Private attribute
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient balance")
def get_balance(self):
return self.__balance
# Creating an object of the class BankAccount
account = BankAccount()
# Accessing and modifying private attribute (not recommended)
account.__balance = 1000 # This will not modify the actual balance
print(account.get_balance()) # Output: 0
Getter and setter methods can be used to access and modify private attributes:
class BankAccount:
def __init__(self):
self.__balance = 0
def deposit(self, amount):
self.__balance += amount
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
else:
print("Insufficient balance")
def get_balance(self):
return self.__balance
def set_balance(self, amount):
if amount >= 0:
self.__balance = amount
else:
print("Invalid amount")
# Creating an object of the class BankAccount
account = BankAccount()
# Using getter and setter methods
account.set_balance(1000)
print(account.get_balance()) # Output: 1000
Polymorphism allows methods to be used with objects of different classes. It enables the same method name to be used for different types of objects:
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("Woof!")
class Cat(Animal):
def speak(self):
print("Meow!")
# Polymorphism
def make_sound(animal):
animal.speak()
# Creating objects of different classes
dog = Dog()
cat = Cat()
# Calling the function with different objects
make_sound(dog) # Output: Woof!
make_sound(cat) # Output: Meow!
Python does not support method overloading in the traditional sense, where multiple methods with the same name but different parameters are defined within a class. However, you can achieve similar behavior using default parameter values or variable-length argument lists:
class Calculator:
def add(self, a, b):
return a + b
def add(self, a, b, c): # This will override the previous add method
return a + b + c
# Creating an object of the class Calculator
calc = Calculator()
# Calling the overloaded method
print(calc.add(1, 2, 3)) # Output: 6
Operator overloading allows operators to be redefined for objects of a class. This is achieved by defining special methods corresponding to the operators:
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other): # Overloading the addition operator
return Vector(self.x + other.x, self.y + other.y)
# Creating objects of the class Vector
v1 = Vector(2, 3)
v2 = Vector(4, 5)
# Adding two vectors using the overloaded '+' operator
result = v1 + v2
print(result.x, result.y) # Output: 6 8
Regular expressions are sequences of characters that define a search pattern. They are used for string manipulation and searching tasks.
import re
# Example: Matching a phone number pattern
pattern = r'\d{3}-\d{3}-\d{4}'
text = 'Call me at 123-456-7890'
match = re.search(pattern, text)
if match:
print("Phone number found:", match.group())
else:
print("Phone number not found")
Regex patterns can include various characters and symbols to define specific search patterns:
# Example: Matching a date pattern
pattern = r'\d{2}/\d{2}/\d{4}'
text = 'Today is 02/06/2024'
match = re.search(pattern, text)
if match:
print("Date found:", match.group())
else:
print("Date not found")
Character classes allow matching of specific sets of characters:
# Example: Matching a vowel
pattern = r'[aeiou]'
text = 'Hello, World!'
match = re.search(pattern, text, re.IGNORECASE)
if match:
print("Vowel found:", match.group())
else:
print("Vowel not found")
Quantifiers specify how many instances of a character or group should be matched:
# Example: Matching multiple digits
pattern = r'\d+'
text = 'There are 10 apples and 20 oranges'
matches = re.findall(pattern, text)
print("Digits found:", matches)
Anchors and boundaries specify where a match should occur within a string:
# Example: Matching a word boundary
pattern = r'\bhello\b'
text = 'Hello, world!'
match = re.search(pattern, text, re.IGNORECASE)
if match:
print("Word 'hello' found:", match.group())
else:
print("Word 'hello' not found")
Python's datetime
module provides classes for manipulating dates and times:
import datetime
# Current date and time
now = datetime.datetime.now()
print("Current date and time:", now)
# Specific date and time
specific_date = datetime.datetime(2023, 12, 31, 23, 59, 59)
print("Specific date and time:", specific_date)
You can format dates and times using the strftime()
method:
# Formatting the current date and time
formatted_now = now.strftime("%Y-%m-%d %H:%M:%S")
print("Formatted date and time:", formatted_now)
# Parsing a string to a datetime object
date_str = "2023-12-31 23:59:59"
parsed_date = datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("Parsed date:", parsed_date)
You can perform arithmetic operations on dates and times:
# Adding days to a date
future_date = now + datetime.timedelta(days=30)
print("Date after 30 days:", future_date)
# Calculating the difference between dates
difference = specific_date - now
print("Difference in days:", difference.days)
Python's pytz
module allows working with timezones:
import pytz
# Localizing a naive datetime object
local_tz = pytz.timezone("America/New_York")
localized_now = local_tz.localize(now)
print("Localized date and time:", localized_now)
# Converting between timezones
utc_now = localized_now.astimezone(pytz.utc)
print("UTC date and time:", utc_now)
The timedelta
class can represent time intervals:
# Time interval of 1 week
one_week = datetime.timedelta(weeks=1)
print("One week interval:", one_week)
# Checking if a date is within a specific range
start_date = datetime.datetime(2024, 1, 1)
end_date = datetime.datetime(2024, 12, 31)
if start_date <= now <= end_date:
print("Now is within the range")
else:
print("Now is outside the range")
One common method for debugging Python code is using print() statements to output the values of variables or to indicate certain points in the code:
def divide(a, b):
result = a / b
print("Result:", result)
return result
# Example usage
divide(10, 5)
The Python Debugger, pdb
, allows you to step through your code line by line and inspect variables:
import pdb
def divide(a, b):
pdb.set_trace()
result = a / b
return result
# Example usage
divide(10, 0)
The unittest
module provides a framework for writing and running tests:
import unittest
def add(a, b):
return a + b
# Test case
class TestAddFunction(unittest.TestCase):
def test_add(self):
self.assertEqual(add(3, 4), 7)
self.assertEqual(add(-1, 1), 0)
# Running the tests
if __name__ == '__main__':
unittest.main()
The unittest.mock
module allows you to replace parts of your system under test with mock objects for testing:
from unittest.mock import MagicMock
# Mock object
mock_obj = MagicMock()
mock_obj.method.return_value = 42
# Example usage
result = mock_obj.method(10, 20)
print("Result:", result) # Output: 42
pytest
is a popular testing framework that provides additional features and flexibility over unittest
:
import pytest
def multiply(a, b):
return a * b
# Test function
def test_multiply():
assert multiply(3, 4) == 12
assert multiply(-1, 1) == -1
# Run tests with pytest
if __name__ == "__main__":
pytest.main()
Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data:
# Example of a functional programming approach
def square(x):
return x * x
def cube(x):
return x * x * x
# Higher-order function
def apply_function(func, x):
return func(x)
# Using higher-order function
result1 = apply_function(square, 3)
result2 = apply_function(cube, 3)
print("Square:", result1) # Output: 9
print("Cube:", result2) # Output: 27
In functional programming, pure functions are functions that have no side effects and always return the same output for the same input:
# Example of a pure function
def add(a, b):
return a + b
# Example of an impure function
def print_and_add(a, b):
print(f"Adding {a} and {b}")
return a + b
# Pure function usage
result1 = add(3, 4)
print("Result of pure function:", result1) # Output: 7
# Impure function usage
result2 = print_and_add(3, 4)
print("Result of impure function:", result2) # Output: Adding 3 and 4\nResult of impure function: 7
In functional programming, data is often immutable, meaning it cannot be changed once it's created:
# Example of using immutable data
original_list = [1, 2, 3, 4, 5]
new_list = [x * 2 for x in original_list]
print("Original list:", original_list) # Output: [1, 2, 3, 4, 5]
print("New list:", new_list) # Output: [2, 4, 6, 8, 10]
Recursion is a common technique in functional programming, where functions call themselves to solve problems:
# Example of recursion
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
result = factorial(5)
print("Factorial of 5:", result) # Output: 120
Python provides built-in functions and modules that support functional programming:
from functools import reduce
# Example of using map, filter, and reduce
numbers = [1, 2, 3, 4, 5]
# Map
squared_numbers = list(map(lambda x: x ** 2, numbers))
# Filter
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
# Reduce
sum_of_numbers = reduce(lambda x, y: x + y, numbers)
print("Squared numbers:", squared_numbers) # Output: [1, 4, 9, 16, 25]
print("Even numbers:", even_numbers) # Output: [2, 4]
print("Sum of numbers:", sum_of_numbers) # Output: 15
SQLite is a lightweight, serverless database engine that is widely used for small-scale applications:
import sqlite3
# Connect to SQLite database
conn = sqlite3.connect('example.db')
# Create a cursor object
cursor = conn.cursor()
# Create a table
cursor.execute('''CREATE TABLE IF NOT EXISTS employees
(id INTEGER PRIMARY KEY, name TEXT, salary REAL)''')
# Insert data into the table
cursor.execute("INSERT INTO employees (name, salary) VALUES (?, ?)", ('John', 50000.00))
# Commit changes and close connection
conn.commit()
conn.close()
MySQL is a popular relational database management system that is commonly used in web development:
import mysql.connector
# Connect to MySQL database
conn = mysql.connector.connect(
host="localhost",
user="username",
password="password",
database="database_name"
)
# Create a cursor object
cursor = conn.cursor()
# Create a table
cursor.execute('''CREATE TABLE IF NOT EXISTS employees (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255),
salary FLOAT)''')
# Insert data into the table
cursor.execute("INSERT INTO employees (name, salary) VALUES (%s, %s)", ('John', 50000.00))
# Commit changes and close connection
conn.commit()
conn.close()
PostgreSQL is a powerful, open-source relational database management system known for its advanced features:
import psycopg2
# Connect to PostgreSQL database
conn = psycopg2.connect(
host="localhost",
user="username",
password="password",
database="database_name"
)
# Create a cursor object
cursor = conn.cursor()
# Create a table
cursor.execute('''CREATE TABLE IF NOT EXISTS employees (
id SERIAL PRIMARY KEY,
name VARCHAR(255),
salary FLOAT)''')
# Insert data into the table
cursor.execute("INSERT INTO employees (name, salary) VALUES (%s, %s)", ('John', 50000.00))
# Commit changes and close connection
conn.commit()
conn.close()
Web scraping is the process of extracting data from websites. Python offers several libraries for web scraping, such as BeautifulSoup, Scrapy, and Requests:
import requests
from bs4 import BeautifulSoup
# Send a GET request to the webpage
url = 'https://example.com'
response = requests.get(url)
# Parse the HTML content
soup = BeautifulSoup(response.text, 'html.parser')
# Extract data from the webpage
title = soup.title.text
print("Title:", title)
# Find all links on the webpage
links = soup.find_all('a')
for link in links:
print("Link:", link['href'])
Some websites use JavaScript to load content dynamically. In such cases, you may need to use a headless browser or a library like Selenium:
from selenium import webdriver
# Initialize a Chrome WebDriver
driver = webdriver.Chrome()
# Load the webpage
driver.get('https://example.com')
# Extract data after the page has fully loaded
title = driver.title
print("Title:", title)
# Find all links on the webpage
links = driver.find_elements_by_tag_name('a')
for link in links:
print("Link:", link.get_attribute('href'))
# Close the WebDriver
driver.quit()
When scraping multiple pages of a website, you may need to handle pagination:
# Example of scraping multiple pages with pagination
for page_num in range(1, 6):
url = f'https://example.com?page={page_num}'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
# Extract data from the current page
# ...
# Wait for some time before scraping the next page
time.sleep(1)
Some websites require authentication to access certain pages. You can use the requests library to handle authentication:
# Example of scraping a page that requires authentication
url = 'https://example.com/login'
login_data = {'username': 'user', 'password': 'password'}
response = requests.post(url, data=login_data)
# Check if login was successful
if response.status_code == 200:
# Continue scraping authenticated pages
# ...
Robots.txt is a file that tells web crawlers which pages or files the crawler can or can't request from a site. It's essential to respect Robots.txt when scraping websites:
# Example of checking Robots.txt before scraping
url = 'https://example.com/robots.txt'
response = requests.get(url)
if response.status_code == 200:
if '/disallow/' in response.text:
print("Scraping disallowed")
else:
print("Scraping allowed")
Tkinter is Python's standard GUI (Graphical User Interface) toolkit. It provides a fast and easy way to create GUI applications:
import tkinter as tk
# Create a Tkinter window
window = tk.Tk()
window.title("Hello, Tkinter!")
# Create a label widget
label = tk.Label(window, text="Hello, Tkinter!")
label.pack()
# Run the Tkinter event loop
window.mainloop()
Tkinter provides various widgets (GUI components) such as buttons, labels, entry fields, etc. You can use layout managers like grid, pack, and place to arrange these widgets:
# Example of using widgets and layout management
button1 = tk.Button(window, text="Button 1")
button1.pack()
button2 = tk.Button(window, text="Button 2")
button2.pack()
entry = tk.Entry(window)
entry.pack()
# Example of using grid layout manager
button1.grid(row=0, column=0)
button2.grid(row=0, column=1)
entry.grid(row=1, column=0, columnspan=2)
Tkinter allows you to bind events (such as button clicks or key presses) to event handlers:
# Example of event handling
def button_click():
label.config(text="Button clicked!")
button = tk.Button(window, text="Click Me", command=button_click)
button.pack()
Tkinter provides built-in dialogs for common tasks like displaying messages, asking for input, etc.:
# Example of creating a message box dialog
from tkinter import messagebox
def show_message_box():
messagebox.showinfo("Info", "This is an info message box!")
button = tk.Button(window, text="Show Message Box", command=show_message_box)
button.pack()
You can create menus in Tkinter to provide options and commands to the user:
# Example of creating a menu
menu = tk.Menu(window)
def do_something():
label.config(text="Menu item clicked!")
menu.add_command(label="Do Something", command=do_something)
window.config(menu=menu)
An API (Application Programming Interface) allows different software applications to communicate with each other. In Python, you can interact with APIs to access data or services provided by other applications or websites:
import requests
# Example of making a GET request to an API
url = 'https://api.example.com/data'
response = requests.get(url)
# Check if the request was successful
if response.status_code == 200:
data = response.json()
print("Data:", data)
else:
print("Failed to fetch data")
JSON (JavaScript Object Notation) is a lightweight data interchange format. Many APIs return data in JSON format, which can be easily processed in Python:
# Example of parsing JSON data from an API response
if response.status_code == 200:
data = response.json()
for item in data:
print("Item:", item)
else:
print("Failed to fetch data")
Some APIs require authentication before allowing access to their resources. You can pass authentication credentials as part of the request:
# Example of making an authenticated request to an API
url = 'https://api.example.com/data'
headers = {'Authorization': 'Bearer YOUR_API_KEY'}
response = requests.get(url, headers=headers)
# Process response data
# ...
Many APIs impose rate limits to prevent abuse. You should handle rate limits gracefully in your code:
# Example of handling rate limits
if response.status_code == 429:
print("Rate limit exceeded. Waiting for retry...")
time.sleep(60)
response = requests.get(url)
# Process response data
else:
print("Failed to fetch data")
API documentation provides details on how to use an API, including available endpoints, request parameters, and response formats. Always refer to the documentation when working with APIs:
# Example of exploring API documentation
url = 'https://api.example.com/docs'
response = requests.get(url)
if response.status_code == 200:
print("API documentation:", response.text)
else:
print("Failed to fetch documentation")
Writing clean and readable code is essential for maintainability and collaboration:
# Example of improving code readability
def calculate_area(radius):
"""Calculate the area of a circle."""
return 3.14 * radius ** 2
Generators are a powerful feature in Python for creating iterators. They are memory-efficient and allow processing of large datasets:
# Example of using generators
def fibonacci_sequence():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
fibonacci_gen = fibonacci_sequence()
for _ in range(10):
print(next(fibonacci_gen))
Decorators are functions that modify the behavior of other functions. They are widely used for adding functionality to existing functions:
# Example of using decorators
def uppercase_decorator(func):
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
return result.upper()
return wrapper
@uppercase_decorator
def greet(name):
return f"Hello, {name}"
print(greet("John")) # Output: HELLO, JOHN
Context managers allow you to allocate and release resources precisely when you want to. They are commonly used with the 'with' statement:
# Example of using context managers
with open('file.txt', 'r') as f:
content = f.read()
print(content)
Asynchronous programming allows for concurrent execution of tasks, improving performance and responsiveness:
# Example of asynchronous programming with asyncio
import asyncio
async def hello():
print("Hello")
await asyncio.sleep(1)
print("World")
asyncio.run(hello())