freeCodeCamp Scientific Computing with Python Syllabus

Scientific Computing with Python syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Scientific Computing with Python in freeCodeCamp, not a summary of it.

1. 1

   Python Fundamentals

   4 topics

   • Variables and Data Types
   • Conditionals and Loops
   • Functions
   • Strings and Formatting
2. 2

   Data Structures

   3 topics

   • Lists and Tuples
   • Dictionaries and Sets
   • Comprehensions
3. 3

   Object Oriented Python

   2 topics

   • Classes and Objects
   • Inheritance and Polymorphism
4. 4

   Working with Files and Modules

   3 topics

   • Reading and Writing Files
   • Importing Modules
   • Regular Expressions
5. 5

   Networking and Databases

   2 topics

   • Working with APIs
   • SQLite Databases
6. 6

   Certification Projects

   5 topics

   • Arithmetic Formatter
   • Time Calculator
   • Budget App
   • Polygon Area Calculator
   • Probability Calculator

Scientific Computing with Python flashcards for freeCodeCamp

21 of 50 cards from the Scientific Computing with Python deck — real questions with worked answers.

1. In Python, what are the four primary primitive data types, and how do you check the type of a variable?

   int (integers), float (decimal numbers), str (text strings), and bool (True/False). Use the built-in function type(x) to check a variable's type, e.g. type(3.14) returns <class 'float'>.

2. What is the difference between dynamic typing and static typing, and which does Python use?

   Python is dynamically typed: a variable's type is determined at runtime from the value assigned, and the same name can be rebound to values of different types. Statically typed languages (like C or Java) fix a variable's type at declaration and check it at compile time.

3. In Python, what do the operators /, //, %, and ** compute? Give the result of each for 7 and 2.

   / is true division: $7 / 2 = 3.5$; // is floor division: $7 \; // \; 2 = 3$; % is modulo (remainder): $7 \bmod 2 = 1$; ** is exponentiation: $7^{2} = 49$.

4. Which values are considered 'falsy' in Python conditionals?

   False, None, zero of any numeric type ($0$, $0.0$), and empty collections: '' (empty string), [] (empty list), () (empty tuple), {} (empty dict), and set(). Everything else evaluates as truthy.

5. What is the difference between the break and continue statements inside a Python loop?

   break exits the loop entirely, skipping any remaining iterations. continue skips the rest of the current iteration and jumps to the next iteration of the loop.

6. What does the else clause on a Python for or while loop do?

   The else block runs only if the loop completes normally, i.e. it was never terminated by a break statement. It is commonly used in search loops to handle the 'not found' case.

7. In a Python function definition, what is the difference between *args and **kwargs?

   *args collects any extra positional arguments into a tuple; **kwargs collects any extra keyword arguments into a dictionary. They let a function accept a variable number of arguments.

8. What does a Python function return if it has no return statement (or a bare return)?

   It returns None. Every Python function returns a value; if none is specified explicitly, the implicit return value is None.

9. What is a lambda function in Python and what is its syntax?

   An anonymous, single-expression function written as lambda parameters: expression. Example: square = lambda x: x**2 defines a function computing $x^{2}$. Lambdas are often passed to functions like sorted(), map(), and filter() as the key or transform.

10. Name the three main ways to format strings in Python and show the modern preferred one.

    1) f-strings: f"Hello {name}" (preferred, Python 3.6+); 2) the str.format() method: "Hello {}".format(name); 3) %-formatting: "Hello %s" % name. F-strings evaluate expressions directly inside the braces.

11. In an f-string, what does the format spec {value:.2f} do, and what does {n:>8} do?

    {value:.2f} formats the number as a float with exactly 2 digits after the decimal point (e.g. 3.14159 becomes 3.14). {n:>8} right-aligns the value in a field 8 characters wide, padding with spaces on the left.

12. Why are Python strings called immutable, and what happens when you 'modify' one?

    Immutable means the character sequence cannot be changed in place; s[0] = 'x' raises a TypeError. Any operation that appears to modify a string (concatenation, replace(), upper()) actually creates and returns a brand-new string object.

13. What are the key differences between a Python list and a tuple?

    Lists are mutable (elements can be added, removed, changed) and written with brackets [1, 2, 3]; tuples are immutable and written with parentheses (1, 2, 3). Tuples can be used as dictionary keys and set elements because they are hashable; lists cannot. Tuples are slightly faster and signal fixed structure.

14. What does the slice syntax list[start:stop:step] return, and what does lst[::-1] do?

    It returns a new list containing elements from index start up to but not including stop, taking every step-th element. lst[::-1] returns a reversed copy of the list. Omitted values default to start=0, stop=len(lst), step=1.

15. Compare the list methods append(), extend(), and insert().

    append(x) adds the single item x to the end of the list; extend(iterable) adds each element of the iterable to the end individually; insert(i, x) inserts x at index i, shifting later elements right. append([1,2]) adds one nested list, while extend([1,2]) adds two elements.

16. What are the requirements for Python dictionary keys, and what happens when you assign to an existing key?

    Keys must be hashable (immutable types such as str, int, float, tuple of immutables); lists and dicts cannot be keys. Assigning to an existing key overwrites its value — dictionaries hold at most one value per key.

17. What is the difference between dict[key] and dict.get(key) when the key is missing?

    dict[key] raises a KeyError if the key does not exist. dict.get(key) returns None instead (or a chosen fallback via dict.get(key, default)), so it never raises for a missing key.

18. What are the four main set operations in Python, with their operators?

    Union: $A \cup B$ via a | b (elements in either); intersection: $A \cap B$ via a & b (elements in both); difference: $A \setminus B$ via a - b (in a but not b); symmetric difference: $A \triangle B$ via a ^ b (in exactly one). Sets also enforce uniqueness — duplicates are automatically removed.

19. Write a list comprehension that produces the squares of the even numbers from 0 to 9, and state the general syntax.

    [x**2 for x in range(10) if x % 2 == 0] gives [0, 4, 16, 36, 64], i.e. $x^{2}$ for even $x$. General syntax: [expression for item in iterable if condition] — the if filter is optional.

20. How do dictionary comprehensions and set comprehensions differ syntactically from list comprehensions?

    Both use braces instead of brackets. A dict comprehension has a key:value pair: {k: v for k, v in pairs}, e.g. {x: x**2 for x in range(5)}. A set comprehension has a single expression: {x % 3 for x in nums}. Brackets [] would instead produce a list.

21. What is the difference between a list comprehension and a generator expression in Python?

    A list comprehension [x*2 for x in data] builds the whole list in memory immediately. A generator expression (x*2 for x in data) uses parentheses and produces values lazily, one at a time, using constant memory — but it can only be iterated once.

See more Scientific Computing with Python flashcards →

Planning Scientific Computing with Python for freeCodeCamp

Scientific Computing with Python (freeCodeCamp) FAQ