Description: This course lays the groundwork for your Python programming journey. You'll learn essential Python syntax, data structures, and control flow, while practicing debugging and basic code optimization techniques.

Python Programming Fundamentals
Ends tomorrow! Save 40% on your access to 10,000+ programs and make a real impact in your career. Save now.

Python Programming Fundamentals
This course is part of multiple programs.

Instructor: Microsoft
106,281 already enrolled
Included with
Recommended experience
Recommended experience
Skills you'll gain
- Category: ScriptingScripting
- Category: Data StructuresData Structures
- Category: Code ReusabilityCode Reusability
- Category: Programming PrinciplesProgramming Principles
- Category: AlgorithmsAlgorithms
- Category: Version ControlVersion Control
- Category: Unit TestingUnit Testing
- Category: DebuggingDebugging
Tools you'll learn
- Category: Git (Version Control System)Git (Version Control System)
- Category: JupyterJupyter
- Category: GitHubGitHub
- Category: Python ProgrammingPython Programming
Details to know

Add to your LinkedIn profile
36 assignments
Build your subject-matter expertise
- Learn new concepts from industry experts
- Gain a foundational understanding of a subject or tool
- Develop job-relevant skills with hands-on projects
- Earn a shareable career certificate

There are 6 modules in this course
This module establishes a foundation in Python programming. Learners examine Python’s key characteristics and common applications before setting up Python and Jupyter Notebook. They explore basic program structure, including indentation, statements, comments, variables, data types, operators, and expressions. Through introductory coding activities, learners write, execute, and troubleshoot simple Python programs.
What's included
11 videos8 readings5 assignments
11 videos•Total 51 minutes
- Programming fundamentals•6 minutes
- Python in action: Real-world examples•2 minutes
- Explaining Python•6 minutes
- Python in the wild: From web apps to machine learning•6 minutes
- Introducing your Python toolkit•3 minutes
- Choosing your IDE: A tour of options•5 minutes
- Demo: Navigating Jupyter notebooks•5 minutes
- Your first Python words: Syntax and structure•6 minutes
- Basic operations, expressions and variables•5 minutes
- Variables in Python: Containers for your data•6 minutes
- How Python outputs code•3 minutes
8 readings•Total 80 minutes
- Python programming fundamentals syllabus•10 minutes
- Welcome to the world of programming•10 minutes
- The power of Python•10 minutes
- Installing Python: A step-by-step guide•10 minutes
- What is Jupyter Notebook?•10 minutes
- Hello, Python world!•10 minutes
- How Python code is interpreted•10 minutes
- Anatomy of a Python program•10 minutes
5 assignments•Total 90 minutes
- Activity: A simple Python program•15 minutes
- Unveiling Python: What, why, and how?•15 minutes
- Your Python toolkit: Setting up the environment•15 minutes
- First steps in code: Writing a Python program•15 minutes
- Introduction to Python•30 minutes
This module introduces the programming constructs used to control program flow and organize ordered data. Learners use conditional statements to support decision-making and loops to repeat actions and process data. They also trace code execution and identify common control-flow errors. The module then introduces Python lists, including their creation, modification, indexing, and slicing, enabling learners to store and process related values in simple programs.
What's included
4 videos6 readings5 assignments
4 videos•Total 22 minutes
- Making decisions with Python: If, else, and elif•5 minutes
- Demo: Step by step of tracing code execution•6 minutes
- Lists are a go-to data container•6 minutes
- Mastering lists: Slicing, dicing, and more•5 minutes
6 readings•Total 60 minutes
- Decisions and selections: What are they?•10 minutes
- Introduction to loops and conditional statements•10 minutes
- Repeating actions: For and while loops•10 minutes
- Control flow in Python: The conductor of your code•10 minutes
- Common code execution pitfalls: How to avoid them•10 minutes
- Introduction to lists•10 minutes
5 assignments•Total 85 minutes
- Activity: Variables and loops•15 minutes
- Controlling the flow: Conditional statements and loops•15 minutes
- Activity: Working with a list•10 minutes
- Organizing your data•15 minutes
- Python basics•30 minutes
This module develops learners’ ability to organize Python code into reusable components. Learners create and call functions, work with parameters and return values, manage variable scope, and apply function-writing best practices. They also decompose programming problems into smaller tasks and create simple classes with attributes and methods. The module concludes with built-in modules, custom modules, external libraries, and the use of the pip package manager to extend Python’s functionality.
What's included
11 videos9 readings8 assignments1 ungraded lab
11 videos•Total 48 minutes
- Functions: Python's building blocks•5 minutes
- Classes: Blueprints for objects•5 minutes
- Built-in functions are Python's handy helpers•6 minutes
- Modules: Your code's toolbox•2 minutes
- Writing your own functions•5 minutes
- Variable scope: Where your data lives•2 minutes
- Functions in the real world•2 minutes
- Crafting custom classes•3 minutes
- Using built-in modules•6 minutes
- External libraries: Supercharging your Python code•6 minutes
- Importing modules: Expanding Python's powers•5 minutes
9 readings•Total 90 minutes
- The art of abstraction: Functions and the DRY principle•10 minutes
- Variable scope: How they behave•10 minutes
- Building custom classes•10 minutes
- Best practices for writing Python functions•10 minutes
- Problem-solving with functions•10 minutes
- Divide and conquer: The power of modularity•10 minutes
- Managing packages with pip: Installing and upgrading Libraries•10 minutes
- Python libraries: The power of the community•10 minutes
- Creating your own module•10 minutes
8 assignments•Total 135 minutes
- Activity: Experimenting with built-in functions•15 minutes
- The power of reusability: Functions, classes, and modules unveiled•15 minutes
- Activity: Practicing functions and modules•15 minutes
- Organizing your code: Functions in action•15 minutes
- Activity: Class and Functions•15 minutes
- Thinking like a programmer: Breaking down problems with functions•15 minutes
- Expanding your toolkit with modules and libraries•15 minutes
- Functions and modules•30 minutes
1 ungraded lab•Total 15 minutes
- Creating your own module: A Python challenge•15 minutes
This module examines Python data structures used to organize, access, and manipulate information. Learners compare lists, tuples, dictionaries, and sets according to characteristics such as ordering, mutability, uniqueness, and access patterns. They apply these structures to practical data-management tasks and select suitable structures for different programming requirements. The module also introduces list sorting and linear and binary searching techniques for organizing and locating data.
What's included
12 videos6 readings7 assignments
12 videos•Total 62 minutes
- Data structures: The containers of your code•2 minutes
- Dictionaries: Key-value powerhouses•5 minutes
- Sets: The unique collection•5 minutes
- Data structures: The right tool for the job•3 minutes
- Ordered vs. unordered: Finding your data•5 minutes
- Demo: Data manipulation in Python using practical examples•7 minutes
- Dictionaries in depth: Beyond the basics•6 minutes
- Demo: Real-world applications and when to use each data structure•7 minutes
- Sorting lists in Python•6 minutes
- Demo: Searching lists in Python: Find what you need•5 minutes
- Choosing the right data structure: A decision framework•5 minutes
- Case studies: Matching data structures to problems•6 minutes
6 readings•Total 60 minutes
- Python data structures: A cheat sheet•10 minutes
- Mutability matters: Changing data in Python•10 minutes
- Unleashing the power of dictionaries: Real-world applications•10 minutes
- Data structures: Your Python organization system•10 minutes
- Algorithms and data structures: A deeper dive•10 minutes
- Tips and tricks for data structure selection•10 minutes
7 assignments•Total 125 minutes
- Understanding data structures•15 minutes
- Putting data structures to work•15 minutes
- Activity: Finding what you need•15 minutes
- Algorithms and lists: Sorting and searching•15 minutes
- Choosing the right tool: Data structure selection•15 minutes
- Data structure exercises: Practice makes perfect•20 minutes
- Data structures in Python•30 minutes
This module develops the skills required to identify and resolve errors in Python programs. Learners examine common exceptions, interpret error messages, and use print statements and interactive debugging tools to trace program execution. They also use try-except blocks to manage anticipated exceptions and prevent unexpected program termination. A systematic debugging process is applied to locate causes, test corrections, and improve program reliability.
What's included
10 videos4 readings6 assignments
10 videos•Total 49 minutes
- Introduction to error handling and debugging•2 minutes
- Python exceptions part 1: Understanding the red flags•6 minutes
- Python exceptions part 2: Anatomy of an exception•5 minutes
- Print debugging: Your trusty sidekick•5 minutes
- Interactive debuggers: Stepping through your code•2 minutes
- Debugger: The why and how•6 minutes
- Catching errors with try-except•6 minutes
- Demo: Examples of real-world exception handling•6 minutes
- The detective's guide to debugging•6 minutes
- Demo: Debugging in action•5 minutes
4 readings•Total 40 minutes
- Common Python exceptions: A field guide•10 minutes
- Debugging toolkit: Essential techniques for Python developers•10 minutes
- Exception handling best practices•10 minutes
- Common debugging strategies used by experienced developers•10 minutes
6 assignments•Total 105 minutes
- Common Python exceptions•15 minutes
- Activity: Debugging code•15 minutes
- Basic debugging techniques•15 minutes
- Exception handling in Python•15 minutes
- The debugging mindset: A systematic approach•15 minutes
- Error handling and debugging•30 minutes
This module introduces practices used to test, manage, and present Python projects. Learners examine the purpose of unit testing and use pytest to create, organize, and execute tests. They then use Git to track changes and manage branches and distinguish Git-based version control from GitHub-based project hosting. The module concludes with the development of a professional GitHub portfolio that presents Python projects and technical skills.
What's included
10 videos10 readings5 assignments1 programming assignment
10 videos•Total 51 minutes
- Why unit tests matter•6 minutes
- Unit testing: Removing bugs from your code•6 minutes
- Demo: Getting started with pytest•6 minutes
- pytest tips and tricks•6 minutes
- Git essentials for working developers•6 minutes
- Git: Your code's time machine•2 minutes
- The benefits of version control•3 minutes
- Demo: Getting setup in GitHub•5 minutes
- Demo: What is the difference between Git and GitHub?•6 minutes
- Demo: Examining a GitHub portfolio•6 minutes
10 readings•Total 100 minutes
- Unit testing fundamentals•10 minutes
- pytest fixtures: Setting the stage for your tests•10 minutes
- Test organization and structure in pytest: Keeping your tests tidy•10 minutes
- Introduction to Git•10 minutes
- Git for beginners•10 minutes
- Setting up Git•10 minutes
- Creating a software development portfolio•10 minutes
- Set up your GitHub account•10 minutes
- A guide to 'Solve problems with Python'•10 minutes
- Python programming fundamentals: Putting it all together•10 minutes
5 assignments•Total 90 minutes
- Introduction to unit testing•15 minutes
- pytest: your Python testing companion•15 minutes
- Rewinding time: Version control with Git•15 minutes
- Your professional portfolio•15 minutes
- Test basics & version control•30 minutes
1 programming assignment•Total 30 minutes
- Activity: Solve problems with Python•30 minutes
Earn a career certificate
Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.
Instructor

Offered by

Why people choose Coursera for their career

Felipe M.

Jennifer J.

Larry W.

Chaitanya A.
Frequently asked questions
You'll learn how to write, run, and troubleshoot Python programs with confidence. It starts with syntax and program flow, then builds into reusable code, data structures, and the habits that help keep code reliable and organized. You'll apply those ideas in short coding tasks such as writing simple scripts, using loops to process lists, and fixing common errors in working code.
No, you don't need prior Python experience, work experience, or a degree to start. The course begins with setting up Python and Jupyter Notebook, then walks you through simple programs, variables, and basic operations. Some general comfort using a computer will help, but it doesn't assume you've coded before.
Yes, it's beginner-friendly if you want a full introduction rather than a quick syntax cheat sheet. The course explains core ideas step by step and reinforces them with short exercises, quizzes, and coding tasks. If you're already comfortable writing Python, it may feel basic at the start, but it's useful if you also want practice with debugging and Git.
Plan on about 25 hours in total. At roughly 10 hours a week, that works out to around 2 to 3 weeks, depending on how much time you spend practicing code. The course includes lessons, readings, quizzes, coding assignments, and guided exercises, so the workload is varied rather than just video-based.
Yes, there is regular hands-on work, but it's mostly guided rather than one large open-ended project. You'll debug small programs, write loops to transform data, work with lists and dictionaries, and complete a programming assignment that applies conditional logic and iteration. There's also a guided lab on creating and using Python modules, so you put each idea to work soon after you learn it.
The course covers writing basic Python programs, controlling flow, and turning repeated logic into reusable code. It also works through data structures, debugging and exception handling, then finishes with testing, Git, and GitHub portfolio basics. Overall, it's about the everyday skills that help you write clean Python and manage your work as it grows.
By the end, you should be able to write small Python scripts that use variables, conditionals, loops, functions, and common data structures. You'll also be able to debug common errors, handle exceptions, and track simple work with Git. For example, you should be comfortable writing a script that processes a list of values, stores results in a dictionary, and then tests or fixes it when something breaks.
It's closer to concept-first learning with regular coding reinforcement than to a project-heavy bootcamp. The course spends time explaining how Python works, then reinforces each topic through short coding activities, quizzes, and debugging exercises.
Choose this course if you want a broad Python foundation that goes beyond syntax into debugging, testing, Git, and GitHub. Instead of stopping at basic scripts, it shows how to organize code with functions and modules, work with data structures, and manage your work more systematically. If you want a beginner course that blends core coding practice with the habits used to maintain and share code, this course is a strong fit.