Python.

Python 3 is a backward-incompatible redesign of the language, so most Python 2 code needs changes to run on it. Python 2 reached its end of life on January 1, 2020, and new projects use Python 3.

The main differences are:

• print became a function, so you write print("hello") instead of print "hello".
• Strings are Unicode text by default, and raw bytes have their own bytes type.
• The / operator does true division, so 5/2 returns 2.5 where Python 2 returned 2. Use // for floor division.
• range() returns a lazy range object instead of a list, and map() and filter() return iterators.
• raw_input() was renamed to input(), which always returns a string.

PEP 8 is the official style guide for Python code. It sets shared conventions so that code from different people looks the same. Its main rules are:

• Indent with 4 spaces per level.
• Keep lines to a maximum of 79 characters.
• Name variables and functions in snake_case, classes in CapWords, and constants in UPPER_CASE.
• Group imports in order: standard library, third-party packages, then your own modules.
• Put single spaces around operators and after commas.

Python uses indentation to mark code blocks, where languages such as C and Java use braces {}. All lines in one block start at the same indentation level, and a deeper level opens a nested block. The parser reads this whitespace, so the layout is part of the syntax.

if x > 0:
    print("Positive")  # 4 spaces indentation
    if x > 10:
        print("Greater than 10")  # 8 spaces indentation
else:
    print("Non-positive")

It matters for two reasons. It gives every Python file the same consistent shape, which makes code easier to read. It also means a wrong indent either moves a line into a different block or stops the file from running. Incorrect indentation raises IndentationError, and mixing tabs and spaces inconsistently raises TabError. PEP 8 recommends four spaces per level.

Keywords are reserved words with a fixed meaning in the language, such as if, def and class. You cannot use them as names. Identifiers are the names you choose for variables, functions and classes. An identifier follows these rules:

• It starts with a letter or an underscore.
• It contains only letters, digits and underscores.
• It is case-sensitive, so count and Count are different names.
• It cannot be a keyword.

# Valid identifiers
variable_name = 10
_private_var = 20
ClassName = "example"

# Invalid identifiers
# 123variable = 10  # Cannot start with digit
# class = "test"    # Cannot use keyword

The keyword module lists every keyword in keyword.kwlist. A few names, such as match and case, are soft keywords, reserved only inside the statements that use them.

Python's most common built-in data types, grouped by the kind of value they hold, are:

• Numeric: int, float and complex.
• Sequence: str, list and tuple.
• Set: set and frozenset.
• Mapping: dict.
• Boolean: bool, with the values True and False.
• None: NoneType, whose only value is None.

Python is dynamically typed, so a variable has no fixed type, and type(value) tells you the type of the value it holds. The types also differ in mutability. Lists, dicts and sets can change in place, while numbers, strings and tuples cannot.

integer = 42
floating = 3.14
string = "Hello"
boolean = True
none_value = None

A list is mutable, so you can add, remove and change its items after you create it. A tuple is immutable, so its contents are fixed once it exists. Use a list for a collection that grows or changes, and a tuple for a fixed group of values, such as a pair of coordinates.

A tuple is a little faster and smaller because Python allocates it once at a fixed size. A list keeps spare room so appends stay cheap. Because a tuple is immutable, it is also hashable when all its items are, so it can be a dictionary key or a set member. A list cannot.

# List - mutable
my_list = [1, 2, 3]
my_list[0] = 10  # Works

# Tuple - immutable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # TypeError

A dictionary is a mutable mapping from unique keys to values. It is built on a hash table, so looking up a value by its key takes O(1) time on average. Its main characteristics are:

• Keys must be unique and hashable, which means their hash value never changes. Strings, numbers and tuples of hashable items work as keys, but lists do not.
• Values can be any object.
• Since Python 3.7, a dictionary keeps its items in insertion order.
• d[key] raises KeyError for a missing key, while d.get(key) returns None or a default you pass.

student = {
    "name": "John",
    "age": 25,
    "grades": [85, 90, 78]
}

# Accessing values
print(student["name"])  # John
print(student.get("age"))  # 25

# Adding/updating
student["email"] = "john@email.com"