Python Cheatsheet: A Simple and Complete Guide

Introduction

Python is a popular and easy-to-learn programming language. It is used in many fields such as web development, data analysis, automation, artificial intelligence, and more. This cheatsheet covers the most important and commonly used concepts in Python. It is helpful for beginners and also for experienced developers who want to revise the basics quickly.

1. Variables

Definition : Variables are used to store values.

  
    name = "Alice"
age = 25

Note : You do not need to declare the data type in Python.

2. Data Types

Common types : int , float , str , bool , list , tuple , dict , set

  
    num = 10             # int
price = 5.5          # float
name = "Tom"         # str
is_valid = True      # bool

3. Lists

Definition: A list is a collection of items. It is mutable (can be changed).

  
    fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits[1])  # banana

4. Tuples

Definition: A tuple is similar to a list, but is immutable (cannot be changed).

  
    colors = ("red", "green", "blue")
print(colors[0])  # red

5. Dictionaries

Definition: A dictionary stores data in key-value pairs.

  
    student = {"name": "John", "age": 20}
print(student["name"])  # John

6. Sets

Definition: A set is a collection of unique items.

  
    nums = {1, 2, 3, 2}
print(nums)  # {1, 2, 3}

7. Conditional Statements

Used for: Decision making in code.

  
    age = 18
if age >= 18:
    print("Adult")
else:
    print("Minor")

8. Loops

For loop: Used to repeat actions.

  
    for i in range(5):
    print(i)

While loop: Runs while a condition is true.

  
    count = 0
while count < 5:
    print(count)
    count += 1

9. Functions

Definition: A block of code that runs when called.

  
    def greet(name):
    print("Hello", name)

greet("Alice")

10. Classes and Objects

Definition: Used in object-oriented programming.

  
    class Person:
    def __init__(self, name):
        self.name = name

    def say_hello(self):
        print("Hi, I am", self.name)

p = Person("David")
p.say_hello()

11. Exception Handling

Used to: Handle errors without stopping the program.

  
    try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

12. List Comprehension

Definition: A short way to create a new list.

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

13. Importing Modules

Used to: Use built-in or external code libraries.

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

14. File Handling

Reading a file

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

Writing to a file

  
    with open("file.txt", "w") as f:
    f.write("Hello, world")

15. Lambda Functions

Definition : A small anonymous function.

  
    add = lambda x, y: x + y
print(add(3, 5))  # 8

16. Map, Filter, Reduce

map(): Applies a function to all items.

  
    nums = [1, 2, 3]
squared = list(map(lambda x: x*x, nums))

filter(): Filters items based on a condition.

  
    even = list(filter(lambda x: x % 2 == 0, nums))

reduce(): Reduces a list to a single value.

  
    from functools import reduce
total = reduce(lambda x, y: x + y, nums)

17. Global and Local Variables

  
    x = 10  # global

def test():
    y = 5  # local
    print(x + y)

test()

18. String Formatting

  
    name = "Tom"
age = 20
print(f"My name is {name} and I am {age} years old.")

19. Type Conversion

  
    x = "123"
y = int(x)  # converts to integer

20. Built-in Functions

Some common ones: len() , type() , str() , int() , input() , print() , sum() , sorted()

21. Enumerate

Used to: Get index and value while looping.

  
    colors = ["red", "green", "blue"]
for index, color in enumerate(colors):
    print(index, color)

22. Zip

Used to: Combine multiple iterables (like lists).

  
    names = ["Alice", "Bob"]
scores = [85, 90]
for name, score in zip(names, scores):
    print(name, score)

23. Docstrings

Used to: Write documentation inside functions/classes.

  
    def greet():
    """This function prints a greeting"""
    print("Hello")

Access using: print(greet.__doc__)

24. args and kwargs

Used to: Pass a variable number of arguments.

  
    def add(*args):
    return sum(args)

def show(**kwargs):
    print(kwargs)

add(1, 2, 3)
show(name="Tom", age=30)

25. Virtual Environment (venv)

Used to: Create an isolated environment for a Python project.

  
    python -m venv env

Activate: env\Scripts\activate (Windows) or source env/bin/activate (Linux/Mac)

26. List Methods

Common methods:

  
    a = [1, 2, 3]
a.append(4)
a.remove(2)
a.pop()
a.sort()
a.reverse()

27. Dictionary Methods

  
    d = {"a": 1, "b": 2}
d.keys()
d.values()
d.items()
d.get("a")

28. Comprehensions with Conditions

  
    evens = [x for x in range(10) if x % 2 == 0]

29. Range

Used to: Generate a sequence of numbers.

  
    range(5)         # 0 to 4
range(1, 6)      # 1 to 5
range(1, 10, 2)  # step by 2

30. Type Hints (Python 3.5+)

Used to: Show expected types in functions.

  
    def add(x: int, y: int) -> int:
    return x + y

31. Unpacking

Used to: Assign values from a list/tuple to variables.

  
    a, b = [1, 2]

32. Ternary Operator

Short way to write if-else :

  
    result = "Yes" if x > 5 else "No"

33. Chained Comparisons

  
    x = 10
if 5 < x < 15:
    print("x is between 5 and 15")

34. Generators

Used to: Create iterators using yield keyword.

  
    def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

35. Decorators

Used to: Modify the behavior of a function.

  
    def decorator(func):
    def wrapper():
        print("Before")
        func()
        print("After")
    return wrapper

@decorator
def greet():
    print("Hello")

greet()

36. Context Manager (with statement)

Used to: Handle resources like files.

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

37. Assertions

Used to: Check conditions during development.

  
    x = 5
assert x > 0, "x must be positive"

38. The `name == "main"` Block

Used to: Run code only when a script is executed directly.

  
    if __name__ == "__main__":
    print("Running directly")

39. Using `pass` , `break` , `continue`

pass : Placeholder for empty blocks
break : Exit a loop
continue : Skip to next loop iteration

  
    for i in range(5):
    if i == 3:
        continue
    print(i)

40. Global Keyword

Used to: Change a global variable inside a function.

  
    x = 10

def modify():
    global x
    x = 20

41. `is` vs `==`

== checks if values are equal.
is checks if both variables point to the same object in memory.

  
    a = [1, 2]
b = [1, 2]
print(a == b)  # True
print(a is b)  # False

42. Python Comments

Single-line: # This is a comment
Multi-line (not officially a comment, but used):

  
    """
This is
a multiline comment
"""

43. Command Line Arguments with `sys.argv`

  
    import sys
print(sys.argv[1])  # First command-line argument

44. Using `dir()` and `help()`

dir(obj) shows all attributes/methods of an object.
help(obj) gives the docstring/documentation.

  
    dir(str)
help(str)

45. Using `init` and `str` in Classes

  
    class Car:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"Car name: {self.name}"

46. Private Variables (by Convention)

  
    class Example:
    def __init__(self):
        self._protected = "Warning only"
        self.__private = "Strongly private"

47. Python Slicing

  
    text = "abcdef"
print(text[1:4])   # 'bcd'
print(text[:3])    # 'abc'
print(text[::-1])  # reverse string

48. Set Operations

  
    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}

49. Using `all()` and `any()`

  
    nums = [1, 2, 3]
print(all(x > 0 for x in nums))  # True
print(any(x > 2 for x in nums))  # True

50. Chained Function Calls

  
    def add(x):
    return x + 1

def multiply(x):
    return x * 2

print(multiply(add(3)))  # 8

51. NamedTuple (from `collections` )

  
    from collections import namedtuple
Point = namedtuple("Point", "x y")
p = Point(1, 2)
print(p.x, p.y)

52. Defaultdict

  
    from collections import defaultdict
d = defaultdict(int)
d["a"] += 1
print(d)  # defaultdict(<class 'int'>, {'a': 1})

53. Counter

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

54. Date and Time

  
    import datetime
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))

55. Regular Expressions (Regex)

  
    import re
text = "abc123"
match = re.search(r"\d+", text)
print(match.group())  # 123

56. JSON Handling

  
    import json
data = {"name": "Tom", "age": 20}
json_str = json.dumps(data)
parsed = json.loads(json_str)

57. Using `slots` (Memory Optimization in Classes)

  
    class Person:
    __slots__ = ['name', 'age']
    def __init__(self, name, age):
        self.name = name
        self.age = age

58. Using `type()` to Create Classes Dynamically

  
    MyClass = type("MyClass", (object,), {"x": 5})
obj = MyClass()
print(obj.x)

59. Using `eval()` and `exec()`

eval() evaluates an expression.
exec() runs dynamic code.

  
    x = 10
print(eval("x + 5"))  # 15

⚠️ Avoid using eval() or exec() with user input due to security risks.

60. Unit Testing (with `unittest` )

  
    import unittest

class TestAdd(unittest.TestCase):
    def test_sum(self):
        self.assertEqual(2 + 3, 5)

if __name__ == "__main__":
    unittest.main()

Conclusion

If you're serious about mastering Python:

For backend development: Learn Flask , FastAPI , or Django .
For data work: Learn NumPy , Pandas , Matplotlib , Seaborn .
For automation: Learn Selenium , PyAutoGUI , Requests .
For testing: Learn pytest .

This is now a complete Python cheatsheet for practical use, projects, interviews, and continued learning.