Python Variables and Data Types: Complete Guide
Table of Contents
1. [Introduction to Variables](#introduction-to-variables) 2. [Variable Declaration and Assignment](#variable-declaration-and-assignment) 3. [Python Data Types Overview](#python-data-types-overview) 4. [Numeric Data Types](#numeric-data-types) 5. [String Data Type](#string-data-type) 6. [Boolean Data Type](#boolean-data-type) 7. [Collection Data Types](#collection-data-types) 8. [Type Conversion](#type-conversion) 9. [Variable Scope](#variable-scope) 10. [Best Practices](#best-practices)Introduction to Variables
Variables in Python are containers that store data values. Unlike other programming languages, Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. Python is dynamically typed, meaning you don't need to specify the data type when creating variables.
Key Characteristics of Python Variables:
- Dynamic typing: Variable types are determined at runtime - Case-sensitive:myVar and myvar are different variables
- No explicit declaration required: Variables are created when first assigned
- Memory management: Python handles memory allocation and deallocation automaticallyVariable Declaration and Assignment
Basic Variable Assignment
`python
Simple variable assignment
name = "John Doe" age = 25 height = 5.9 is_student = TrueMultiple assignment
x, y, z = 1, 2, 3Same value to multiple variables
a = b = c = 10Chain assignment
first_name = last_name = "Unknown"Variable Naming Rules and Conventions
| Rule Type | Description | Valid Examples | Invalid Examples |
|-----------|-------------|----------------|------------------|
| Must start with | Letter (a-z, A-Z) or underscore (_) | name, _private, Name | 2name, $var |
| Can contain | Letters, numbers, underscores | user_1, firstName, my_var_2 | user-name, first name |
| Cannot be | Python keywords | my_class, user_def | class, def, if |
| Case sensitivity | Variables are case-sensitive | Name ≠ name ≠ NAME | N/A |
Python Keywords (Reserved Words)
`python
import keyword
print(keyword.kwlist)
Output: ['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert',
'async', 'await', 'break', 'class', 'continue', 'def', 'del',
'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
Python Data Types Overview
Python has several built-in data types that can be categorized into different groups:
| Category | Data Types | Mutable | Examples |
|----------|------------|---------|----------|
| Numeric | int, float, complex | No | 42, 3.14, 2+3j |
| Text | str | No | "Hello World" |
| Boolean | bool | No | True, False |
| Sequence | list, tuple, range | list: Yes, tuple/range: No | [1,2,3], (1,2,3), range(5) |
| Mapping | dict | Yes | {"key": "value"} |
| Set | set, frozenset | set: Yes, frozenset: No | {1,2,3}, frozenset({1,2,3}) |
| Binary | bytes, bytearray, memoryview | bytearray: Yes, others: No | b"hello" |
| None | NoneType | No | None |
Checking Data Types
`python
Using type() function
number = 42 print(type(number)) #Using isinstance() function (recommended)
print(isinstance(number, int)) # True print(isinstance(number, (int, float))) # True (checking multiple types)Getting type name as string
print(type(number).__name__) # intNumeric Data Types
Integer (int)
Integers are whole numbers without decimal points. Python 3 has unlimited precision for integers.
`python
Integer examples
positive_int = 42 negative_int = -17 zero = 0 large_int = 123456789012345678901234567890Different number systems
binary = 0b1010 # Binary (base 2) = 10 in decimal octal = 0o12 # Octal (base 8) = 10 in decimal hexadecimal = 0xA # Hexadecimal (base 16) = 10 in decimalprint(f"Binary {binary}, Octal {octal}, Hex {hexadecimal}")
Output: Binary 10, Octal 10, Hex 10
Float (float)
Floating-point numbers represent real numbers with decimal points.
`python
Float examples
pi = 3.14159 scientific_notation = 1.5e2 # 150.0 negative_float = -2.5 very_small = 1e-10Float precision limitations
result = 0.1 + 0.2 print(result) # 0.30000000000000004 (floating-point precision issue)Using decimal for precise calculations
from decimal import Decimal precise_result = Decimal('0.1') + Decimal('0.2') print(precise_result) # 0.3Complex (complex)
Complex numbers have real and imaginary parts.
`python
Complex number examples
complex_num1 = 3 + 4j complex_num2 = complex(2, -3) # 2 - 3jAccessing real and imaginary parts
print(complex_num1.real) # 3.0 print(complex_num1.imag) # 4.0Complex number operations
result = complex_num1 + complex_num2 print(result) # (5+1j)Numeric Operations Table
| Operation | Operator | Example | Result |
|-----------|----------|---------|--------|
| Addition | + | 5 + 3 | 8 |
| Subtraction | - | 5 - 3 | 2 |
| Multiplication | | 5 3 | 15 |
| Division | / | 5 / 3 | 1.6666666666666667 |
| Floor Division | // | 5 // 3 | 1 |
| Modulus | % | 5 % 3 | 2 |
| Exponentiation | | 5 3 | 125 |
String Data Type
Strings are sequences of characters enclosed in quotes. Python treats single and double quotes equally.
String Creation
`python
Different ways to create strings
single_quoted = 'Hello World' double_quoted = "Hello World" triple_quoted = """This is a multi-line string""" triple_single = '''Another way for multi-line strings'''Raw strings (ignore escape characters)
raw_string = r"C:\Users\name\Documents" print(raw_string) # C:\Users\name\Documentsf-strings (formatted string literals)
name = "Alice" age = 30 f_string = f"My name is {name} and I am {age} years old" print(f_string) # My name is Alice and I am 30 years oldString Operations and Methods
| Method | Description | Example | Result |
|--------|-------------|---------|--------|
| len() | Get string length | len("hello") | 5 |
| upper() | Convert to uppercase | "hello".upper() | "HELLO" |
| lower() | Convert to lowercase | "HELLO".lower() | "hello" |
| strip() | Remove whitespace | " hello ".strip() | "hello" |
| replace() | Replace substring | "hello".replace("l", "x") | "hexxo" |
| split() | Split string | "a,b,c".split(",") | ['a', 'b', 'c'] |
| join() | Join list elements | ",".join(['a','b','c']) | "a,b,c" |
| find() | Find substring index | "hello".find("ll") | 2 |
| count() | Count occurrences | "hello".count("l") | 2 |
| startswith() | Check if starts with | "hello".startswith("he") | True |
String Indexing and Slicing
`python
text = "Python Programming"
Indexing (0-based)
print(text[0]) # P print(text[-1]) # g (last character)Slicing [start:end:step]
print(text[0:6]) # Python print(text[7:]) # Programming print(text[:6]) # Python print(text[::2]) # Pto rgamn print(text[::-1]) # gnimmargorP nohtyP (reversed)Boolean Data Type
Boolean values represent truth values: True or False.
`python
Boolean literals
is_active = True is_complete = FalseBoolean from expressions
age = 18 is_adult = age >= 18 # TrueBoolean operations
a = True b = Falseprint(a and b) # False
print(a or b) # True
print(not a) # False
`
Truthy and Falsy Values
| Falsy Values | Truthy Values |
|--------------|---------------|
| False | True |
| None | Any non-empty string |
| 0, 0.0, 0j | Any non-zero number |
| Empty collections: [], {}, (), set() | Non-empty collections |
| Empty string: "" | Any object (by default) |
`python
Testing truthiness
def test_truthiness(value): if value: print(f"{value} is truthy") else: print(f"{value} is falsy")test_truthiness("") # "" is falsy
test_truthiness("hello") # "hello" is truthy
test_truthiness(0) # 0 is falsy
test_truthiness(42) # 42 is truthy
test_truthiness([]) # [] is falsy
test_truthiness([1, 2]) # [1, 2] is truthy
`
Collection Data Types
Lists
Lists are ordered, mutable collections that can contain different data types.
`python
Creating lists
empty_list = [] numbers = [1, 2, 3, 4, 5] mixed_list = [1, "hello", 3.14, True] nested_list = [[1, 2], [3, 4], [5, 6]]List operations
fruits = ["apple", "banana", "orange"]Adding elements
fruits.append("grape") # Add to end fruits.insert(1, "kiwi") # Insert at index fruits.extend(["mango", "pear"]) # Add multiple elementsRemoving elements
fruits.remove("banana") # Remove by value popped = fruits.pop() # Remove and return last element del fruits[0] # Remove by indexList comprehensions
squares = [x2 for x in range(10)] even_squares = [x2 for x in range(10) if x % 2 == 0]Tuples
Tuples are ordered, immutable collections.
`python
Creating tuples
empty_tuple = () single_element = (42,) # Note the comma coordinates = (10, 20) mixed_tuple = (1, "hello", 3.14)Tuple unpacking
x, y = coordinates print(f"x: {x}, y: {y}") # x: 10, y: 20Named tuples
from collections import namedtuple Point = namedtuple('Point', ['x', 'y']) p = Point(10, 20) print(p.x, p.y) # 10 20Dictionaries
Dictionaries are unordered collections of key-value pairs.
`python
Creating dictionaries
empty_dict = {} person = { "name": "John", "age": 30, "city": "New York" }Dictionary operations
person["email"] = "john@example.com" # Add new key-value pair person["age"] = 31 # Update existing value del person["city"] # Remove key-value pairDictionary methods
keys = person.keys() # dict_keys(['name', 'age', 'email']) values = person.values() # dict_values(['John', 31, 'john@example.com']) items = person.items() # dict_items([('name', 'John'), ('age', 31), ('email', 'john@example.com')])Dictionary comprehensions
squares_dict = {x: x2 for x in range(5)}{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Sets
Sets are unordered collections of unique elements.
`python
Creating sets
empty_set = set() # Note: {} creates an empty dict, not set numbers = {1, 2, 3, 4, 5} from_list = set([1, 2, 2, 3, 3, 4]) # {1, 2, 3, 4} - duplicates removedSet operations
set1 = {1, 2, 3, 4} set2 = {3, 4, 5, 6}union = set1 | set2 # {1, 2, 3, 4, 5, 6}
intersection = set1 & set2 # {3, 4}
difference = set1 - set2 # {1, 2}
symmetric_diff = set1 ^ set2 # {1, 2, 5, 6}
`
Type Conversion
Implicit Type Conversion (Coercion)
Python automatically converts data types when needed.
`python
Implicit conversion examples
int_num = 10 float_num = 3.14 result = int_num + float_num # int automatically converted to float print(result, type(result)) # 13.14Boolean to numeric
print(True + 1) # 2 (True is treated as 1) print(False * 5) # 0 (False is treated as 0)Explicit Type Conversion (Casting)
| Function | Description | Example | Result |
|----------|-------------|---------|--------|
| int() | Convert to integer | int("42") | 42 |
| float() | Convert to float | float("3.14") | 3.14 |
| str() | Convert to string | str(42) | "42" |
| bool() | Convert to boolean | bool(1) | True |
| list() | Convert to list | list("hello") | ['h', 'e', 'l', 'l', 'o'] |
| tuple() | Convert to tuple | tuple([1, 2, 3]) | (1, 2, 3) |
| set() | Convert to set | set([1, 2, 2, 3]) | {1, 2, 3} |
| dict() | Convert to dictionary | dict([('a', 1), ('b', 2)]) | {'a': 1, 'b': 2} |
`python
Explicit conversion examples
string_number = "42" converted_int = int(string_number) print(converted_int, type(converted_int)) # 42Handling conversion errors
try: invalid_conversion = int("hello") except ValueError as e: print(f"Conversion error: {e}") # Conversion error: invalid literal for int()Converting between collections
text = "hello" char_list = list(text) # ['h', 'e', 'l', 'l', 'o'] char_tuple = tuple(text) # ('h', 'e', 'l', 'l', 'o') char_set = set(text) # {'h', 'e', 'l', 'o'} - 'l' appears onceVariable Scope
Variable scope determines where variables can be accessed in your code.
Local Scope
`python
def my_function():
local_var = "I'm local"
print(local_var) # Accessible inside function
my_function()
print(local_var) # NameError: name 'local_var' is not defined
Global Scope
`python
global_var = "I'm global"
def my_function(): print(global_var) # Accessible inside function
my_function() # I'm global
print(global_var) # I'm global
`
Global Keyword
`python
counter = 0 # Global variable
def increment(): global counter # Declare that we want to modify global variable counter += 1
increment()
print(counter) # 1
`
Nonlocal Keyword
`python
def outer_function():
x = "outer"
def inner_function():
nonlocal x # Refer to the outer function's variable
x = "inner"
inner_function()
print(x) # inner
outer_function()
`
LEGB Rule
Python follows the LEGB rule for variable lookup:
| Scope | Description | Example |
|-------|-------------|---------|
| Local | Inside the current function | Variables defined in function |
| Enclosing | In enclosing functions | Variables in outer functions |
| Global | At module level | Variables defined at top level |
| Built-in | Built-in names | print, len, int, etc. |
`python
LEGB example
builtin_name = len # Built-in functionglobal_var = "global" # Global scope
def outer(): enclosing_var = "enclosing" # Enclosing scope def inner(): local_var = "local" # Local scope print(f"Local: {local_var}") print(f"Enclosing: {enclosing_var}") print(f"Global: {global_var}") print(f"Built-in: {builtin_name([1, 2, 3])}") inner()
outer()
`
Best Practices
Variable Naming Conventions
`python
Good naming conventions
user_name = "john_doe" # Snake case for variables MAX_CONNECTIONS = 100 # UPPER_CASE for constants is_active = True # Boolean variables with is_, has_, can_ prefix total_count = 0 # Descriptive namesClass names use PascalCase
class UserAccount: passFunction names use snake_case
def calculate_total_price(): passCode Organization and Documentation
`python
Module-level constants
DEFAULT_TIMEOUT = 30 MAX_RETRIES = 3def process_user_data(user_id: int, user_name: str) -> dict:
"""
Process user data and return formatted information.
Args:
user_id (int): The unique identifier for the user
user_name (str): The name of the user
Returns:
dict: Formatted user information
"""
# Local variables with clear names
processed_data = {
'id': user_id,
'name': user_name.strip().title(),
'timestamp': '2024-01-01'
}
return processed_data
`
Memory Management Tips
`python
Efficient memory usage
import sysCheck memory usage of different data types
numbers_list = [1, 2, 3, 4, 5] numbers_tuple = (1, 2, 3, 4, 5)print(f"List size: {sys.getsizeof(numbers_list)} bytes") print(f"Tuple size: {sys.getsizeof(numbers_tuple)} bytes")
Use generators for large datasets
def number_generator(n): for i in range(n): yield i * iThis uses less memory than creating a list
squares = number_generator(1000000)Error Handling with Variables
`python
Safe variable operations
def safe_divide(a, b): """Safely divide two numbers with error handling.""" try: if not isinstance(a, (int, float)) or not isinstance(b, (int, float)): raise TypeError("Arguments must be numbers") if b == 0: raise ValueError("Cannot divide by zero") result = a / b return result except (TypeError, ValueError) as e: print(f"Error: {e}") return NoneUsage examples
print(safe_divide(10, 2)) # 5.0 print(safe_divide(10, 0)) # Error: Cannot divide by zero, None print(safe_divide(10, "2")) # Error: Arguments must be numbers, NonePerformance Considerations
`python
import time
String concatenation performance
def slow_concatenation(items): result = "" for item in items: result += str(item) # Creates new string each time return resultdef fast_concatenation(items): return "".join(str(item) for item in items) # More efficient
Testing performance
items = range(10000)start_time = time.time() slow_result = slow_concatenation(items) slow_time = time.time() - start_time
start_time = time.time() fast_result = fast_concatenation(items) fast_time = time.time() - start_time
print(f"Slow method: {slow_time:.4f} seconds")
print(f"Fast method: {fast_time:.4f} seconds")
`
This comprehensive guide covers the fundamental concepts of Python variables and data types. Understanding these concepts is crucial for effective Python programming, as they form the foundation for more advanced topics like object-oriented programming, data structures, and algorithm implementation. Regular practice with these concepts will help you write more efficient and maintainable Python code.