Skip to main content

Python Dynamic Typing Quiz

· 6 min read

Progress

Score: 0/20

🎩 Master Quiz: Dynamic Typing

20 Questions. Sticker vs. Box. Strong vs. Weak. Green = Correct, Red = Incorrect.

BeginnerAnalogy

In the "Sticker vs. Box" analogy, what corresponds to Static Typing (Java/C++)?​

  • **A) The Handheld Label Maker**
  • **B) The Engraved Box ("Shoes Only")**
  • **C) The Pizza**
  • **D) The Shoe**

💡 Explanation​

The Engraved Box.

In Static typing, the container (variable) enforces the type. If the box says "Shoes Only", you cannot put a Pizza in it.

BeginnerAnalogy

In the "Sticker vs. Box" analogy, what corresponds to Dynamic Typing (Python)?​

  • **A) The Handheld Sticker Gun**
  • **B) The Engraved Box**
  • **C) The Factory**
  • **D) The Compiler**

💡 Explanation​

The Sticker Gun.

You create a label (variable) and can stick it on anything (Integer, String, etc.). The sticker doesn't care what it's attached to.

CoreType Binding

Where is the "Type" tied to in Python?​

  • **A) The Variable Name**
  • **B) The Object (Value) in Memory**
  • **C) The Compiler**
  • **D) The File Extension**

💡 Explanation​

The Object in Memory.

The variable is just a name tag. The actual object (e.g., the number 5) holds the type information.

IntermediateReassignment

What happens if you run x = 5 then x = "Guru"?​

  • **A) Allowed (x now points to "Guru")**
  • **B) TypeError (x is an Integer)**
  • **C) Compiler Error**
  • **D) x becomes "5"**

💡 Explanation​

Allowed.

You are simply peeling the sticker off the Integer 5 and sticking it onto the String "Guru".

IntermediateType Checking

When does Python check for type errors?​

  • **A) Compile Time (Before running)**
  • **B) While typing in the IDE**
  • **C) Runtime (When the line executes)**
  • **D) Never**

💡 Explanation​

Runtime.

Python checks the type only when the code actually runs. This is why some bugs can hide until that specific line is executed.

BeginnerComparison

When does Java/C++ check for type errors?​

  • **A) Compile Time (Before running)**
  • **B) Runtime**
  • **C) Only when user inputs data**
  • **D) Never**

💡 Explanation​

Compile Time.

The compiler screams at you before you can even run the program if you violate type rules.

AdvancedClassification

Is Python "Strongly Typed" or "Weakly Typed"?​

  • **A) Strongly Typed**
  • **B) Weakly Typed**
  • **C) Both**
  • **D) Neither**

💡 Explanation​

Strongly Typed.

Do not confuse Dynamic with Weak. Python is Strong because it forbids implicit weird conversions like 1 + "1".

AdvancedStrong vs Weak

What happens if you run 1 + "1" in Python?​

  • **A) "11"**
  • **B) 2**
  • **C) TypeError (Crash)**
  • **D) None**

💡 Explanation​

TypeError.

JavaScript (Weak) would give "11". Python (Strong) refuses to mix types implicitly.

ArchitectRisk

What is the biggest risk of Dynamic Typing for Architects?​

  • **A) Slow compilation**
  • **B) Runtime Errors (Crashes in production)**
  • **C) Hard drive space**
  • **D) Too much boilerplate**

💡 Explanation​

Runtime Errors.

If a variable unexpectedly holds None instead of a User object, the script crashes only when that line is hit in production.

ArchitectModern Python

What feature (Python 3.5+) helps mitigate dynamic typing risks?​

  • **A) Compilers**
  • **B) Strict Mode**
  • **C) Type Hints**
  • **D) Macros**

💡 Explanation​

Type Hints.

Example: age: int = 25. This helps IDEs and linters catch errors before you run the code.

AdvancedType Hints

Do Type Hints prevent the code from running if violated?​

  • **A) Yes, Python stops execution**
  • **B) No, Python ignores them at runtime**
  • **C) Only in Python 3.10+**
  • **D) Yes, if using VS Code**

💡 Explanation​

No.

Type hints are for developers and tools (like MyPy). The Python interpreter completely ignores them at runtime.

ConceptDuck Typing

What is the core philosophy of "Duck Typing"?​

  • **A) "If it walks and quacks like a duck, it's a duck"**
  • **B) "Variables must be declared as Ducks"**
  • **C) "Ducks are immutable"**
  • **D) "Type checking is strict"**

💡 Explanation​

If it walks/quacks like a duck...

Python doesn't care about the official class type. It only cares if the object has the methods/behaviors you are trying to use.

IntermediateDuck Typing Example

Does Python care if an object is officially a "File"?​

  • **A) Yes, it must inherit from File**
  • **B) No, as long as it has a .read() method**
  • **C) Only in standard libraries**
  • **D) Yes, for security reasons**

💡 Explanation​

No.

If you create a custom class that has a .read() method, Python will happily treat it like a file.

AdvancedPerformance

Why is Dynamic Typing generally slower than Static Typing?​

  • **A) Runtime Type Checking overhead**
  • **B) It uses more Hard Drive space**
  • **C) It requires internet access**
  • **D) It isn't slower**

💡 Explanation​

Runtime Type Checking overhead.

Python has to ask "What type is this?" every single time you touch a variable, whereas C++ knows the type in advance.

BenefitUse Case

What is a major benefit of Dynamic Typing?​

  • **A) Compilation speed**
  • **B) Zero runtime errors**
  • **C) Less Boilerplate / Rapid Prototyping**
  • **D) Strict memory management**

💡 Explanation​

Less Boilerplate.

You don't need to write int, float, string everywhere. You just write logic, making it faster to write.

IntermediateGeneric Functions

How does Python handle "Generic Functions" (one function for multiple types)?​

  • **A) You must write overloaded functions**
  • **B) It happens automatically (Natural support)**
  • **C) You need a special library**
  • **D) It is impossible**

💡 Explanation​

Natural support.

Since Python doesn't enforce types on arguments, a single function process(data) can handle Lists, Tuples, or JSON without extra code.

SyntaxType Hinting

What is the correct syntax for a Type Hint?​

  • **A) age: int = 25``**
  • **B) int age = 25``**
  • **C) var age = 25``**
  • **D) age = (int) 25``**

💡 Explanation​

age: int = 25

This syntax (introduced in PEP 484) allows you to annotate the expected type.

ArchitectMemory

When x = 5 is reassigned to x = "Guru", what happens to the 5?​

  • **A) It stays in memory forever**
  • **B) It is overwritten by "Guru"**
  • **C) It is Garbage Collected**
  • **D) It moves to the Stack**

💡 Explanation​

It is Garbage Collected.

Since the label x no longer points to 5, the reference count for 5 drops to zero, and the Cleaning Crew deletes it.

IntermediateComparison

Can you reuse a variable name for a different type in Static Typing (Java)?​

  • **A) Yes**
  • **B) No, Compiler Error**
  • **C) Only for Strings**
  • **D) Only if you cast it**

💡 Explanation​

No.

In Static typing, the type is tied to the variable (The Box). You cannot put a String into a variable declared as an Integer.

ArchitectCode Readability

What is the "Mystery Meat" variable problem?​

  • **A) Not knowing a variable's type without reading context**
  • **B) Variables getting deleted randomly**
  • **C) Variables with long names**
  • **D) Using too many global variables**

💡 Explanation​

Not knowing a variable's type.

In large scripts, seeing a variable named data is confusing. Is it a list? A dict? A string? Static typing avoids this ambiguity.

🎉 Quiz Complete!​

Your Final Score:

0/20 Novice

Keep practicing to reach Architect level!

  • **↺ Retake Quiz**