**Advanced Python Fundamentals for People Analytics

Python's built-in data structures are fundamental to any analytical task. Let's revisit dictionaries, sets, and tuples with an advanced perspective.

• Dictionaries: Focus on dictionary comprehensions for concise creation, using defaultdict for handling missing keys gracefully, and understanding the impact of key types (immutable types like strings and numbers are essential). Consider the time complexity of dictionary operations (lookup, insertion, deletion) and how they affect performance. Example: ```python
  data = [('employee_id', 101), ('salary', 60000), ('employee_id', 102), ('salary', 75000)]
  employee_data = {k: v for k, v in data}
  from collections import defaultdict
  salary_by_id = defaultdict(list)
  for emp_id, salary in data:
  salary_by_id[emp_id].append(salary)

*   **Sets:** Explore set operations (union, intersection, difference) for data cleaning and comparison, particularly relevant for identifying employee overlaps, distinct values, and anomalies in your People Analytics data. Example: ```python
emp_ids_department_a = {101, 102, 103, 104}
emp_ids_department_b = {103, 104, 105, 106}
common_employees = emp_ids_department_a.intersection(emp_ids_department_b)

• Tuples: Although immutable, tuples are essential as dictionary keys and for efficiency when data shouldn't be changed. They offer faster access times than lists in some scenarios. Consider using named tuples for improved readability. Example: python from collections import namedtuple Employee = namedtuple('Employee', ['id', 'name', 'department']) emp = Employee(id=101, name='Alice', department='HR') print(emp.department) # Access elements by name

Functions are at the heart of modular code. We will explore lambda functions for creating anonymous, single-expression functions, closures for encapsulating data, and decorators for extending function behavior without modifying the function itself. This enables code reuse, clean design, and more complex data transformations.

• Lambda Functions: Create concise functions for simple operations inline. Example: square = lambda x: x * x
• Closures: Functions that 'remember' the environment in which they were created, essential for creating function factories. Example:```python
  def outer_function(x):
  def inner_function(y):
  return x + y
  return inner_function
  closure = outer_function(10)
  result = closure(5) #result will be 15

*   **Decorators:** Apply decorators to modify or enhance other functions.  This is a powerful technique for adding logging, timing, or other functionality without altering the original function's core logic. Example: ```python
import time
def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timer
def calculate_sum(n):
    total = 0
    for i in range(n):
        total += i
    return total

calculate_sum(1000000)

Model HR processes and entities using OOP principles: classes, objects, inheritance, polymorphism, and encapsulation. Create classes representing 'Employee', 'Department', 'PerformanceReview', and their relationships. This approach structures code and makes it easier to manage complex HR data. Explore designing class methods to calculate performance metrics, generate reports, or simulate employee movement across departments. Example:

class Employee:
    def __init__(self, employee_id, name, department, salary):
        self.employee_id = employee_id
        self.name = name
        self.department = department
        self.salary = salary
    def raise_salary(self, percentage):
        self.salary *= (1 + percentage / 100)
    def __repr__(self):
        return f"Employee(ID={self.employee_id}, Name={self.name})"

employee1 = Employee(101, "Alice", "HR", 60000)
employee1.raise_salary(5)
print(employee1)

The collections and itertools modules provide specialized data structures and iterator functions for efficient data manipulation, vital for handling large HR datasets.

• collections Module: This module contains useful classes like Counter (for counting occurrences of elements, ideal for analyzing employee skills or department sizes), defaultdict (to gracefully handle missing keys in dictionaries), and namedtuple (creating tuple-like objects with named fields, improving readability). Example: ```python
  from collections import Counter
  employee_departments = ['HR', 'IT', 'HR', 'Finance', 'IT', 'HR']
  department_counts = Counter(employee_departments)
  print(department_counts) # Output: Counter({'HR': 3, 'IT': 2, 'Finance': 1})

*   **`itertools` Module:** This module provides tools to work with iterators, enabling efficient data processing. Functions like `groupby` (for grouping related data) and `chain` (for combining multiple iterables) are particularly valuable for preparing data for analysis. Example: ```python
import itertools
data = [('HR', 'Alice'), ('IT', 'Bob'), ('HR', 'Charlie'), ('IT', 'David')]
data.sort()
for department, employees in itertools.groupby(data, key=lambda x: x[0]):
    print(f"Department: {department}")
    for employee in employees:
        print(f"  - {employee[1]}")