MBA FT 609: Business Intelligence and Programming with Python

Unit IV
Business Intelligence User Interfaces

Syllabus :-

4.1 Project Planning: Steps, resources, roles ,risks

4.2 Human Factors: BI teams, leadership, user roles
4.3 Architecture Choices: Cost, scalability, best practices

4.1 Project Planning: Steps, resources, roles ,risks

✅ Steps in BI Project Planning:

1. Define Objectives – Understand the business goals and what insights are
needed.
2. Requirements Gathering – Collect functional and technical needs from
stakeholders.
3. Tool & Technology Selection – Choose BI tools, databases, and platforms.
4. Data Source Identification – Identify internal and external sources of
relevant data.
5. Development & Testing – Build ETL processes, reports, dashboards; test
thoroughly.
6. Deployment – Roll out to users; integrate with existing systems.
7. Maintenance – Monitor performance and make improvements as needed.
✅ Resources:

1. Human Resources – Project managers, data analysts, ETL developers, BI

developers.
2. Technical Resources – Hardware, software (BI tools, databases), cloud
infrastructure.
3. Financial Resources – Budget for licensing, training, consulting, and
implementation.
4. Data Resources – Access to clean, reliable, and timely data sources.
5. Time Resources – Sufficient time allocated for each phase of the project.
6. Training Resources – Materials and sessions for end-user training and
adoption.

✅ Roles in a BI Project:

1. Project Manager – Oversees timeline, budget, and communication.

2. Business Analyst – Gathers and translates business requirements into
technical specs.
3. ETL Developer – Designs and implements data extraction, transformation,
and loading processes.
4. BI Developer – Creates dashboards, reports, and analytics models.
5. Data Engineer/Architect – Designs data models and database architecture.
6. End Users – Business stakeholders who consume reports and provide
feedback.
7. QA/Testers – Validate the accuracy and performance of BI components.

✅ Risks in BI Projects:

1. Poor Data Quality – Leads to incorrect insights and bad decisions.

2. Changing Requirements – Frequent changes can delay the project.
3. Scope Creep – Adding features mid-project increases complexity and cost.
4. Lack of User Adoption – If users aren’t trained or don’t trust the system, it
fails.
5. Underestimated Complexity – BI projects often involve complex
integrations.
6. Technology Limitations – Choosing the wrong tools can affect scalability
and performance.
7. Security & Compliance Risks – Mishandling sensitive data can lead to
legal issues.
4.2 Human Factors: BI Teams, Leadership, User Roles

✅ BI Teams:

1. Cross-functional Teams – Combine IT, business, and data expertise.

2. Collaboration – Effective communication between business and technical
users is critical.
3. Skill Diversity – Includes data modeling, visualization, data integration, and
business acumen.
4. Team Size – Depends on the project scope and complexity.
5. Agile Approach – Many BI teams follow agile for flexibility and feedback.
6. Clear Responsibilities – Defined roles reduce confusion and delays.
7. Continuous Learning – BI teams must stay updated with tools and trends.

✅ Leadership:

1. Vision Setting – Leaders define the strategic goals of the BI initiative.

2. Support and Sponsorship – Executive backing ensures resources and
adoption.
3. Decision Making – Leadership helps prioritize features and resolve
conflicts.
4. Communication – Bridges gap between IT and business teams.
5. Risk Management – Proactively identifies and mitigates project risks.
6. Change Management – Helps users transition to new BI tools and
processes.
7. Performance Monitoring – Evaluates success and ROI of BI efforts.

✅ User Roles in BI:

1. Report Consumers – View and use standard dashboards/reports.

2. Business Analysts – Perform deeper analysis, create custom queries.
3. Power Users – Create their own dashboards; need advanced tool access.
4. Executives/Managers – Use high-level reports for strategic decisions.
5. IT Support Users – Manage system performance, data quality, and user
access.
6. Trainers/Champions – Promote BI usage and provide support to peers.
7. Data Stewards – Ensure data accuracy and consistency across systems.
4.3 Architecture Choices: Cost, Scalability, Best Practices

✅ Cost Considerations:

1. Tool Licensing – Cost of BI software (Tableau, Power BI, Qlik, etc.).

2. Infrastructure – Hardware or cloud service expenses (AWS, Azure, etc.).
3. Training & Support – Cost of onboarding users and maintaining the
system.
4. Development Time – Labor costs for designing and implementing
solutions.
5. Data Storage – Costs related to databases, data lakes, and backups.
6. Consulting/External Help – Budget for hiring experts if needed.
7. Long-Term Maintenance – Ongoing costs for updates, patches, and
support.

✅ Scalability:

1. Data Volume – Architecture must support increasing data over time.

2. User Load – System should scale with more concurrent users or teams.
3. Performance – Maintain speed as complexity or volume of queries grows.
4. Modularity – New features/modules should be easy to add.
5. Cloud Integration – Offers elastic scalability and cost control.
6. Automation – Scalable systems should support automated ETL and
reporting.
7. Storage Management – Must handle structured, semi-structured, and
unstructured data efficiently.

✅ Best Practices:

1. Data Governance – Ensure accuracy, consistency, and security of data.

2. Single Source of Truth – Avoid duplication by using centralized data
repositories.
3. Security & Access Control – Role-based access to reports and data.
4. Modular Design – Build components that can be reused or extended.
5. User-Centric Design – Dashboards should be intuitive and meet user needs.
6. Documentation – Maintain detailed documentation for development and
support.
7. Monitoring & Maintenance – Regular audits and performance monitoring.

**************
 MBA FT 609: Business Intelligence and Programming with Python

Unit V
Python Programming Basics

Syllabus :-

5.1 Introduction: Features, Data types, variables, operators, input-output

5.2 Control Structures: Conditions and loops
5.3 Data Structures: Strings, lists, tuples, dictionaries
5.4 Functions and Modules: Definitions, imports, packages

5.1 Introduction: Features, Data Types, Variables, Operators,

Input-Output

✅ Features of Python:

1. Easy to Read and Write – Simple syntax similar to English.

2. Interpreted Language – Executes code line-by-line.
3. Dynamically Typed – No need to declare variable types.
4. High-Level Language – Abstracts complex low-level details.
5. Extensive Libraries – Supports various fields (e.g., AI, data science, web
dev).
 6. Open Source – Free to use and has a large community.
7. Cross-Platform – Works on Windows, macOS, Linux.

✅ Data Types:

1. int – Integer values (e.g., 5)

2. float – Decimal values (e.g., 3.14)
3. str – String/text (e.g., "Hello")
4. bool – Boolean values (True, False)
5. list, tuple, dict, set – Built-in data structures
6. type() – Function used to check a variable’s data type.
7. Python allows type conversion (e.g., int("10") → 10)

✅ Variables:

1. Used to store values in memory.

2. No need to declare type – Python infers it (x = 10)
3. Variable names are case-sensitive.
4. Use meaningful names (e.g., student_name, not sn).
5. Cannot start with a digit or use special characters.
6. Variables can be reassigned to different types (x = 10, then x = "Ten").
7. Constants are typically written in uppercase (e.g., PI = 3.14).

✅ Operators:

1. Arithmetic: +, -, *, /, %, //, **
2. Comparison: ==, !=, <, >, <=, >=
3. Logical: and, or, not
4. Assignment: =, +=, -=, *=, /=, etc.
5. Membership: in, not in (e.g., "a" in "apple")
6. Identity: is, is not – checks object identity.
7. Bitwise: &, |, ^, ~, <<, >>

✅ Input-Output:

1. input() – Takes input from the user (as a string).

2. name = input("Enter your name: ")
3. print() – Displays output to the screen.
4. print("Hello, world!")
 5. Combine text and variables using f-strings:
6. print(f"Hello, {name}")
7. Use int() or float() to convert input to numbers.
8. Escape characters like \n, \t are used in strings.
9. sep and end parameters in print() allow formatting.
10.I/O is essential for interaction in console-based programs.

5.2 Control Structures: Conditions and Loops

✅ Conditional Statements (if, elif, else):

1. Used to make decisions in code.

2. Syntax:
3. if condition:
4. # code
5. elif condition:
6. # code
7. else:
8. # code
9. Conditions use comparison/logical operators.
[Link] is required (4 spaces by convention).
[Link] if statements are allowed.
[Link]-hand if expression: x = 10 if y > 5 else 0
[Link] deep nesting for better readability.

✅ Loops:

For Loop:

1. Used to iterate over a sequence (list, string, range, etc.).

2. for i in range(5):
3. print(i)
4. Can use break to exit early.
5. continue skips the current iteration.
6. range(start, stop, step) generates sequences.
7. Can be used with enumerate() to get index and value.
8. Nested loops are allowed.
While Loop:

1. Repeats as long as a condition is True.

2. while x < 5:
3. x += 1
4. Must ensure the condition will eventually be false (to avoid infinite loops).
5. Can also use break and continue.
6. Ideal when number of iterations is unknown beforehand.

5.3 Data Structures: Strings, Lists, Tuples, Dictionaries

✅ Strings:

1. Sequence of characters (immutable).

2. Created with quotes: 'hello' or "hello"
3. Supports indexing and slicing (s[0], s[1:4]).
4. Common methods: .upper(), .lower(), .replace(), .find()
5. Strings are iterable in loops.
6. Can be concatenated using + and repeated with *.
7. Use len() to find length.

✅ Lists:

1. Ordered, mutable collection (e.g., [1, 2, 3]).

2. Supports indexing, slicing, nesting, and iteration.
3. Methods: append(), insert(), pop(), remove(), sort(), reverse()
4. Can contain mixed data types.
5. List comprehensions provide compact syntax:
6. squares = [x*x for x in range(5)]
7. Use len() to get number of elements.
8. Lists are dynamic (can grow/shrink in size).
✅ Tuples:

1. Ordered, immutable collection (e.g., (1, 2, 3)).

2. Faster than lists, used for fixed data.
3. Support indexing and slicing.
4. Can be nested and contain other data types.
5. Useful as dictionary keys (lists can't be keys).
6. Only methods available: count() and index().
7. Single-element tuple must have a comma: (1,)

✅ Dictionaries:

1. Unordered collection of key-value pairs.

2. student = {"name": "Alice", "age": 20}
3. Keys must be unique and immutable (strings, numbers, tuples).
4. Access values via keys: student["name"]
5. Methods: keys(), values(), items(), get(), update(), pop()
6. Supports dynamic updates (add/remove keys).
7. Useful for fast lookup and structured data.
8. Dictionary comprehension allows concise creation:
9. squares = {x: x*x for x in range(5)}

5.4 Functions and Modules: Definitions, Imports, Packages

✅ Functions:

1. Reusable blocks of code defined with def keyword.

2. def greet(name):
3. return f"Hello, {name}"
4. Can have parameters and return values.
5. Use return to send back a result; else returns None.
6. Function call: greet("Alice")
7. Default arguments: def func(x=10):
8. *args and **kwargs handle variable numbers of arguments.
9. Functions improve modularity and reduce code repetition.

✅ Imports (Modules):

1. Modules are files containing Python code (functions, variables).

 2. Use import module_name to use built-in or external modules.
3. Use from module import function to import specific parts.
4. Examples: math, random, datetime, os, sys
5. Custom modules can be created as .py files and imported.
6. Use dir(module) to list available functions/attributes.
7. Use as to create an alias: import numpy as np

✅ Packages:

1. A package is a collection of related modules in a folder.

2. Folder must contain an __init__.py file to be recognized as a package.
3. Packages allow hierarchical organization of modules.
4. Import modules from packages using dot notation:
5. from mypackage import mymodule
6. Many third-party packages can be installed via pip.
7. Examples: numpy, pandas, matplotlib, scikit-learn
8. Promotes code reuse and maintainability in large projects.
 MBA FT 609: Business Intelligence and Programming with Python

Unit VI
Exception Handling & Regular Expressions

Syllabus :-

6.1 Exception Handling: Raising, Assertion Error Exception; Handling Exceptions

using try - except block, the else- finally Clause.
6.2 Regular Expressions: Search, match, patterns, modifiers

6.1 Exception Handling

✅ Raising Exceptions:

1. Use the raise keyword to manually trigger an exception.

2. raise ValueError("Invalid input")
3. Helps handle logical errors before they crash the program.
4. Common raised exceptions: ValueError, TypeError, ZeroDivisionError.
5. Can raise custom messages for clarity.
6. Can be used to enforce constraints (e.g., input validation).
7. Useful in large programs to maintain control over errors.
8. Raising can also propagate exceptions to higher-level functions.

✅ AssertionError Exception:

1. assert statement checks if a condition is True.

2. assert x > 0, "x must be positive"
 3. If the condition is False, it raises an AssertionError.
4. Useful during testing and debugging.
5. Helps detect bugs early in development.
6. Optional message explains the failure.
7. Assertions can be disabled in optimized mode (with -O).
8. Should not be used for user input validation in production.

✅ Handling Exceptions using try-except block:

1. try-except is used to catch and handle runtime errors gracefully.

2. try:
3. x=1/0
4. except ZeroDivisionError:
5. print("Cannot divide by zero")
6. Prevents program from crashing on exceptions.
7. Can handle multiple exceptions with multiple except blocks.
8. except can catch specific or all exceptions.
9. Error object can be accessed using except Exception as e.
[Link] isolate risky code and respond accordingly.
[Link] practice to catch only expected exceptions.

✅ The else Clause:

1. Placed after all except blocks.

2. Executes only if no exception occurs in the try block.
3. Used for code that should run only if try succeeds.
4. try:
5. x=5/1
6. except:
7. print("Error")
8. else:
9. print("Success")
[Link] code clarity and separation of logic.
[Link] mandatory but enhances structure.
[Link] avoid placing too much logic in the try block.
✅ The finally Clause:

1. Code inside finally always runs, no matter what.

2. Used for cleanup actions like closing files or releasing resources.
3. Syntax:
4. try:
5. # code
6. except:
7. # handle error
8. finally:
9. # cleanup code
[Link] even if exception is unhandled or raised again.
[Link] resources like file handles or DB connections are closed.
[Link] used in file I/O and network programming.
[Link] reliability to code execution flow.

6.2 Regular Expressions (Regex)

✅ Search:

1. [Link]() looks for the first match anywhere in the string.

2. [Link]("cat", "A black cat sat")
3. Returns a match object if found, else None.
4. Useful for finding patterns in large texts.
5. Can be combined with group() to extract matched content.
6. Common for form validation, log scanning, etc.
7. Faster than scanning manually using loops.
8. Can include complex patterns using metacharacters.

✅ Match:

1. [Link]() checks for a match only at the beginning of the string.

2. [Link]("Hello", "Hello World") # Match
3. Returns None if pattern is not at the start.
4. Often used when exact start is expected (e.g., file headers).
5. Returns match object with methods like .group() and .start().
 6. Use [Link]() to match the entire string.
7. Faster than search() for fixed-position checks.
8. Case-sensitive by default unless modified.

✅ Patterns (Metacharacters):

1. . – Matches any character except newline.

2. * – Matches 0 or more repetitions.
3. + – Matches 1 or more repetitions.
4. ? – Matches 0 or 1 occurrence.
5. [] – Matches any one character in brackets (e.g., [abc]).
6. ^ – Matches start of string; $ – Matches end of string.
7. \d, \w, \s – Match digits, word chars, whitespace respectively.

✅ Modifiers (Flags):

1. [Link] / re.I – Case-insensitive match.

2. [Link] / re.M – Makes ^ and $ match at line boundaries.
3. [Link] / re.S – Makes . match newline too.
4. Combine multiple flags using |:
5. [Link]("pattern", text, re.I | re.M)
6. Flags modify how patterns behave — useful for flexible matching.
7. Improve readability and reusability of regex code.
8. Flags are passed as optional third arguments in regex functions.