This Tutorial introduces the fundamentals of Python programming, encompassing basic to intermediate concepts. To learn and understand about Python operations, package management, object-oriented programming, and more.
Prerequisites:
Basic understanding of computer operations
Familiarity with any programming language is helpful but not mandatory
What is Python?
Python is a general-purpose programming language that is interpreted, high-level, and dynamically typed. It is designed to be easy to read and write. Python is popular because it is versatile, has a large community, and is used for a wide variety of applications.
Python 2 vs. Python 3
Python 2 is the older version of the language, and it is still widely used. However, Python 3 is the newer version, and it is the recommended version to use. Python 3 has a number of improvements over Python 2, including:
It is more secure. Python 3 has a number of security features that are not present in Python 2.
It is more consistent. Python 3 has a more consistent syntax and semantics than Python 2.
It is more future-proof. Python 3 is the future of the language, and it is the version that is being developed by the Python community.
Setting up the Python environment
To set up the Python environment, you will need to:
Download and install the Python interpreter.https://www.python.org/downloads/
Create a new project directory.
Open a terminal window in the project directory.
Type the following command to create a new Python file:
print("Hello, Worl")
Variables and Data Types
Variables are names that refer to values. Python is dynamically-typed, which means you don't declare variable types explicitly.
x = 10 # Integer
y = 3.14 # Floating point
name = "Alice" # String
print(x)
print(y)
print(name)
Basic Operators and Operands
Python supports various types of operators, which are used to perform operations on values and variables. Here are some basic arithmetic operators:
Operators are the constructs which can manipulate the value of operands. Python language supports the following types of operators.
Arithmetic Operators
Comparison (Relational) Operators
Assignment Operators
Logical Operators
Bitwise Operators
Membership Operators
Identity Operators
# Arthematic Operations
a = 10
b = 3
# Addition
print(a + b)
# Subtraction
print(a - b)
# Multiplication
print(a * b)
# Division
print(a / b)
# Arthematic Operations
integer_variable = 10
float_variable = 20.5
string_variable = "Hello, World!"
boolean_variable = True
# Print the variables and their types
print("Integer variable:", integer_variable, type(integer_variable))
print("Float variable:", float_variable, type(float_variable))
print("String variable:", string_variable, type(string_variable))
print("Boolean variable:", boolean_variable, type(boolean_variable))
# Basic Operators and Operands
# Perform basic arithmetic operations
addition = integer_variable + float_variable
subtraction = float_variable - integer_variable
multiplication = integer_variable * 2
division = float_variable / 3
# Print the results of the operations
print("Addition:", addition)
print("Subtraction:", subtraction)
print("Multiplication:", multiplication)
print("Division:", division)
# String Manipulation
# Concatenation
concatenated_string = string_variable + " Let's learn Python!"
print("Concatenated String:", concatenated_string)
# Repetition
repeated_string = string_variable * 2
print("Repeated String:", repeated_string)
# Writing to a file
with open('output.txt', 'w') as file:
file.write("This is a sample text written to the file.")
print("File writing operation completed. Check the 'output.txt' file in your Colab files.")
String Manipulation
String manipulation is one of Python's strengths. Here's some common string manipulation:
Python allows for user input via the input() function:
# This line will not execute as expected in a non-interactive environment such as a markdown document.
name = input("What is your name? ")
print("It's nice to meet you " + name)
Basic I/O Operations
Reading from and writing to files is a common task in Python programming.
# Open a file for writing and create it if it doesn't exist
with open('/content/sample_data/example.txt', 'w') as file:
file.write("Hello, world!")
The with statement automatically takes care of closing the file once it leaves the block, even in cases of error. I/O operations should always be done carefully to handle potential exceptions such as file not found errors.
# Open a file for reading
with open('/content/sample_data/example.txt', 'r') as file:
content = file.read()
print(content)
Python Control Structures
Control structures in Python determine the flow of program execution based on conditions and loops.
Indentation in Python
Indentation is crucial in Python and is used to define the blocks of code. Consistent spacing is key.
if condition:
# Indented four spaces or one tab
execute_code()
Conditional Statements
Conditional statements allow for branching in code execution based on conditions.
If Statement
The if statement is used to execute a block of code if a condition is true.
if condition:
# code to execute if condition is true
Elif Statement
The elif (else if) statement is used to check multiple expressions for True and execute a block of code as soon as one of the conditions evaluates to True.
if condition_a:
# code to execute if condition_a is true
elif condition_b:
# code to execute if condition_b is true
Else Statement
The else statement is used to execute a block of code if none of the preceding conditions are true.
if condition:
# code to execute if condition is true
else:
# code to execute if condition is false
Logical Operators
Logical operators are used to combine conditional statements:
and: True if both operands are true
or: True if either operand is true
not: True if operand is false (complements the operand)
Loops
Loops are used for iterating over a sequence (such as a list, tuple, dictionary, set, or string).
For Loops
The for loop is used to iterate over the elements of a sequence.
for element in sequence:
# code to execute for each element
While Loops
The while loop executes a set of statements as long as a condition is
# Python Control Structures
Control structures in Python determine the flow of program execution based on conditions and loops.
## Indentation in Python
Indentation is crucial in Python and is used to define the blocks of code. Consistent spacing is key.
```plaintext
if condition:
# Indented four spaces or one tab
execute_code()
Conditional Statements
Conditional statements allow for branching in code execution based on conditions.
If Statement
The if statement is used to execute a block of code if a condition is true.
if condition:
# code to execute if condition is true
Elif Statement
The elif (else if) statement is used to check multiple expressions for True and execute a block of code as soon as one of the conditions evaluates to True.
if condition_a:
# code to execute if condition_a is true
elif condition_b:
# code to execute if condition_b is true
Else Statement
The else statement is used to execute a block of code if none of the preceding conditions are true.
if condition:
# code to execute if condition is true
else:
# code to execute if condition is false
Logical Operators
Logical operators are used to combine conditional statements:
and: True if both operands are true
or: True if either operand is true
not: True if operand is false (complements the operand)
Loops
Loops are used for iterating over a sequence (such as a list, tuple, dictionary, set, or string).
For Loops
The for loop is used to iterate over the elements of a sequence.
for element in sequence:
# code to execute for each element
While Loops
The while loop executes a set of statements as long as a condition is true.
while condition:
# code to execute while condition is true
Break and Continue
break and continue are used inside loops to alter their normal behavior.
Break
Python Control Structures
Control Structures
Python control structures manage the flow of your code's execution. There are two main types: conditional statements and loops.
Indentation in Python
Python uses indentation to define blocks of code. All code within the same block must have the same indentation.
if condition:
# This is a block of code
pass
Conditional Statements (if, elif, else)
Conditional statements allow you to execute different blocks of code depending on various conditions.
if condition:
# Code runs if condition is true
elif another_condition:
# Code runs if another_condition is true
else:
# Code runs if above conditions are false
Logical Operators
Logical operators are used to combine conditional statements.
and: Both conditions must be true
or: At least one condition must be true
not: Inverts the truth value
Loops (for and while loops)
Loops are used for iterating over a sequence (like a list, tuple, or string) or executing a block of code multiple times.
For Loops
For loops iterate over each item in a sequence.
for item in iterable:
# Code to execute for each item
While Loops
While loops repeat as long as a certain boolean condition is met.
while condition:
# Code to execute while the condition is true
Break and Continue
break and continue control the flow of loops.
break: Exit the loop immediately
continue: Skip the rest of the code inside the loop for the current iteration and move on to the next iteration
for item in iterable:
if some_condition:
break # Exit loop
if another_condition:
continue # Skip to next iteration
# Code to execute for each item
Remember, these are just the basic structures. Python offers more complex control structures and features that you can explore as you become more comfortable with the language.
# Python Control Structures with Examples
## Indentation in Python
# Correct indentation
if True:
print("This is correctly indented.")
# Incorrect indentation will raise an IndentationError
if True:
print("This will cause an error.")
# if condition
age = 18
if age >= 18:
print("You are eligible to vote.")
# if ..else
### Logical Operators
a = True
b = False
if a and b:
print("Both a and b are True.")
else:
print("Either a or b is False.")
if a or b:
print("Either a or b is True.")
else:
print("Both a and b are False.")
if not a:
print("a is False.")
else:
print("a is True.")
# For loop
# Iterating over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(f"I like {fruit}.")
# while loop
# Using while loop to count down
countdown = 5
while countdown > 0:
print(countdown)
countdown -= 1
print("Liftoff!")
# Break and Continue
# Using break
for number in range(1, 11):
if number == 5:
break
print(number)
# Will print numbers 1 to 4 and then break out of the loop
# Using continue
for number in range(1, 11):
if number % 2 == 0:
continue
print(number)
# Will print only odd numbers, as even numbers are skipped
Data Collections in Python
Python provides several data structures for storing and manipulating collections of data. Understanding these collections is vital for efficient Python programming.
Lists
A list in Python is an ordered collection of items which can be modified (mutable). Lists are defined using square brackets [] and can contain items of different types.
Data Collections in Python
In Python, there are several built-in data types that can be used to group multiple data together, known as collections. Among these are lists, tuples, sets, and dictionaries. Understanding how to create and iterate over these collections is fundamental in Python programming.
Lists
A list is an ordered collection of items that are mutable, meaning we can modify them after their creation. Lists are created by placing all the items (elements) inside square brackets [], separated by commas.
Example of List Operations:
# Define a list
my_list = [1, 2, 3, 'Python', 'Code']
# Append a new element
my_list.append('New Item')
print(my_list)
# Access elements
first_item = my_list[0]
print(first_item)
# Negative indexing
last_item = my_list[-1]
print(last_item)
# Slicing
sub_list = my_list[1:3]
print(sub_list)
# Length of a list
list_length = len(my_list)
print(list_length)
```python
# Define a list
my_list=[1,2,3,'Python','Code']
# Append a new element
my_list.append('New Item')
print(my_list)
# Access elements
first_item=my_list[0]
print(first_item)
# Negative indexing
last_item=my_list[-1]
print(last_item)
# Slicing
sub_list=my_list[1:3]
print(sub_list)
# Length of a list
list_length=len(my_list)
print(list_length)
Tuples are similar to lists, but they are immutable, meaning they cannot be changed after they are created. Tuples are defined using parentheses ().
# Define a tuple
my_tuple = (1, 2, 3, 'Python')
# Accessing elements
second_item = my_tuple[1]
print(second_item)
# Length of a tuple
tuple_length = len(my_tuple)
print(tuple_length)
# Tuples are immutable
# my_tuple[1] = 'New Value' # This would raise an error
Sets
A set is an unordered collection of items where every element is unique (no duplicates). Sets are defined using curly braces {}.
# Define a set
my_set = {1, 2, 3, 'Python'}
# Adding an element
my_set.add('Code')
print(my_set)
# Checking if an element exists
print(2 in my_set) # Output: True
# Removing an element
my_set.discard(2)
print(my_set)
# Length of a set
set_length = len(my_set)
print(set_length)
# Sets are unordered
# Items may appear in a different order every time you use them
A dictionary in Python is an unordered collection of data in a key:value pair form. A collection of such pairs is enclosed in curly braces {}.
# Define a dictionary
my_dict = {'name': 'Python', 'type': 'Programming Language'}
# Accessing elements
language_type = my_dict['type']
print(language_type)
# Adding a new key-value pair
my_dict['version'] = '3.8'
print(my_dict)
# Length of a dictionary
dict_length = len(my_dict)
print(dict_length)
# Iterating over dictionary keys
for key in my_dict:
print(key, my_dict[key])
iteration over Collections
You can iterate over the elements of a collection using a loop. For dictionaries, you can iterate over the keys, values, or key:value pairs.
# Iterating over a list
for item in my_list:
print(item)
# Iterating over a tuple
for item in my_tuple:
print(item)
# Iterating over a set
for item in my_set:
print(item)
# Iterating over dictionary keys
for key in my_dict:
print(key)
# Iterating over dictionary values
for value in my_dict.values():
print(value)
# Iterating over dictionary key-value pairs
for key, value in my_dict.items():
print(key, value)
Functions in Python
Functions are one of the most important constructs in Python. They allow you to create blocks of code that can be easily executed multiple times, without needing to rewrite the code.
Defining Functions
A function is defined using the def keyword, followed by a function name with parentheses and a colon. The indented block of code following the : is executed each time the function is called.
Example of Function Definition:
# Define a function
def greet(name):
print(f"Hello, {name}!")
# Call the function
greet('Alice')
### Function Parameters and Return Values
Functions can take parameters, which are values you pass into the function to be used within it. Functions can also return values back to the caller using the return keyword.
```python
# Example of Function Parameters and Return Values
# Function with parameters and a return value
def add_numbers(num1, num2):
return num1 + num2
# Call the function and print the result
result = add_numbers(10, 15)
print(result)
Scope of Variables
Variables defined within a function have a local scope, meaning they can only be accessed within the function. Variables defined outside of any function have a global scope, and can be accessed anywhere in the code.
# Global variable
x = 'global x'
def test():
# Local variable
y = 'local y'
print(y)
print(x)
test()
# print(y) # This will raise an error because y is not accessible here
#Lambda Functions Lambda functions are small anonymous functions defined with the lambda keyword. They can take any number of arguments, but can only have one expression.
# A simple lambda function
multiply = lambda a, b: a * b
# Use the lambda function
print(multiply(5, 6))
square = lambda x: x**2
print(square(5)) # Prints "25", which is the square of 5
#Modules and Importing A module is a file containing Python code that can define functions, classes, and variables. These modules can then be imported into other Python programs.
# Assume we have a module named `my_module` with a function `greet()`
import my_module
my_module.greet() # Calls the greet function from the imported module
When you import a module, Python looks at several places defined in sys.path. It is a list of directory locations.
Using the from Keyword
You can also use the from keyword to import specific functions, classes, or variables from a module.
from my_module import greet
greet() # Directly calls the greet function without the module's name prefix
Python Packages and PIP
Python packages and the Python Package Installer (PIP) are fundamental tools for any Python developer. They enable you to easily use and manage additional libraries and dependencies in your Python projects.
What are Python Packages?
A Python package is a collection of Python modules under a common namespace. In simpler terms, it's a directory that contains a special file named __init__.py and can include other modules and subpackages. Packages allow for a hierarchical structuring of the module namespace using dot notation. For example, a package named my_package could have a module named my_module accessible as my_package.my_module.
Here, my_package is a Python package containing a module my_module and a subpackage sub_package with a module another_module.
Introduction to PIP (Python Package Installer)
PIP is a package management system used to install and manage software packages written in Python. It connects to an online repository of public packages, called the Python Package Index (PyPI), to download and install packages.
Features of PIP:
Installing Python packages from PyPI.
Managing package versions.
Listing installed packages.
Uninstalling packages.
Installing Packages with PIP
To install a package using PIP, you use the command pip install package_name. PIP downloads the
package from PyPI and installs it in your Python environment.
# Examples of Installaing Package
pip install requests
! pip install requests
Managing Package Versions
PIP allows you to specify the version of a package you want to install. You can also upgrade or downgrade a package to a specific version.
pip install requests==2.25.1
# upgrading
pip install --upgrade requests
vritual Environment
Virtual environments in Python are a tool to keep dependencies required by different projects in separate places. They solve the "Project X depends on version 1.x but, Project Y needs 4.x" dilemma and keep your global site-packages directory clean and manageable.
# Creating a Virtual Environment
python -m venv myenv
# This creates a new virtual environment named myenv.
# on Unix or Mac OS
# source myenv/bin/activate
# deactivate the virtual env
deactivate
#This command will return you to the global Python environment.
#Using virtual environments with PIP ensures that your projects have access to only the packages they need and reduces conflicts between package versions.
File Operations in Python
Working with files is a common task in many programming projects. Python provides straightforward methods to handle files, which include reading from and writing to files, managing file paths, and handling exceptions.
Reading from and Writing to Files
Python allows you to read content from a file and write content to a file. This is commonly done using the built-in open() function.
This opens example.txt in read mode ('r'), reads its content into the variable content, and then closes the file.
file = open('example.txt', 'w')
file.write('Hello, World!')
file.close()
# This opens (or creates if it doesn't exist) example.txt in write mode ('w') and writes a string to it.
File Paths, Opening and Closing Files
When working with files, you need to provide the file path, which can be an absolute or relative path.
File modes determine the actions you can perform on the file, like reading, writing, or appending.
'r' - Read mode
'w' - Write mode
'a' - Append mode
'r+' - Read and write mode
Handling File Exceptions
try:
file = open('non_existent_file.txt', 'r')
content = file.read()
file.close()
except FileNotFoundError:
print("The file does not exist")
The Context Managers (with statement)
The with statement in Python simplifies exception handling by encapsulating common preparation and cleanup tasks in so-called context managers. For file operations, it ensures that the file is properly closed after its suite finishes, even if an exception is raised.
Example of Reading with a Context Manager:
with open('example.txt', 'r') as file:
content = file.read()
print(content)
This automatically closes example.txt after the nested block of code is executed, even if an exception occurs.
``` python
with open('example.txt', 'w') as file:
file.write('Hello, Python!')
##### This writes to example.txt and ensures the file is closed properly afterwards.
Using the with statement for file operations is a best practice in Python, as it makes the code cleaner and more readable, and it handles file closing automatically.
# Object-Oriented Programming in Python
Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs.
## Understanding Classes and Objects
- **Class**: A blueprint for creating objects (a particular data structure), providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods).
```python
class MyClass:
pass
- **Object**: An instance of a class. It can have attributes and behavior defined by its class.
```python
my_object = MyClass()
The self parameter
self represents the instance of the class. It's used to access variables that belong to the class.
class MyClass:
def my_method(self):
pass
The init method and Constructors
__init__ is a special method called a constructor, used to initialize a newly created object’s attributes.
class MyClass:
def __init__(self, attribute):
self.attribute = attribute
Class Methods, Instance Methods, and Static Methods
Instance Methods: Take self as the first argument and relate to a specific instance of the class.
Inheritance: Allows a new class to inherit attributes and methods from an existing class.
class BaseClass:
pass
class DerivedClass(BaseClass):
pass
Polymorphism: Refers to the way in which different object classes can share the same method name, but those methods can act differently based on which object calls them.
class Dog:
def speak(self):
return "Woof!"
class Cat:
def speak(self):
return "Meow!"
# Polymorphism in use
for animal in [Dog(), Cat()]:
print(animal.speak())
This provides an overview of the key concepts of Object-Oriented Programming in Python, which is a powerful paradigm for structuring and organizing code, especially in large programs or when dealing with complex data models.
```python
import socket
class PortScanner:
def __init__(self, target_ip, start_port, end_port):
self.target_ip = target_ip
self.start_port = start_port
self.end_port = end_port
def scan_tcp_port(self, port):
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(1)
result = s.connect_ex((self.target_ip, port))
if result == 0:
return True
else:
return False
except:
return False
def scan_udp_port(self, port):
try:
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
s.settimeout(1)
s.sendto(bytes("", "utf-8"), (self.target_ip, port))
s.recvfrom(1024)
return True
except:
return False
def perform_scan(self):
for port in range(self.start_port, self.end_port + 1):
if self.scan_tcp_port(port):
print(f"TCP Port {port} is open")
if self.scan_udp_port(port):
print(f"UDP Port {port} is open")
A PortScanner class is defined with methods for scanning TCP and UDP ports.
An object scanner is created from the PortScanner class.
The perform_scan method is called on the scanner object to perform the port scanning.
Please Note:
UDP scanning is unreliable using this method, as UDP is connectionless and doesn't respond with errors like TCP.
Scanning networks without permission can be illegal and unethical. Always obtain explicit authorization before scanning any network or system.
The script's performance can be improved with multithreading or asynchronous I/O, but this simple version is for demonstration purposes.
Error Handling in Python
Error handling in Python is managed through the use of exceptions. Exceptions are a way of signaling error conditions in a program. Python provides several built-in exceptions, but also allows the creation of custom exceptions.
Basic Exception Handling
Exception handling in Python is done through the use of try and except blocks.
Try Block: Encloses the code that might throw an exception.
Except Block: Handles the exception if one occurs in the try block.
try:
# Code that might raise an exception
result = 10 / 0
except ZeroDivisionError:
# Handling specific exception
print("Divided by zero!")
Finally Block
The finally block is optional and is executed regardless of whether an exception is raised or not. It's typically used for clean-up code.
try:
# Code that might raise an exception
result = 10 / 0
except ZeroDivisionError:
# Handling specific exception
print("Divided by zero!")
finally:
# This block is always executed
print("This is the finally block.")
Raising Exceptions
You can raise exceptions using the raise statement. This is useful for throwing custom errors or re-raising caught exceptions.
x = -1
if x < 0:
raise ValueError("x must be non-negative")
Creating Custom Exceptions
Custom exceptions can be created by defining a new class that inherits from the base Exception class.
class MyCustomError(Exception):
"""A custom exception class."""
pass
try:
# Code that raises the custom exception
raise MyCustomError("An error occurred")
except MyCustomError as e:
print(e)
Understanding and properly implementing error handling in Python can greatly improve the reliability and
robustness of your code, allowing for more graceful handling of unexpected situations and better user experiences.
# Advanced Topics and Course Wrap-up
As we conclude this Python course, let's delve into some advanced topics that can enhance your Python programming skills and prepare you for more complex projects.
## Comprehensions
Python supports a concise syntax to create new collections based on existing ones.
- **List Comprehensions**: A concise way to create lists.
```python
squares = [x**2 for x in range(10)]
Dictionary Comprehensions: Similar to list comprehensions, but for dictionaries.
squares_dict = {x: x**2 for x in range(10)}
Set Comprehensions: Used for creating sets in a concise way.
even_numbers = {x for x in range(10) if x % 2 == 0}
Iterators and Generators
Iterators: Objects that can be iterated over.
iter_obj = iter([1, 2, 3])
Generators: Simple way to create iterators using functions and the yield keyword.
def my_decorator(func):
def wrapper():
print("Something before the function is called.")
func()
print("Something after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
Advanced Modules
Python provides a vast standard library that includes several advanced modules:
os: Interacting with the operating system.
import os
os.listdir('.')
sys: Accessing variables used or maintained by the interpreter and functions that interact strongly with the interpreter.
# Python version
from platform import python_version
print(python_version())
Python Packages
import platform
print(platform.node())
platform.processor()
platform.machine()
platform.uname()
import math #package : we need include packages to obtain certain capability
import math
# Rounding a number upwards to its nearest integer
print(math.ceil(1.4)) # Output: 2
# Rounding a number downwards to its nearest integer
print(math.floor(1.4)) # Output: 1
# Square root of a number
print(math.sqrt(16)) # Output: 4.0
# Power of numbers (x^y)
print(math.pow(2, 3)) # Output: 8.0
import requests
# URL to send the request
url = "https://api.open-meteo.com/v1/forecast?latitude=32.814018&longitude=-96.948891¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
# Send a GET request to the URL
response = requests.get(url)
# Print the status code of the response
print(f"Status Code: {response.status_code}")
import requests
# URL to send the request
url = "https://api.open-meteo.com/v1/forecast?latitude=32.814018&longitude=-96.948891¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
# Send a GET request to the URL
response = requests.get(url)
# Print the status code and response content
print(f"Status Code: {response.status_code}")
print(f"Response Content:\n{response.text}")
import requests
import json
# URL to send the request
url = "https://api.open-meteo.com/v1/forecast?latitude=32.814018&longitude=-96.948891¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
# Send a GET request to the URL
response = requests.get(url)
# Check if the request was successful
if response.status_code == 200:
# Parse JSON response and print it in a formatted way
data = response.json()
formatted_json = json.dumps(data, indent=4)
print(formatted_json)
else:
print(f"Error: Status code {response.status_code}")
import requests
import json
import csv
# URL to send the request
url = "https://api.open-meteo.com/v1/forecast?latitude=32.814018&longitude=-96.948891¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
# Send a GET request to the URL
response = requests.get(url)
# Check if the request was successful
if response.status_code == 200:
# Parse JSON response
data = response.json()
# Extract hourly data
hourly_data = data.get('hourly', {})
hourly_temp = hourly_data.get('temperature_2m', [])
hourly_humidity = hourly_data.get('relative_humidity_2m', [])
hourly_wind_speed = hourly_data.get('wind_speed_10m', [])
time = hourly_data.get('time', [])
# Create and write data to CSV
with open('/content/sample_data/weather_data.csv', 'w', newline='') as file:
writer = csv.writer(file)
writer.writerow(["Time", "Temperature (°C)", "Relative Humidity (%)", "Wind Speed (m/s)"])
for i in range(len(time)):
writer.writerow([time[i], hourly_temp[i], hourly_humidity[i], hourly_wind_speed[i]])
print("Data saved to CSV successfully.")
else:
print(f"Error: Status code {response.status_code}")
import pandas as pd
# Read the CSV file into a DataFrame
df = pd.read_csv('/content/sample_data/weather_data.csv')
# Display the DataFrame
df
!pip install pandas matplotlib seaborn
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
