100+ Python Commands List With Examples PDF (2025 Guide)

by

Python is one of the most popular programming languages in the world. It is an interpreted, high-level, general-purpose programming language created by Guido van Rossum in 1991. Thanks to its simple syntax and readability, Python has become the go-to first language for beginners and is equally powerful for professionals working in data science, web development, automation, and AI.

When learners search for Python commands, they usually mean:

  • Python keywords / statements (e.g., if, for, try, def, import)
  • Python built-in functions (e.g., print(), len(), type())
  • Object methods for strings, lists, tuples, sets, and dictionaries (e.g., append(), split(), get())
  • REPL commands (e.g., help(), dir(), _) used in the Python shell
  • CLI commands like python script.py, pip install, or python -m venv

In this guide, we’ll treat “commands” as all the actions you can run in Python: from built-in functions to common shell commands.

By the end of this post, you’ll have a complete Python commands list with examples that covers:

  • Basic Python commands for beginners
  • String, list, tuple, set, and dictionary commands
  • Loop commands with real-world usage
  • Advanced commands for files, modules, and exceptions
  • Python REPL & CLI commands (pip install, python -m pip)
  • Common pitfalls and pro tips

Python Commands List With Examples

Table of Contents

Basic Python Commands You Must Know

If you’re just starting with Python, there are a handful of basic commands you’ll use every single day. These commands cover printing output, taking input, checking types, working with ranges, rounding numbers, and managing packages.

Let’s go through them one by one with syntax, examples, and pro tips.

print() Command

The print() command is used to display output on the screen or console.

Syntax:

print(object, ..., sep=' ', end='\n')

Example:

print("Hello, World!")  
print("Sum =", 5 + 3)

Pro Tip: You can use the sep and end parameters for formatted output:

print("Python", "Commands", sep=" - ", end=" !!!\n")
# Output: Python - Commands !!!

input() Command

The input() command is used to take input from the user.

Syntax:

input("message")

Example:

name = input("Enter your name: ")
print("Welcome,", name)

Pro Tip: The input() command always returns a string. If you need an integer, convert it using int():

age = int(input("Enter your age: "))

type() Command

The type() command is used to check the type of an object.

Syntax:

type(object)

Example:

print(type(42))       # <class 'int'>
print(type("hello"))  # <class 'str'>
print(type([1,2,3]))  # <class 'list'>

len() Command

The len() command is used to find the length (number of elements) in an object.

Syntax:

len(object)

Example:

print(len("Python"))       # 6
print(len([10, 20, 30]))   # 3

Pro Tip: Works on strings, lists, tuples, sets, and dictionaries, but not on integers.

range() Command

The range() command generates a sequence of numbers, often used in loops.

Syntax:

range(start, stop, step)
  • start: starting number (default 0)
  • stop: number before which to stop (required)
  • step: increment (default 1)

Example:

for i in range(5):
    print(i)  
# Output: 0 1 2 3 4

for i in range(2, 10, 2):
    print(i)
# Output: 2 4 6 8

Pro Tip: If you give two parameters, Python treats them as (start, stop) and not (stop, step).

round() Command

The round() command is used to round numbers to a given decimal precision.

Syntax:

round(number, digits)
  • number: floating-point number
  • digits: how many decimal places (default = 0)

Example:

print(round(3.14159, 2))   # 3.14
print(round(15.678, 0))    # 16.0

pip install Command (CLI)

The pip install command is used to install external Python packages.

Syntax (Windows/Linux/macOS):

python -m pip install package-name

Example:

python -m pip install requests
Pro Tip: Always use python -m pip instead of pip directly to avoid version conflicts.

Loop Commands in Python

Loops are an essential part of Python programming. They allow us to execute a block of code multiple times until a condition is met or a sequence is exhausted.

Python provides two primary loop commands:

  • for loop → iterate over a sequence
  • while loop → repeat until a condition is false

Additionally, loop control commands like break, continue, and pass help fine-tune loop execution.

while Loop

The while loop executes as long as a condition remains True.

Syntax:

while condition:
    statements
    update

Example:

count = 1
while count <= 5:
    print("Count:", count)
    count += 1

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5

Pro Tip: Always make sure to update the loop variable inside a while loop. Forgetting it will create an infinite loop.

for Loop

The for loop in Python is used to iterate directly over sequences (like lists, strings, dictionaries, etc.).

Syntax:

for variable in sequence:
    statements

Example (list iteration):

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

Output:

apple
banana
cherry

Example (string iteration):

for ch in "Python":
    print(ch, end=" ")
# Output: P y t h o n

Pro Tip: Use enumerate() when you need both index and value:

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output: 0 apple, 1 banana, 2 cherry

break Command

The break command stops the loop completely, even if the condition isn’t finished.

Example:

for n in range(10):
    if n == 5:
        break
    print(n)

Output:

0
1
2
3
4

continue Command

The continue command skips the current iteration and moves to the next.

Example:

for n in range(6):
    if n % 2 == 0:
        continue
    print(n)

Output:

1
3
5

pass Command

The pass command does nothing – it’s used as a placeholder when a statement is required but you don’t want any action.

Example:

for n in range(3):
    pass  # Placeholder for future code

Pro Tip: pass is commonly used when defining empty classes or functions during prototyping.

String Commands in Python

Strings are one of the most commonly used data types in Python. They are immutable sequences of characters, meaning once created, a string cannot be changed – every modification returns a new string.

Python provides dozens of string methods (often called string commands). Below are the most important ones with syntax, examples, and outputs.

Table: Common String Commands in Python

Command Purpose Syntax Example Output
upper() Converts string to uppercase string.upper() "python".upper() PYTHON
lower() Converts string to lowercase string.lower() "HELLO".lower() hello
capitalize() Capitalizes the first letter string.capitalize() "python".capitalize() Python
title() Capitalizes first letter of each word string.title() "python commands".title() Python Commands
strip() Removes spaces (leading/trailing) string.strip() " hello ".strip() hello
replace() Replaces substring with another string.replace(old, new) "hello".replace("l","x") hexxo
split() Splits string into list string.split(sep) "a,b,c".split(",") ['a', 'b', 'c']
join() Joins list into string sep.join(list) ",".join(["a","b"]) a,b
find() Finds first occurrence index string.find(sub) "python".find("t") 2
count() Counts substring occurrences string.count(sub) "banana".count("a") 3
startswith() Checks if string starts with substring string.startswith(sub) "python".startswith("py") True
endswith() Checks if string ends with substring string.endswith(sub) "hello".endswith("o") True
isalnum() Returns True if all characters are alphanumeric string.isalnum() "abc123".isalnum() True
isalpha() Returns True if all characters are alphabets string.isalpha() "python".isalpha() True
isdigit() Returns True if all characters are digits string.isdigit() "12345".isdigit() True

Examples in Action

s = "  python programming  "

print(s.strip())           # python programming
print(s.upper())           # PYTHON PROGRAMMING
print(s.capitalize())      # Python programming
print(s.find("pro"))       # 9
print(s.count("m"))        # 2

Pro Tips:

  • Use split() + join() together to clean and reformat strings.
  • Always remember: strings are immutable, so methods like .replace() don’t modify the original string.

List Commands in Python

A list in Python is a mutable, ordered collection that can hold elements of different data types.
Lists are one of the most powerful and widely used data structures in Python.

Python provides many built-in list methods (often called list commands). Below are the most important ones with syntax, examples, and outputs.

Table: Common List Commands in Python

Command Purpose Syntax Example Output
append() Adds element to end of list list.append(x) nums = [1,2]; nums.append(3) [1, 2, 3]
insert() Inserts element at index list.insert(i, x) nums = [1,2]; nums.insert(1, 99) [1, 99, 2]
extend() Adds multiple elements list.extend(iterable) [1,2].extend([3,4]) [1,2,3,4]
pop() Removes & returns element (last by default) list.pop(i) nums=[10,20,30]; nums.pop() Returns 30, list → [10,20]
remove() Removes first occurrence of element list.remove(x) nums=[1,2,3]; nums.remove(2) [1,3]
clear() Removes all items list.clear() nums=[1,2]; nums.clear() []
sort() Sorts list in ascending order list.sort() [3,1,2].sort() [1,2,3]
reverse() Reverses order of list list.reverse() [1,2,3].reverse() [3,2,1]
copy() Returns shallow copy list.copy() a=[1,2]; b=a.copy() b = [1,2]
count() Counts occurrences of element list.count(x) [1,2,2,3].count(2) 2
index() Returns index of first occurrence list.index(x) [10,20,30].index(20) 1

Examples in Action

nums = [3, 1, 2]
nums.append(4)
print(nums)  # [3, 1, 2, 4]

nums.insert(1, 99)
print(nums)  # [3, 99, 1, 2, 4]

nums.sort()
print(nums)  # [1, 2, 3, 4, 99]

nums.reverse()
print(nums)  # [99, 4, 3, 2, 1]

Pro Tips:

  • Use list.copy() instead of = when you need an actual copy (not a reference).
  • Prefer sorted(list) (returns a new sorted list) if you don’t want to modify the original list.
  • list.remove(x) raises an error if x doesn’t exist – use if x in list: before removing.

Tuple Commands in Python

A tuple in Python is an ordered, immutable collection.
Unlike lists, tuples cannot be modified once created – meaning you can’t append, insert, or remove elements.
However, they are faster than lists and are often used when you need read-only collections.

Python provides only two built-in tuple methods: count() and index().

Tuple Commands in Python

Command Purpose Syntax Example Output
count() Returns number of times an element appears in the tuple tuple.count(x) (1,2,2,3).count(2) 2
index() Returns the index of the first occurrence of an element tuple.index(x) (10,20,30).index(20) 1

Examples in Action

t = (5, 10, 15, 10, 20)

print(t.count(10))   # 2
print(t.index(15))   # 2

Pro Tips:

  • Since tuples are immutable, you cannot modify them – but you can convert them into a list if needed:
t = (1, 2, 3)
lst = list(t)
lst.append(4)
print(lst)  # [1, 2, 3, 4]
  • Use tuples when you need fixed data, such as coordinates ((x, y)), RGB colors, or database keys.

Set Commands in Python

A set in Python is an unordered, unindexed collection that does not allow duplicate values.
Sets are commonly used when you need to store unique elements or perform mathematical operations like union, intersection, and difference.

Python provides a variety of built-in set methods to manipulate and query sets.

Common Set Commands in Python

Command Purpose Syntax Example Output
add() Adds an element to the set set.add(x) s={1,2}; s.add(3) {1,2,3}
remove() Removes element, raises error if not found set.remove(x) s={1,2}; s.remove(2) {1}
discard() Removes element, does nothing if not found set.discard(x) s={1,2}; s.discard(3) {1,2}
pop() Removes & returns a random element set.pop() s={1,2,3}; s.pop() Removes one random element
clear() Removes all elements set.clear() s={1,2}; s.clear() set()
union() Returns union of sets (all elements) set1.union(set2) {1,2}.union({2,3}) {1,2,3}
intersection() Returns common elements set1.intersection(set2) {1,2}.intersection({2,3}) {2}
difference() Returns elements in first set but not in second set1.difference(set2) {1,2,3}.difference({2,3}) {1}
symmetric_difference() Returns elements in either set but not both set1.symmetric_difference(set2) {1,2}.symmetric_difference({2,3}) {1,3}
issubset() Checks if all elements of set A are in set B setA.issubset(setB) {1,2}.issubset({1,2,3}) True
issuperset() Checks if set A contains all elements of set B setA.issuperset(setB) {1,2,3}.issuperset({2,3}) True
copy() Returns a shallow copy of set set.copy() s={1,2}; t=s.copy() t={1,2}

Examples in Action

A = {1, 2, 3}
B = {3, 4, 5}

print(A.union(B))            # {1, 2, 3, 4, 5}
print(A.intersection(B))     # {3}
print(A.difference(B))       # {1, 2}
print(A.symmetric_difference(B))  # {1, 2, 4, 5}

# Subset / Superset checks
print({1,2}.issubset(A))     # True
print(A.issuperset({2,3}))   # True

Pro Tips:

  • Use discard() instead of remove() if you’re not sure an element exists (avoids KeyError).
  • Sets are unordered, so the order of elements when printed may vary.
  • Great for deduplication:
nums = [1, 2, 2, 3, 3, 3]
unique = set(nums)
print(unique)  # {1, 2, 3}

Dictionary Commands in Python

A dictionary in Python is an unordered, mutable collection that stores data in key-value pairs.

  • Keys must be unique and immutable (e.g., strings, numbers, tuples).
  • Values can be of any data type and may repeat.

Python dictionaries are extremely powerful, and Python provides many built-in dictionary methods to manipulate and query them.

Common Dictionary Commands in Python

Command Purpose Syntax Example Output
get() Returns value of key (default if not found) dict.get(key, default) d={"a":1}; d.get("b",0) 0
keys() Returns all keys dict.keys() d={"a":1,"b":2}; d.keys() dict_keys(['a','b'])
values() Returns all values dict.values() d={"a":1,"b":2}; d.values() dict_values([1,2])
items() Returns key-value pairs dict.items() d={"a":1,"b":2}; d.items() dict_items([('a',1),('b',2)])
update() Updates dictionary with another dict dict.update(other_dict) d={"a":1}; d.update({"b":2}) {'a':1,'b':2}
pop() Removes key and returns its value dict.pop(key) d={"a":1,"b":2}; d.pop("a") Returns 1, dict → {'b':2}
popitem() Removes & returns last inserted key-value pair dict.popitem() d={"a":1,"b":2}; d.popitem() Returns ('b',2)
clear() Removes all items dict.clear() d={"a":1}; d.clear() {}
copy() Returns shallow copy dict.copy() d={"a":1}; c=d.copy() {'a':1}
setdefault() Returns value of key; inserts if missing dict.setdefault(key, default) d={"a":1}; d.setdefault("b",99) {'a':1,'b':99}
fromkeys() Creates new dict from keys with given value dict.fromkeys(keys, value) dict.fromkeys(["x","y"],0) {'x':0,'y':0}

Examples in Action

user = {"name": "Alice", "age": 25}

print(user.get("name"))      # Alice
print(user.get("city", "N/A"))  # N/A

print(user.keys())           # dict_keys(['name', 'age'])
print(user.values())         # dict_values(['Alice', 25])
print(user.items())          # dict_items([('name','Alice'),('age',25)])

# Updating and removing
user.update({"city": "Paris"})
print(user)                  # {'name':'Alice','age':25,'city':'Paris'}

print(user.pop("age"))       # 25
print(user)                  # {'name':'Alice','city':'Paris'}

Pro Tips:

  • Use get() instead of direct indexing (dict[key]) when you’re unsure if a key exists → avoids KeyError.
  • Use setdefault() to initialize missing keys in one line.
  • popitem() removes the last inserted item (in Python 3.7+ dictionaries preserve insertion order).
  • Use dictionary comprehensions for quick transformations:
squares = {x: x*x for x in range(5)}
print(squares)  # {0:0, 1:1, 2:4, 3:9, 4:16}

Intermediate & Advanced Python Commands

Once you’re comfortable with Python basics, the next step is mastering commands that let you write cleaner, faster, and more powerful code.
These include comprehensions, functions, error handling, file handling, and modules.

List, Dictionary & Set Comprehensions

Comprehensions are shortcuts for creating new collections from existing ones. They are concise and usually faster than loops.

Examples:

# List comprehension
squares = [x*x for x in range(5)]
print(squares)  # [0, 1, 4, 9, 16]

# Dictionary comprehension
squares_dict = {x: x*x for x in range(5)}
print(squares_dict)  # {0:0, 1:1, 2:4, 3:9, 4:16}

# Set comprehension
unique_chars = {c for c in "programming"}
print(unique_chars)  # {'m', 'o', 'i', 'a', 'g', 'n', 'p', 'r'}

Pro Tip: Use comprehensions instead of loops for transforming data – they’re cleaner and faster.

Functions (def & lambda)

Defining Functions

def greet(name, loud=False):
    msg = f"Hello, {name}"
    return msg.upper() if loud else msg

print(greet("Ada"))        # Hello, Ada
print(greet("Ada", True))  # HELLO, ADA

Lambda Functions (Anonymous Functions)

square = lambda x: x*x
print(square(4))  # 16

Pro Tip: Use lambda for one-line throwaway functions, but prefer def for reusable logic.

File Handling Commands

Python makes file I/O simple with the open() function and the modern pathlib module.

Using open()

with open("data.txt", "w") as f:
    f.write("Hello, Python!\n")

with open("data.txt", "r") as f:
    print(f.read())  # Hello, Python!

Using pathlib (Recommended)

from pathlib import Path

p = Path("example.txt")
p.write_text("Python commands are awesome!")
print(p.read_text())

Pro Tip: Always use with open() or pathlib to automatically close files and avoid leaks.

Exception Handling Commands

Errors are inevitable. Python provides the try-except block to handle them gracefully.

try:
    num = int("abc")  # invalid conversion
except ValueError as e:
    print("Error:", e)
finally:
    print("This always runs")

Pro Tips:

  • Catch specific errors (ValueError, KeyError) instead of using bare except:.
  • Use raise to create your own exceptions.

Importing and Using Modules

Python modules let you organize and reuse code.

Examples:

import math
print(math.sqrt(16))  # 4.0

from collections import Counter
print(Counter("banana"))  # Counter({'a':3,'n':2,'b':1})

Pro Tip:

  • Use aliases (import numpy as np) for long module names.
  • Avoid from module import * – it pollutes the namespace.

Python REPL Commands

The REPL (Read–Eval–Print Loop) is Python’s interactive shell that lets you run commands line by line without writing a full script. It’s an excellent tool for testing, debugging, and exploring objects in Python. Here are the most useful Python REPL commands:

help() Command

Displays the documentation of objects, modules, or functions.

Example:

help(str)         # Shows documentation for string type
help(str.split)   # Shows help for split() method

Pro Tip: Type help() alone, and you’ll enter an interactive help system.

dir() Command

Lists all the attributes and methods of an object.

Example:

print(dir(list))  
# Output includes: append, extend, insert, pop, remove, sort, ...

Pro Tip: dir() is perfect for discovering what methods a type or module provides.

type() Command (often used in REPL)

Shows the class/type of an object.

print(type(42))       # <class 'int'>
print(type([1, 2]))   # <class 'list'>

The Underscore _ Command

In REPL, _ stores the result of the last evaluated expression.

Example:

>>> 5 + 3
8
>>> _ * 2
16

Pro Tip: _ is handy for quick calculations but avoid using it in scripts (only works in REPL).

quit() and exit()

Used to exit the Python shell.

Example:

quit()
# or
exit()

Python CLI & pip Commands

Python doesn’t just run inside scripts – it can also be executed directly from the command line (CLI).
This is where you use commands like python, python -m venv, and pip install.

Let’s break them down:

Running Python from the Command Line

You can run Python interactively or execute scripts from your terminal.

Check your Python version:

python --version

Run Python in interactive mode (REPL):

python

Run a Python script:

python script.py

Pro Tip: On some systems, you may need to use python3 instead of python.

Virtual Environment Commands (venv)

Virtual environments are used to isolate dependencies so projects don’t conflict.

Create a virtual environment:

python -m venv .venv

Activate the environment:

  • On macOS/Linux: 
    source .venv/bin/activate
  • On Windows: 
    .venv\Scripts\activate

Deactivate the environment:

deactivate

Pro Tip: Always use virtual environments to keep dependencies clean, especially in professional projects.

pip (Python Package Installer) Commands

pip is Python’s package manager, used to install, upgrade, and remove libraries.

Install a package:

python -m pip install requests

Upgrade a package:

python -m pip install --upgrade requests

Uninstall a package:

python -m pip uninstall requests

List installed packages:

python -m pip list

Pro Tip: Always use python -m pip instead of just pip to avoid version mismatches.

Common Pitfalls & Pro Tips in Python Commands

Even though Python is beginner-friendly, many learners fall into common traps when using commands.
Here’s a list of mistakes + best practices to help you avoid bugs and write cleaner code.

Using is Instead of ==

  • Wrong:
a = [1, 2, 3]
b = [1, 2, 3]
print(a is b)   # False
  • Fix: Use == to compare values, is only for identity.
print(a == b)   # True

Forgetting That Strings Are Immutable

  • Wrong:
s = "hello"
s[0] = "H"   # Error: strings don’t support item assignment
  • Fix: Create a new string.
s = "H" + s[1:]

Mutable Default Arguments in Functions

  • Wrong:
def add_item(x, items=[]):
    items.append(x)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] (unexpected!)
  • Fix: Use None as a default and initialize inside.
def add_item(x, items=None):
    if items is None:
        items = []
    items.append(x)
    return items

Infinite While Loops

  • Wrong:
count = 1
while count <= 5:
    print(count)
    # forgot to update count → infinite loop!
  • Fix: Always update the loop variable.
count = 1
while count <= 5:
    print(count)
    count += 1

Using list.remove(x) Without Checking

  • Wrong:
nums = [1, 2, 3]
nums.remove(4)   # ValueError
  • Fix: Check membership first.
if 4 in nums:
    nums.remove(4)

Overusing from module import *

  • Wrong:
from math import *
print(sqrt(16))   # Works but namespace polluted
  • Fix: Use explicit imports.
import math
print(math.sqrt(16))

Forgetting to Close Files

  • Wrong:
f = open("data.txt", "w")
f.write("Hello")
# File stays open!
  • Fix: Use a context manager (with).
with open("data.txt", "w") as f:
    f.write("Hello")

Pro Tips Recap:

  • Use == for value comparison, is for identity.
  • Strings are immutable → always create new ones.
  • Avoid mutable defaults in functions.
  • Always update loop variables.
  • Check membership before removing list items.
  • Import only what you need.
  • Use with open() for file safety.

Python Commands Quick Reference Cheat Sheet

If you ever need a fast refresher, here’s a compact Python commands list you can refer to.
For a detailed printable version, grab the Python Commands Cheat Sheet PDF.

Core Python Keywords

if, elif, else, for, while, def, return, import, from, as, try, except, finally,
with, lambda, class, pass, break, continue, yield, global, nonlocal

Basic Built-in Functions

print(), input(), len(), type(), isinstance(), range(), enumerate(), zip(),
sum(), min(), max(), any(), all(), sorted(), open()

String Methods

upper(), lower(), capitalize(), title(), strip(), replace(),
split(), join(), find(), count(), startswith(), endswith(),
isalnum(), isalpha(), isdigit()

List Methods

append(), insert(), extend(), pop(), remove(), clear(),
sort(), reverse(), copy(), count(), index()

Tuple Methods

count(), index()

Set Methods

add(), remove(), discard(), pop(), clear(), union(),
intersection(), difference(), symmetric_difference(),
issubset(), issuperset(), copy()

Dictionary Methods

get(), keys(), values(), items(), update(), pop(),
popitem(), clear(), copy(), setdefault(), fromkeys()

File Handling

with open("file.txt", "r") as f:
    data = f.read()

from pathlib import Path
p = Path("file.txt")
p.write_text("Hello")
print(p.read_text())

Exception Handling

try:
    risky_code()
except ValueError:
    print("Handled error")
finally:
    print("Always runs")

CLI & pip Commands

python --version
python script.py
python -m venv .venv
source .venv/bin/activate   # macOS/Linux
.venv\Scripts\activate      # Windows
deactivate

python -m pip install package
python -m pip list
python -m pip uninstall package

Pro Tip: Bookmark this section or download the PDF Cheat Sheet to keep these commands handy!

Conclusion & FAQs

In this guide, we explored the complete Python commands list with examples – covering everything from basic functions (print(), len(), input()) to advanced commands like comprehensions, exception handling, and file operations.

We also looked at string, list, tuple, set, and dictionary methods, along with REPL commands, CLI commands, and pip usage.

Remember:

  • You don’t need to memorize all commands – just practice them regularly.
  • Python is all about clean, readable code – keep pro tips and pitfalls in mind.
  • Bookmark this guide or download the Python Commands Cheat Sheet PDF for quick reference.

Read Official Python Docs

Frequently Asked Questions (FAQs)

Q1. What are Python commands?

In Python, “commands” generally refer to keywords, built-in functions, object methods, REPL commands, and CLI commands. For example, print(), len(), if, for, pip install, etc.

Q2. How do you run Python commands?

You can run Python commands in:

  • Python shell (REPL): Just type commands like print("Hello").
  • Script files (.py): Save commands in a .py file and run python script.py.
  • Command line (CLI): Use commands like python --version or pip install package.

Q3. What are the most common Python commands?

Some of the most common Python commands are:

  • print() → display output
  • input() → take user input
  • len() → get length of object
  • range() → generate numbers
  • append() → add list item
  • get() → access dictionary value
  • union() → combine sets

Q4. What are magic commands in Python?

“Magic commands” usually refer to IPython/Jupyter Notebook commands that simplify tasks.
Examples:

  • %timeit → measure execution time
  • %run script.py → run a script inside Jupyter
  • %pwd → show current directory

Q5. What is the difference between Python commands and functions?

Technically, Python doesn’t have “commands” – it has functions, keywords, and statements.
However, learners often use “command” as a catch-all term for anything you can type in Python to make it work.

5 Common Interview Questions You Must Prepare For:

Leave a Comment

error: Content is protected !!