Python Interpreter: Interactive Programming and Command-Line Mastery

# Start the Python interpreter
$ python
Python 3.12.0 (main, Oct  2 2023, 15:00:00)
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

# Start with specific Python version
$ python3.12
>>> 

# Start with immediate command execution
$ python -c "print('Hello, World!')"
Hello, World!

# Execute a script
$ python script.py

# Interactive mode after script execution
$ python -i script.py

# Check Python version and build info
>>> import sys
>>> print(sys.version)
3.12.0 (main, Oct  2 2023, 15:00:00)

>>> print(sys.version_info)
sys.version_info(major=3, minor=12, micro=0, releaselevel='final', serial=0)

# Check platform
>>> import platform
>>> platform.platform()
'Linux-5.4.0-74-generic-x86_64-with-glibc2.31'

>>> platform.python_implementation()
'CPython'

# Environment paths
>>> sys.executable
'/usr/bin/python3'

>>> sys.path
['', '/usr/lib/python312.zip', '/usr/lib/python3.12', ...]

# Simple expressions and assignments
>>> x = 42
>>> y = x * 2
>>> y
84

# The special _ variable holds last result
>>> 10 + 5
15
>>> _ * 3
45
>>> previous_result = _
>>> previous_result
45

# Multi-line statements
>>> if x > 40:
...     print("x is large")
...     print(f"x equals {x}")
... 
x is large
x equals 42

# Function definitions
>>> def greet(name):
...     return f"Hello, {name}!"
... 
>>> greet("Python")
'Hello, Python!'

# Command history (if readline is available)
# Use Up/Down arrows to navigate history
# Ctrl+R for reverse search

# View command history programmatically
>>> import readline
>>> readline.get_current_history_length()
15

# Get specific history item
>>> readline.get_history_item(1)
'x = 42'

# Save and load history
>>> readline.write_history_file('my_session.hist')
>>> readline.read_history_file('my_session.hist')

# Built-in help system
>>> help()  # Enters help mode
help> modules  # List all modules
help> quit     # Exit help mode

# Get help on specific objects
>>> help(str)
>>> help(str.upper)
>>> help(print)

# Quick help with ?
>>> str.split?  # In IPython

# Directory listing of objects
>>> dir()  # Current namespace
['__annotations__', '__builtins__', '__doc__', ...]

>>> dir(str)  # String methods
['capitalize', 'casefold', 'center', ...]

# Object introspection
>>> type("hello")
<class 'str'>

>>> hasattr(str, 'upper')
True

>>> callable(print)
True

>>> isinstance(42, int)
True

# Using the debugger
>>> import pdb
>>> def buggy_function(x):
...     result = x * 2
...     pdb.set_trace()  # Breakpoint
...     return result + 1
... 
>>> buggy_function(5)
> <stdin>(4)buggy_function()
(Pdb) p x
5
(Pdb) p result
10
(Pdb) c  # Continue
11

# Post-mortem debugging
>>> def divide(a, b):
...     return a / b
... 
>>> divide(10, 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in divide
ZeroDivisionError: division by zero

>>> import pdb; pdb.pm()  # Debug the last exception
> <stdin>(2)divide()
(Pdb) p a
10
(Pdb) p b
0

# Custom startup file (.pythonrc.py)
import sys
import os
import readline
import rlcompleter

# Enable tab completion
readline.parse_and_bind("tab: complete")

# Colorful prompts
class ColorPrompt:
    def __str__(self):
        return '\033[1;32m>>> \033[0m'
    
    def __repr__(self):
        return '\033[1;31m... \033[0m'

sys.ps1 = ColorPrompt()
sys.ps2 = '... '

# Useful imports for interactive work
from pprint import pprint as pp
from datetime import datetime, timedelta
import json
import collections

print("Interactive environment ready!")

# Set PYTHONSTARTUP environment variable
# export PYTHONSTARTUP=~/.pythonrc.py

# Import and explore modules
>>> import math
>>> dir(math)
['acos', 'acosh', 'asin', 'asinh', ...]

# Check module documentation
>>> math.__doc__
'This module provides access to the mathematical functions defined by the C standard.'

# Find module file location
>>> math.__file__
'/usr/lib/python3.12/lib-dynload/math.cpython-312-x86_64-linux-gnu.so'

# Reload modules (useful during development)
>>> import importlib
>>> importlib.reload(math)

# Import specific functions
>>> from collections import Counter, defaultdict
>>> Counter("hello world")
Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# List all available modules
>>> help('modules')

# Find modules by pattern
>>> import pkgutil
>>> [name for importer, name, ispkg in pkgutil.iter_modules() 
...  if 'test' in name]
['test', 'unittest', ...]

# Check if module is available
>>> try:
...     import requests
...     print("requests is available")
... except ImportError:
...     print("requests not installed")
... 

# Alternative check
>>> import importlib.util
>>> spec = importlib.util.find_spec("requests")
>>> spec is not None
True  # or False if not available

# Install: pip install ipython
# Start: ipython

# Magic commands
%timeit sum(range(100))  # Time execution
%who  # List variables
%whos  # Detailed variable info
%history  # Command history
%save filename 1-10  # Save commands to file

# System commands
!ls  # Run shell commands
files = !ls *.py  # Capture output

# Auto-completion and object inspection
obj?   # Quick info
obj??  # Source code
%pdoc obj  # Print docstring

# Install: pip install jupyter
# Start: jupyter console

# Rich display
from IPython.display import HTML, Image, display
display(HTML("<h1>Hello World</h1>"))

# Tab completion with rich information
# Magic commands for visualization
%matplotlib inline
import matplotlib.pyplot as plt

# Execute string as script
python -c "import sys; print(sys.version)"

# Execute module as script
python -m http.server 8000
python -m json.tool data.json  # Pretty-print JSON
python -m py_compile script.py  # Compile to bytecode

# Debug mode
python -d script.py  # Debug parser
python -v script.py  # Verbose import

# Optimization
python -O script.py   # Basic optimization
python -OO script.py  # Remove docstrings too

# Unbuffered output
python -u script.py

# Interactive after script
python -i script.py

# Warning control
python -W ignore script.py
python -W error::DeprecationWarning script.py

# Python path
export PYTHONPATH=/path/to/modules:$PYTHONPATH

# Startup script
export PYTHONSTARTUP=~/.pythonrc.py

# Disable writing .pyc files
export PYTHONDONTWRITEBYTECODE=1

# Force UTF-8 encoding
export PYTHONIOENCODING=utf-8

# Hash randomization
export PYTHONHASHSEED=0  # Disable
export PYTHONHASHSEED=random  # Enable (default)

# Unbuffered output
export PYTHONUNBUFFERED=1

# Data exploration session
>>> import pandas as pd
>>> import numpy as np
>>> import matplotlib.pyplot as plt

# Load and explore data
>>> df = pd.read_csv('data.csv')
>>> df.head()
>>> df.info()
>>> df.describe()

# Quick visualization
>>> df.plot()
>>> plt.show()

# Interactive analysis
>>> df[df['column'] > threshold].groupby('category').mean()

# Save useful results
>>> results = df.groupby('category').agg({'value': ['mean', 'std']})
>>> results.to_csv('analysis_results.csv')

# API exploration
>>> import requests
>>> import json

# Test endpoint
>>> response = requests.get('https://api.example.com/users')
>>> response.status_code
200

>>> data = response.json()
>>> len(data)
25

# Explore structure
>>> type(data)
<class 'list'>
>>> data[0].keys()
dict_keys(['id', 'name', 'email', 'created_at'])

# Test POST request
>>> payload = {'name': 'Test User', 'email': 'test@example.com'}
>>> response = requests.post('https://api.example.com/users', json=payload)
>>> response.json()

# Function development
>>> def fibonacci(n):
...     if n <= 1:
...         return n
...     return fibonacci(n-1) + fibonacci(n-2)
... 

# Test the function
>>> [fibonacci(i) for i in range(10)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Profile performance
>>> import timeit
>>> timeit.timeit('fibonacci(10)', globals=globals(), number=1000)

# Improve and test again
>>> from functools import lru_cache
>>> @lru_cache(maxsize=None)
... def fibonacci_cached(n):
...     if n <= 1:
...         return n
...     return fibonacci_cached(n-1) + fibonacci_cached(n-2)
... 

>>> timeit.timeit('fibonacci_cached(10)', globals=globals(), number=1000)

# Check site packages location
>>> import site
>>> site.getsitepackages()
['/usr/local/lib/python3.12/dist-packages', '/usr/lib/python3/dist-packages']

>>> site.getusersitepackages()
'/home/user/.local/lib/python3.12/site-packages'

# Check if user site is enabled
>>> site.ENABLE_USER_SITE
True

# Add custom paths
>>> site.addsitedir('/path/to/custom/packages')

# Check encoding settings
>>> import locale
>>> locale.getpreferredencoding()
'UTF-8'

>>> import sys
>>> sys.getdefaultencoding()
'utf-8'

>>> sys.getfilesystemencoding()
'utf-8'

# Set locale
>>> locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
'en_US.UTF-8'

# Memory usage
>>> import sys
>>> sys.getsizeof([1, 2, 3, 4, 5])
104

# Memory profiling
>>> import tracemalloc
>>> tracemalloc.start()
>>> # ... do some work ...
>>> current, peak = tracemalloc.get_traced_memory()
>>> print(f"Current: {current / 1024 / 1024:.1f} MB")
>>> print(f"Peak: {peak / 1024 / 1024:.1f} MB")
>>> tracemalloc.stop()

# Garbage collection info
>>> import gc
>>> gc.get_count()
(595, 9, 1)
>>> gc.collect()
0

# Keep sessions organized
>>> # === Data Loading ===
>>> import pandas as pd
>>> df = pd.read_csv('data.csv')

>>> # === Analysis ===
>>> summary_stats = df.describe()

>>> # === Visualization ===
>>> import matplotlib.pyplot as plt
>>> df.plot(kind='hist')

# Use descriptive variable names
>>> user_data = load_users()
>>> filtered_users = user_data[user_data.age > 25]
>>> active_users_count = len(filtered_users)

# Save important results
>>> important_result = complex_calculation()
>>> with open('result.pkl', 'wb') as f:
...     import pickle
...     pickle.dump(important_result, f)

# Save and restore sessions
>>> import dill  # More powerful than pickle
>>> dill.dump_session('my_session.pkl')

# In new session
>>> import dill
>>> dill.load_session('my_session.pkl')

# Export useful functions to modules
>>> def useful_function(x):
...     return x * 2 + 1
... 

# Save to file for reuse
>>> with open('my_utils.py', 'w') as f:
...     f.write('''
... def useful_function(x):
...     return x * 2 + 1
... ''')

# Import in future sessions
>>> from my_utils import useful_function

# Enable automatic debugging on errors
>>> import sys
>>> def debug_on_error(type, value, tb):
...     import pdb
...     pdb.post_mortem(tb)
... 
>>> sys.excepthook = debug_on_error

# Context managers for temporary debugging
>>> import contextlib
>>> @contextlib.contextmanager
... def debug_context():
...     import pdb
...     pdb.set_trace()
...     try:
...         yield
...     except Exception:
...         pdb.post_mortem()
...         raise

>>> with debug_context():
...     # Code that might have issues
...     result = complex_function()