Various essays A genre of writing arguing that Excel's dominance is not a failure of the status quo but reflects genuine, irreplaceable strengths. Worth reading to sharpen your thinking about when *not* to use Python. → Further Reading — Chapter 1: Why Python? The Business Case for Coding
"How to Detect Outliers in Machine Learning"
Jason Brownlee, Machine Learning Mastery A clear, practical walkthrough of IQR and z-score outlier detection with Python code. While the context is machine learning, the techniques are identical to what you use in business analytics. → Chapter 25 Further Reading: Descriptive Statistics for Business Decisions
Real Python realpython.com/python-virtual-environments-a-primer/ The most comprehensive beginner-friendly guide to virtual environments available. Read this after this chapter if the concept still feels fuzzy. → Further Reading — Chapter 2: Setting Up Your Python Environment
"Simpson's Paradox in Real Life"
Eric Topol, Nature Medicine (and numerous blog adaptations) The Berkeley admissions case (the most famous real-world example of Simpson's Paradox) has been written about extensively. Search for "Berkeley admissions Simpson's Paradox" to read the original story and several modern retellings with clea → Chapter 25 Further Reading: Descriptive Statistics for Business Decisions
Allen Downey, Probably Overthinking It blog A related statistical trap not covered in this chapter: why samples you draw are often biased toward overrepresenting high-frequency or high-visibility events. Relevant for any analyst trying to understand customer behavior from observed data. → Chapter 25 Further Reading: Descriptive Statistics for Business Decisions
**The model identifies 82% of churning accounts in advance** (based on held-out validation) - **The top 20 at-risk accounts represent $310,000 in ARR — accounts your team can reach before Q2 ends** → Case Study 34-01: Priya Builds the Acme Churn Predictor
TextBlob's `polarity` is a float from -1.0 (most negative) to +1.0 (most positive), with 0 being neutral. It is not a count of words (A), not a percentage (C), and not a readability measure (D). → Chapter 35 Quiz: Natural Language Processing for Business Text
1. C
Environment variables set outside the code are the correct approach. Hardcoding credentials (A) is dangerous. A `.env` committed to version control (B) exposes credentials. Comments (D) are still in the source code. → Chapter 24 Quiz: Connecting Python to Cloud Services
`pool_pre_ping=True` runs a lightweight "SELECT 1" test query before giving a connection to your code. If the connection has been dropped (cloud databases often drop idle connections), SQLAlchemy reconnects automatically rather than returning a broken connection. → Chapter 24 Quiz: Connecting Python to Cloud Services
10. B
`groupby(dt.month)["revenue"].mean()` groups all revenue observations by calendar month number and computes the average for each month, pooling across all years in the dataset. This reveals the seasonal pattern: which months are typically high and which are typically low. It does not compute trend c → Chapter 26 Quiz: Business Forecasting and Trend Analysis
10. c
`matplotlib.use("Agg")` selects the Agg backend, which renders to in-memory bitmaps without needing a GUI display. This is essential for server-side and scheduled execution where no screen is available. → Chapter 36 Quiz: Automated Report Generation
100 hours per year
for one person. If Priya can write the script in 4 hours, the ROI is a 25:1 ratio in the first year alone, with zero additional investment in subsequent years. → Chapter 17: Automating Repetitive Office Tasks
10:00 AM
Opens python.org, downloads the Python 3.12 installer. Runs it. Remembers to check "Add Python to PATH" at the bottom of the installer screen (she'd read that this matters). → Case Study 2.1: Priya Sets Up Her Work Laptop
Installs the core packages: ```bash pip install pandas matplotlib seaborn openpyxl requests ``` Watches the packages install. The download takes about 2 minutes on the office Wi-Fi. → Case Study 2.1: Priya Sets Up Her Work Laptop
10:22 AM
Creates a new file: `hello_business.py`. Types the code from Section 2.5 (she types it rather than copying, following the book's advice). Runs it. → Case Study 2.1: Priya Sets Up Her Work Laptop
10:28 AM
Stares at the output. It worked. She wrote something and the computer did exactly what she told it to. It's a small thing, but it doesn't feel small. → Case Study 2.1: Priya Sets Up Her Work Laptop
The chapter explicitly describes the shared-password session approach as appropriate for internal intranet tools with controlled network access, while noting it is not suitable for public-facing applications, applications with PII, or those requiring audit logging. Flask-Login (B) and OAuth (A) are → Chapter 37 Quiz: Building Simple Business Applications with Flask
Bigram analysis would capture "not helpful" as a single distinct phrase, distinguishing it from "very helpful" or just "helpful." This is a key advantage of n-gram analysis over single-word frequency analysis. → Chapter 35 Quiz: Natural Language Processing for Business Text
12. d
Both a cron job and a systemd timer are valid, standard approaches. Cron is simpler and more common; systemd timers offer more control and better logging integration. The `schedule` library in option a also works but requires a persistent running process. → Chapter 36 Quiz: Automated Report Generation
12. False
`load_dotenv()` does NOT override existing environment variables by default. This is intentional: production servers set real credentials in their environment, and `load_dotenv()` will not clobber them. You can force overriding with `load_dotenv(override=True)`. → Chapter 24 Quiz: Connecting Python to Cloud Services
13. B
Stemming applies algorithmic rules to chop word endings (fast but crude — "ran" does not stem correctly to "run"). Lemmatization uses a dictionary (vocabulary) and morphological analysis to find the actual base form, handling irregular forms correctly. Both work on all word types with appropriate PO → Chapter 35 Quiz: Natural Language Processing for Business Text
13. False
R-squared measures how well the trend explains historical variation, not how accurately it will forecast the future. A very high R-squared means the trend fits the past well, but the future can always diverge due to structural changes, unexpected events, or simply because the historical period was u → Chapter 26 Quiz: Business Forecasting and Trend Analysis
13. True
AWS Lambda functions have a maximum execution time of 15 minutes (900 seconds). If your task requires more time, you need a different solution such as an EC2 instance, ECS container, or Step Functions workflow. → Chapter 24 Quiz: Connecting Python to Cloud Services
14. C
LDA topic modeling discovers latent thematic structures in a collection of documents without predefined categories. Keyword classification requires predefined categories and their keywords. NER extracts specific named entities. Sentiment analysis scores emotional direction — it does not discover top → Chapter 35 Quiz: Natural Language Processing for Business Text
14. True
Service accounts have their own Google identity (an email address). The sheet must be explicitly shared with that email address, just as you would share it with a human colleague. Without this sharing step, the script receives a SpreadsheetNotFound error. → Chapter 24 Quiz: Connecting Python to Cloud Services
15. B
74% accuracy means 26% of tickets are misclassified. For a fully automated system handling thousands of tickets daily, that misclassification rate would create significant problems. The appropriate recommendation is to use the classifier as a routing aid with human review for low-confidence predicti → Chapter 35 Quiz: Natural Language Processing for Business Text
15. False
The computation runs on actual server hardware in AWS or Google data centers. "Serverless" means you do not manage the servers — the cloud provider handles provisioning, scaling, and maintenance. The hardware still exists. → Chapter 24 Quiz: Connecting Python to Cloud Services
15. True
`statsmodels.tsa.holtwinters.Holt` has an `optimized=True` parameter (the default) that uses maximum likelihood estimation to find the smoothing parameters (alpha for level, beta for trend) that best fit the historical data. You can also specify parameters manually if you have a business reason to p → Chapter 26 Quiz: Business Forecasting and Trend Analysis
16. B
`ngram_range=(1, 2)` tells TfidfVectorizer to analyze text at both the unigram (single word) level AND the bigram (2-word phrase) level simultaneously. This is more informative than either level alone. → Chapter 35 Quiz: Natural Language Processing for Business Text
16. False
`os.environ.get("MY_KEY")` returns `None` silently, not an error. The error will typically occur later, when code tries to use `None` as a string or pass it to an API call. This is why explicit validation (checking for `None` and raising a helpful error) is a recommended pattern. → Chapter 24 Quiz: Connecting Python to Cloud Services
16. True
Template inheritance is specifically designed for this: the base template defines the shared structure (header, footer, CSS), and child templates fill in the unique content blocks. → Chapter 36 Quiz: Automated Report Generation
17. B
Sarcasm like "Oh, wonderful, another delay" contains positive words that lexicon-based systems misclassify as positive. TextBlob does not require labeled data for sentiment (C is false) — it uses a pre-built lexicon. It can process long text (A is false). It is designed for English generally, not ju → Chapter 35 Quiz: Natural Language Processing for Business Text
17. False
For a 12-element series with `rolling(window=4).mean()`, the result will have NaN for the first 3 positions (indices 0, 1, 2) and non-NaN values for indices 3 through 11 — that is 9 non-NaN values, not 4. The first valid window covers indices 0–3, the second covers 1–4, and so on through indices 8–1 → Chapter 26 Quiz: Business Forecasting and Trend Analysis
17. True
A worksheet created via the API is a standard Google Sheets worksheet. Other users with access to the spreadsheet can view, filter, sort, export, and work with it exactly as they would any other sheet. The API is just an alternative creation method. → Chapter 24 Quiz: Connecting Python to Cloud Services
18.
`{{ expression }}` outputs the value of an expression into the rendered document. Use it to display data: `{{ company_name }}`, `{{ revenue | currency }}`, `{{ regions | length }}`. The expression is evaluated and its string representation is inserted at that position. - `{% statement %}` controls t → Chapter 36 Quiz: Automated Report Generation
18. C
Named entity recognition with the `ORG` entity type extracts company and organization names from text. This is precisely the use case NER is designed for. TF-IDF would surface frequent terms but cannot reliably distinguish between "Apple" the company and "apple" the fruit without entity classificati → Chapter 35 Quiz: Natural Language Processing for Business Text
19. B
`min_df` stands for "minimum document frequency." Setting it to 3 means a word must appear in at least 3 documents to be included in the vocabulary. This filters out rare words that are unlikely to generalize. `max_df` is the parameter for excluding words that appear in too many documents (D describ → Chapter 35 Quiz: Natural Language Processing for Business Text
2. B
`load_dotenv()` reads a `.env` file and injects its key-value pairs into the process environment via `os.environ`. It does not communicate with AWS (A), create files (C), or encrypt data (D). → Chapter 24 Quiz: Connecting Python to Cloud Services
2. C
`rolling(window=4).mean()` requires 4 values in the window before it can compute a result. For the first three observations, there are fewer than 4 preceding values, so the result is `NaN`. This is expected and correct behavior, not an error. → Chapter 26 Quiz: Business Forecasting and Trend Analysis
2. D
Both A and C create valid routes, but C provides automatic type conversion. If you visit `/client/42/report`, both routes match. However, `` automatically converts `"42"` to the integer `42`, and returns a 404 automatically if the segment is not a valid integer (e.g., `/client/abc/rep → Chapter 37 Quiz: Building Simple Business Applications with Flask
The data supports the interpretation that the Monday spike is a weekend order processing artifact: customers place orders Thursday-Sunday, carriers have reduced Sunday service, and customers who see no movement in tracking by Monday morning contact support. This is an operational insight about order → Chapter 35 Quiz: Natural Language Processing for Business Text
3. B
TF-IDF (Term Frequency-Inverse Document Frequency) converts text to numerical vectors where words that are frequent in a specific document but rare across the collection get higher scores. This weights distinctive terms more heavily than common ones. Stopword removal is a separate step (A); TfidfVec → Chapter 35 Quiz: Natural Language Processing for Business Text
3. C
`os.environ.get()` returns `None` by default when the variable is not present. This is why validation is essential — `None` will cause confusing errors later if not caught. To raise an error immediately, use `os.environ["KEY"]` (which raises `KeyError`) or validate explicitly. → Chapter 24 Quiz: Connecting Python to Cloud Services
A script that monitors stock levels in Acme's inventory database and emails Marcus and the warehouse manager when any SKU falls below reorder point. It prevented three stockout situations in Q3 and paid for itself in the first month. → Case Study 40-A: Priya Okonkwo — Eighteen Months of Python at Acme Corp
4. B
Labeled data should be used to train a classifier. Using keyword rules ignores the advantage of having labels. LDA operates on unlabeled data but does not use the labels you already have. Sentiment analysis categorizes positive/negative — not support topics. → Chapter 35 Quiz: Natural Language Processing for Business Text
4. C
A presigned URL grants temporary, time-limited access to a private object without requiring AWS credentials. Making the bucket public (A) exposes all objects to anyone forever. Giving Sandra an AWS account (B) is administrative overhead for a simple sharing need. Sharing access keys (D) is a serious → Chapter 24 Quiz: Connecting Python to Cloud Services
R-squared = 0.25 means the linear trend accounts for 25% of the total variation in revenue. The remaining 75% is unexplained by the trend (it is seasonality, noise, or other factors). R-squared does not represent probability (B), growth rate (C), or average error (D). → Chapter 26 Quiz: Business Forecasting and Trend Analysis
5. B
S3 is a flat object store. Keys can contain slashes, and tools like the AWS Console display these as folders for convenience, but no actual folder structure exists. You do not need to create folders before uploading (C), and slashes in keys are not constrained to global uniqueness (D). → Chapter 24 Quiz: Connecting Python to Cloud Services
Priya's most technically ambitious project: a logistic regression model trained on 18 months of customer transaction data that scores each active account on churn probability. Sandra considers it the most valuable analytics tool the company has ever had. The model has correctly flagged four accounts → Case Study 40-A: Priya Okonkwo — Eighteen Months of Python at Acme Corp
6. B
The `Prefix` parameter filters the listing to only return objects whose keys start with the given string. This simulates "listing a folder" by using the folder path as the prefix. → Chapter 24 Quiz: Connecting Python to Cloud Services
6. C
Flask serves static files from the `static/` directory. Reference them in templates with `url_for('static', filename='...')`. Option A (CSS in Python strings) works technically but is unmaintainable. Option B would create a path that Flask does not know to serve. Option D is false. → Chapter 37 Quiz: Building Simple Business Applications with Flask
Opens each of the four CSV files. Notes immediately that Nashville exported with column headers in a different order than usual. (This happens roughly once a month.) → Case Study 1.1: Priya's Monday Morning
7. B
Calculation: $45,000 × 1.96 × √3 = $45,000 × 1.96 × 1.732 ≈ $152,860 ≈ $153,000. The formula is `z_score × std_error × sqrt(horizon)`. For the 1-quarter-ahead forecast the margin is $45,000 × 1.96 × 1 ≈ $88,200, so (A) is the 1-period band, not the 3-period band. → Chapter 26 Quiz: Business Forecasting and Trend Analysis
7. C
AWS allows presigned URLs to be valid for up to 7 days (604,800 seconds). For most business use cases, 24–48 hours is appropriate to balance convenience and security. → Chapter 24 Quiz: Connecting Python to Cloud Services
7:00 AM
Opens the "master" Excel workbook, which she built by hand six months ago. Copies the data from each CSV into the appropriate sheet, making sure to paste as "values only" to avoid breaking the formulas. → Case Study 1.1: Priya's Monday Morning
Refreshes the pivot tables. One of them breaks — the pivot table source range needs to be extended to include the new rows. Updates the range. → Case Study 1.1: Priya's Monday Morning
7:35 AM
Checks the week-over-week totals manually against last week's numbers. They're $47,000 higher than expected. Investigates. Finds that a large Chicago order was entered with a date two weeks in the past, causing it to appear in this week's data even though it's not a new sale. → Case Study 1.1: Priya's Monday Morning
Holt's Linear Trend method is specifically designed for data with a trend but no seasonality. It models both the current level and the current trend direction, making it appropriate when consistent growth is present. SES (A) would underperform on trending data because it ignores the trend component. → Chapter 26 Quiz: Business Forecasting and Trend Analysis
8. C
Writing all rows in a single `update()` call is one API request regardless of row count. Cell-by-cell writes (B) would consume hundreds of requests for a 50-row table. Sleeping (A) wastes time unnecessarily. Creating new spreadsheets (D) does not help. → Chapter 24 Quiz: Connecting Python to Cloud Services
Formats the report: column widths, number formats, color coding for regions that hit quota (green) vs. those that missed (red). → Case Study 1.1: Priya's Monday Morning
A professional forecast must include a confidence interval or range to communicate uncertainty, and explicit model assumptions and limitations so stakeholders understand what the model is and is not capturing. Source code (A) is irrelevant to executives. Competitor comparisons (C) are often unavaila → Chapter 26 Quiz: Business Forecasting and Trend Analysis
9. C
SQLAlchemy abstracts the database driver. Change `sqlite:///local.db` to `postgresql://user:pass@host/db` in the connection string and the same query code runs against either database. The SQL syntax (A) may need minor adjustments for complex queries, but basic CRUD is identical. → Chapter 24 Quiz: Connecting Python to Cloud Services
9. d
Both `page-break-before: always` (the older CSS2 property) and `break-before: page` (the newer CSS3 property) are correct. WeasyPrint supports `page-break-before: always`. → Chapter 36 Quiz: Automated Report Generation
Train the model. Give it your training data (features `X` and labels `y`). The model learns from this data and stores what it learned internally. For unsupervised methods, `.fit(X)` takes only features. → Chapter 33: Introduction to Machine Learning for Business
Like `.groupby()` but specifically for time-indexed Series or DataFrames. Supports resampling to any frequency ("D" for daily, "W" for weekly, "ME" for month-end, "QE" for quarter-end). Covered in the pandas Time Series documentation. → Chapter 13 Further Reading and Resources
this is a **decorator**, a Python feature that wraps a function with additional behavior. Here, it registers the function below it as the handler for the URL path `/`. When Flask receives a request for `/`, it calls `index()` and returns whatever that function returns as the HTTP response. → Chapter 37: Building Simple Business Applications with Flask
`app = Flask(__name__)`
creates an instance of the Flask application. The `__name__` argument tells Flask where to find templates and static files relative to this file. When this file is run directly, `__name__` equals `"__main__"`. When it is imported as a module, `__name__` is the module name. Flask uses this to resolve → Chapter 37: Building Simple Business Applications with Flask
Complete end-to-end ML workflow: data loading, splitting, training, evaluation, and interpretation for a customer churn classification problem - **`case-study-01.md`** — Priya frames the churn prediction problem at Acme Corp before writing a single line of code - **`case-study-02.md`** — Maya walks → Chapter 33: Introduction to Machine Learning for Business
a standard Python function that returns a string. Flask sends that string back as the response body. Returning a string causes Flask to set the `Content-Type` header to `text/html`, so the browser renders it as HTML (or plain text, depending on the content). → Chapter 37: Building Simple Business Applications with Flask
6 projects have no hours logged. This is a problem. Every project should have hours recorded. She suspects these are early projects where she did not track time carefully, or perhaps projects that were very short and she forgot to log. → Case Study 11-2: Maya Explores Her Project and Customer Data
`if __name__ == "__main__": app.run(debug=True)`
runs the development server when this file is executed directly. The `debug=True` parameter enables two important features: automatic reloading when you save file changes (no need to restart the server), and the interactive debugger in the browser if your code raises an exception. → Chapter 37: Building Simple Business Applications with Flask
A CSV file she has maintained in a spreadsheet and periodically exports. Contains all client projects since she started freelancing: project name, client, start date, end date, status, hours logged, hourly rate, and total billed. → Case Study 11-2: Maya Explores Her Project and Customer Data
`on_bad_lines`
A `pd.read_csv` parameter controlling behavior for lines with incorrect field counts. `"error"` raises an exception; `"skip"` drops the malformed row silently; `"warn"` drops it with a warning. → Chapter 16 Key Takeaways: Excel and CSV Integration
`os.environ.get("KEY")` vs. `os.environ["KEY"]`:
`.get()` returns `None` if the variable is not set (use for optional variables) - `["KEY"]` raises a `KeyError` if the variable is not set (use for required variables) - `load_dotenv()` does not override variables already set in the environment — this is intentional and correct → Chapter 19 Key Takeaways: Email Automation and Notifications
`pd.crosstab()`
A convenience wrapper around `pd.pivot_table()` that automatically counts co-occurrences. Useful for frequency tables and contingency tables. → Chapter 13 Further Reading and Resources
`pd.cut()` and `pd.qcut()`
Bin continuous variables into discrete categories. `pd.cut()` uses fixed bin edges; `pd.qcut()` uses quantiles to ensure equal-frequency bins. → Chapter 13 Further Reading and Resources
`plotly`
Interactive versions of the charts built in this chapter. Particularly effective for the cohort heatmap (which benefits from hover-over tooltips showing exact retention numbers) and the customer scatter plot. ``` pip install plotly ``` → Further Reading: Chapter 27 — Customer Analytics and Segmentation
`prepare_transactions()` as a reusable function
applying it to both weeks kept the logic consistent and the code DRY (Don't Repeat Yourself). 2. **Left merge** — keeping all transactions even if the customer master had a gap, and then explicitly checking for unmatched rows. 3. **Named aggregations in `.agg()`** — self-documenting column names tha → Case Study 13-1: Priya Builds the Weekly Regional Report
A pandas extension that provides cleaner, more readable data transformation syntax. Particularly useful for the ETL work that precedes most marketing analytics (cleaning UTM parameters, standardizing channel names, etc.). → Further Reading: Chapter 31 — Marketing Analytics and Campaign Analysis
`pymc`
Bayesian statistical modeling. For teams that want to move beyond frequentist p-values toward probability distributions over conversion rate lifts. The Bayesian approach naturally solves the peeking problem by treating posterior distributions rather than point estimates. → Further Reading: Chapter 31 — Marketing Analytics and Campaign Analysis
You used this in the chapter. It is worth exploring the full documentation. The `norm`, `chi2_contingency`, `ttest_ind`, and `mannwhitneyu` functions cover the majority of statistical tests you will need for marketing work. → Further Reading: Chapter 31 — Marketing Analytics and Campaign Analysis
`seaborn`
The `heatmap()` function used for cohort visualization. Also useful for distribution plots of RFM score components and segment-level comparisons. ``` pip install seaborn # Usually included with the Anaconda distribution ``` → Further Reading: Chapter 27 — Customer Analytics and Segmentation
"Run this every Monday at 6 AM" via Amazon EventBridge - **An S3 event** — "A new file was uploaded to this bucket" - **An API call** — via API Gateway - **Many other AWS services** → Chapter 24: Connecting Python to Cloud Services
Account features (context):
`account_age_days` — tenure (longer = more loyal on average) - `plan_type` — enterprise customers churn less than basic - `contract_value` — high-value accounts may get more proactive attention → Case Study 33-01: Priya Frames the Churn Prediction Problem
Acme Corp
A mid-sized regional distributor of office supplies. We'll use their sales data, inventory records, and customer database across multiple chapters to ground every technique in a real context. - **Maya's Consulting Tracker** — Maya is a freelance business consultant who tracks her projects, invoices, → Python for Business for Beginners
acme_inventory.db
The SQLite database from Chapter 23, containing current stock levels, reorder parameters, and supplier information for Acme's product catalog - **acme_sales_2023.csv** — The sales transaction file from Chapter 11, which tells you how fast products are actually moving - Supplier lead time records emb → Chapter 32: Inventory and Supply Chain Analytics
You have learned the fundamentals. The next level includes MultiIndex DataFrames, advanced groupby operations (custom aggregations, named aggregations), window functions (rolling, expanding), and performance optimization with categorical dtypes and chunked reading for files too large to fit in memor → Chapter 40: Building Your Python Business Portfolio
Multi-table dataset with listings, reviews, and calendar data. Requires multiple merge operations to combine into an analysis-ready DataFrame. → Chapter 13 Further Reading and Resources
Your Python source files - `requirements.txt` - `README.md` - Sample data (small, anonymized or synthetic) - Configuration templates — the structure without the secrets → Chapter 40: Building Your Python Business Portfolio
Always open CSV files with `newline=""`
prevents blank-row bugs from newline translation - `csv.reader` — rows as lists; positional access only; brittle when columns change - `csv.DictReader` — rows as dicts keyed by header; recommended for all business use - `csv.writer` — write rows as lists - `csv.DictWriter` — write rows as dicts; req → Chapter 9 Key Takeaways: File I/O — Reading and Writing Business Data
lists, ranges, strings, dictionary items, tuples, and more. - The loop variable (e.g., `for invoice in invoices`) is created by the `for` statement and holds one item per iteration. - The loop body executes once for each item. When the sequence is exhausted, the loop ends. - For loops are the right → Key Takeaways — Chapter 5: Loops and Iteration
Apache Airflow
A workflow orchestration platform for scheduling, monitoring, and managing data pipelines. When your pipelines need to run on schedules, depend on each other, and retry on failure, Airflow manages all of that. It is the standard tool for production data engineering. → Chapter 40: Building Your Python Business Portfolio
API Reference → DataFrame
When you want to know "does pandas have a method that does X?", the API reference is the authoritative answer. You do not read it cover-to-cover; you search it when you have a specific question. → Further Reading and Resources: Chapter 10
a more powerful Python library that supports cron expressions, persistent job stores, timezone-aware scheduling, and running multiple jobs concurrently. Best for more complex scheduling requirements within Python. → Chapter 22: Scheduling and Task Automation
Chapter 16 — Generates and emails invoices monthly without manual intervention 2. **Scheduled reporting pipeline** — Chapter 22 — Runs data aggregation and PDF generation on schedule 3. **SQLite project database** — Chapter 23 — Replaces CSV files with a properly structured relational database 4. ** → Case Study 37-2: Maya Builds the Client-Facing Project Status Portal
Automated price change alerts
the script emails Marcus when any competitor price changes by more than 5% - **A full price history** in `competitor_prices.csv` showing when each price changed - **A comparison dashboard** (simple CSV fed into a chart) showing Acme's position relative to competitors → Case Study 20-1: Acme Corp Competitor Price Monitoring
If a form submission triggers a long-running operation (generating a PDF, calling a slow API), Flask will hold the HTTP connection open until the operation completes. Celery or RQ are task queue solutions for this. → Chapter 37: Building Simple Business Applications with Flask
Always start the y-axis at zero. A truncated y-axis makes small differences look enormous and is one of the most common ways charts mislead. - Sort bars by value (descending) unless category order carries inherent meaning (e.g., time periods, ordinal scales). - Remove the top and right spines (`ax.s → Chapter 14: Introduction to Data Visualization with matplotlib
Base64 encoding
A method of encoding binary data as ASCII text. Used to embed PNG chart images directly in HTML without external file references. → Chapter 36: Automated Report Generation
BCC works differently than To and CC:
To and CC addresses go in message headers — everyone can see them - BCC addresses go in the `to_addrs` parameter of `sendmail()` only — never in a header - Using `send_message()` will miss BCC recipients because it reads addresses from headers → Chapter 19 Key Takeaways: Email Automation and Notifications
`logins_last_7_days` — recent engagement - `logins_last_30_days` — medium-term engagement - `logins_last_90_days` — long-term engagement - `login_trend` — ratio of last 30 days to 90-day average (is engagement increasing or declining?) - `features_used_last_30_days` — depth of product adoption - `se → Case Study 33-01: Priya Frames the Churn Prediction Problem
everything indented beneath the `if` line — runs only when the condition is satisfied. If the condition is `False`, Python skips the block entirely and continues with the next unindented line. → Chapter 4: Control Flow — Making Decisions in Your Programs
Bokeh
Another interactive visualization library. Better suited for large datasets (handles streaming data) but has a steeper learning curve than plotly. → Chapter 14 Further Reading and Resources
BOM (Byte Order Mark)
A sequence of bytes at the start of a file that indicates the encoding. The `utf-8-sig` encoding reads and writes a UTF-8 BOM, which Excel requires to auto-detect UTF-8 encoding when opening CSV files. → Chapter 16 Key Takeaways: Excel and CSV Integration
`"N/A"` cannot be converted by `.astype(float)` — it will raise a `ValueError`. Use `pd.to_numeric()` with `errors="coerce"` instead: ```python df["revenue"] = df["revenue"].str.replace("$", "", regex=False) df["revenue"] = df["revenue"].str.replace(",", "", regex=False) df["revenue"] = pd.to_numeri → Chapter 12 Quiz: Cleaning and Preparing Data for Analysis
Bug 3
`"Inactive"` is not in `status_map`, so it becomes `NaN`. The final `isna().sum()` will print `1`, not `0`. Fix by adding `"Inactive"` to the map: ```python status_map = { "active": "Active", "ACTIVE": "Active", "Inactive": "Inactive", "inactive": "Inactive", } ``` → Chapter 12 Quiz: Cleaning and Preparing Data for Analysis
Business correlations worth measuring:
Marketing spend vs. new customer acquisitions - Average deal size vs. sales cycle length - Employee satisfaction score vs. customer satisfaction score - Temperature vs. sales of seasonal products → Chapter 25: Descriptive Statistics for Business Decisions
Business examples where RL appears:
Dynamic pricing (adjusting prices in real time based on demand signals) - Recommendation systems (learning which content or products to show to maximize engagement or purchases) - Supply chain optimization (learning ordering policies to minimize cost and stockouts) - Automated trading systems → Chapter 33: Introduction to Machine Learning for Business
Typical deal size (especially with enterprise outliers) - Typical customer support wait time (especially with complex cases skewing the mean) - Typical employee tenure (especially in a company with a few 20-year veterans) → Chapter 25: Descriptive Statistics for Business Decisions
Business use cases for the mode:
Most common product ordered (great for inventory decisions) - Most common support issue type (great for identifying training needs) - Most common payment method (great for checkout optimization) → Chapter 25: Descriptive Statistics for Business Decisions
Converting string columns with low cardinality (e.g., "region", "tier") to `pd.CategoricalDtype` can dramatically speed up groupby operations on large DataFrames. → Chapter 13 Further Reading and Resources
Caveats:
Feature importances reflect predictive power in the training data, not causal relationships - Highly correlated features split importance between them — one may appear unimportant even if it is not - Use importances to guide investigation, not as final business conclusions → Chapter 34: Key Takeaways — Predictive Models: Regression and Classification
Chapter 11 (Reading Real Data)
This chapter built DataFrames by hand from Python dictionaries. In real work, you will load data from CSV files, Excel workbooks, and databases. Chapter 11 covers `pd.read_csv()`, `pd.read_excel()`, handling missing values, and fixing data type issues. → Key Takeaways: Chapter 10 — Introduction to pandas
Chapter 12 (Grouping and Aggregation)
The `groupby()` method unlocks category-level summaries: "total revenue by region," "average margin by product category," "count of projects by status." This is where pandas goes from a data viewer to a genuine analytical engine. → Key Takeaways: Chapter 10 — Introduction to pandas
Full RFM analysis with two-dimensional segment maps, automated targeting lists, and customer lifetime value modeling - **Chapter 29** — Financial analytics: connecting sales data to P&L, contribution margin, and break-even analysis - **Chapter 31** — Building interactive dashboards with Plotly and D → Further Reading: Chapter 28 — Sales and Revenue Analytics
Chapter 9 (Functions)
The functions you write in Chapter 9 become more useful when they accept and return DataFrames. Many of the analysis patterns here (filter → calculate → summarize) are natural candidates for encapsulation as functions. → Key Takeaways: Chapter 10 — Introduction to pandas
Two to four charts maximum — more than that and none of them get absorbed - Trend chart over time, regional or product breakdown, and one diagnostic chart - Every chart has a one-sentence takeaway caption written into the report → Chapter 36: Automated Report Generation
Chinook Database
A sample database representing a digital music store. Available at https://github.com/lerocha/chinook-database. Good for practicing queries against a more normalized, real-world-shaped schema. → Chapter 23 Further Reading: Database Basics
Choosing the right color map:
`"Blues"` — sequential, good for all-positive values - `"RdYlGn"` — diverging, good for values above/below a target (red=bad, green=good) - `"coolwarm"` — diverging, symmetric around zero - Add `_r` suffix to reverse any palette: `"Blues_r"` goes dark-to-light → Chapter 15: Advanced Charts and Dashboards with seaborn and plotly
Continuous Integration and Continuous Deployment. Automated systems that test code on every push (CI) and deploy passing code to production automatically (CD). → Chapter 38: Deploying Python to the Cloud
**Class A:** Top SKUs accounting for the first 80% of annual consumption value (typically 10-20% of SKUs) - **Class B:** Next SKUs accounting for the following 15% of value (typically 20-30% of SKUs) - **Class C:** Remaining SKUs accounting for the last 5% of value (typically 50-60% of SKUs) → Chapter 32: Key Takeaways — Inventory and Supply Chain Analytics
Classification:
Accuracy: proportion correct — misleading with class imbalance - Precision: of predicted positives, what fraction were correct — optimize when false alarms are costly - Recall: of actual positives, what fraction were caught — optimize when missing cases is costly - F1: harmonic mean of precision and → Chapter 33 Key Takeaways: Introduction to Machine Learning for Business
Robert C. Martin (Prentice Hall) A widely read reference on writing code that humans can understand. The chapter on meaningful names and the chapter on functions translate well to Python. Read critically — some advice is dated or overly prescriptive for a non-professional-developer audience. → Further Reading — Chapter 39: Python Best Practices and Collaborative Development
Clients
companies and individuals she works with 2. **Projects** — engagements for a client; a client can have multiple projects 3. **Invoices** — billing documents; one invoice can cover multiple projects or time periods 4. **TimeEntries** — individual work sessions; the raw source of truth for billable ho → Case Study 23-2: Maya Builds Her Business Database
Palantir Engineering (https://github.com/palantir/gradle-baseline/blob/develop/docs/best-practices/code-reviews/README.md) Detailed guidance on giving and receiving code review feedback in a professional context. The distinction between "nit" (style preference), "suggestion" (non-blocking), and "blo → Further Reading — Chapter 39: Python Best Practices and Collaborative Development
Cold start
The latency experienced when a serverless function (Lambda) or sleeping container (Render free tier) receives a request after a period of inactivity. → Chapter 38: Deploying Python to the Cloud
Commentary/Narrative
Human language explaining what happened and why - Can be partially auto-generated: "The Midwest region increased revenue 8.7% year-over-year. This follows three months of new territory expansion announced in Q3." - Flag anomalies explicitly: "Southeast revenue declined 2.1%. Investigation shows this → Chapter 36: Automated Report Generation
Forgetting `import datetime` — Python doesn't know what `datetime` is without it. - Writing `datetime.today()` instead of `datetime.date.today()` — the `today()` method lives on the `date` class inside the `datetime` module. → Answers to Selected Exercises
Company overview
industry, size, what they do 2. **Recent news** — anything significant in the last 30 days 3. **Financial context** — for public companies, key metrics that shape their business pressures 4. **Weather/logistics note** — if the company is in a city with current weather events, a quick note (useful fo → Case Study 21-2: Maya Researches Prospective Clients Before Every New Business Call
Component 1 — Invoice Generation
A `create_invoice.py` script that takes client name, email, amount, and description via command-line arguments - Generates a text-based invoice (plain text is fine) with a unique invoice ID (format: INV-YYYY-NNN) - Appends the new invoice to `invoices.csv` with status "unpaid" and a due date 30 days → Chapter 19 Exercises: Email Automation and Notifications
Component 1 — Market Scanner
Scrape all categories available on `https://books.toscrape.com/catalogue/category/books/index.html` - For each category, follow its link and scrape all books (all pages) - Total: approximately 1000 books across 50 categories - Rate limit appropriately — complete the full scrape in a single session w → Chapter 20 Exercises: Web Scraping for Business Intelligence
Component 2 — Payment Reminder Engine
Extends `payment_reminders.py` from Case Study 19-2 - Adds a fourth tier: "pre-due reminder" sent 3 days before the due date (friendly, not a warning) - Generates drafts for all tiers (pre-due, gentle, firm, final) - Adds an HTML version of each draft in addition to the plain text version → Chapter 19 Exercises: Email Automation and Notifications
Component 3 — Dashboard Email
A `billing_dashboard.py` script that reads `invoices.csv` and sends Maya a weekly summary email containing: - Total invoiced this month - Total collected this month - Collection rate percentage - List of outstanding invoices with days overdue - List of invoices collected this month → Chapter 19 Exercises: Email Automation and Notifications
Component 4 — Testing and Safety
A `--test-mode` flag on all scripts that uses a test recipient (your own email) instead of real clients - A `--dry-run` flag that prints output without sending anything - Proper error handling for all SMTP operations - A `README.txt` file (or printed help text) explaining how to set up the `.env` fi → Chapter 19 Exercises: Email Automation and Notifications
Component 5 — Scheduling and Logging
Add a `--run-log` flag that appends a summary of each run to `run_history.csv` - Add a `--dry-run` flag that generates the report without sending the email - Ensure all scraping includes rate limiting, error handling, and a polite user agent → Chapter 20 Exercises: Web Scraping for Business Intelligence
Construction
you build the message object, set headers, add a body 2. **Transmission** — you open a connection to the SMTP server, authenticate, and deliver → Chapter 19: Email Automation and Notifications
Container
A portable, isolated runtime environment that packages an application with all its dependencies. Built from an image, runs identically everywhere Docker is available. → Chapter 38: Deploying Python to the Cloud
if the customer has a negotiated contract price, use it (no other discounts apply) 2. **Promotional override** — if a product is on promotion, use the promotional price (no tier discount applies, but volume discounts still do) 3. **Tier + volume discount** — apply tier discount first, then volume di → Chapter 4 Exercises: Control Flow — Making Decisions in Your Programs
A SQL expression language that builds SQL programmatically with Python objects (closer to raw SQL) 2. **ORM** (Object-Relational Mapper) — Maps Python classes to database tables; you work with Python objects instead of SQL strings → Chapter 23: Database Basics — SQL and Python with SQLite and PostgreSQL
Core behaviors to internalize:
Zero-indexed. The first item is at position `0`. Negative indices count from the end: `list[-1]` is always the last item. - Slicing returns a sub-list: `list[start:stop]` where `start` is inclusive and `stop` is exclusive. - `.append()` adds one item to the end. `.extend()` merges another iterable i → Chapter 7 Key Takeaways: Data Structures
Core user flows work
Login with correct credentials → dashboard loads - Expense form submission → success page - Login with wrong credentials → error message (not crash) → Pre-Deployment Checklist
University of Virginia Part of the Business Analytics Specialization. Covers customer lifetime value, attribution, and market mix modeling with hands-on exercises. More academic than this chapter but provides the theoretical grounding behind the practical tools. → Further Reading: Chapter 31 — Marketing Analytics and Campaign Analysis
Did the company grow revenue by winning more customers or by selling more to existing customers? Both are valuable, but new customer acquisition signals market health while expansion of existing accounts signals product depth. If revenue grew 10% but customer count declined, the business may be incr → Chapter 28 Quiz: Sales and Revenue Analytics
The framework for building full analytical web applications in pure Python, built on top of Plotly. A Dash app is a genuine alternative to Tableau or Power BI for many internal analytics use cases. → Chapter 40: Building Your Python Business Portfolio
Data assets introduced:
`acme_sales_2023.csv` — introduced in Chapter 11 - `acme_inventory.db` — introduced in Chapter 23 - `acme_customers.xlsx` — introduced in Chapter 11 - **Key characters:** - **Sandra Chen** — VP of Sales, wants dashboards - **Marcus Webb** — IT manager, maintains legacy Excel system - **Priya Okonkwo → _continuity.md — Cross-Chapter Consistency Tracker
Data source confirmed
Where does the data come from? Database, API, CSV? - [ ] **Aggregation point identified** — Does Python aggregate, or does the query return pre-aggregated data? - [ ] **Template structure planned** — Executive summary first, then KPIs, then charts, then tables - [ ] **Parameterization designed** — W → Chapter 36 Key Takeaways: Automated Report Generation
Data Tables
Complete detail for readers who want it - Sortable in Excel; paginated in HTML - Footnotes explaining methodology or data sources → Chapter 36: Automated Report Generation
Data:
Data files are either in persistent storage or populated on first run - The application handles missing data gracefully (shows a warning rather than crashing) → Chapter 38: Deploying Python to the Cloud
Database migrations
Flask does not manage database schema changes. If you add a column to a database table, you handle that SQL yourself. Flask-Migrate (wrapping Alembic) handles this for SQLAlchemy-based apps. → Chapter 37: Building Simple Business Applications with Flask
A framework for transforming data in your data warehouse using SQL, with version control, testing, and documentation built in. Increasingly standard in modern analytics engineering stacks. → Chapter 40: Building Your Python Business Portfolio
dbt documentation
`docs.getdbt.com` — The official documentation for dbt (data build tool) is exceptionally well written and serves as a primary learning resource, not just a reference. The "Getting Started" tutorial takes about two hours and gives you a genuine sense of how dbt transforms analytics workflows. → Further Reading — Chapter 40: Building Your Python Business Portfolio
Decision guide in plain English:
You're including a chart in a **PDF report or print document**: use matplotlib or seaborn - You're doing **exploratory data analysis** and want to understand distributions and correlations: use seaborn - You're sharing a chart that **stakeholders need to explore**: use plotly (HTML) - You need a **p → Chapter 15: Advanced Charts and Dashboards with seaborn and plotly
Deliverables:
All four Python scripts - A sample `invoices.csv` with at least eight rows covering various states (paid, overdue, current) - A `.env.example` file showing required variables - Running all scripts in test mode without errors → Chapter 19 Exercises: Email Automation and Notifications
Write a one-page "How to Deploy" guide for a hypothetical second team member - Include: how to create a branch, how to test locally, how to push and verify CI, how to merge, how to watch the deployment, and how to roll back → Chapter 38 Exercises: Deploying Python to the Cloud
Deployment:
`FLASK_DEBUG=false` is set in the platform's environment variables - The deployment completes without errors in the platform's build log - The application responds at the production URL - The login flow works with production credentials → Chapter 38: Deploying Python to the Cloud
Dictionary
key-value pairs, accessed by key: - Use when you need to look something up by name or ID - Use when you have labeled data - Example: `{"customer_id": "C001", "name": "Acme", "revenue": 50000}` → Appendix D: Frequently Asked Questions
Containerization is how modern software is deployed reliably. A basic understanding of Docker lets you deploy your Python applications anywhere without "it works on my machine" problems — and lets others reproduce your environment exactly. → Chapter 40: Building Your Python Business Portfolio
`docs.docker.com` — The official documentation, which includes a "Getting Started" guide that explains containerization from first principles. For Python practitioners, the "Dockerize your app" guides for Flask and FastAPI applications are the most directly relevant starting points. → Further Reading — Chapter 40: Building Your Python Business Portfolio
"Docker Deep Dive" (Poulton) for understanding containers, networking, and volumes more thoroughly 2. **CI/CD for Python** — Real Python's GitHub Actions tutorial, then "Continuous Delivery" for the full methodology 3. **Production Flask** — "Flask Web Development" (Grinberg) for application structu → Chapter 38 Further Reading: Deploying Python to the Cloud
Docker:
`docker build` completes without errors locally - `docker run --env-file .env image-name` starts and the application responds at the mapped port - The container runs as a non-root user - Gunicorn (not Flask dev server) is the CMD → Chapter 38: Deploying Python to the Cloud
First line: one-sentence summary of what the function does - Args section: each parameter, its type, what it represents - Returns section: what the function returns and its type - Example (optional but very helpful for calculation functions) - Raises section if the function intentionally raises exce → Chapter 6: Functions — Building Reusable Business Logic
does not add newlines automatically
`.writelines(iterable)` — writes each string from an iterable; **also does not add newlines** - Mode `"w"` truncates (empties) the file on open — all previous content is gone - Mode `"a"` appends to the end; creates the file if it does not exist - Close the file after each individual write for criti → Chapter 9 Key Takeaways: File I/O — Reading and Writing Business Data
A configuration value provided to a running process through the operating system's environment, rather than through a file or code. → Chapter 38: Deploying Python to the Cloud
EOQ rules of thumb:
If your current order quantity is 2× or more the EOQ, you are likely over-ordering - If your current order quantity is less than 0.5× EOQ, you are likely ordering too frequently - EOQ is a benchmark, not a mandate — quantity discounts and min order requirements often justify deviations → Chapter 32: Key Takeaways — Inventory and Supply Chain Analytics
Implementation projects (only at higher rates, or for strategic relationships) - Nonprofit engagements (selective — limit to 1-2 per year as pro bono/relationship work, not core revenue) → Case Study 25-2: When Your Average Is a Lie
Three to five bullet points maximum - The most important numbers: total revenue, whether you hit your target, the biggest outlier - Written for someone who will read nothing else in the report - Auto-generate this from your data: "Revenue of $X.XM exceeded target by X%, driven by strong performance → Chapter 36: Automated Report Generation
Exercise 15-1 (key points):
Data must be reshaped to long format for `sns.barplot` with `hue`. Use `pd.DataFrame` with columns `["product", "quarter", "sales"]` or use `.melt()`. - `errorbar=None` prevents seaborn from drawing confidence intervals on aggregated single-observation data. → Chapter 15 Exercises: Advanced Charts and Dashboards
Exercise 15-12 (key points):
`fig.update_layout(yaxis2={"overlaying": "y", "side": "right"})` is the correct syntax for dual y-axes in graph objects. - The cumulative line is `df["revenue"].cumsum()`. → Chapter 15 Exercises: Advanced Charts and Dashboards
Exercise 15-14 (key points):
Each `go.Bar` trace has `visible=False` except the first. Dropdown buttons set `visible` to a list of booleans matching trace count. - Use `"method": "update"` (not `"restyle"`) when updating both data and layout simultaneously. → Chapter 15 Exercises: Advanced Charts and Dashboards
Exercise 15-7 (key points):
The deviation matrix: `deviation = (revenue_matrix - 110000) / 110000` - `sns.heatmap(..., center=0)` ensures zero maps to the center of the diverging palette. - Format annotations with `f"{v:+.0%}"` to show the `+` sign for positive values. → Chapter 15 Exercises: Advanced Charts and Dashboards
Exercise 16-10 (key points):
`ws["B3:F20"]` returns a tuple of row tuples. Each inner tuple is a sequence of Cell objects. Access `.value` on each cell. - The first element of `data` (index 0) is the header row. Subsequent elements are data rows. - This pattern is more reliable than `skiprows` when the layout is irregular. → Chapter 16 Exercises: Excel and CSV Integration
Exercise 16-13 (key points):
Read just the first line: `with open(filepath) as f: first_line = f.readline()` - Count tokens: `len(first_line.split(","))`, `len(first_line.split(";"))`, etc. - Edge case: a file with quoted values containing the delimiter will count incorrectly. The `csv.Sniffer` class handles this more robustly: → Chapter 16 Exercises: Excel and CSV Integration
Exercise 16-16 (key points):
Conditional formatting in openpyxl applies Excel's native formatting rules — the logic runs in Excel, not in Python. Python only writes the rule specification. - The `ColorScaleRule` `start_value`, `mid_value`, `end_value` with `type="percentile"` sets the color scale relative to the data range, so → Chapter 16 Exercises: Excel and CSV Integration
Exercise 16-3 (key points):
`utf-8-sig` writes a BOM (byte order mark, `\ufeff`) at the start of the file. Excel uses this to auto-detect UTF-8 encoding when opening CSV files directly. Without the BOM, Excel may interpret the file as the system default encoding, producing garbled characters. - When reading `utf-8-sig` files w → Chapter 16 Exercises: Excel and CSV Integration
The model performs no better than account manager intuition - The model is built but never integrated into the workflow - The model degrades after 6 months due to product changes and no one notices → Case Study 33-01: Priya Frames the Churn Prediction Problem
If you've used SQL before, Chapter 23 will feel familiar. If not, that chapter covers what you need from scratch. - **Some exposure to statistics** — If you've taken a stats course, Part 4 will move faster. If not, Chapter 25 starts from the beginning. - **Experience with any programming language** → Prerequisites
A modern, high-performance web framework for building APIs. If you train a model and want to serve predictions via a web endpoint that other applications can call, FastAPI is the current Python standard. → Chapter 40: Building Your Python Business Portfolio
saving outputs (reports, exports, processed data) somewhere accessible 2. **Shared data** — reading from and writing to data sources others maintain (Google Sheets, cloud databases) 3. **Automation** — triggering scripts on a schedule or in response to events, without manual intervention → Chapter 24: Connecting Python to Cloud Services
filter
a transformation applied to the variable value before it is output. Jinja2 has many built-in filters, and you can define your own. → Chapter 36: Automated Report Generation
Extrapolate existing trends using principled mathematical methods - Quantify the typical uncertainty in a prediction based on historical variance - Identify seasonal patterns and cyclical behavior - Provide a range of likely outcomes rather than a single point estimate → Chapter 26: Business Forecasting and Trend Analysis
Forecasting cannot:
Predict unprecedented events (recessions, pandemics, competitor actions) - Be more accurate than the data it is built on - Replace business judgment — it informs judgment - Give you certainty — it gives you probabilities and ranges → Chapter 26: Business Forecasting and Trend Analysis
Foreign keys create relationships
a column in one table holds the primary key of a row in another table. This is how you link customers to orders, orders to products, and products to categories. → Chapter 23 Key Takeaways: Database Basics
appearing in only two or three months of the year. Maya had been treating these as "active clients." Looking at the red-and-yellow heat map, they barely registered. They were project-based relationships masquerading as ongoing ones. Time to re-classify them — and think about whether to actively purs → Case Study 15-2: Maya's Revenue Heatmap and Hours-vs-Revenue Scatter
Four weeks after deployment:
Sandra had not sent Priya a "can you pull the sales numbers" message once - The finance team processed expenses 40% faster with the centralized log - Marcus had received zero support tickets about the application - Priya had shipped two minor updates (the regional comparison and expense approval sta → Case Study 37-1: Priya Builds the Acme Corp Internal Dashboard
freeze_panes
A worksheet property that makes a specific row and/or column remain visible while the rest of the sheet scrolls. The value is the first cell that is NOT frozen. → Chapter 16 Key Takeaways: Excel and CSV Integration
Full-text search
`tsvector`, `tsquery` for searching document content - **JSON columns** — store and query JSON data natively - **Window functions** — `ROW_NUMBER()`, `RANK()`, `LAG()`, `LEAD()` for analytical queries - **ENUM types** — restrict a column to a fixed set of values at the database level - **Concurrent → Chapter 23: Database Basics — SQL and Python with SQLite and PostgreSQL
Functional requirements:
Read all projects from `maya_projects.csv` that are marked "Invoiced" and have an invoice date in the current billing month - Group projects by client - Calculate the billed amount for each project (hours × rate, or fixed fee) - Generate one Excel invoice per client - Each invoice must contain: her → Case Study 16-2: Maya's Complete Invoicing System
functions
the mechanism for packaging your loop code into reusable, named units. The `generate_weekly_summary` function you saw in Case Study 1 is a preview of how functions transform a one-time script into a reusable tool. Once you can write loops and functions together, you have the core building blocks of → Chapter 5: Loops and Iteration — Automating Repetitive Tasks
G
Geographic fit:
Maya works remotely-first; local travel is acceptable - She requires virtual-first capability; if the client refuses to work remotely at all, it is a no-fit for her current practice model → Case Study 2: Maya's Project Intake Screening Tool
GET
retrieves data. Used when a user navigates to a URL. No side effects expected — the server should return the same data every time (given the same inputs). This is the default method for all Flask routes. → Chapter 37: Building Simple Business Applications with Flask
GitHub Actions CI workflow:
Runs tests with pytest - Checks code style with `flake8` (PEP 8 compliance) - Builds the Docker image and verifies it starts successfully - Runs the health check endpoint against the locally-started container - Fails fast: if any step fails, subsequent steps are skipped → Chapter 38 Exercises: Deploying Python to the Cloud
GitHub repository structure:
`main` branch → deploys to production automatically if CI passes - `staging` branch → deploys to staging automatically if CI passes - Feature branches → CI runs tests on push; no deployment → Chapter 38 Exercises: Deploying Python to the Cloud
GitHub's own documentation
`docs.github.com` — is the authoritative reference for everything GitHub-related. The "Getting Started" section covers everything from creating a repository to writing a good README to using GitHub Actions for automation. → Further Reading — Chapter 40: Building Your Python Business Portfolio
Available on GitHub. Wide-format time series data that must be melted into long format before analysis. A real-world use case for `.melt()`. → Chapter 13 Further Reading and Resources
Revenue growing while margins compress could mean the business is discounting more aggressively or product mix is shifting toward lower-margin items. If revenue grew 10% but gross margin grew only 3%, the business is actually less financially healthy despite the top-line growth. → Chapter 28 Quiz: Sales and Revenue Analytics
A chart that encodes a matrix of values as colors. Rows and columns are categorical; cell color represents the numeric value. Ideal for two-dimensional comparison across categorical axes. → Chapter 15 Key Takeaways: Advanced Charts and Dashboards
Herself
she needs operational charts to spot trends and make decisions 2. **Her accountant** — who wants a clean revenue breakdown for tax planning 3. **Potential clients** — to whom she sometimes shows a sanitized "portfolio overview" → Case Study 14-2: Maya Visualizes Her Consulting Business
Higher-level plot types
one function call produces what would take 15 lines of matplotlib 2. **Built-in statistical summaries** — bar plots show means with confidence intervals automatically 3. **Attractive default themes** — seaborn's default look is publication-ready without customization 4. **Tight pandas integration** → Chapter 15: Advanced Charts and Dashboards with seaborn and plotly
Tier 1 and 2 exercises can be completed in a Python file or directly in the Python REPL. - Tier 3 exercises require careful reading and analysis before writing code. - Tier 4 exercises should be completed as standalone `.py` files with sensible test data included. - Tier 5 exercises are open-ended d → Chapter 4 Exercises: Control Flow — Making Decisions in Your Programs
**Run whether user is logged on or not** — required for the task to run unattended - **Run with highest privileges** — needed for scripts that write to system directories or manage other processes - **Start in** (Working Directory) — set this to the directory containing your script; relative file pa → Chapter 22: Scheduling and Task Automation
prices can change monthly or more often - **Time-intensive** — half a day per cycle, consumed by mechanical work - **Error-prone** — manual transcription introduces mistakes - **No history** — a snapshot every quarter does not show trends → Case Study 20-1: Acme Corp Competitor Price Monitoring
Input data (per request):
`employee_name` (str) - `leave_type` ("vacation", "sick", "personal", "bereavement", "unpaid") - `days_requested` (int) - `days_balance_available` (float — current PTO balance) - `months_employed` (int) - `team_coverage_available` (bool — whether someone can cover their work) - `days_notice_given` ( → Chapter 4 Exercises: Control Flow — Making Decisions in Your Programs
The process of accessing each element in a sequence one at a time. - **Loop** — A control structure that repeats a block of code multiple times. - **for loop** — A loop that iterates over each element in a defined sequence. - **while loop** — A loop that repeats as long as a Boolean condition remain → Chapter 5: Loops and Iteration — Automating Repetitive Tasks
J
Jinja2
The most widely used Python templating engine. If you have used Flask, you have used Jinja2. It produces HTML from templates and data. - **weasyprint** or **reportlab** — Libraries that convert HTML to PDF, or build PDFs programmatically. - **matplotlib** — For chart generation. - **pandas** — For d → Chapter 36: Automated Report Generation
Both offer CSV datasets on business, economics, and government topics that you can import into SQLite for practice. Start with a topic you find interesting — the engagement makes the SQL practice stick. → Chapter 23 Further Reading: Database Basics
Top 20% of customers by revenue generated 74% of total billings - Northeast region margin improved 3.2 percentage points YoY - Three product categories accounted for 89% of margin erosion → [Project Name]
Key metrics displayed prominently, ideally with sparklines or mini-charts - Traffic-light coloring: green for on/above target, yellow for within 5%, red for below - Prior period comparisons alongside current values → Chapter 36: Automated Report Generation
Prewritten Python code you can use in your own programs (e.g., `pandas`, `matplotlib`) - **pandas** — The primary Python library for working with tabular data - **Open source** — Software whose source code is freely available and modifiable - **ROI (Return on Investment)** — The ratio of net benefit → Key Takeaways — Chapter 1: Why Python? The Business Case for Coding
Limitations explicitly stated:
"This model assumes recent growth rates continue. A macro shift — new competitor, supply disruption, economic contraction — is not captured." - "18 months of data is a relatively short history. A 3–5 year dataset would produce more reliable seasonality estimates." - "The confidence bands reflect his → Case Study 26-1: Priya Builds the Quarterly Sales Forecast
LinkedIn integration
If the prospect has a LinkedIn company page, scrape their recent updates (though LinkedIn's ToS requires care here) 2. **CRM integration** — If the company is already in Maya's client database, pull the history automatically 3. **Industry benchmarks** — Add industry-average margins and PE ratios so → Case Study 21-2: Maya Researches Prospective Clients Before Every New Business Call
List
ordered collection of items, accessed by position: - Use when order matters - Use when you have a sequence of similar things - Example: a list of sales records, a list of customer names → Appendix D: Frequently Asked Questions
`df = pd.read_csv("file.csv", parse_dates=[...], dtype={...}, na_values=[...])` 2. **Check dimensions** — `print(df.shape)` 3. **Visual inspection** — `print(df.head())` and `print(df.tail())` 4. **Check data types** — `print(df.dtypes)` 5. **Run .info()** — `df.info()` 6. **Statistical summary** — → Chapter 11 Quiz: Loading and Exploring Real Business Datasets
Log levels
messages are categorized by severity - **Timestamps** — every message is automatically timestamped - **Log files** — messages can be written to a file, not just the screen - **Structured output** — consistent format across your entire application - **Filtering** — in production, you can suppress DEB → Chapter 8: Error Handling — Writing Robust Business Applications
You are paying more to acquire customers than they are worth. This is existential. - **LTV:CAC 1:1 to 3:1** — You are acquiring customers profitably but likely not efficiently. - **LTV:CAC 3:1 to 5:1** — Generally considered healthy for a scaling business. - **LTV:CAC > 5:1** — You are probably unde → Chapter 31: Marketing Analytics and Campaign Analysis
added comprehensive error handling, logging to a file, and a failure notification function 2. **Moved credentials to environment variables** — the SMTP password and any API keys now live in the server's system environment, not in the code 3. **Tested the pipeline manually three times** — once with t → Case Study 22-1: Priya's Monday Report Goes Fully Automated
Open System Properties → Advanced → Environment Variables - Find the "Path" variable in User variables - Add the path to your Python installation (typically `C:\Users\YourName\AppData\Local\Programs\Python\Python312\`) - Add the Scripts subdirectory too (`...\Python312\Scripts\`) → Chapter 2: Setting Up Your Python Environment
For production reporting, define a reusable `figure_template()` function that applies your organization's brand colors, font settings, and standard formatting before drawing any chart. This ensures every output looks consistent. → Chapter 14 Further Reading and Resources
matplotlib styles
matplotlib includes a set of built-in style sheets (`plt.style.use("ggplot")`, `plt.style.use("seaborn-v0_8-whitegrid")`) that apply pre-configured aesthetics. The `"ggplot"` style mimics R's ggplot2. Use `plt.style.available` to see all options. → Chapter 14 Further Reading and Resources
All 12 rows have complete data — no missing values. - Hourly rates range from $125 to $175. She has three legacy clients below her standard rate. - Contracted hours range from 20 to 120. The 120-hour Oakwood Medical engagement is by far her largest. - Hours worked ranges from 8 to 71 (excluding comp → Case Study 2: Maya Organizes Her Consulting Practice with pandas
microframework
not because it is limited, but because it starts small and lets you add only what you need. A minimal Flask application is five lines of Python. It does not assume a particular database, a particular template engine, or a particular project structure. You are in control. → Chapter 37: Building Simple Business Applications with Flask
MIME types you will use most:
`MIMEMultipart("alternative")` — for HTML + plain text (same content, different formats) - `MIMEMultipart("mixed")` — for email + attachments - `MIMEMultipart("related")` — for HTML + inline images - `MIMEText(body, "plain")` — plain text body part - `MIMEText(html, "html")` — HTML body part - `MIME → Chapter 19 Key Takeaways: Email Automation and Notifications
Minimum viable performance:
ROC AUC > 0.80 on held-out test set (versus random baseline of 0.50) - Recall > 0.70 for the top 20% of scored customers (we need to catch most churners in the high-risk tier) - Precision > 0.40 at recall 0.70 (we can tolerate some false alarms but not an overwhelming flood) → Case Study 33-01: Priya Frames the Churn Prediction Problem
An open-source platform for managing the machine learning lifecycle: tracking experiments, versioning models, and deploying predictions. When you have multiple model versions and experiments, MLflow makes them manageable. → Chapter 40: Building Your Python Business Portfolio
API schemas change infrequently; HTML changes constantly - **Explicitly permitted** — no ToS concerns about authorized access - **More structured** — you get clean JSON rather than messy HTML → Chapter 20: Web Scraping for Business Intelligence
MultiIndex DataFrames
When you group by multiple columns or create pivot tables with multiple value columns, pandas creates hierarchical column indexes. Understanding how to index and slice MultiIndex objects unlocks more advanced data manipulation. → Chapter 13 Further Reading and Resources
Identifying and classifying specific entities mentioned in text: company names, people's names, locations, dates, dollar amounts. This powers contract analysis, competitive intelligence, and data extraction from unstructured documents. → Chapter 35: Natural Language Processing for Business Text
especially lists of dicts — represent tables of business data and are the foundation of nearly all real-world Python data processing. - **Copying** requires attention: shallow copies share nested objects; use `copy.deepcopy()` when you need a true independent snapshot. → Chapter 7: Data Structures — Lists, Tuples, Dictionaries, and Sets
Never commit:
API keys, passwords, or credentials of any kind - Large data files — use `.gitignore` and link to the data source in your README - Personal or confidential business data - Your virtual environment folder (`venv/`, `.env/`) - Python cache files (`__pycache__/`, `*.pyc`) - Operating system files (`.DS → Chapter 40: Building Your Python Business Portfolio
Every method logs its activity at the DEBUG level - Every error produces a user-readable message (not a raw exception traceback) - The class works as a context manager (supports `with APIClient(...) as client:`) - Constructor validates that at least base_url was provided → Chapter 21 Exercises: Working with APIs and External Data Services
Non-negotiable requirements:
Every job must be wrapped in error handling (decorator pattern from the chapter) - Every job must log start, end, and duration - The scheduler must write a heartbeat file every 2 minutes - The scheduler must handle Ctrl+C gracefully → Chapter 22 Exercises: Scheduling and Task Automation
Northwind Database
A classic sample database representing a small trading company. Available in SQLite format at multiple GitHub repositories (search "northwind sqlite"). Contains customers, orders, products, employees, and suppliers — more complex than Acme Corp's schema and good for advanced JOIN practice. → Chapter 23 Further Reading: Database Basics
Available from the NYC Taxi & Limousine Commission. Large-scale time-series data with pickup/dropoff times, fare amounts, and trip distances. Excellent for date operations, rolling averages, and `.resample()`. → Chapter 13 Further Reading and Resources
Python stops at the first `True` condition. - **Order matters.** More specific conditions go before more general ones. - The `else` clause is optional but provides a safety net for unexpected inputs. → Chapter 4 Key Takeaways: Control Flow
openpyxl
openpyxl documentation: https://openpyxl.readthedocs.io/ The official tutorial is essential reading. The "Working with styles" section covers fonts, fills, borders, and alignments with complete examples. The "Charts" section documents every supported chart type. - openpyxl API reference: https://ope → Chapter 16 Further Reading: Excel and CSV Integration
Operational requirements:
Runs without modification month-to-month (the period is a command-line argument) - Handles the case where a client has no projects this month (doesn't generate an empty invoice) - Produces a console summary after running so she can verify the totals before sending - If something goes wrong with one → Case Study 16-2: Maya's Complete Invoicing System
Option A: B2B Software Subscriptions
Replace frequency with "feature adoption score" (number of distinct product features used per month) - Replace monetary with "contract value" (annual contract value) - Add a fourth dimension: "expansion" (whether the account has grown, stayed flat, or shrunk) → Chapter 27 Exercises: Customer Analytics and Segmentation
Replace raw transaction counts with "project count" and "average project duration" - Add a "referral score" (has this client referred other clients?) - Define segment names that make sense in a services context → Chapter 27 Exercises: Customer Analytics and Segmentation
Option C: Windows Task Scheduler (OS-level)
Pros: Built into Windows, no additional Python process required, survives reboots, IT already knows how to manage it, provides task history in the Windows Event Log - Cons: Slightly more setup for the first task → Case Study 22-1: Priya's Monday Report Goes Fully Automated
OS-level scheduling
Windows Task Scheduler or Linux/macOS cron. These run Python scripts as external processes. Best for production deployments, server-based automation, and scripts that need to run even when no Python program is already running. → Chapter 22: Scheduling and Task Automation
A cloud service category that provides managed infrastructure for deploying applications. Render and Railway are PaaS providers. → Chapter 38: Deploying Python to the Cloud
Packaging
Learn how to package your Python projects so others can install them with `pip install your-tool`. This is the step that turns a useful script into a properly distributable tool. → Chapter 40: Building Your Python Business Portfolio
Page 1: Executive Summary
Q3 total company forecast: $X.XM to $X.XM (95% confidence range) - Q4 total company forecast: $X.XM to $X.XM (95% confidence range) - North region has the strongest trend (R² = 0.87, +4.2% quarterly growth) - South region has the widest uncertainty band (R² = 0.63, higher variability) - Q3 adjusted → Case Study 26-1: Priya Builds the Quarterly Sales Forecast
for working with tabular data (the Excel equivalent, but better) - **matplotlib** and **seaborn** — for data visualization - **plotly** — for interactive charts - **openpyxl** and **xlrd** — for reading and writing Excel files - **requests** — for making HTTP requests to web APIs - **SQLAlchemy** — → Chapter 1: Why Python? The Business Case for Coding
pandas Excel I/O
pandas I/O documentation: https://pandas.pydata.org/docs/user_guide/io.html The "Excel files" and "CSV and text files" sections of the pandas I/O guide. Covers all parameters for `read_excel`, `to_excel`, `read_csv`, and `to_csv` with complete examples. → Chapter 16 Further Reading: Excel and CSV Integration
Parameters:
`df`: The DataFrame to clean - `string_cols`: List of string columns to strip and apply title case - `numeric_cols_with_dollar`: List of columns with `$` signs to strip and convert - `date_cols`: List of date columns to convert to datetime - `category_maps`: Dictionary of `{column_name: mapping_dict → Chapter 12 Exercises: Cleaning and Preparing Data for Analysis
`payment_failures_last_year` — billing issues are a leading indicator - `days_since_last_payment_failure` — recency of payment issues - `has_valid_payment_method` — critical binary flag → Case Study 33-01: Priya Frames the Churn Prediction Problem
Under 2-5%: consider dropping. Over 20%: consider dropping the column entirely. Between: assess further. 2. **Randomness of missing data** — Randomly missing: safe to drop rows. Systematically missing (e.g., high-value customers more likely to skip a field): dropping introduces bias; fill instead. 3 → Chapter 12 Quiz: Cleaning and Preparing Data for Analysis
Persistent disk
Storage that survives container restarts and redeployments. Required for applications that write data locally (like SQLite databases). → Chapter 38: Deploying Python to the Cloud
Persistent disk + pipeline update
configure a Render Persistent Disk at `/app/data`, update the automated data pipeline to write to a shared S3 bucket, and have the Flask app download from S3 on startup (or per-request). Marcus favored this approach because it separated data from application code. → Case Study 38-1: Priya Deploys the Acme Dashboard to Render
Runs every weekday at 8:00 AM - Checks all open invoices for overdue status - Flags any invoice that has been unpaid more than 30 days - Sends Maya a brief email if there are overdue invoices - Logs to a file so she has a running history of what was checked and when → Case Study 22-2: Maya Automates Her Weekly Business Rhythm
Pipeline 2: Friday Weekly Business Health Report
Runs every Friday at 5:00 PM - Pulls revenue data from Maya's invoices CSV - Calculates utilization rate (billable hours / total available hours) - Summarizes active pipeline - Generates a brief report and emails it to herself - Includes a "look back" section: same week last year and last quarter → Case Study 22-2: Maya Automates Her Weekly Business Rhythm
A library for creating interactive charts that work in web browsers and Jupyter notebooks. Particularly useful for dashboards where users want to hover over data points, zoom, and filter. The free version supports most chart types; Plotly Dash adds full web application capability. → Chapter 14 Further Reading and Resources
Plotly documentation
`plotly.com/python` — The official documentation for Plotly's Python library, with extensive examples for every chart type. The Dash documentation at `dash.plotly.com` covers building full web applications with Python. → Further Reading — Chapter 40: Building Your Python Business Portfolio
submits data to the server. Used when a user submits a form. The submitted data travels in the request body, not the URL. POST requests typically change server state — inserting a database record, sending an email, writing a file. → Chapter 37: Building Simple Business Applications with Flask
We start from absolute zero in Chapter 2. - **Mathematics beyond arithmetic** — We use business math (percentages, averages, growth rates) but no calculus, statistics beyond high school level, or linear algebra. Chapter 25 introduces more formal statistics, and the concepts are always explained intu → Prerequisites
Prioritize:
Enterprise clients seeking training or strategy work - Mid-size company strategy engagements (strong margins, interesting work) - Any client where the project can be templated for training delivery → Case Study 25-2: When Your Average Is a Lie
Below $8,000: Too small — the project economics do not work for her rate and the overhead of client management - $8,000–$25,000: Sweet spot — meaningful work, manageable scope - $25,001–$60,000: Acceptable — larger projects are fine with the right structure in place - Above $60,000: Requires special → Case Study 2: Maya's Project Intake Screening Tool
Project name and client
**Status:** Active, On Hold, or Completed - **Contracted hours** — what she agreed to deliver - **Hours worked** — what she has logged so far - **Hourly rate** (most are $175, but she has a few legacy clients at lower rates) - **Budget cap** — some clients have a fixed cap on the engagement in dolla → Case Study 2: Maya Organizes Her Consulting Practice with pandas
Project Type (must be in her wheelhouse)
Process improvement, systems design, change management, training design, organizational assessment: Yes - Software development, graphic design, legal services, accounting/tax: No — these are not her expertise and she will not pretend otherwise → Case Study 2: Maya's Project Intake Screening Tool
your application code lives in a GitHub repository 2. **Connect to Render** — Render watches your repository 3. **Push a commit** — Render automatically detects the change, builds your Docker image, and deploys the new version 4. **Monitor the deploy** — Render's dashboard shows build logs and deplo → Chapter 38: Deploying Python to the Cloud
PyCon regional events
There are PyCon events in Europe, Africa, Asia, Latin America, and Australia. Smaller, often more intimate, and equally valuable for meeting practitioners in your region. → Chapter 40: Building Your Python Business Portfolio
PyCon US
The premier annual Python conference, held in North America in late spring. Multiple days of talks, tutorials, sprints (open-source contribution sessions), and networking. All talks are posted on YouTube for free — the archive going back to 2011 is an extraordinary learning resource that most people → Chapter 40: Building Your Python Business Portfolio
PyCon US talks
Available at `pyvideo.org` and on the PyCon YouTube channel. The archive going back to 2011 contains thousands of talks on practical Python applications. Search by topic. Excellent talks on data engineering, testing, type hints, packaging, and business applications exist at all skill levels. → Further Reading — Chapter 40: Building Your Python Business Portfolio
PyData conferences
Focused on the data science and analytics ecosystem. Highly relevant for business Python practitioners working with pandas, NumPy, scikit-learn, and visualization libraries. → Chapter 40: Building Your Python Business Portfolio
`docs.pytest.org` — The definitive reference for Python testing. The "Get Started" section is brief and immediately practical. The "How-to guides" section covers fixtures, parametrize, and other patterns that make tests maintainable. → Further Reading — Chapter 40: Building Your Python Business Portfolio
A large, active community with channels organized by topic, experience level, and domain. The `#learning` and `#data-science` channels are particularly active. → Chapter 40: Building Your Python Business Portfolio
simple, pure-Python scheduling that runs inside a long-running Python process. Best for quick scripts you'll run in the background or on a personal machine. → Chapter 22: Scheduling and Task Automation
Python.org/downloads
Download Python directly - **Google Colab (colab.research.google.com)** — Run Python in your browser with no installation - **Replit (replit.com)** — Another browser-based Python environment, good for quick experiments → Further Reading — Chapter 1: Why Python? The Business Case for Coding
Python: Default Interpreter Path
Point to your venv's Python executable - **Editor: Format on Save** — Set to `true` to auto-format your code on every save - **Python: Linting Enabled** — Set to `true` to show errors inline → Chapter 2: Setting Up Your Python Environment
Q
Q10: B
The `try/except` inside the loop creates an error boundary at the level of a single region. If processing Region A fails, the except clause runs, the loop moves to the next iteration, and Region B is processed. A `try/except` outside the loop would catch the first failure and stop all subsequent pro → Chapter 8 Quiz: Error Handling
Q1: C
Catch specific exceptions, log detailed messages, and continue processing where possible. This produces partial output (useful) and a log explaining what failed (actionable). Option A leaves the operator with nothing; option B produces an uninformative message; option D silently hides all problems. → Chapter 8 Quiz: Error Handling
Q2: B
`KeyError` is raised when you access a dictionary with a key that does not exist. `IndexError` is for list index out of range. `LookupError` is the parent class of both and can be used to catch either, but is not the specific type raised. → Chapter 8 Quiz: Error Handling
Q2: C — `Standard`
`revenue >= 50_000 and tier == "Gold"` → 45,000 is not >= 50,000, so the whole `and` is `False`. Skip. - `revenue >= 50_000 or tier == "Gold"` → Neither is true (revenue is 45,000; tier is "Silver"). Skip. - `tier == "Silver"` → `True`. Print `"Standard"`. → Chapter 4 Quiz: Control Flow — Making Decisions in Your Programs
Q3: B
Only "Validation step complete." is printed. Because `float("pending approval")` raises `ValueError`, the `except ValueError` block runs (setting `result = 0.0`) and the `else` block is skipped (it only runs when no exception occurred). The `finally` block always runs, so its `print()` executes. → Chapter 8 Quiz: Error Handling
Q4: B
A bare `except:` catches `KeyboardInterrupt` (making the script impossible to stop with Ctrl+C) and `SystemExit`, and — more commonly — it catches `NameError`, `AttributeError`, and other programming bugs that should be visible rather than silently swallowed. It does not cause a `SyntaxError`. → Chapter 8 Quiz: Error Handling
Q5: B
Grouping exception types in a tuple means both types are handled by the same except clause. When either a `ValueError` or a `KeyError` is raised, the same recovery code (`amount = 0.0`) runs. This is equivalent to two separate except clauses that execute the same code. → Chapter 8 Quiz: Error Handling
Q6: C
`logging.WARNING`. The script can continue; no data has been lost (yet); but something unexpected happened that someone should review. `DEBUG` is for developer diagnostics; `INFO` is for normal operations; `ERROR` and `CRITICAL` imply something more serious than a skipped row. → Chapter 8 Quiz: Error Handling
Q7: C
The `finally` block always runs, whether the `try` block completed normally, whether an exception was caught by an `except` clause, or even whether an uncaught exception is propagating upward. This is why it is used for cleanup (closing files, releasing connections). → Chapter 8 Quiz: Error Handling
Q8: A
The class must inherit from `Exception` (or a subclass of `Exception`). Without inheritance, Python will not treat it as a true exception and you cannot raise it with `raise InvoiceError(...)` in a way that integrates with the exception system. → Chapter 8 Quiz: Error Handling
Q9: B
`logger.exception(message)` logs at ERROR level and automatically appends the full traceback of the currently-handled exception. It is equivalent to `logger.error(message, exc_info=True)`. → Chapter 8 Quiz: Error Handling
Quality requirements:
Professional appearance — looks like something a real business would send - Consistent formatting across all invoices - Clear, readable line items with enough description for the client to understand what they're paying for - Due date computed automatically (not typed) - Invoice numbers sequential a → Case Study 16-2: Maya's Complete Invoicing System
The session-based password check above is simple but limited. It lacks password hashing, account lockout after failed attempts, session expiration, and many other features of a proper auth system. → Chapter 37: Building Simple Business Applications with Flask
Online Retail dataset: 500,000+ transactions from a UK gift wholesaler - Bank Marketing dataset: Portuguese bank telemarketing campaign results - Adult Income dataset: census income data for classification → Appendix C: Free Business Datasets for Practice
which of the four regions is performing, which needs attention 3. **Margin vs order size** — Sandra wants to see whether large deals are actually profitable 4. **Product mix** — how much revenue is coming from Technology vs Office Supplies vs Furniture → Case Study 15-1: Priya Builds an Interactive Dashboard for Sandra
Regression:
MAE: average absolute error, same units as target, interpretable - RMSE: penalizes large errors more, good when large errors are especially costly - R²: proportion of variance explained, ranges from 0 to 1 (higher is better) → Chapter 33 Key Takeaways: Introduction to Machine Learning for Business
A Client has many Projects - A Project belongs to one Client - A Project has many TimeEntries - An Invoice belongs to one Client - An Invoice can reference multiple TimeEntries (an invoice "covers" a set of time entries) → Case Study 23-2: Maya Builds Her Business Database
Remove exact duplicate rows
`.duplicated()`, `.drop_duplicates()` 2. **Handle missing values** — `.isna()`, `.fillna()`, `.dropna()`, `.interpolate()` 3. **Fix data types** — `.astype()`, `pd.to_numeric()`, `pd.to_datetime()` 4. **Strip whitespace from strings** — `.str.strip()` 5. **Standardize string case** — `.str.lower()`, → Chapter 12 Key Takeaways: Cleaning and Preparing Data for Analysis
Render configuration:
Production service: connected to `main` branch - Staging service: connected to `staging` branch - Both services have appropriate environment variables set - Both services have the health check endpoint configured → Chapter 38 Exercises: Deploying Python to the Cloud
Requirements:
If `days_overdue` is greater than 60, print: `"URGENT: Invoice is seriously overdue."` - If `days_overdue` is between 31 and 60 (inclusive), print: `"NOTICE: Invoice is overdue."` - If `days_overdue` is between 1 and 30 (inclusive), print: `"REMINDER: Invoice will be due soon."` - If `days_overdue` → Chapter 4 Exercises: Control Flow — Making Decisions in Your Programs
sales records, product catalogs, customer transactions - **Finance** — stock prices, company financials, loan applications - **Human Resources** — employee records, salaries, performance data - **Real Estate** — property listings, sales history → Further Reading and Resources: Chapter 10
Revenue concentration change
If the top 10 customers now represent 80% of revenue compared to 65% last year, risk is increasing even if total revenue is up. This is a strategic vulnerability that the board needs to understand alongside the growth rate. → Chapter 28 Quiz: Sales and Revenue Analytics
Review on first run
Manually review the first automated output before trusting the schedule - [ ] **Check PDF page breaks** — Open the PDF and verify sections don't split awkwardly across pages - [ ] **Verify numbers against source** — Cross-check three or four key metrics against the source data - [ ] **Test with one → Chapter 36 Key Takeaways: Automated Report Generation
Variable names can contain letters, numbers, and underscores - Variable names cannot start with a number - Variable names are case-sensitive (`revenue` and `Revenue` are different variables) - Variable names cannot be Python keywords (`if`, `for`, `while`, `class`, etc.) → Chapter 3: Python Basics — Variables, Data Types, and Operators
`scikit-learn.org/stable` — The official documentation includes excellent user guides for every major algorithm, with examples that go beyond the API reference. The "Common pitfalls and recommended practices" section is particularly valuable for practitioners. → Further Reading — Chapter 40: Building Your Python Business Portfolio
scikit-learn, deepened
You have seen it in action. The next level is cross-validation pipelines, custom transformers, hyperparameter search, and the sklearn Pipeline object that chains preprocessing and modeling into a single deployable unit. → Chapter 40: Building Your Python Business Portfolio
where Chapter 23 leaves you 2. **Script uploads its output to cloud storage** — what this chapter covers 3. **Script runs automatically in the cloud on a schedule** — AWS Lambda or Google Cloud Functions → Chapter 24: Connecting Python to Cloud Services
seaborn
A statistical visualization library built on matplotlib. seaborn handles styling, statistical summary charts (distribution plots, box plots, violin plots, heatmaps), and multi-panel grids with significantly less code. It is the natural next step after matplotlib. See Chapter 15. → Chapter 14 Further Reading and Resources
Secondary metrics:
Precision and recall at several probability thresholds - The confusion matrix at the threshold used for operational decisions - Performance broken down by plan type (the model should work for enterprise customers, not just basic) → Case Study 33-01: Priya Frames the Churn Prediction Problem
`FLASK_DEBUG` is `false` in production - `SECRET_KEY` is a long random string, not a hardcoded default - All secrets are in platform environment variables, not in source code - `.env` is in `.gitignore` → Chapter 38: Deploying Python to the Cloud
Segment Labels (sum of R + F + M):
10–12: Champions — reward and leverage - 8–9: Loyal Customers — nurture and deepen - 6–7: Potential Loyalists — engage and cross-sell - 4–5: At Risk — win-back campaigns - 3: Lost — minimal investment → Key Takeaways: Chapter 28 — Sales and Revenue Analytics
A software design principle: keep business logic (calculations) separate from presentation logic (formatting). In the Excel workflow context: compute in pandas, format with openpyxl. → Chapter 16 Key Takeaways: Excel and CSV Integration
a bot identity for your script, separate from your personal Google account. Go to IAM and Admin, then Service Accounts, then Create Service Account. → Chapter 24: Connecting Python to Cloud Services
unordered collection of unique items: - Use when you need uniqueness and do not care about order - Use for fast membership testing (`"x" in my_set` is O(1) vs O(n) for lists) - Example: set of unique regions, set of processed order IDs → Appendix D: Frequently Asked Questions
Severity levels
with `print()`, all messages look the same; with `logging`, a `WARNING` is visually distinct from `DEBUG`. In a long log output, you can instantly see which lines represent problems. (2) **Automatic timestamps** — `logging` can be configured to prefix every message with the exact date and time, whic → Chapter 8 Quiz: Error Handling
divide the DataFrame into groups based on one or more columns 2. **Apply** — compute a statistic or transformation within each group 3. **Combine** — reassemble the results into a new DataFrame → Chapter 13: Transforming and Aggregating Business Data
SQL Cheat Sheet
W3Schools (https://www.w3schools.com/sql/sql_cheatsheet.asp) Quick reference for SQL syntax. Keep a browser tab open while writing queries. → Chapter 23 Further Reading: Database Basics
SQL is the universal query language
SELECT, INSERT, UPDATE, DELETE, JOIN. These operations work across SQLite, PostgreSQL, MySQL, and SQL Server with minor dialect differences. → Chapter 23 Key Takeaways: Database Basics
SQLAlchemy
The comprehensive Python SQL toolkit. If you are working with relational databases seriously, SQLAlchemy's ORM and core expression language handle the full complexity of database interaction in production applications. → Chapter 40: Building Your Python Business Portfolio
SQLAlchemy ORM Cheat Sheet
Search "SQLAlchemy ORM cheat sheet 2.0" for community-maintained quick references. The syntax changed significantly between SQLAlchemy 1.x and 2.0, so verify the version matches what you installed. → Chapter 23 Further Reading: Database Basics
SQLite
A file-based database engine built into Python's standard library. No server required. Perfect for development, testing, desktop applications, and datasets under a few hundred gigabytes. This is where we start. - **PostgreSQL** — A full-featured, production-grade open-source database. Handles millio → Chapter 23: Database Basics — SQL and Python with SQLite and PostgreSQL
Statistical modeling in Python: OLS regression with proper statistical tests and confidence intervals, time series analysis (ARIMA, SARIMA), and econometric models. Where scikit-learn is optimized for prediction, statsmodels is optimized for interpretation. → Chapter 40: Building Your Python Business Portfolio
Statsmodels documentation
`statsmodels.org` — The official documentation includes detailed tutorials for time series analysis, regression with proper inference, and econometric models. More statistically rigorous than scikit-learn's approach, which makes it complementary rather than competing. → Further Reading — Chapter 40: Building Your Python Business Portfolio
rows and columns, like a spreadsheet, but with strict rules about what goes in each column 2. **Answers questions efficiently** — using a query language (SQL) designed for exactly this purpose 3. **Manages concurrent access** — multiple users can read and write simultaneously without corrupting data → Chapter 23: Database Basics — SQL and Python with SQLite and PostgreSQL
Streamlit
The fastest way to turn a Python script into a shareable web app. Excellent for prototyping dashboards, sharing analyses with colleagues, and building internal tools without a web development background. → Chapter 40: Building Your Python Business Portfolio
no parsing, no regex, no extracting values from HTML noise - **More stable** — API response schemas change far less often than HTML layouts - **Faster** — no overhead of transmitting HTML formatting, CSS, JS references - **Lighter** — JSON responses are typically much smaller than full HTML pages - → Chapter 20 Quiz: Web Scraping for Business Intelligence
Available on Kaggle. Contains retail transaction data with region, category, sub-category, sales, profit, and discount columns. Perfect for groupby, pivot tables, and merge exercises. → Chapter 13 Further Reading and Resources
Python keywords, strings, and variables are color-coded - **IntelliSense** — code completion as you type (suggests function names, parameters, etc.) - **Inline error detection** — problems are underlined before you even run the code - **Integrated terminal** — run Python directly from within VS Code → Chapter 2: Setting Up Your Python Environment
T
Talk Python to Me
`talkpython.fm` — Episode archives cover practitioners across every Python domain. The interviews with data analysts, consultants, and business users who learned Python as their second discipline are particularly relevant to readers of this book. → Further Reading — Chapter 40: Building Your Python Business Portfolio
A Jinja2 pattern where a child template extends a base template, filling in named blocks while inheriting the rest of the layout. → Chapter 36: Automated Report Generation
Templates
HTML files with Jinja2 expressions, rendered with `render_template()` - **Template inheritance** — `base.html` defines shared structure; child templates extend it - **Forms** — HTML forms send POST requests; `request.form` gives you access to the data - **Static files** — CSS, JavaScript, and images → Chapter 37: Building Simple Business Applications with Flask
The standard testing framework. Writing tests for your business code makes it more reliable and demonstrates professional practice to any technical reviewer of your portfolio. → Chapter 40: Building Your Python Business Portfolio
generate a report, upload to S3, create a presigned URL, email the link — is a workflow you can implement today and apply to almost any reporting task. → Chapter 24: Connecting Python to Cloud Services
The minimum every scheduled job should log:
Job start (timestamp + job name) - Key milestones (data loaded, report generated, email sent — with measurable quantities) - Job completion with elapsed time and status - Any errors or warnings with enough context to diagnose → Chapter 22 Key Takeaways: Scheduling and Task Automation
The Pragmatic Programmer
Andrew Hunt and David Thomas (Addison-Wesley) The book that coined "DRY" (Don't Repeat Yourself) and many other principles that underpin good software practice. Not Python-specific, but every principle applies directly. Chapter 7 on "Coding" and Chapter 8 on "Before the Project" are particularly rel → Further Reading — Chapter 39: Python Best Practices and Collaborative Development
Use exponential smoothing or seasonal decomposition where you have sufficient data (at least 6-12 months). Forecasting errors for A items are costly; more sophisticated models are justified. → Chapter 32: Inventory and Supply Chain Analytics
**Axis labels** with units for both axes - **Appropriate scale** — bar charts must start at zero; line charts can use a meaningful range - A **legend** when more than one series is shown (omit it when it would be redundant) - **Light horizontal grid lines** to support quantitative comparisons - **Sp → Chapter 14 Key Takeaways: Introduction to Data Visualization with matplotlib
The modern business skills gap: why Excel isn't enough anymore - What Python actually is (and what it's not) - Real-world business use cases: analytics, automation, reporting, data pipelines - Python vs. alternatives (R, SQL, VBA, no-code tools) — when to use what - The ROI of learning Python: time → 00-outline.md — Full Textbook Outline
Transactions ensure consistency
a group of related operations either all succeed or all fail. A database that crashes mid-write will roll back to the last committed state. → Chapter 23 Key Takeaways: Database Basics
Python 3.10+ supports sophisticated type hints. Adding type hints to your functions makes code more readable, catches bugs at development time, and is now considered standard practice in professional Python. → Chapter 40: Building Your Python Business Portfolio
Your dataset is small (less than 10,000 examples) — you cannot afford to hold out 20% for testing - You are comparing multiple models or hyperparameter settings — cross-validation gives more reliable comparisons - You want to understand the variance of your performance estimate → Chapter 33: Introduction to Machine Learning for Business
Use Excel directly when:
The dataset is small (under 50,000 rows) and won't grow - The analysis is one-time and won't be repeated - The output needs to be modified by non-technical users after you deliver it - The formatting requirements are complex and unique to this one report - You're building a model someone else will m → Chapter 16: Excel and CSV Integration — Python Meets Spreadsheets
Use K-means when:
You want to discover natural groupings in the data without imposing your assumptions - You are adding many features beyond R, F, M (product categories bought, support tickets raised, geography, etc.) - You are building a model that will run automatically on new data → Chapter 27: Customer Analytics and Segmentation
Use Python → Excel when:
The report is generated repeatedly (weekly, monthly) from fresh data - The data comes from a source that's awkward to work with in Excel (SQL database, API, web scrape) - The same report structure is needed for multiple outputs (one per region, one per client) - The formatting is consistent and can → Chapter 16: Excel and CSV Integration — Python Meets Spreadsheets
Use rule-based RFM when:
You need to explain the segmentation to non-technical stakeholders ("Champions are customers with R, F, and M scores all above 4") - Your team will take manual action on specific segments - You need stable, consistent segment definitions over time → Chapter 27: Customer Analytics and Segmentation
Building an application where you create, update, and delete individual records - You want Python objects with methods and properties - You need to switch between database backends (SQLite for dev, PostgreSQL for production) - Your team is more comfortable with Python than SQL → Chapter 23: Database Basics — SQL and Python with SQLite and PostgreSQL
User Guide → 10 Minutes to pandas
A concise, well-written introduction that complements what you have learned here. It shows more variations of common operations and is a good second exposure to reinforce this chapter. → Further Reading and Resources: Chapter 10
User Guide → Indexing and Selecting Data
An exhaustive reference for `.loc[]`, `.iloc[]`, Boolean indexing, and related selection patterns. Once you have read Chapter 10, this reference will make complete sense and will fill gaps. → Further Reading and Resources: Chapter 10
check that prices are numeric, titles are non-empty, URLs are valid 2. **Log when structure seems wrong** — zero results on a page that usually has twenty is a signal worth capturing 3. **Separate configuration from logic** — store CSS selectors and site URLs in a configuration dict, not scattered t → Chapter 20 Key Takeaways: Web Scraping for Business Intelligence
**count:** How many non-null values exist. If this is less than your total row count, you have missing data. - **mean:** The arithmetic average. Compare to median (50%) to sense skewness. - **std:** Standard deviation. Compare to mean — if std is more than half the mean, your data is highly variable → Chapter 25: Descriptive Statistics for Business Decisions
What is available:
American Community Survey (ACS): demographic, income, housing, education, employment data by geography (state, county, zip code, census tract) - Decennial Census: population counts every 10 years - Economic Census: business data by industry and geography (every 5 years) - Business Patterns: employme → Appendix C: Free Business Datasets for Practice
What Priya deliberately excludes:
Future-dated features (anything measured after the snapshot date) - Features with more than 30% missing values at this stage - Account manager subjective ratings (too inconsistent across reps) → Case Study 33-01: Priya Frames the Churn Prediction Problem
What python-docx can do well:
Read all text content from a document - Create documents from scratch with headings, paragraphs, tables - Apply styles (Bold, Heading 1, Table Style, etc.) - Replace placeholder text throughout a document - Add images - Control fonts, sizes, colors, alignment → Chapter 18: Working with PDFs and Word Documents
What python-docx cannot do well:
Preserve complex layouts from existing documents exactly - Work with `.doc` (pre-2007 Word format) files — only `.docx` - Render documents (you cannot generate a PDF from a docx through python-docx alone) - Handle all the edge cases of macro-enabled documents (`.docm`) → Chapter 18: Working with PDFs and Word Documents
What to do more of:
Deliberate referral cultivation: reaching out to past clients quarterly, not just when she needed work - Speaking engagements: not for direct lead generation, but because speaking clients become referral sources - LinkedIn organic content: it was cost-effective at an LTV:CAC of 5.9, and content posi → Case Study 31-2: Maya Finds Out Where Her Best Clients Actually Come From
What to showcase:
The input data format and where it comes from - The transformations applied - The output format and delivery method - The time savings — quantify this: "reduces weekly reporting from 2 hours to 3 minutes" → Chapter 40: Building Your Python Business Portfolio
Tenure-at-separation analysis reveals whether the problem is early (onboarding) or late (career ceiling) 2. **Why are they leaving?** — Voluntary vs. involuntary split narrows the cause 3. **When during the year?** — Seasonal index reveals cyclical vs. structural issues 4. **Is it specific to this l → Chapter 30 Key Takeaways: HR Analytics and People Data
When not to comment:
Don't state the obvious: `# Add 1 to count` on `count += 1` - Don't leave old code commented out in production — delete it (version control keeps history) - Don't explain Python syntax to beginners in production code — comments are for domain knowledge → Chapter 3: Python Basics — Variables, Data Types, and Operators
When PDF text extraction works well:
Simple, consistently-formatted documents (pay stubs, bank statements, invoices from modern billing systems) - Documents with mostly text content and simple layouts - PDFs generated directly from software (Word exports, accounting system outputs) → Chapter 18: Working with PDFs and Word Documents
When to comment:
Explain *why*, not *what*. The code says what it does. Comments say why. - Flag non-obvious business rules: `# Discount applies only to orders over $500 (company policy)` - Mark assumptions: `# Assumes fiscal year starts January 1` - Explain tricky workarounds: `# Using string comparison here becaus → Chapter 3: Python Basics — Variables, Data Types, and Operators
When to use `.map()` vs `.replace()`:
Use `.map()` when you want to recode every value and need strict control — any unmapped value becomes `NaN`, signaling a gap in your mapping. - Use `.replace()` when you want to fix specific known problems while leaving other values alone. → Chapter 12: Cleaning and Preparing Data for Analysis
When to use Jupyter vs. VS Code:
**Jupyter:** Exploratory analysis, building charts, presenting findings interactively, learning - **VS Code:** Scripts that run unattended (automation), larger programs with multiple files, production code → Chapter 2: Setting Up Your Python Environment
Why cross-validation over a single split:
A single train/test split gives one estimate, which can be lucky or unlucky - 5-fold CV gives five estimates from five different test sets - The standard deviation tells you how stable the model's performance is - High variance across folds (std > 0.10 for F1) means the model is sensitive to which d → Chapter 34: Key Takeaways — Predictive Models: Regression and Classification
premium product, $85/unit, higher margin - **Widget Lite** — volume product, $52/unit, broad distribution - **Widget Max** — enterprise product, $145/unit, low volume, high touch → Case Study 29-1: Priya Builds the Annual Revenue Model
Write the core logic
the function that does the actual work 2. **Add error handling** — every job catches its own exceptions 3. **Add logging** — start, milestones, completion, and failures 4. **Test failure paths** — deliberately trigger each error mode and verify the handling 5. **Configure credentials** — environment → Chapter 22 Key Takeaways: Scheduling and Task Automation
xlwings documentation: https://docs.xlwings.org/ Comprehensive docs covering the Excel object model, UDFs (User Defined Functions), and the xlwings add-in for Excel. The "QuickStart" and "Syntax overview" sections are most useful for beginners. - xlwings UDF guide: https://docs.xlwings.org/en/stable → Chapter 16 Further Reading: Excel and CSV Integration
Y
You can scrape:
Static HTML pages where content is present in the initial HTTP response - Public data pages that `robots.txt` and ToS permit - HTML tables (with BeautifulSoup or `pd.read_html()`) - Paginated listings (with a loop following next-page links) → Chapter 20 Key Takeaways: Web Scraping for Business Intelligence
You cannot easily scrape:
JavaScript-rendered pages (React, Vue, Angular SPAs) — content is not in the initial HTML - Pages behind login walls (complex session management) - CAPTCHA-protected pages (designed to block automation) - Real-time WebSocket data → Chapter 20 Key Takeaways: Web Scraping for Business Intelligence