Data Science with Python
For analysts building with Python: create a traceable project, keep raw files protected, validate inputs early, and make reusable code easy to review.
Free module
Complete module 1 without creating an account
The complete content is available on this page.
Start module 1 freeComplete and no account required · Data Science with Python
Module 1 · complete and free
Data Science with Python
It opens here, with no account or page change.
About this course
This course is for data practitioners who want notebooks to explain analysis rather than hide production logic. You will separate raw, processed, and output data, pin dependencies, and check columns, types, nulls, and ranges before analysis. In practice, collaborators can reproduce the setup and catch bad data early. A reproducible data project separates raw, processed, and output files into distinct folders, treats raw data as read-only, and isolates dependencies in a virtual environment pinned to a `requirements.txt`. Reusable logic lives in `src/` as `.py` modules that notebooks import, keeping notebooks as thin narrative layers. Data is loaded with explicit `dtype`, `parse_dates`, and `na_values` arguments, then validated immediately for correct columns, types, and value ranges so problems surface at load time rather than deep in analysis. Pandas provides a consistent toolkit for diagnosing and repairing real-world datasets: `df.info()`, `df.isna().sum()`, and `df.describe()` expose shape, missing counts, and distribution before any transformation begins. Missing values are handled deliberately—dropped when rare and random, filled with the median or mode when imputation is appropriate, or flagged with a boolean column when absence itself carries meaning. Date strings are converted to proper datetime objects with `pd.to_datetime()` so the `.dt` accessor can extract components and compute durations, while `pd.merge()` joins tables using the SQL-style join type that preserves the rows the analysis cannot afford to lose. Exploratory data analysis follows a structured sequence—checking shape and types, summarizing distributions with `describe()`, and then visualizing with histograms, box plots, scatter plots, and grouped bar charts using Matplotlib and Seaborn. The choice of chart is determined by the variable types involved: histograms and box plots for single numeric variables, scatter plots for numeric pairs, and grouped box plots or bar charts when comparing a numeric variable across categories. Outliers are identified with the IQR method or z-scores and investigated before removal, and findings are communicated as plain-language business insights supported by clearly annotated, single-purpose charts. Scikit-learn's supervised learning workflow follows a consistent four-step pattern—split with `train_test_split`, fit a model, predict, and evaluate—applied to classification tasks with metrics such as precision, recall, and F1, or to regression tasks with RMSE and R². Preprocessing steps like scaling and encoding are wrapped in a `Pipeline` so they are refit inside each cross-validation fold, preventing data leakage and producing honest performance estimates reported as a mean and standard deviation across folds. A defensible model report states what decision the model supports, which features it uses, its cross-validated performance range, and the conditions under which it is not reliable. Reproducible delivery means converting exploratory notebook cells into named functions inside a `.py` script that runs top-to-bottom with a single command, using relative paths throughout and saving all outputs to an `outputs/` folder. Dependencies are pinned by version in a `requirements.txt` generated with `pip freeze`, and a `README.md` documents setup and execution so any colleague can rerun the project without assistance. A short stakeholder findings document leads with the conclusion in plain language, presents two or three key insights each supported by a properly labeled chart, and explicitly states the data's limitations and assumptions.
What you'll learn
- By the end of this module, you'll be able to structure a Python data project by separating `data/raw/`, `data/processed/`, `src/`, `notebooks/`, and `outputs/` into distinct folders and enforcing a read-only policy on raw files.
- By the end of this module, you'll be able to isolate project dependencies by creating a virtual environment with `venv` and generating a frozen `requirements.txt` that allows any collaborator to reproduce your setup with a single command.
- By the end of this module, you'll be able to validate a DataFrame at load time by checking column presence, `dtype` correctness, null constraints, and value ranges so that schema violations raise errors before any analysis runs.
- By the end of this module, you'll be able to choose an appropriate missing-value strategy—drop, fill, or boolean flag—for each column in a dataset by reasoning about why the data is absent rather than applying a default reflex.
- By the end of this module, you'll be able to convert date strings to `datetime` objects using `pd.to_datetime()` with `errors='coerce'` and extract time components via the `.dt` accessor to engineer duration and period features.
- By the end of this module, you'll be able to combine two DataFrames using the correct join type—inner, left, right, or outer—and summarize the merged result with `groupby` and `.agg()` to produce a clean, multi-metric summary table.
- By the end of this module, you'll be able to select the appropriate chart type—histogram, box plot, scatter plot, or bar chart—for a given variable pair and annotate each plot with a one-sentence business insight rather than a raw statistic.
Roles this course opens up
Typical job titles that ask for this skill.
See live job listings (171,231)Other courses you might like
Account Management Fundamentals
For account managers taking over a client relationship: turn handover notes into a clear account brief, credible next steps and a communication rhythm.
Accounting Fundamentals
Build a sound accounting habit from the start: learn how transactions change assets, liabilities and equity, then record them with clear double-entry logic.
Administrative Management
For administrators and team coordinators: build a filing system people can follow, with clear folders, consistent names and one reliable version of every document.