Python is a high-level, interpreted, dynamically-typed programming language known for readable syntax and a huge standard library.

x = 5          # int, type inferred
x = 'hello'    # same variable can be reassigned to a different type
print(type(x)) # <class 'str'>

my_list = [1, 2, 3]
my_list.append(4)  # works fine
my_list[0] = 99     # works fine

my_tuple = (1, 2, 3)
# my_tuple.append(4)  # AttributeError
# my_tuple[0] = 99     # TypeError

# Tuples can be dict keys, lists cannot
locations = {(28.7, 77.1): 'Delhi'}  # works
# {[28.7, 77.1]: 'Delhi'}  # TypeError - unhashable

Python uses indentation (whitespace) instead of braces {} to define code blocks. Consistent indentation is mandatory - inconsistent indentation raises an IndentationError.

def check_age(age):
    if age >= 18:
        print('Adult')
    else:
        print('Minor')

# Inconsistent indentation causes an error
def broken():
    if True:
        print('A')
      print('B')  # IndentationError - mismatched spaces

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True - same values
print(a is b)  # False - different objects in memory
print(a is c)  # True - c points to the SAME object as a

# Small integer caching - CPython caches small ints (-5 to 256)
x = 100
y = 100
print(x is y)  # True - both point to the same cached int object

x = 1000
y = 1000
print(x is y)  # False (usually) - large ints not cached, separate objects

# Best practice: use 'is' only for None, True, False comparisons
if a is None:
    print('a is None')

print(type(5))          # <class 'int'>
print(type(5.0))        # <class 'float'>
print(type('text'))     # <class 'str'>
print(type([1, 2]))     # <class 'list'>
print(type((1, 2)))     # <class 'tuple'>
print(type({'a': 1}))   # <class 'dict'>
print(type({1, 2}))     # <class 'set'>
print(type(True))       # <class 'bool'>
print(type(None))       # <class 'NoneType'>

# Checking types
x = 5
print(isinstance(x, int))  # True - preferred over type() == comparison

# Mutable - list changes in place, same object id
my_list = [1, 2, 3]
print(id(my_list))
my_list.append(4)
print(id(my_list))  # SAME id - modified in place

# Immutable - string 'change' actually creates a NEW object
s = 'hello'
print(id(s))
s = s + ' world'
print(id(s))  # DIFFERENT id - new string object created

# Common gotcha: mutable default arguments
def add_item(item, items=[]):  # DANGEROUS - default list is shared across calls!
    items.append(item)
    return items

print(add_item('a'))  # ['a']
print(add_item('b'))  # ['a', 'b'] - unexpected! Same default list reused

# Fix - use None as default, create new list inside
def add_item_safe(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

def describe(*args, **kwargs):
    print('Positional:', args)
    print('Keyword:', kwargs)

describe(1, 2, 3, name='John', age=30)
# Positional: (1, 2, 3)
# Keyword: {'name': 'John', 'age': 30}

# Practical use: flexible function signatures
def sum_all(*numbers):
    return sum(numbers)
print(sum_all(1, 2, 3, 4))  # 10

# Unpacking when CALLING a function
def greet(name, greeting):
    return f'{greeting}, {name}'

args_list = ['John', 'Hello']
kwargs_dict = {'name': 'John', 'greeting': 'Hello'}
print(greet(*args_list))    # unpacks list as positional args
print(greet(**kwargs_dict)) # unpacks dict as keyword args

# Combining with regular parameters (order matters)
def func(a, b, *args, **kwargs):
    print(a, b, args, kwargs)
func(1, 2, 3, 4, x=5, y=6)  # 1 2 (3, 4) {'x': 5, 'y': 6}

import copy

original = [[1, 2], [3, 4]]

# Shallow copy - outer list is new, but inner lists are SHARED
shallow = copy.copy(original)
shallow[0].append(99)
print(original)  # [[1, 2, 99], [3, 4]] - original affected too!

# Deep copy - fully independent
original2 = [[1, 2], [3, 4]]
deep = copy.deepcopy(original2)
deep[0].append(99)
print(original2)  # [[1, 2], [3, 4]] - original untouched

# list.copy() and slicing also do SHALLOW copies
shallow2 = original2.copy()  # or original2[:]
shallow2[0].append(100)
print(original2)  # affected - same nested reference

# List - ordered, allows duplicates
tags = ['python', 'web', 'python']
print(tags)  # ['python', 'web', 'python']

# Dict - key-value pairs
user = {'name': 'John', 'age': 30}
print(user['name'])  # John

# Set - unique values, fast membership check
unique_tags = set(tags)
print(unique_tags)  # {'python', 'web'}
print('python' in unique_tags)  # O(1) average - much faster than list 'in'

# Choosing based on need
visited_ids = set()  # fast duplicate checking
for user_id in [1, 2, 1, 3]:
    if user_id not in visited_ids:
        visited_ids.add(user_id)
        print(f'Processing {user_id}')

PEP 8 is Python's official style guide, defining conventions for naming, indentation, line length, imports, and formatting to keep code consistent and readable across projects and teams.

# PEP 8 compliant
MAX_RETRIES = 5

class UserAccount:
    def __init__(self, user_name):
        self.user_name = user_name

    def get_display_name(self):
        return self.user_name.title()

# Not PEP 8 compliant
class useraccount:
    def __init__(self,UserName):
        self.UserName=UserName

Tools like flake8, pylint, and black help automatically check or enforce PEP 8 compliance.