Base Python for Data Analytics

Learn how to use bool() to find if value is True or False

Resources:

• Code: Notebook from class (U_6_base__truth_value_testing.ipynb)

• Exercise: 10 Questions (U_6_exercise.ipynb)

Learn boolean operations such as: and, or, not

Resources:

• Code: Notebook from class (U_7_base__boolean_operations.ipynb)

• Exercise: 5 Questions (U_7_exercise.ipynb)

Learn boolean comparisons such as: ==, !=, >=, <=, > and <

Resources:

• Code: Notebook from class (U_8_base__comparisons.ipynb)

• Exercise: 10 Questions (U_8_exercise.ipynb)

What you will learn:

• Integer, float, and complex operations

• Bitwise and binary operations

• Type conversions

• Real-world number handling

Resources:

• Code: Notebook from class (U_9_base__int_float_complx.ipynb)

• Exercise: 10 Questions (U_9_exercise.ipynb)

What you will learn:

• Basic Arithmetic – Addition, subtraction, multiplication, division, and exponentiation.

• Integer and Float Operations – Understanding precise calculations, division types, and rounding.

• Modulo and Floor Division – Finding remainders and integer quotients.

• Type Conversions – Converting between integers, floats, and complex numbers.

• Absolute Values and Negation – Handling positive and negative numbers.

• Power and Roots – Squaring, cubing, and finding square roots.

• Complex Numbers – Using imaginary numbers in calculations.

Resources:

• Code: Notebook from class (U_10_base__math_operators.ipynb)

• Exercise: 10 Questions (U_10_exercise.ipynb)

What you will learn:

• Creating Lists – Learn different ways to define lists with numbers, strings, and mixed data types.

• Accessing Elements – Use indexing and slicing to retrieve specific values from a list.

• Modifying Lists – Add, remove, and update items dynamically.

• Sorting and Organizing Data – Arrange items in ascending/descending order.

• Nested Lists – Work with lists inside lists for more complex data structures.

Resources:

• Code: Notebook from class (U_11_base__seq_type__list.ipynb)

• Exercise: 10 Questions (U_11_exercise.ipynb)

What you will learn:

• Check if an item exists in a sequence using in and not in operators.

• Join two sequences together using concatenation (+).

• Repeat sequences multiple times using multiplication (*).

• Access elements using indexing.

• Extract portions of sequences using slicing (s[i:j] and s[i:j:k]).

• Find the length of a sequence using len().

• Identify the smallest and largest values using min() and max().

• Find the position of an element using index().

• Count occurrences of a value in a sequence using count().

Resources:

• Code: Notebook from class (U_12_base__seq_type__list.ipynb)

• Exercise: 10 Questions (U_12_exercise.ipynb)

What you will learn:

• Tuples are immutable (students' data cannot be modified directly)

• Lists allow modifications (students can be added, removed, or updated)

• Indexing & Slicing are used to access, modify, and manipulate data

• Basic sequence operations without loops, functions, or conditionals

Resources:

• Code: Notebook from class (U_13_base__seq_oper_mutable.ipynb)

• Exercise: 10 Questions (U_13_exercise.ipynb)

What you will learn:

• Create ranges with different start, stop, and step values

• Convert ranges into lists for better visualization

• Access elements using indexing and negative indexing

• Perform slicing on range sequences

• Check for membership in a range

• Compare different range objects

Resources:

• Code: Notebook from class (U_14_base__seq_ranges.ipynb)

• Exercise: 10 Questions (U_14_exercise.ipynb)

What you will learn:

• How to clean and structure unformatted text.

• The importance of case manipulation in string processing.

• How to split and join text efficiently.

• How to format text into proper sentence without using loops or complex logic.

Resources:

• Code: Notebook from class (U_15_base__seq_string.ipynb)

• Exercise: 10 Questions (U_15_exercise.ipynb)

What you will learn:

• Understand different ways to use print()

• Use string concatenation, formatting, and f-strings

Resources:

• Code: Notebook from class (U_16_base__seq_print.ipynb)

• Exercise: 10 Questions (U_16_exercise.ipynb)

What you will learn:

1. User Input Handling: Learn to take user input using the input() function.

2. Basic Printing: Display messages using the print() function.

3. String Concatenation: Combine text and variables for personalized messages.

4. Using format(): Format strings dynamically with the .format() method.

5. Using f-strings: Use f-strings for cleaner and more readable string formatting.

6. Code Readability: Write clear, structured, and readable code following best practices.

7. Debugging Practice: Identify and fix errors in simple Python programs.

8. Real-World Application: Create a personalized greeting generator using Python.

Resource:

• Code: Notebook (U_16_mini_project.ipynb)

What you will learn:

1. Data Formatting: Clean and format messy data with inconsistent spacing and mixed cases.

2. Boolean Conversion: Convert "YES"/"NO" responses into Boolean values.

3. Data Type Conversion: Extract and transform numerical values into appropriate types.

4. Loop-Free Processing: Perform data cleaning without using loops.

5. Basic Statistics: Compute total students, highest and lowest scores.

6. Built-in Functions: Utilize len(), max(), and min() for analysis.

7. String Manipulation: Format and present data using Python string methods.

8. Report Generation: Generate a structured report using string.Template.

9. Boolean Logic: Apply truth value testing and Boolean operations.

10. Real-World Application: Develop data analysis skills through a practical scenario.

    
    

Resource:

• Code: Notebook (U_16_section_project.ipynb)

What you will learn:

• Binary Representation of Text: Convert regular text into binary format using encoding.

• Binary String Manipulation: Extract, replace, and modify parts of binary data.

• Text Encoding & Decoding: Convert between binary data and human-readable text.

• Basic String Operations: Apply transformations like uppercase, lowercase, and title case.

• Checking String Properties: Identify whether a string contains only alphabets, numbers, or special characters.

Resources:

• Code: Notebook from class (U_17_base__seq_binary_data.ipynb)

• Exercise: 10 Questions (U_17_exercise.ipynb)

What you will learn:

1. User Input Handling – Accept and process user input for name and age.

2. Binary Encoding – Convert string inputs into binary format using UTF-8 encoding.

3. String Formatting Techniques – Print formatted sentences using f-strings, .format(), and % formatting.

4. Binary Data Manipulation – Extract, replace, and modify specific parts of a binary string.

5. Text Case Transformations – Convert text to uppercase, lowercase, and title case from binary format.

6. String Property Checks – Verify if a string contains only letters or only numbers.

7. Slicing and Indexing – Extract specific words or characters from binary-encoded messages.

8. Decoding Binary Strings – Convert binary-encoded data back into readable text.

Resource:

• Code: Notebook (U_17_mini_project.ipynb)

What will you learn:

Basic Printing with print() – How to print byte strings (b"Hello, World!").
Printing Multiple Values – Using print() to display multiple byte string values.

Resources:

• Code: Notebook from class (U_18_base__seq_binary_print.ipynb)

• Exercise: 10 Questions (U_18_exercise.ipynb)

What you will learn:

1. User Input Handling – Accept and process user input for name and age.

2. Binary Encoding – Convert string inputs into binary format using UTF-8 encoding.

3. String Formatting Techniques – Print formatted sentences using:

4. • String concatenation

   • % operator formatting

   • f-strings

   • Template from the string module

5. Decoding Binary Data – Convert binary data back into readable string format.

Resource:

• Code: Notebook (U_18_mini_project.ipynb)

What you will learn:

1. Handling Byte Strings – Store and process numerical data in byte format.

2. Converting Bytes to Integers – Decode byte values and perform arithmetic operations.

3. Calculating Basic Statistics – Compute total entries, sum, and average of byte-encoded numbers.

4. Formatting Byte Output – Convert numerical results back to bytes for display.

5. Printing Methods – Use basic print statements, string concatenation, f-strings, and template strings.

Resource:

• Code: Notebook (U_18_section_project.ipynb)

What you will learn:

1. Understanding Sets and Frozen Sets – Learn the difference between mutable set and immutable frozenset.

2. Basic Set Operations – Adding, removing, and discarding elements from a set.

3. Membership Testing – Check if an element exists in a set using in and not in.

4. Set Operations – Perform union, intersection, difference, and symmetric difference to manipulate sets effectively.

5. Practical Use Cases of Sets – Apply sets in data analysis to remove duplicates, compare datasets, and perform fast lookups.

Resources:

• Code: Notebook from class (U_19_base__set_types.ipynb)

• Exercise: 10 Questions (U_19_exercise.ipynb)

What you will learn:

1. Defining Product Categories – Store and organize product data using Python sets.

2. Identifying All Products – Use set union to find all unique products across stores.

3. Finding Common Products – Apply set intersection to determine products available in both stores.

4. Discovering Exclusive Products – Use set difference to find products unique to each store.

5. Analyzing Unique Items – Utilize symmetric difference to identify products available in only one store.

Resource:

• Code: Notebook (U_19_mini_project.ipynb)

What will you learn:

1. How to create and modify dictionaries using {} and dict().

2. Accessing, updating, and deleting key-value pairs.

3. Using dictionary methods like .get(), .keys(), and .values().

4. Applying dictionaries for structured data storage in analytics.

Resources:

• Code: Notebook from class (U_20_base__mapping_types_dict.ipynb)

• Exercise: 10 Questions (U_20_exercise.ipynb)

What you will learn:

1. Managing Student Data – Store and organize student grades using Python dictionaries.

2. Adding New Students – Dynamically insert new student records and their grades.

3. Retrieving Student Grades – Access and print specific student grade records efficiently.

4. Calculating Averages – Compute the average grade for each student using Python’s built-in functions.

5. Finding Top Performers – Identify the student with the highest average grade.

6. Practicing Best Coding Habits – Write clear, structured, and readable Python code.

7. Debugging & Self-Learning – Strengthen problem-solving skills by debugging and improving code independently.

Resource:

• Code: Notebook (U_20_mini_project.ipynb)

What you will learn:

1. Storing Customer Data – Use lists, tuples, dictionaries, and sets to organize purchase records.

2. Identifying Unique Customers – Extract distinct customer names using set operations.

3. Counting Product Categories – Determine the total number of unique product categories available.

4. Calculating Total Spending – Sum up purchase amounts to analyze customer spending.

5. Checking VIP Status – Verify if a customer qualifies as a VIP using set membership.

6. Evaluating Purchase Thresholds – Determine if customers spent more than $100 using Boolean logic.

Resource:

• Code: Notebook (U_20_section_project.ipynb)

What will you learn:

1. How to use if, elif, and else statements to control program flow.

2. How to apply conditions using comparison and logical operators (==, >, <, and, or).

3. How to make data-driven decisions in Python without using loops or functions.

4. How to analyze and process data using conditional logic in real-world scenarios.

5. How to calculate and apply discounts, classifications, and validations using if statements.

Resources:

• Code: Notebook from class (U_21_base__control_flow_IF.ipynb)

• Exercise: 10 Questions (U_21_exercise.ipynb)

What you will learn:

1. Checking Discount Eligibility – Determine if a customer qualifies for a discount based on their purchase amount.

2. Applying VIP Benefits – Adjust the discount percentage for VIP customers.

3. Calculating Final Discount – Compute the total discount a customer receives.

4. Determining Total Payable Amount – Apply the discount to the purchase amount and calculate the final cost.

5. Writing Clear & Readable Code – Follow best coding practices to structure your solution efficiently.

Resource:

• Code: Notebook (U_21_mini_project.ipynb)

What you will learn:

1. Understanding how for loops work in Python

2. Iterating through lists, dictionaries, and nested structures

3. Using range(), enumerate(), and list comprehensions

4. Filtering data using if conditions within for loops

5. Extracting key insights from data dictionaries

6. Performing basic analytics using loops

7. Modifying and updating lists during iteration

Resources:

• Code: Notebook from class (U_22_base__control_flow_FOR.ipynb)

• Exercise: 10 Questions (U_22_exercise.ipynb)

What you will learn:

1. Printing Product Information – Display each product along with its revenue using loops.

2. Calculating Total Revenue – Sum up all revenues to determine overall earnings.

3. Identifying Top Performers – Find the product with the highest revenue.

4. Categorizing Sales Performance – Classify revenues into "Low," "Medium," and "High" categories based on predefined thresholds.

5. Storing Data in Dictionaries – Map product names to their revenue categories for easy reference.

Resource:

• Code: Notebook (U_22_mini_project.ipynb)

What you will learn:

1. Understanding while loops and their purpose.

2. Writing a basic while loop with a stopping condition.

3. Updating variables inside a while loop to control execution.

4. Using while loops for interactive programs like guessing games.

5. Implementing infinite loops and breaking out using break.

6. Ensuring loops terminate properly to avoid infinite execution.

Resources:

• Code: Notebook from class (U_23_base__WHILE.ipynb)

• Exercise: 10 Questions (U_23_exercise.ipynb)

What you will learn:

1. Using While Loops for Iteration – Master how to iterate through lists using while loops instead of for loops.

2. Computing Averages – Learn to calculate the average of a dataset using cumulative sums.

3. Counting Specific Conditions – Identify how many days had temperatures above the calculated average.

4. Finding Extremes – Determine the highest and lowest recorded temperatures.

5. Tracking Consecutive Events – Detect and count the longest streak of hot days (>30°C).

Resource:

• Code: Notebook (U_23_mini_project.ipynb)

What you will learn:

1. Understanding the purpose of break and continue statements.

2. Using break to exit a loop when a condition is met.

3. Using continue to skip certain iterations without terminating the loop.

4. Applying break in nested loops for optimized execution.

5. Filtering and processing data using break and continue.

6. Identifying prime numbers using loop control statements.

7. Handling real-world scenarios where loop control is necessary.

Resources:

• Code: Notebook from class (U_24_base__BREAK_CONTINUE.ipynb)

• Exercise: 10 Questions (U_24_exercise.ipynb)

What you will learn:

1. Handling Missing Values – Use continue to skip transactions where Units Sold is missing.

2. Detecting Invalid Data – Stop processing immediately (break) if a negative value is found in Units Sold.

3. Filtering Unwanted Records – Skip transactions where Units Sold is 0, as they are not valid sales.

4. Using Loop Control Statements – Learn how to combine break and continue effectively for real-world data filtering.

5. Printing Valid Transactions – Display only meaningful sales records in a structured format.

Resource:

• Code: Notebook (U_24_mini_project.ipynb)

What you will learn:

1. Understanding the use of else with a for loop in Python.

2. How else executes only if the loop completes without a break.

3. Real-world applications of else in data analytics.

4. Searching for values in datasets using for-else.

Resources:

• Code: Notebook from class (U_25_base__ELSE.ipynb)

• Exercise: 10 Questions (U_25_exercise.ipynb)

What you will learn:

1. Looping Through Transactions – Learn how to iterate over a dataset containing customer purchases.

2. Detecting Low Purchase Amounts – Identify transactions that fall below a specified threshold.

3. Implementing Early Stopping – Halt processing immediately when an issue is found using break.

4. Using Conditional Logic – Apply if-else statements to validate transactions.

Resource:

• Code: Notebook (U_25_mini_project.ipynb)

What you will learn:

1. Understanding the pass statement in Python.

2. Why pass is useful in loops, conditionals, and placeholders.

3. How pass allows code structure without execution.

4. When to use pass in data analytics workflows.

5. Writing loops with pass to plan code before implementation.

Resources:

• Code: Notebook from class (U_26_base__PASS.ipynb)

• Exercise: 10 Questions (U_26_exercise.ipynb)

What you will learn:

1. Looping Through Transactions – Learn how to iterate over a dataset containing customer purchases.

2. Handling Missing Data – Identify transactions with missing purchase amounts and flag them for further processing.

3. Detecting Pending Transactions – Mark transactions with a "Pending" status without modifying them.

4. Error Identification – Recognize transactions marked as "Error" and isolate them for future corrections.

5. Writing Placeholder Logic – Understand how to structure a program with placeholders (pass) for future enhancements.

6. Building a Foundation for Data Cleaning – Gain hands-on experience in detecting inconsistencies in a dataset before applying transformations.

Resource:

• Code: Notebook (U_26_mini_project.ipynb)

What you will learn:

1. Understanding the match statement in Python.

2. How match is different from traditional if-elif-else conditions.

3. Using match to compare values and patterns efficiently.

4. Matching multiple values in one case statement.

5. Using _ as a wildcard/default case.

6. Matching data structures like lists and dictionaries.

7. Applying match conditions with expressions (if statements).

8. Using match in data analytics to process different data formats.

Resources:

• Code: Notebook from class (U_27_base__MATCH.ipynb)

• Exercise: 10 Questions (U_27_exercise.ipynb)

What you will learn:

1. Using the match Statement – Learn how to categorize data efficiently with Python’s match statement (introduced in Python 3.10).

2. Dictionary Iteration – Understand how to loop through a dictionary of movie ratings using .items().

3. Conditional Logic with Ranges – Learn how to define rating categories based on numerical ranges using match cases.

4. Formatted Output – Practice using f-strings to display the movie name, rating, and classification in a structured format.

5. Writing Clean and Readable Code – Develop good coding habits by following best practices for indentation, variable naming, and structured conditional logic.

Resource:

• Code: Notebook (U_27_mini_project.ipynb)

What you will learn:

1. Use lists, and dictionaries to store race data

2. Apply if-else and match to analyze driver performance

3. Loop through race stats with for, while, and nested loops

4. Work with numeric types to calculate lap times and rankings

5. Use booleans to check team participation and track availability

6. Gain hands-on experience in data analytics with real-world NASCAR stats

Resource:

• Code: Notebook (U_27_section_project.ipynb)

What you will learn:

1. Understanding Functions: Learn what functions are and why they are essential in Python.

2. Defining Functions: Learn how to create reusable functions using the def keyword.

3. Calling Functions: Understand how to call functions and pass arguments to them.

4. Positional vs. Keyword Arguments: Learn the difference between positional and keyword arguments and how to use them.

5. Default Parameter Values: Explore how to set default values for function parameters.

6. Variable-Length Arguments (*args and **kwargs): Learn how to pass a varying number of arguments to a function.

7. Lambda Functions: Understand how to use anonymous functions (lambda expressions) for quick operations.

8. Docstrings and Function Annotations: Learn how to document your functions and use type hints for better readability.

9. Special Parameter Syntax (/, *): Understand how to enforce positional and keyword-only arguments.

Resources:

• Code: Notebook from class (U_28_base__functions.ipynb)

• Exercise: 10 Questions (U_28_exercise.ipynb)

What you will learn:

1. Reading and processing race data – Work with structured data related to NASCAR race results.

2. Defining and using functions – Break down the analysis into modular and reusable functions.

3. Computing performance metrics – Calculate key race statistics such as average speed and lap time.

4. Sorting and filtering data – Organize race results based on performance criteria.

5. Printing formatted results – Display race insights in a clear and structured manner.

Resource:

• Code: Notebook (U_28_mini_project.ipynb)

What you will learn:

1. Defining functions for structural analysis – Write Python functions to calculate different types of loads.

2. Computing total load on a structure – Implement formulas for summing forces acting on a bridge.

3. Basic conditional checks – Apply simple pass/fail logic to assess structural safety.

4. Working with lists and basic data storage – Store and manage load values effectively.

5. Printing structured analysis results – Format output to display calculated loads clearly.

Resource:

• Code: Notebook (U_28_mini_project_2.ipynb)

What. you will learn:

1. Creating Your First Class – Step-by-step guidance on defining and using a class.

2. Instance Variables & Methods – Learn how to create attributes and methods within a class.

3. Instantiating Objects – Understand how to create multiple objects from a class.

4. Using __init__ Method – Learn how to initialize objects with specific data.

5. Adding Functionality with Methods – Implement functions inside a class to manipulate object data.

6. Namespace & Scope in Classes – Learn how variables and attributes are stored and accessed in classes.

7. Global & Instance Variables – Understand the difference between class-wide and object-specific data.

Resources:

• Code: Notebook from class (U_29_base__classes.ipynb)

• Exercise: 10 Questions (U_29_exercise.ipynb)

Key Topics Covered:

1. What is a Class? – Understanding the blueprint for creating objects.

2. Creating Objects (Instances) – How to use classes to create real-world objects.

3. Attributes and Methods – Storing data and defining behaviors in a class.

4. The __init__ Method (Constructor) – Initializing object attributes.

5. Adding Functionality with Methods – Writing functions inside a class.

6. Working with Multiple Objects – Managing and interacting with multiple instances.

7. Building a Mini Project – Creating a Song and Playlist class to practice OOP concepts.

Resource:

• Code: Notebook (U_29_mini_project_1.ipynb.ipynb)

What you will learn:

1. Understanding Classes & Objects – Learn how to define and use classes in Python.

2. Writing a Constructor (__init__ Method) – Initialize instance variables when creating an object.

3. Creating & Using Instance Variables – Store and update data within a class.

4. Defining and Implementing Methods – Write functions inside a class to perform actions.

5. Modifying Object State – Learn how to update instance variables dynamically.

6. Using Lists to Manage Data – Store, add, and remove items from a list inside a class.

7. Implementing Conditional Logic in Methods – Check book availability and handle different cases.

8. Testing & Using a Class in a Realistic Scenario – Simulate borrowing and returning books.

9. Writing Clean & Well-Commented Code – Understand best practices for readability and structure.

Resource:

• Code: Notebook (U_29_mini_project_2.ipynb)

What you will learn:

1. Concept of Inheritance – Understand how a child class inherits properties and methods from a parent class.

2. Defining a Parent Class – Learn how to create a base class with shared attributes and behaviors.

3. Creating Child Classes – Extend a parent class to define specialized behaviors.

4. Using super() – Call methods from the parent class in a derived class.

5. Overriding Methods – Customize inherited methods to suit specific class requirements.

6. Encapsulation in Inheritance – Learn how to manage access to attributes within an inherited structure.

7. Reusing Parent Methods – Avoid code duplication by leveraging existing methods in derived classes.

8. Instantiating Parent and Child Classes – Create objects from both parent and derived classes.

9. Polymorphism Basics – See how different child classes can use the same method name with different outputs.

Resources:

• Code: Notebook from class (U_30_base__class_inheritance.ipynb)

• Exercise: 10 Questions (U_30_exercise.ipynb)

What you will learn:

1. Understanding Inheritance – Learn how child classes inherit attributes and methods from a parent class.

2. Creating a Base Class – Define a parent class to store common attributes and behaviors.

3. Overriding Methods – Modify inherited methods to customize behavior in child classes.

4. Using super() – Call methods from the parent class within a child class.

5. Instantiating Objects – Create objects from both parent and child classes.

6. Polymorphism in Action – Use the same method name across different classes for different behaviors.

7. Using __init__ in Derived Classes – Initialize child class attributes while reusing the parent’s constructor.

Resource:

• Code: Notebook (U_30_mini_project.ipynb)

What you will learn:

1. Fetch Live Weather Data using urllib.request from Open-Meteo API.

2. Parse JSON Data using json.loads() to extract temperature, wind speed, and other weather details.

3. Store Data in Tuples and Lists to organize city weather information.

4. Use Loops (for loop) to iterate over multiple cities and fetch data dynamically.

5. Use if-else Statements to check for extreme cold or heat conditions.

6. Define a WeatherReport Class to store weather data for each city.

7. Implement Class Inheritance to create ColdWeatherAlert and HotWeatherAlert subclasses.

8. Create and Use Objects to represent city weather reports.

9. Print and Format Outputs to display weather conditions in a readable format.

This project reinforces real-world Python skills using only base Python, without any external libraries.

Resource:

• Code: Notebook (U_30_section_project.ipynb)

What you will learn:

1. Object-Oriented Programming (OOP) Concepts

   • Inheritance: Product, Customer, Order, and Staff classes inherit from Supermarket.

   • Encapsulation: The Supermarket class encapsulates operations like managing inventory and sales.

   • Composition: Order and Customer interact with Product and Supermarket without inheriting from them.

2. Working with Classes and Objects

   • Define multiple classes (Supermarket, Product, Customer, Order, Staff).

   • Create and use objects to manage a supermarket's operations.

3. Data Handling and Operations

   • Use data types: Strings (name), floats (price, sales), and booleans (membership).

   • Perform calculations (discounts, taxes, stock updates).

   • Store items in lists of tuples to manage orders.

4. Control Flow and Logic

   • Use conditional logic to apply membership-based discounts.

   • Loop through product lists to calculate order totals.

5. Utility Functions

   • Calculate discounts and taxes with separate functions.

   • Format and display information for products, customers, and staff.

This project gives you hands-on experience in structuring a real-world Python application using OOP principles.

Resource:

• Code: Notebook (U_31_Project_Supermarket.ipynb)