dataset.json

[
  {
    "id": 1,
    "input": "def fibonacci(n):\n    a, b = 0, 1\n    for _ in range(n):\n        yield a\n        a, b = b, a + b",
    "output": "Generates the first 'n' numbers of the Fibonacci sequence."
  },
  {
    "id": 2,
    "input": "data = [1, 5, 2, 8]\nsorted_data = sorted(data)",
    "output": "Sorts a list of numbers into a new list (ascending order)."
  },
  {
    "id": 3,
    "input": "my_dict = {'a': 1, 'b': 2}\nvalue = my_dict.get('d', 'Not Found')",
    "output": "Safely gets value for key 'd', using 'Not Found' as default."
  },
  {
    "id": 4,
    "input": "squared_numbers = [x**2 for x in range(10) if x % 2 == 0]",
    "output": "List comprehension for squared even numbers from 0 to 9."
  },
  {
    "id": 5,
    "input": "def is_palindrome(s):\n    return s == s[::-1]",
    "output": "Checks if string 's' is a palindrome using slicing."
  },
  {
    "id": 6,
    "input": "try:\n    result = 10 / 0\nexcept ZeroDivisionError:\n    result = 'Cannot divide by zero'",
    "output": "Handles 'ZeroDivisionError' when dividing by zero."
  },
  {
    "id": 7,
    "input": "with open('data.txt', 'r') as file:\n    content = file.read()",
    "output": "Opens and reads entire content of 'data.txt', closes file automatically."
  },
  {
    "id": 8,
    "input": "def greet(name, message='Hello'):\n    return f'{message}, {name}!'",
    "output": "Returns a greeting with an optional default message."
  },
  {
    "id": 9,
    "input": "from collections import Counter\nwords = ['a', 'b', 'a']\nword_counts = Counter(words)",
    "output": "Counts frequency of all items in the 'words' list."
  },
  {
    "id": 10,
    "input": "data_tuple = (1, 2, 3)\na, b, c = data_tuple",
    "output": "Unpacks elements of a tuple into three variables."
  },
  {
    "id": 11,
    "input": "def recursive_sum(n):\n    if n <= 1:\n        return n\n    return n + recursive_sum(n - 1)",
    "output": "Calculates the sum of integers up to 'n' recursively."
  },
  {
    "id": 12,
    "input": "def calculate_average(*args):\n    return sum(args) / len(args)",
    "output": "Calculates the average of a variable number of arguments."
  },
  {
    "id": 13,
    "input": "matrix = [[1], [3, 4]]\nflat_list = [item for row in matrix for item in row]",
    "output": "Flattens a two-dimensional list (matrix) into a single list."
  },
  {
    "id": 14,
    "input": "class Dog:\n    def __init__(self, name):\n        self.name = name",
    "output": "A basic class 'Dog' with a method to set the name."
  },
  {
    "id": 15,
    "input": "my_list = [10, 20]\nmy_list.append(30)\nmy_list.pop(0)",
    "output": "Appends 30 to the list, then removes the first element."
  },
  {
    "id": 16,
    "input": "import math\narea = math.pi * (5 ** 2)",
    "output": "Uses 'math.pi' to calculate the area of a circle with radius 5."
  },
  {
    "id": 17,
    "input": "names = ['A', 'B']\nfor index, name in enumerate(names):\n    print(index, name)",
    "output": "Iterates over a list, getting both the index and the value."
  },
  {
    "id": 18,
    "input": "numbers = {1, 2, 3, 3}\nunique_count = len(numbers)",
    "output": "Creates a set to count the number of unique elements."
  },
  {
    "id": 19,
    "input": "def check_age(age):\n    assert age >= 0, 'Age cannot be negative'",
    "output": "Uses 'assert' to ensure the 'age' parameter is non-negative."
  },
  {
    "id": 20,
    "input": "user_input = input('Enter name: ')\nif user_input:\n    print(user_input)",
    "output": "Prompts for input and prints it only if not empty."
  },
  {
    "id": 21,
    "input": "message = 'Hello world'\nchar_count = len(message)",
    "output": "Calculates the number of characters in the string 'message'."
  },
  {
    "id": 22,
    "input": "text = 'example'\nreversed_text = ''.join(reversed(text))",
    "output": "Reverses a string using the 'reversed' function and 'join'."
  },
  {
    "id": 23,
    "input": "nums = [1, 2, 3]\nnums.insert(1, 99)",
    "output": "Inserts the value 99 into the list 'nums' at index 1."
  },
  {
    "id": 24,
    "input": "def print_info(**kwargs):\n    for key, value in kwargs.items():\n        print(f'{key}: {value}')",
    "output": "Prints key-value pairs from keyword arguments."
  },
  {
    "id": 25,
    "input": "colors = ['red', 'blue', 'green']\nfor color in colors:\n    if color == 'blue':\n        break",
    "output": "Iterates until 'blue' is found, then stops the loop."
  },
  {
    "id": 26,
    "input": "if temperature > 30:\n    status = 'Hot'\nelif temperature < 10:\n    status = 'Cold'\nelse:\n    status = 'Mild'",
    "output": "Assigns a status based on the value of 'temperature'."
  },
  {
    "id": 27,
    "input": "names = ['A', 'B', 'C']\njoined_names = ', '.join(names)",
    "output": "Concatenates list elements into a single string separated by ', '."
  },
  {
    "id": 28,
    "input": "def power(base, exp):\n    return base ** exp",
    "output": "Calculates the exponent of a base number."
  },
  {
    "id": 29,
    "input": "from datetime import datetime\nnow = datetime.now()",
    "output": "Gets the current date and time using the 'datetime' module."
  },
  {
    "id": 30,
    "input": "numbers = [5, 1, 4]\nnumbers.sort()",
    "output": "Sorts the 'numbers' list in-place (modifies the original list)."
  },
  {
    "id": 31,
    "input": "data = [1, None, 3, None, 5]\nfiltered = [x for x in data if x is not None]",
    "output": "Removes all 'None' values from the list using list comprehension."
  },
  {
    "id": 32,
    "input": "user = {'name': 'Alice', 'age': 30}\nif 'name' in user:\n    print(user['name'])",
    "output": "Checks if the 'name' key exists in the dictionary and prints its value."
  },
  {
    "id": 33,
    "input": "def process_data(data):\n    pass",
    "output": "A function that is defined but currently does nothing (placeholder)."
  },
  {
    "id": 34,
    "input": "count = 0\nwhile count < 5:\n    print(count)\n    count += 1",
    "output": "A while loop that iterates and prints 'count' from 0 to 4."
  },
  {
    "id": 35,
    "input": "def safe_divide(a, b):\n    return a / b if b != 0 else 0",
    "output": "Divides 'a' by 'b', returning 0 if 'b' is zero (ternary operator)."
  },
  {
    "id": 36,
    "input": "points = [(1, 2), (3, 4)]\nfor x, y in points:\n    print(x, y)",
    "output": "Iterates over a list of tuples, unpacking each tuple into 'x' and 'y'."
  },
  {
    "id": 37,
    "input": "import random\nrand_num = random.randint(1, 10)",
    "output": "Generates a random integer between 1 and 10 (inclusive)."
  },
  {
    "id": 38,
    "input": "text = 'python is great'\ncapitalized = text.title()",
    "output": "Capitalizes the first letter of every word in the string."
  },
  {
    "id": 39,
    "input": "my_set = {1, 2, 3}\nmy_set.add(4)",
    "output": "Adds the element 4 to the set 'my_set'."
  },
  {
    "id": 40,
    "input": "def double(x):\n    return x * 2\nresult = double(10)",
    "output": "A simple function that multiplies its input by 2."
  },
  {
    "id": 41,
    "input": "def logger(func):\n    def wrapper(*args, **kwargs):\n        print('Calling function...')\n        return func(*args, **kwargs)\n    return wrapper",
    "output": "A basic Python decorator function for logging function calls."
  },
  {
    "id": 42,
    "input": "class Animal:\n    def speak(self):\n        raise NotImplementedError",
    "output": "A base class method that forces subclasses to implement their own 'speak' method."
  },
  {
    "id": 43,
    "input": "def get_defaults(a, b=1, c=2):\n    return a + b + c",
    "output": "Function with required argument 'a' and two optional arguments 'b' and 'c'."
  },
  {
    "id": 44,
    "input": "import os\nfile_list = os.listdir('.')",
    "output": "Gets a list of all files and directories in the current directory."
  },
  {
    "id": 45,
    "input": "data = {'a': 1, 'b': 2}\nfor key in data.keys():\n    print(key)",
    "output": "Iterates over and prints only the keys of the dictionary."
  },
  {
    "id": 46,
    "input": "my_string = '  strip me  '\ntrimmed = my_string.strip()",
    "output": "Removes leading and trailing whitespace from the string."
  },
  {
    "id": 47,
    "input": "def greet_all(names):\n    for name in names:\n        yield f'Hi {name}'",
    "output": "A generator that yields a greeting for each name in the list."
  },
  {
    "id": 48,
    "input": "num = 5\nif num % 2 == 0:\n    print('Even')\nelse:\n    print('Odd')",
    "output": "Checks if the number is even or odd using the modulo operator."
  },
  {
    "id": 49,
    "input": "numbers = [1, 2, 3, 4]\nresult = list(map(lambda x: x * 2, numbers))",
    "output": "Uses 'map' with a 'lambda' function to double every number in the list."
  },
  {
    "id": 50,
    "input": "def print_message():\n    global count\n    count = 10\n    print(count)",
    "output": "Modifies a global variable 'count' inside the function."
  },
  {
    "id": 51,
    "input": "import sys\nprint(sys.version)",
    "output": "Prints the current Python interpreter version."
  },
  {
    "id": 52,
    "input": "user_data = ('John', 25)\nname, age = user_data",
    "output": "Assigns elements of a two-item tuple to separate variables."
  },
  {
    "id": 53,
    "input": "s1 = {1, 2, 3}\ns2 = {3, 4, 5}\nunion = s1.union(s2)",
    "output": "Calculates the union (all unique elements) of two sets."
  },
  {
    "id": 54,
    "input": "text = 'hello'\nif text.startswith('h'):\n    print('Starts with h')",
    "output": "Checks if the string 'text' begins with the letter 'h'."
  },
  {
    "id": 55,
    "input": "def sum_and_prod(a, b):\n    return a + b, a * b",
    "output": "Returns both the sum and the product of two numbers as a tuple."
  },
  {
    "id": 56,
    "input": "class Car:\n    color = 'Red'",
    "output": "A class 'Car' with a single class-level attribute 'color'."
  },
  {
    "id": 57,
    "input": "numbers = [1, 2, 3]\ncount = numbers.count(2)",
    "output": "Counts how many times the number 2 appears in the list."
  },
  {
    "id": 58,
    "input": "for i in range(10):\n    if i == 5:\n        continue\n    print(i)",
    "output": "Prints numbers from 0 to 9, skipping the number 5."
  },
  {
    "id": 59,
    "input": "def process_kwargs(**kwargs):\n    if 'debug' in kwargs:\n        print('Debug mode is on')",
    "output": "Checks for the presence of a 'debug' key in keyword arguments."
  },
  {
    "id": 60,
    "input": "with open('log.txt', 'a') as f:\n    f.write('App started\\n')",
    "output": "Opens 'log.txt' in append mode and writes a new line."
  },
  {
    "id": 61,
    "input": "def get_first_item(lst):\n    return lst[0] if lst else None",
    "output": "Returns the first item of a list, or None if the list is empty."
  },
  {
    "id": 62,
    "input": "nums = [1, 2, 3]\ndoubled = [n * 2 for n in nums]",
    "output": "Creates a new list where each element is doubled (list comprehension)."
  },
  {
    "id": 63,
    "input": "try:\n    value = int('abc')\nexcept ValueError:\n    value = 0",
    "output": "Handles a 'ValueError' when trying to convert a non-numeric string to an integer."
  },
  {
    "id": 64,
    "input": "import json\ndata = {'key': 'value'}\njson_str = json.dumps(data)",
    "output": "Converts a Python dictionary into a JSON formatted string."
  },
  {
    "id": 65,
    "input": "while True:\n    user_input = input('Exit? (y/n): ')\n    if user_input.lower() == 'y':\n        break",
    "output": "An infinite loop that breaks only when the user enters 'y'."
  },
  {
    "id": 66,
    "input": "list1 = [1, 2]\nlist2 = [3, 4]\ncombined = list1 + list2",
    "output": "Concatenates two lists using the '+' operator."
  },
  {
    "id": 67,
    "input": "def filter_long_words(words, min_len):\n    return [w for w in words if len(w) >= min_len]",
    "output": "Filters a list of words, keeping only those longer than 'min_len'."
  },
  {
    "id": 68,
    "input": "class Parent:\n    def method(self):\n        return 'Parent method'\nclass Child(Parent):\n    pass",
    "output": "A class 'Child' that inherits all methods and properties from 'Parent'."
  },
  {
    "id": 69,
    "input": "text = '123_abc'\nif text.isalnum():\n    print('Alphanumeric')",
    "output": "Checks if all characters in the string are alphanumeric (not including underscore)."
  },
  {
    "id": 70,
    "input": "def power_of_two(n):\n    return 2 ** n",
    "output": "Calculates 2 raised to the power of 'n'."
  },
  {
    "id": 71,
    "input": "def get_last_element(lst):\n    return lst[-1]",
    "output": "Returns the last element of a list using a negative index."
  },
  {
    "id": 72,
    "input": "user = {'name': 'Bob'}\nuser.update({'age': 40})",
    "output": "Adds or updates key-value pairs in the dictionary."
  },
  {
    "id": 73,
    "input": "import re\nmatch = re.search(r'\\d+', 'abc123xyz')",
    "output": "Searches for the first occurrence of one or more digits using regex."
  },
  {
    "id": 74,
    "input": "numbers = [1, 2, 3]\nnumbers.clear()",
    "output": "Removes all items from the 'numbers' list."
  },
  {
    "id": 75,
    "input": "def calculate_discount(price, rate=0.1):\n    return price * (1 - rate)",
    "output": "Calculates the final price after applying a default discount rate."
  },
  {
    "id": 76,
    "input": "my_tuple = (1, 2)\nif 1 in my_tuple:\n    print('1 is present')",
    "output": "Checks for the existence of an element within the tuple."
  },
  {
    "id": 77,
    "input": "def calculate_length(iterable):\n    count = 0\n    for _ in iterable:\n        count += 1\n    return count",
    "output": "Calculates the length of an iterable manually without using 'len()'."
  },
  {
    "id": 78,
    "input": "data = [1, 2, 3, 4, 5]\nsubset = data[1:4]",
    "output": "Slices the list to get a subset from index 1 up to (but not including) 4."
  },
  {
    "id": 79,
    "input": "def validate_email(email):\n    return '@' in email and '.' in email",
    "output": "A simple check to see if a string contains '@' and '.' for email validation."
  },
  {
    "id": 80,
    "input": "class StaticDemo:\n    @staticmethod\n    def helper_method(x):\n        return x + 1",
    "output": "A class method that can be called without instantiating the class."
  },
  {
    "id": 81,
    "input": "temp_c = 25\ntemp_f = (temp_c * 9/5) + 32",
    "output": "Converts a temperature from Celsius to Fahrenheit."
  },
  {
    "id": 82,
    "input": "def is_even(n):\n    return n % 2 == 0",
    "output": "Checks if an integer 'n' is divisible by 2 (even)."
  },
  {
    "id": 83,
    "input": "text = 'One two three'\nwords = text.split()",
    "output": "Splits a string into a list of words using whitespace as a delimiter."
  },
  {
    "id": 84,
    "input": "def counter():\n    i = 0\n    while True:\n        yield i\n        i += 1",
    "output": "An infinite generator that yields incrementing integer values."
  },
  {
    "id": 85,
    "input": "import time\ntime.sleep(1)",
    "output": "Pauses the execution of the program for 1 second."
  },
  {
    "id": 86,
    "input": "numbers = [10, 20, 30]\nindex = numbers.index(20)",
    "output": "Finds the index of the value 20 in the list."
  },
  {
    "id": 87,
    "input": "def check_user(user):\n    if user is None:\n        return 'Guest'\n    return user",
    "output": "Returns 'Guest' if the 'user' variable is None, otherwise returns the user."
  },
  {
    "id": 88,
    "input": "data = [1, 2, 3]\nduplicate = data.copy()",
    "output": "Creates a shallow copy of the list."
  },
  {
    "id": 89,
    "input": "def count_vowels(s):\n    return sum(1 for char in s if char in 'aeiou')",
    "output": "Counts the total number of vowels in the input string 's'."
  },
  {
    "id": 90,
    "input": "class Circle:\n    def __init__(self, radius):\n        self.radius = radius\n    def get_area(self):\n        return 3.14 * self.radius ** 2",
    "output": "A class 'Circle' with a method to calculate the area."
  },
  {
    "id": 91,
    "input": "def swap(a, b):\n    return b, a",
    "output": "Swaps the values of two variables using tuple unpacking."
  },
  {
    "id": 92,
    "input": "my_set = {1, 2, 3}\nif 4 not in my_set:\n    print('4 not in set')",
    "output": "Checks if an element is not present in the set."
  },
  {
    "id": 93,
    "input": "def combine_dicts(d1, d2):\n    return {**d1, **d2}",
    "output": "Merges two dictionaries using the dictionary unpacking operator."
  },
  {
    "id": 94,
    "input": "with open('temp.txt', 'w') as f:\n    f.write('Temporary data')",
    "output": "Creates and writes 'Temporary data' to 'temp.txt' and closes the file."
  },
  {
    "id": 95,
    "input": "def get_full_name(first, last):\n    return f'{first} {last}'",
    "output": "Returns a full name by combining first and last names (f-string)."
  },
  {
    "id": 96,
    "input": "import random\nnames = ['a', 'b', 'c']\nwinner = random.choice(names)",
    "output": "Randomly selects one element from the list 'names'."
  },
  {
    "id": 97,
    "input": "numbers = [1, 2, 3]\ndecimal = 4.5\nnumbers.append(decimal)",
    "output": "Appends a floating-point number to the end of an integer list."
  },
  {
    "id": 98,
    "input": "text = 'HELLO'\nlowercase = text.lower()",
    "output": "Converts the entire string to lowercase."
  },
  {
    "id": 99,
    "input": "def my_func():\n    x = 10\n    def inner_func():\n        nonlocal x\n        x = 20\n    inner_func()\n    return x",
    "output": "Modifies a variable in the nearest enclosing scope (nonlocal)."
  },
  {
    "id": 100,
    "input": "while True:\n    try:\n        num = int(input('Enter num: '))\n        break\n    except ValueError:\n        print('Invalid input')",
    "output": "Repeats input prompt until a valid integer is entered."
  },
  {
    "id": 101,
    "input": "from decimal import Decimal\nresult = Decimal('0.1') + Decimal('0.2')",
    "output": "Performs precise decimal arithmetic using the 'Decimal' type."
  },
  {
    "id": 102,
    "input": "def divide(a, b):\n    if b == 0:\n        raise ValueError('Cannot divide by zero')\n    return a / b",
    "output": "Raises a 'ValueError' exception if the divisor is zero."
  },
  {
    "id": 103,
    "input": "data = [('a', 1), ('b', 2)]\nmy_dict = dict(data)",
    "output": "Converts a list of key-value tuples into a dictionary."
  },
  {
    "id": 104,
    "input": "nums = [1, 2, 3]\nproduct = 1\nfor num in nums:\n    product *= num",
    "output": "Calculates the product of all elements in the list."
  },
  {
    "id": 105,
    "input": "class MyClass:\n    @classmethod\n    def create_obj(cls, value):\n        return cls(value)",
    "output": "A method that is bound to the class and receives the class itself as the first argument."
  },
  {
    "id": 106,
    "input": "def log_time(func):\n    import time\n    def wrapper(*args, **kwargs):\n        start = time.time()\n        result = func(*args, **kwargs)\n        end = time.time()\n        print(f'Time: {end - start}')\n        return result\n    return wrapper",
    "output": "A decorator that measures and logs the execution time of a function."
  },
  {
    "id": 107,
    "input": "numbers = [10, 20, 30, 40]\nlast_two = numbers[-2:]",
    "output": "Gets the last two elements of the list using negative slicing."
  },
  {
    "id": 108,
    "input": "def get_square(x):\n    return x * x\nresult = get_square(5)",
    "output": "A simple function that returns the square of its input."
  },
  {
    "id": 109,
    "input": "def check_empty(data):\n    return not data",
    "output": "Checks if an iterable (list, string, etc.) is empty (truthiness)."
  },
  {
    "id": 110,
    "input": "my_set = {1, 2, 3}\nmy_set.remove(2)",
    "output": "Removes the element 2 from the set (raises KeyError if not found)."
  },
  {
    "id": 111,
    "input": "import requests\nresponse = requests.get('http://api.com')",
    "output": "Makes an HTTP GET request to a specified URL."
  },
  {
    "id": 112,
    "input": "def custom_sort(item):\n    return item['key']\ndata = [{'key': 3}, {'key': 1}]\ndata.sort(key=custom_sort)",
    "output": "Sorts a list of dictionaries based on the value of the 'key' field."
  },
  {
    "id": 113,
    "input": "text = 'hello'\nif text.endswith('o'):\n    print('Ends with o')",
    "output": "Checks if the string 'text' ends with the letter 'o'."
  },
  {
    "id": 114,
    "input": "def check_type(data):\n    if isinstance(data, list):\n        print('Is a list')",
    "output": "Checks if the variable 'data' is an instance of the 'list' class."
  },
  {
    "id": 115,
    "input": "a, b, *rest = [1, 2, 3, 4, 5]",
    "output": "Unpacks the first two elements and assigns the rest to a list 'rest'."
  },
  {
    "id": 116,
    "input": "try:\n    # code that might fail\n    pass\nexcept:\n    print('An unknown error occurred')",
    "output": "A general exception handler that catches all errors."
  },
  {
    "id": 117,
    "input": "def generate_sequence():\n    yield 1\n    yield 2",
    "output": "A generator function that yields two distinct values."
  },
  {
    "id": 118,
    "input": "data = [1, 2, 3]\nreversed_data = list(reversed(data))",
    "output": "Reverses the order of elements in the list."
  },
  {
    "id": 119,
    "input": "def absolute_value(n):\n    return abs(n)",
    "output": "Returns the absolute (non-negative) value of a number."
  },
  {
    "id": 120,
    "input": "def check_all_true(bools):\n    return all(bools)",
    "output": "Checks if all elements in an iterable are truthy."
  },
  {
    "id": 121,
    "input": "text = 'one,two,three'\nparts = text.split(',')",
    "output": "Splits a string by a comma delimiter."
  },
  {
    "id": 122,
    "input": "user = {'name': 'Alice'}\nname = user.pop('name')",
    "output": "Removes the 'name' key from the dict and returns its value."
  },
  {
    "id": 123,
    "input": "for i in range(10):\n    if i % 3 == 0:\n        continue",
    "output": "Skips printing numbers that are divisible by 3."
  },
  {
    "id": 124,
    "input": "def count_up_to(n):\n    for i in range(1, n + 1):\n        print(i)",
    "output": "Iterates and prints integers from 1 up to 'n' (inclusive)."
  },
  {
    "id": 125,
    "input": "import datetime\ntoday = datetime.date.today()",
    "output": "Gets the current date (year, month, day)."
  },
  {
    "id": 126,
    "input": "data = [1, 2, 3]\ndata.insert(0, 0)",
    "output": "Inserts the value 0 at the beginning of the list."
  },
  {
    "id": 127,
    "input": "def dict_from_list(keys, value=None):\n    return dict.fromkeys(keys, value)",
    "output": "Creates a dictionary with keys from a list and an optional default value."
  },
  {
    "id": 128,
    "input": "def print_type(data):\n    print(type(data))",
    "output": "Prints the data type of the input variable."
  },
  {
    "id": 129,
    "input": "def factorial(n):\n    if n == 0:\n        return 1\n    return n * factorial(n - 1)",
    "output": "Calculates the factorial of 'n' using recursion."
  },
  {
    "id": 130,
    "input": "text = 'hello world'\nif 'world' in text:\n    print('Found')",
    "output": "Checks if the substring 'world' is present in the string 'text'."
  },
  {
    "id": 131,
    "input": "def max_of_two(a, b):\n    return max(a, b)",
    "output": "Returns the larger of two given numbers."
  },
  {
    "id": 132,
    "input": "class Counted:\n    count = 0\n    def __init__(self):\n        Counted.count += 1",
    "output": "A class that tracks the number of its instances using a class variable."
  },
  {
    "id": 133,
    "input": "numbers = [1, 2, 3, 4]\nfiltered = list(filter(lambda x: x > 2, numbers))",
    "output": "Uses 'filter' with a 'lambda' to keep only numbers greater than 2."
  },
  {
    "id": 134,
    "input": "def repeat_string(s, n):\n    return s * n",
    "output": "Repeats a string 'n' times using the multiplication operator."
  },
  {
    "id": 135,
    "input": "def default_list(val, size):\n    return [val] * size",
    "output": "Creates a list of a specified size, initialized with a single value."
  },
  {
    "id": 136,
    "input": "my_set = {1, 2}\nmy_set.discard(3)",
    "output": "Removes an element if present, without raising an error if it's missing."
  },
  {
    "id": 137,
    "input": "def get_index(lst, val):\n    try:\n        return lst.index(val)\n    except ValueError:\n        return -1",
    "output": "Safely finds the index of a value or returns -1 if not found."
  },
  {
    "id": 138,
    "input": "import itertools\nperms = list(itertools.permutations([1, 2]))",
    "output": "Generates all possible permutations of the elements in a list."
  },
  {
    "id": 139,
    "input": "def count_args(*args):\n    return len(args)",
    "output": "Returns the number of positional arguments passed to the function."
  },
  {
    "id": 140,
    "input": "data = {'a': 1}\ndata['b'] = 2",
    "output": "Adds a new key-value pair to the dictionary."
  },
  {
    "id": 141,
    "input": "text = '  leading whitespace'\nno_leading = text.lstrip()",
    "output": "Removes only the leading whitespace from the string."
  },
  {
    "id": 142,
    "input": "def check_any_true(bools):\n    return any(bools)",
    "output": "Checks if at least one element in an iterable is truthy."
  },
  {
    "id": 143,
    "input": "list1 = [1, 2]\nlist2 = list1",
    "output": "Assigns a reference to 'list1' to 'list2' (no copy is made)."
  },
  {
    "id": 144,
    "input": "def greet_user(user_name):\n    print(f'Welcome, {user_name}')",
    "output": "Prints a simple welcome message using a formatted string."
  },
  {
    "id": 145,
    "input": "def sum_list(lst):\n    return sum(lst)",
    "output": "Calculates the sum of all numeric elements in a list."
  },
  {
    "id": 146,
    "input": "import random\nrandom.shuffle(my_list)",
    "output": "Shuffles the list elements randomly (in-place modification)."
  },
  {
    "id": 147,
    "input": "class NamedObject:\n    def __repr__(self):\n        return f'<NamedObject name={self.name}>'",
    "output": "Defines the object's string representation for debugging and logging."
  },
  {
    "id": 148,
    "input": "for i in range(5):\n    print('Looping...')\nelse:\n    print('Loop finished')",
    "output": "Prints a message after a for loop completes normally (without a break)."
  },
  {
    "id": 149,
    "input": "def flatten_dict(d):\n    return [(k, v) for k, v in d.items()]",
    "output": "Converts a dictionary into a list of key-value tuples."
  },
  {
    "id": 150,
    "input": "text = 'Python'\nmiddle = text[1:-1]",
    "output": "Gets a substring from the second character up to the second to last character."
  },
  {
    "id": 151,
    "input": "def check_negative(n):\n    return n < 0",
    "output": "Checks if a number is negative."
  },
  {
    "id": 152,
    "input": "def get_tuple_size(t):\n    return len(t)",
    "output": "Returns the number of elements in a tuple."
  },
  {
    "id": 153,
    "input": "data = [1, 2, 3]\nvalue = data.pop()",
    "output": "Removes and returns the last element of the list."
  },
  {
    "id": 154,
    "input": "import time\nstart = time.time()\n# ...\nend = time.time()\nduration = end - start",
    "output": "Measures the duration of a code block using 'time.time()'."
  },
  {
    "id": 155,
    "input": "text = 'hello'\nif text.isupper():\n    print('Uppercase')",
    "output": "Checks if all characters in the string are uppercase."
  },
  {
    "id": 156,
    "input": "def set_intersection(s1, s2):\n    return s1 & s2",
    "output": "Calculates the intersection of two sets using the '&' operator."
  },
  {
    "id": 157,
    "input": "def print_var_info(*args):\n    print(f'Count: {len(args)}')",
    "output": "Prints the count of positional arguments passed to the function."
  },
  {
    "id": 158,
    "input": "my_dict = {'a': 1}\nmy_dict.setdefault('b', 2)",
    "output": "Gets the value for key 'b' or sets it to 2 if missing."
  },
  {
    "id": 159,
    "input": "import re\nresult = re.match(r'^start', 'starting point')",
    "output": "Checks if the string begins with 'start' using regex matching."
  },
  {
    "id": 160,
    "input": "def is_divisible(a, b):\n    return a % b == 0",
    "output": "Checks if number 'a' is perfectly divisible by number 'b'."
  },
  {
    "id": 161,
    "input": "temp = 40\ntemp_type = 'C' if temp < 100 else 'H'",
    "output": "Assigns a value based on a condition using a ternary operator."
  },
  {
    "id": 162,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2:\n        continue\n    print(item)",
    "output": "Iterates over a list, skipping the element '2'."
  },
  {
    "id": 163,
    "input": "from datetime import timedelta\ndelta = timedelta(days=1)",
    "output": "Creates a time difference object representing one day."
  },
  {
    "id": 164,
    "input": "def get_default_dict(key, default_dict):\n    return default_dict.get(key)",
    "output": "Retrieves a value from a dictionary using the safe 'get' method."
  },
  {
    "id": 165,
    "input": "names = ['a', 'b', 'c']\nfor name in names:\n    if name == 'b':\n        print('Found b')\n        break",
    "output": "Searches for 'b' in a list and stops the loop when found."
  },
  {
    "id": 166,
    "input": "def check_falsy(data):\n    return not bool(data)",
    "output": "Checks if the data structure or variable is falsy (empty, zero, None, etc.)."
  },
  {
    "id": 167,
    "input": "class MyClass:\n    def __init__(self, value):\n        self._value = value",
    "output": "Initializes a class instance with a private-like attribute '_value'."
  },
  {
    "id": 168,
    "input": "def calculate_remainder(a, b):\n    return a % b",
    "output": "Calculates the remainder of division of 'a' by 'b' (modulo operation)."
  },
  {
    "id": 169,
    "input": "data = [1, 2, 3]\ndata.reverse()",
    "output": "Reverses the list in-place."
  },
  {
    "id": 170,
    "input": "def combine_sets(s1, s2):\n    return s1 | s2",
    "output": "Calculates the union of two sets using the '|' operator."
  },
  {
    "id": 171,
    "input": "def print_global():\n    global my_var\n    print(my_var)",
    "output": "Accesses a global variable 'my_var' from within a function."
  },
  {
    "id": 172,
    "input": "text = '12345'\nif text.isdigit():\n    print('All digits')",
    "output": "Checks if the string contains only digits."
  },
  {
    "id": 173,
    "input": "def create_tuple(a, b):\n    return a, b",
    "output": "Returns two variables as a tuple implicitly."
  },
  {
    "id": 174,
    "input": "import os\nif os.path.exists('file.txt'):\n    print('File exists')",
    "output": "Checks if a file or directory at the specified path exists."
  },
  {
    "id": 175,
    "input": "def filter_non_numeric(lst):\n    return [x for x in lst if isinstance(x, (int, float))]",
    "output": "Filters a list, keeping only integer and float types (numeric values)."
  },
  {
    "id": 176,
    "input": "from collections import namedtuple\nPoint = namedtuple('Point', ['x', 'y'])",
    "output": "Defines a custom tuple type with named fields 'x' and 'y'."
  },
  {
    "id": 177,
    "input": "def unpack_tuple_with_star(t):\n    a, *rest = t\n    return rest",
    "output": "Unpacks the first element of a tuple, assigning the rest to a list using '*'."
  },
  {
    "id": 178,
    "input": "def sort_list_by_key(lst, key_func):\n    return sorted(lst, key=key_func)",
    "output": "Sorts a list using a custom function to determine the sort key."
  },
  {
    "id": 179,
    "input": "d1 = {'a': 1}\nd2 = {'b': 2}\nd3 = d1.copy()\nd3.update(d2)",
    "output": "Copies one dictionary and updates it with key-value pairs from another."
  },
  {
    "id": 180,
    "input": "def loop_for_n(n):\n    for i in range(n):\n        print(i)",
    "output": "A simple for loop that iterates 'n' times starting from 0."
  },
  {
    "id": 181,
    "input": "text = 'hello world'\ntext.count('l')",
    "output": "Counts the number of occurrences of the character 'l' in the string."
  },
  {
    "id": 182,
    "input": "def get_exponent(a, b):\n    return pow(a, b)",
    "output": "Calculates 'a' raised to the power of 'b' using the built-in 'pow' function."
  },
  {
    "id": 183,
    "input": "try:\n    pass\nfinally:\n    print('Cleanup done')",
    "output": "Executes the 'finally' block regardless of whether an exception occurred or not."
  },
  {
    "id": 184,
    "input": "def check_in_range(n, min_val, max_val):\n    return min_val <= n <= max_val",
    "output": "Checks if a number 'n' is within a specified inclusive range."
  },
  {
    "id": 185,
    "input": "def print_only_kwargs(*, a, b):\n    print(a, b)",
    "output": "Function where 'a' and 'b' must be passed as keyword arguments only."
  },
  {
    "id": 186,
    "input": "def filter_by_length(words, length):\n    return list(filter(lambda w: len(w) == length, words))",
    "output": "Filters a list of words to include only those of a specific length using 'filter'."
  },
  {
    "id": 187,
    "input": "data = [1, 2, 3]\nlist_copy = data[:]",
    "output": "Creates a shallow copy of the list using full slicing."
  },
  {
    "id": 188,
    "input": "text = 'abc_def'\ntext.split('_')",
    "output": "Splits the string into a list using the underscore '_' as a separator."
  },
  {
    "id": 189,
    "input": "def make_set(lst):\n    return set(lst)",
    "output": "Converts a list into a set, removing duplicate elements."
  },
  {
    "id": 190,
    "input": "class Base:\n    def __init__(self, val):\n        self.val = val\nclass Derived(Base):\n    def __init__(self, val):\n        super().__init__(val)",
    "output": "A derived class correctly calling the base class's constructor using 'super()'."
  },
  {
    "id": 191,
    "input": "def print_items_and_index(lst):\n    for i, item in enumerate(lst):\n        print(f'{i}: {item}')",
    "output": "Iterates over a list, printing both the index and the item."
  },
  {
    "id": 192,
    "input": "def is_title_case(s):\n    return s.istitle()",
    "output": "Checks if a string is in title case."
  },
  {
    "id": 193,
    "input": "data = [1, 2, 3]\ndata.insert(len(data), 4)",
    "output": "Inserts the value 4 at the end of the list (same as append)."
  },
  {
    "id": 194,
    "input": "def get_dict_values(d):\n    return list(d.values())",
    "output": "Returns a list of all values contained in the dictionary."
  },
  {
    "id": 195,
    "input": "import re\ntext = '12 apples'\nnum = re.search(r'\\d+', text).group(0)",
    "output": "Extracts the first sequence of digits from the string using regex search."
  },
  {
    "id": 196,
    "input": "def check_value_type(data):\n    if isinstance(data, (int, str)):\n        print('Int or String')",
    "output": "Checks if a variable is an instance of either 'int' or 'str' type."
  },
  {
    "id": 197,
    "input": "def loop_with_while(condition):\n    while condition:\n        break",
    "output": "A while loop that immediately terminates using 'break'."
  },
  {
    "id": 198,
    "input": "def generate_cubes(n):\n    return (i**3 for i in range(n))",
    "output": "Returns a generator expression for the cubes of numbers up to 'n'."
  },
  {
    "id": 199,
    "input": "data = {'x': 1, 'y': 2}\nfor key, val in data.items():\n    print(f'{key}={val}')",
    "output": "Iterates over and prints both keys and values of the dictionary."
  },
  {
    "id": 200,
    "input": "def calculate_sum_of_squares(n):\n    return sum(i**2 for i in range(1, n+1))",
    "output": "Calculates the sum of the squares of numbers from 1 up to 'n'."
  },
  {
    "id": 201,
    "input": "my_list = [10, 20, 30]\nmy_list.remove(20)",
    "output": "Removes the first occurrence of the value 20 from the list."
  },
  {
    "id": 202,
    "input": "def get_file_extension(filename):\n    return filename.split('.')[-1]",
    "output": "Splits a filename by '.' and returns the last part (extension)."
  },
  {
    "id": 203,
    "input": "text = 'hello'\ntext.upper()",
    "output": "Converts the entire string to uppercase."
  },
  {
    "id": 204,
    "input": "class AreaCalculator:\n    @staticmethod\n    def rect_area(w, h):\n        return w * h",
    "output": "A class with a static method to calculate the area of a rectangle."
  },
  {
    "id": 205,
    "input": "def greet_mixed(a, b, *args, **kwargs):\n    return (a, b, args, kwargs)",
    "output": "Function that accepts required, positional (*args), and keyword (**kwargs) arguments."
  },
  {
    "id": 206,
    "input": "data = [1, 2, 3]\ntuples = tuple(data)",
    "output": "Converts a mutable list into an immutable tuple."
  },
  {
    "id": 207,
    "input": "s1 = {'a', 'b'}\ns2 = {'b', 'c'}\ndiff = s1.difference(s2)",
    "output": "Calculates the elements in set 's1' that are not in set 's2'."
  },
  {
    "id": 208,
    "input": "text = 'Hello'\ntext.replace('l', 'x')",
    "output": "Replaces all occurrences of 'l' with 'x' in the string."
  },
  {
    "id": 209,
    "input": "def get_float(s):\n    try:\n        return float(s)\n    except ValueError:\n        return 0.0",
    "output": "Converts a string to a float, returning 0.0 on failure."
  },
  {
    "id": 210,
    "input": "with open('input.txt', 'r') as f:\n    first_line = f.readline()",
    "output": "Opens a file and reads only the first line."
  },
  {
    "id": 211,
    "input": "def check_truthy(data):\n    return bool(data)",
    "output": "Checks if the data structure or variable evaluates to True."
  },
  {
    "id": 212,
    "input": "def calculate_absolute_diff(a, b):\n    return abs(a - b)",
    "output": "Calculates the absolute difference between two numbers."
  },
  {
    "id": 213,
    "input": "data = [1, 2, 3, 4, 5]\ndata.pop(2)",
    "output": "Removes the element at index 2 from the list."
  },
  {
    "id": 214,
    "input": "def is_alpha_only(s):\n    return s.isalpha()",
    "output": "Checks if the string contains only alphabetic characters."
  },
  {
    "id": 215,
    "input": "my_list = [10, 20]\nmy_list.insert(0, 5)\nmy_list.remove(20)",
    "output": "Inserts 5 at the start, then removes the value 20."
  },
  {
    "id": 216,
    "input": "class Base:\n    def __init__(self, x):\n        self.x = x\nclass Derived(Base):\n    pass",
    "output": "A derived class that implicitly inherits the base class's constructor."
  },
  {
    "id": 217,
    "input": "def unpack_dict_items(d):\n    for k, v in d.items():\n        print(k, v)",
    "output": "Iterates over a dictionary and unpacks key/value pairs."
  },
  {
    "id": 218,
    "input": "if 'a' < 'b':\n    print('a is smaller')",
    "output": "Compares two strings lexicographically."
  },
  {
    "id": 219,
    "input": "data = [1, 2]\ndata += [3, 4]",
    "output": "Extends the list by adding another list using the '+=' operator."
  },
  {
    "id": 220,
    "input": "def double_map(lst):\n    return list(map(lambda x: x * 2, lst))",
    "output": "Applies a function to all elements of a list using 'map' and converts the result to a list."
  },
  {
    "id": 221,
    "input": "def find_max(lst):\n    return max(lst)",
    "output": "Returns the largest item in a list."
  },
  {
    "id": 222,
    "input": "import random\nrandom.seed(42)",
    "output": "Initializes the random number generator with a fixed seed (42)."
  },
  {
    "id": 223,
    "input": "def get_dict_keys(d):\n    return list(d.keys())",
    "output": "Returns a list of all keys in the dictionary."
  },
  {
    "id": 224,
    "input": "data = [1, 2, 3]\ndata.append(4)",
    "output": "Adds the element 4 to the end of the list."
  },
  {
    "id": 225,
    "input": "def join_by_newline(lst):\n    return '\\n'.join(lst)",
    "output": "Joins a list of strings with newline characters."
  },
  {
    "id": 226,
    "input": "text = 'value'\ntext.ljust(10, '-')",
    "output": "Left-justifies the string and pads the right with '-' up to length 10."
  },
  {
    "id": 227,
    "input": "def print_var(var):\n    print(var)",
    "output": "Prints the raw value of a variable."
  },
  {
    "id": 228,
    "input": "my_set = {1, 2}\nmy_set.add(1)",
    "output": "Tries to add an existing element (1) to the set (no change occurs)."
  },
  {
    "id": 229,
    "input": "import re\nresult = re.findall(r'\\d+', 'a1 b2 c3')",
    "output": "Finds all occurrences of one or more digits in a string using regex."
  },
  {
    "id": 230,
    "input": "def check_is(a, b):\n    return a is b",
    "output": "Checks if two variables refer to the exact same object in memory."
  },
  {
    "id": 231,
    "input": "def lazy_even_numbers():\n    i = 0\n    while True:\n        yield i\n        i += 2",
    "output": "An infinite generator that yields increasing even numbers."
  },
  {
    "id": 232,
    "input": "from datetime import date\ndate.today().year",
    "output": "Gets the current year from the date object."
  },
  {
    "id": 233,
    "input": "try:\n    raise TypeError('Custom error')\nexcept TypeError as e:\n    print(e)",
    "output": "Raises a custom 'TypeError' and catches it to print the error message."
  },
  {
    "id": 234,
    "input": "def count_up_down(n):\n    for i in range(n):\n        yield i\n    for i in range(n, 0, -1):\n        yield i",
    "output": "A generator that counts up from 0 to n-1, then down from n to 1."
  },
  {
    "id": 235,
    "input": "data = [1, 2, 3, 4, 5]\nnew_list = [x for x in data if x != 3]",
    "output": "Creates a new list containing all elements except the number 3."
  },
  {
    "id": 236,
    "input": "def check_keyword_present(**kwargs):\n    return 'required_key' in kwargs",
    "output": "Checks if a specific key ('required_key') is present in the keyword arguments."
  },
  {
    "id": 237,
    "input": "text = 'hello world'\ntext.find('world')",
    "output": "Returns the starting index of the substring 'world'."
  },
  {
    "id": 238,
    "input": "class MyClass:\n    @classmethod\n    def from_string(cls, s):\n        return cls(s.upper())",
    "output": "A class method to create a new instance from a string input."
  },
  {
    "id": 239,
    "input": "def get_dict_len(d):\n    return len(d)",
    "output": "Returns the number of key-value pairs in a dictionary."
  },
  {
    "id": 240,
    "input": "data = [('a', 1), ('b', 2)]\nreversed_data = data[::-1]",
    "output": "Reverses the order of elements in a list using slicing."
  },
  {
    "id": 241,
    "input": "def calculate_mean(lst):\n    return sum(lst) / len(lst)",
    "output": "Calculates the arithmetic mean (average) of the numbers in a list."
  },
  {
    "id": 242,
    "input": "def is_lower_only(s):\n    return s.islower()",
    "output": "Checks if all cased characters in the string are lowercase."
  },
  {
    "id": 243,
    "input": "nums = [1, 2, 3]\nnums.extend([4, 5])",
    "output": "Extends the 'nums' list by adding elements from another list."
  },
  {
    "id": 244,
    "input": "def safe_pop(lst, index):\n    if len(lst) > index:\n        return lst.pop(index)",
    "output": "Safely removes and returns the element at a specific index if it exists."
  },
  {
    "id": 245,
    "input": "def list_difference(list1, list2):\n    return list(set(list1) - set(list2))",
    "output": "Finds elements present in list1 but not in list2 using set difference."
  },
  {
    "id": 246,
    "input": "if True and False:\n    print('Impossible')",
    "output": "A conditional statement using the logical AND operator."
  },
  {
    "id": 247,
    "input": "def get_last_n(lst, n):\n    return lst[-n:]",
    "output": "Gets the last 'n' elements of the list using negative slicing."
  },
  {
    "id": 248,
    "input": "data = [1, 2, 3]\ndata.insert(1, 10)\ndata.pop(3)",
    "output": "Inserts 10 at index 1, then removes the element at index 3."
  },
  {
    "id": 249,
    "input": "def filter_list(lst):\n    return [x for x in lst if x]",
    "output": "Filters a list, removing all falsy values (0, None, '', [] etc.)."
  },
  {
    "id": 250,
    "input": "class Adder:\n    def __call__(self, a, b):\n        return a + b",
    "output": "A class that makes its instances callable like a function by defining '__call__'."
  },
  {
    "id": 251,
    "input": "def apply_map(func, lst):\n    return list(map(func, lst))",
    "output": "Applies a given function to all items in a list using 'map'."
  },
  {
    "id": 252,
    "input": "def safe_divide_try(a, b):\n    try:\n        return a / b\n    except ZeroDivisionError:\n        return 0",
    "output": "Divides 'a' by 'b', catching 'ZeroDivisionError' and returning 0."
  },
  {
    "id": 253,
    "input": "import re\nreplaced = re.sub(r'a', 'x', 'banana')",
    "output": "Replaces all occurrences of the letter 'a' with 'x' using regex substitution."
  },
  {
    "id": 254,
    "input": "def get_min_val(lst):\n    return min(lst)",
    "output": "Returns the smallest item in a list."
  },
  {
    "id": 255,
    "input": "data = [('a', 1), ('b', 2)]\nnew_dict = dict(data)",
    "output": "Creates a dictionary from a list of key-value tuples."
  },
  {
    "id": 256,
    "input": "def square_generator(n):\n    for i in range(n):\n        yield i * i",
    "output": "A generator function that yields the squares of numbers up to 'n-1'."
  },
  {
    "id": 257,
    "input": "def check_equal(a, b):\n    return a == b",
    "output": "Checks if two values are equal."
  },
  {
    "id": 258,
    "input": "text = 'hello'\ntext.replace('l', 'L', 1)",
    "output": "Replaces only the first occurrence of 'l' with 'L'."
  },
  {
    "id": 259,
    "input": "def check_not_in(val, container):\n    return val not in container",
    "output": "Checks if a value is not present in a list, tuple, or dictionary."
  },
  {
    "id": 260,
    "input": "def print_global_and_local():\n    global x\n    x = 5\n    y = 10\n    print(x, y)",
    "output": "Sets a global variable 'x' and a local variable 'y', then prints both."
  },
  {
    "id": 261,
    "input": "def print_var_and_type(var):\n    print(var, type(var))",
    "output": "Prints both the value and the type of the input variable."
  },
  {
    "id": 262,
    "input": "def merge_dicts(d1, d2):\n    merged = d1.copy()\n    merged.update(d2)\n    return merged",
    "output": "Merges two dictionaries by copying the first and updating with the second."
  },
  {
    "id": 263,
    "input": "class Point:\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y\n    def __str__(self):\n        return f'({self.x}, {self.y})'",
    "output": "Defines the informal string representation of the object using '__str__'."
  },
  {
    "id": 264,
    "input": "def is_iterable(obj):\n    try:\n        iter(obj)\n        return True\n    except TypeError:\n        return False",
    "output": "Checks if an object is iterable by attempting to get an iterator."
  },
  {
    "id": 265,
    "input": "data = [1, 2, 3]\nfor item in reversed(data):\n    print(item)",
    "output": "Iterates over the elements of the list in reverse order."
  },
  {
    "id": 266,
    "input": "def print_index(lst, val):\n    try:\n        print(lst.index(val))\n    except ValueError:\n        print(-1)",
    "output": "Prints the index of a value, or -1 if the value is not found."
  },
  {
    "id": 267,
    "input": "def remove_duplicates(lst):\n    return list(set(lst))",
    "output": "Removes duplicate elements from a list by converting it to a set and back."
  },
  {
    "id": 268,
    "input": "def count_chars(s):\n    return len(s)",
    "output": "Calculates the total length (number of characters) of a string."
  },
  {
    "id": 269,
    "input": "def get_first_n(lst, n):\n    return lst[:n]",
    "output": "Gets the first 'n' elements of the list using slicing."
  },
  {
    "id": 270,
    "input": "data = [1, 2, 3]\ndata.insert(-1, 99)",
    "output": "Inserts the value 99 before the last element of the list."
  },
  {
    "id": 271,
    "input": "def check_startswith(s, prefix):\n    return s.startswith(prefix)",
    "output": "Checks if a string begins with a specific prefix."
  },
  {
    "id": 272,
    "input": "def check_endswith(s, suffix):\n    return s.endswith(suffix)",
    "output": "Checks if a string ends with a specific suffix."
  },
  {
    "id": 273,
    "input": "def calculate_power(base, exp):\n    return base ** exp",
    "output": "Calculates the exponentiation using the '**' operator."
  },
  {
    "id": 274,
    "input": "my_set = {1, 2}\nmy_set.remove(1)",
    "output": "Removes the element 1 from the set."
  },
  {
    "id": 275,
    "input": "def check_is_not(a, b):\n    return a is not b",
    "output": "Checks if two variables do not refer to the exact same object."
  },
  {
    "id": 276,
    "input": "def print_keys_and_values(d):\n    for k, v in d.items():\n        print(k, v)",
    "output": "Iterates through the dictionary and prints each key-value pair."
  },
  {
    "id": 277,
    "input": "def sort_list_desc(lst):\n    return sorted(lst, reverse=True)",
    "output": "Returns a new list sorted in descending order."
  },
  {
    "id": 278,
    "input": "data = [1, 2, 3]\nif 2 in data and 3 in data:\n    print('Both present')",
    "output": "Checks if two different elements are both present in the list."
  },
  {
    "id": 279,
    "input": "def get_dict_item(d, key):\n    return d[key]",
    "output": "Retrieves the value associated with a given key from the dictionary."
  },
  {
    "id": 280,
    "input": "class MyClass:\n    def __del__(self):\n        print('Object destroyed')",
    "output": "Defines a destructor method that runs when the object is garbage collected."
  },
  {
    "id": 281,
    "input": "def add_and_print(a, b):\n    print(a + b)",
    "output": "Calculates the sum of two numbers and prints the result."
  },
  {
    "id": 282,
    "input": "def get_tuple_element(t, index):\n    return t[index]",
    "output": "Returns the element of a tuple at a specified index."
  },
  {
    "id": 283,
    "input": "text = '123_456'\nif text.isalnum() or '_' in text:\n    print('Contains non-alpha numeric or underscore')",
    "output": "Checks if the string contains non-alphanumeric characters or an underscore."
  },
  {
    "id": 284,
    "input": "import re\nmatch = re.search(r'\\w+', 'hello world')",
    "output": "Searches for the first sequence of word characters using regex."
  },
  {
    "id": 285,
    "input": "def map_to_string(lst):\n    return list(map(str, lst))",
    "output": "Converts all elements of a list to strings using the 'map' function."
  },
  {
    "id": 286,
    "input": "data = [10, 5, 1]\ndata.sort(reverse=True)",
    "output": "Sorts the list in descending order (in-place modification)."
  },
  {
    "id": 287,
    "input": "def custom_sum(*nums):\n    total = 0\n    for n in nums:\n        total += n\n    return total",
    "output": "Calculates the sum of a variable number of positional arguments manually."
  },
  {
    "id": 288,
    "input": "my_set = {1, 2}\nmy_set.discard(1)",
    "output": "Removes the element 1 from the set (no error if not found)."
  },
  {
    "id": 289,
    "input": "def check_instance_not(obj, type_class):\n    return not isinstance(obj, type_class)",
    "output": "Checks if an object is not an instance of a specified class."
  },
  {
    "id": 290,
    "input": "def get_second_element(lst):\n    return lst[1]",
    "output": "Returns the element at index 1 of the list."
  },
  {
    "id": 291,
    "input": "def print_formatted(a, b):\n    print(f'{a=}, {b=}')",
    "output": "Prints variables and their values using an f-string debug format."
  },
  {
    "id": 292,
    "input": "def check_not_none(val):\n    return val is not None",
    "output": "Checks if a variable is not None."
  },
  {
    "id": 293,
    "input": "try:\n    raise NameError('Variable not defined')\nexcept NameError as e:\n    print(e)",
    "output": "Raises a 'NameError' and catches it to print the error message."
  },
  {
    "id": 294,
    "input": "data = [1, 2, 3]\nfor i in range(len(data)):\n    print(data[i])",
    "output": "Iterates through the list using index ranging from 0 to length - 1."
  },
  {
    "id": 295,
    "input": "def safe_index(lst, val):\n    try:\n        return lst.index(val)\n    except ValueError:\n        return None",
    "output": "Returns the index of a value, or None if the value is not found."
  },
  {
    "id": 296,
    "input": "def filter_non_true(lst):\n    return list(filter(None, lst))",
    "output": "Filters a list, keeping only truthy elements (using 'filter' with None)."
  },
  {
    "id": 297,
    "input": "def check_or(a, b):\n    return a or b",
    "output": "Returns the first truthy value among 'a' and 'b', or the last value if none are truthy."
  },
  {
    "id": 298,
    "input": "class ReadOnly:\n    def __init__(self, value):\n        self._value = value\n    def get_value(self):\n        return self._value",
    "output": "A simple class with a method to return the value of a private-like attribute."
  },
  {
    "id": 299,
    "input": "data = [1, 2, 3, 4, 5]\ndata.pop(0)",
    "output": "Removes and returns the first element (index 0) of the list."
  },
  {
    "id": 300,
    "input": "def calculate_product_of_list(lst):\n    return reduce(lambda x, y: x * y, lst)",
    "output": "Calculates the product of all elements in a list using 'reduce'."
  },
  {
    "id": 301,
    "input": "def get_list_count(lst, val):\n    return lst.count(val)",
    "output": "Counts the number of occurrences of a specific value in the list."
  },
  {
    "id": 302,
    "input": "def swap_first_last(lst):\n    lst[0], lst[-1] = lst[-1], lst[0]",
    "output": "Swaps the first and last elements of the list in-place."
  },
  {
    "id": 303,
    "input": "text = 'hello'\ntext.capitalize()",
    "output": "Capitalizes the first letter of the string."
  },
  {
    "id": 304,
    "input": "def convert_to_int(s):\n    return int(s)",
    "output": "Converts a string to an integer."
  },
  {
    "id": 305,
    "input": "def check_not_equal(a, b):\n    return a != b",
    "output": "Checks if two values are not equal."
  },
  {
    "id": 306,
    "input": "data = {'a': 1, 'b': 2}\nfor val in data.values():\n    print(val)",
    "output": "Iterates over and prints only the values of the dictionary."
  },
  {
    "id": 307,
    "input": "def print_global_if_exists():\n    if 'my_global' in globals():\n        print(globals()['my_global'])",
    "output": "Checks for the existence of a global variable and prints it using 'globals()'."
  },
  {
    "id": 308,
    "input": "import random\nrandom.uniform(1.0, 5.0)",
    "output": "Generates a random floating-point number between 1.0 and 5.0."
  },
  {
    "id": 309,
    "input": "my_tuple = (1, 2, 3)\nif 4 not in my_tuple:\n    print('4 not present')",
    "output": "Checks if an element is not present in the tuple."
  },
  {
    "id": 310,
    "input": "def check_is_alpha_or_digit(s):\n    return s.isalnum()",
    "output": "Checks if all characters in the string are either alphabetic or numeric."
  },
  {
    "id": 311,
    "input": "def reverse_list(lst):\n    lst.reverse()",
    "output": "Reverses the list in-place."
  },
  {
    "id": 312,
    "input": "text = '  trim me  '\ntext.strip()",
    "output": "Removes leading and trailing whitespace from the string."
  },
  {
    "id": 313,
    "input": "def get_dict_keys_list(d):\n    return list(d.keys())",
    "output": "Converts dictionary keys into a list."
  },
  {
    "id": 314,
    "input": "def calculate_diff(a, b):\n    return a - b",
    "output": "Calculates the difference between two numbers."
  },
  {
    "id": 315,
    "input": "data = [1, 2, 3]\nfor i in data:\n    if i > 2:\n        break\n    print(i)",
    "output": "Prints elements of the list until a value greater than 2 is found, then stops."
  },
  {
    "id": 316,
    "input": "def list_sum_with_for(lst):\n    total = 0\n    for item in lst:\n        total += item\n    return total",
    "output": "Calculates the sum of list elements using a for loop."
  },
  {
    "id": 317,
    "input": "try:\n    pass\nexcept Exception as e:\n    print(e)\nelse:\n    print('No exception')",
    "output": "Executes 'else' block if no exception occurred in the 'try' block."
  },
  {
    "id": 318,
    "input": "def check_has_vowels(s):\n    return any(c in 'aeiou' for c in s)",
    "output": "Checks if a string contains any vowel using a generator expression and 'any'."
  },
  {
    "id": 319,
    "input": "def count_args_kwargs(*args, **kwargs):\n    return len(args) + len(kwargs)",
    "output": "Returns the total count of all positional and keyword arguments."
  },
  {
    "id": 320,
    "input": "def return_if_not_none(val, default='-'):\n    return val if val is not None else default",
    "output": "Returns the value if not None, otherwise returns a default string."
  },
  {
    "id": 321,
    "input": "def sort_by_length(words):\n    return sorted(words, key=len)",
    "output": "Sorts a list of strings by their length."
  },
  {
    "id": 322,
    "input": "def is_uppercase_only(s):\n    return s.isupper()",
    "output": "Checks if all cased characters in the string are uppercase."
  },
  {
    "id": 323,
    "input": "data = [1, 2, 3]\ndata.clear()",
    "output": "Removes all elements from the list."
  },
  {
    "id": 324,
    "input": "def get_middle_slice(lst):\n    return lst[1:-1]",
    "output": "Returns a slice containing all elements except the first and last."
  },
  {
    "id": 325,
    "input": "def check_is_callable(obj):\n    return callable(obj)",
    "output": "Checks if an object can be called (is a function, method, or callable class instance)."
  },
  {
    "id": 326,
    "input": "my_set = {1, 2, 3}\nmy_set.update([4, 5])",
    "output": "Adds multiple elements (4 and 5) to the set."
  },
  {
    "id": 327,
    "input": "import re\ntext = 'price: $10.99'\nmatch = re.search(r'\\$(\\d+\\.\\d+)', text).group(1)",
    "output": "Extracts the decimal number after '$' using a capturing group in regex."
  },
  {
    "id": 328,
    "input": "def recursive_power(a, b):\n    if b == 0: return 1\n    return a * recursive_power(a, b - 1)",
    "output": "Calculates 'a' to the power of 'b' using recursion."
  },
  {
    "id": 329,
    "input": "def get_dict_items(d):\n    return list(d.items())",
    "output": "Returns a list of key-value tuples from the dictionary."
  },
  {
    "id": 330,
    "input": "class Parent:\n    def method(self):\n        return 'Base'\nclass Child(Parent):\n    def method(self):\n        return super().method() + ' and Derived'",
    "output": "A derived class overriding a method and calling the base class implementation using 'super()'."
  },
  {
    "id": 331,
    "input": "def check_and(a, b):\n    return a and b",
    "output": "Returns 'a' if it is falsy, otherwise returns 'b' (short-circuiting)."
  },
  {
    "id": 332,
    "input": "data = [1, 2, 3]\ndata.insert(len(data) // 2, 99)",
    "output": "Inserts the value 99 in the middle of the list."
  },
  {
    "id": 333,
    "input": "def fibonacci_list(n):\n    lst = [0, 1]\n    while len(lst) < n:\n        lst.append(lst[-1] + lst[-2])\n    return lst[:n]",
    "output": "Generates the first 'n' Fibonacci numbers and returns them as a list."
  },
  {
    "id": 334,
    "input": "def get_index_of_tuple(t, val):\n    return t.index(val)",
    "output": "Returns the index of a specified value in the tuple."
  },
  {
    "id": 335,
    "input": "def check_not(val):\n    return not val",
    "output": "Returns the boolean opposite of the value's truthiness."
  },
  {
    "id": 336,
    "input": "text = 'hello'\ntext.startswith(('h', 'H'))",
    "output": "Checks if the string starts with 'h' or 'H' using a tuple of prefixes."
  },
  {
    "id": 337,
    "input": "def get_dict_len_for(d):\n    count = 0\n    for _ in d:\n        count += 1\n    return count",
    "output": "Calculates the size of the dictionary using a manual iteration."
  },
  {
    "id": 338,
    "input": "def combine_lists_zip(l1, l2):\n    return list(zip(l1, l2))",
    "output": "Combines elements from two lists into a list of tuples using 'zip'."
  },
  {
    "id": 339,
    "input": "try:\n    # code that might raise\n    pass\nexcept Exception:\n    print('An error occurred')\nfinally:\n    print('Always runs')",
    "output": "A try-except block with a 'finally' block that always executes."
  },
  {
    "id": 340,
    "input": "def create_set_from_list(lst):\n    return {x for x in lst}",
    "output": "Creates a set from a list using set comprehension."
  },
  {
    "id": 341,
    "input": "def filter_by_type(lst, target_type):\n    return [x for x in lst if type(x) is target_type]",
    "output": "Filters a list, keeping only elements of the exact specified type."
  },
  {
    "id": 342,
    "input": "def get_default_value(d, key, default):\n    return d.get(key, default)",
    "output": "Safely retrieves a dictionary value, providing a custom default if missing."
  },
  {
    "id": 343,
    "input": "def print_items_reverse(lst):\n    for item in lst[::-1]:\n        print(item)",
    "output": "Iterates over and prints the list elements in reverse using slicing."
  },
  {
    "id": 344,
    "input": "text = '  trim space right  '\ntext.rstrip()",
    "output": "Removes only the trailing whitespace from the string."
  },
  {
    "id": 345,
    "input": "def join_with_comma_space(lst):\n    return ', '.join(lst)",
    "output": "Joins a list of strings using ', ' as the delimiter."
  },
  {
    "id": 346,
    "input": "def sort_list_in_place(lst):\n    lst.sort()",
    "output": "Sorts the list in-place (mutates the original list)."
  },
  {
    "id": 347,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.difference_update(other)",
    "output": "Removes elements found in 'other' from 'my_set' (in-place update)."
  },
  {
    "id": 348,
    "input": "def get_file_size(filename):\n    import os\n    return os.path.getsize(filename)",
    "output": "Returns the size of a file in bytes using the 'os' module."
  },
  {
    "id": 349,
    "input": "def is_decimal_only(s):\n    return s.isdigit()",
    "output": "Checks if all characters in the string are decimal digits (0-9)."
  },
  {
    "id": 350,
    "input": "class MyLogger:\n    def __init__(self):\n        self.logs = []\n    def log(self, msg):\n        self.logs.append(msg)",
    "output": "A simple class with a method to append messages to an internal list."
  },
  {
    "id": 351,
    "input": "def get_list_slice_from(lst, start):\n    return lst[start:]",
    "output": "Returns a slice from the specified start index to the end of the list."
  },
  {
    "id": 352,
    "input": "def calculate_round(n):\n    return round(n)",
    "output": "Rounds a number to the nearest integer."
  },
  {
    "id": 353,
    "input": "def apply_lambda(x):\n    return (lambda a: a * 3)(x)",
    "output": "Defines and immediately executes an anonymous lambda function."
  },
  {
    "id": 354,
    "input": "def nested_if_check(x, y):\n    if x > 0:\n        if y > 0:\n            return 'Both positive'",
    "output": "Uses nested if statements to check multiple conditions."
  },
  {
    "id": 355,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 4:\n        print('Found')\n        break\nelse:\n    print('Not found')",
    "output": "Uses 'for-else' to execute a block only if the loop completes without 'break'."
  },
  {
    "id": 356,
    "input": "def remove_from_dict(d, key):\n    d.pop(key, None)",
    "output": "Removes a key from a dictionary, suppressing KeyError if it doesn't exist."
  },
  {
    "id": 357,
    "input": "def filter_zeros(lst):\n    return [x for x in lst if x != 0]",
    "output": "Filters a list, removing all zero values."
  },
  {
    "id": 358,
    "input": "def check_is_upper_or_lower(s):\n    return s.islower() or s.isupper()",
    "output": "Checks if a string is composed entirely of either lowercase or uppercase characters."
  },
  {
    "id": 359,
    "input": "def convert_to_float(s):\n    return float(s)",
    "output": "Converts a string to a floating-point number."
  },
  {
    "id": 360,
    "input": "def generate_range(start, end, step=1):\n    yield from range(start, end, step)",
    "output": "A generator that delegates to the built-in 'range' using 'yield from'."
  },
  {
    "id": 361,
    "input": "def check_length_greater_than(lst, n):\n    return len(lst) > n",
    "output": "Checks if the length of a list is strictly greater than 'n'."
  },
  {
    "id": 362,
    "input": "def format_with_name(name, age):\n    return 'Name: {}, Age: {}'.format(name, age)",
    "output": "Formats a string using the 'str.format()' method with positional arguments."
  },
  {
    "id": 363,
    "input": "def print_var_attrs(obj):\n    print(vars(obj))",
    "output": "Prints the '__dict__' attribute of an object using the 'vars()' function."
  },
  {
    "id": 364,
    "input": "def is_type_float(var):\n    return type(var) is float",
    "output": "Checks if the exact type of a variable is 'float'."
  },
  {
    "id": 365,
    "input": "def get_dict_keys_and_values(d):\n    return list(d.keys()), list(d.values())",
    "output": "Returns a tuple containing a list of keys and a list of values."
  },
  {
    "id": 366,
    "input": "def convert_to_set(lst):\n    return set(lst)",
    "output": "Converts a list to a set."
  },
  {
    "id": 367,
    "input": "import random\nrandom.sample(range(100), 5)",
    "output": "Selects 5 unique random elements from the range 0 to 99."
  },
  {
    "id": 368,
    "input": "def sort_by_desc_length(words):\n    return sorted(words, key=len, reverse=True)",
    "output": "Sorts a list of strings in descending order based on their length."
  },
  {
    "id": 369,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.intersection_update(other)",
    "output": "Updates 'my_set' to contain only elements common to both sets (in-place)."
  },
  {
    "id": 370,
    "input": "def list_contains_any(lst, values):\n    return any(v in lst for v in values)",
    "output": "Checks if the list contains at least one of the values in the 'values' iterable."
  },
  {
    "id": 371,
    "input": "def get_last_element_pop(lst):\n    return lst.pop()",
    "output": "Removes and returns the last element of the list."
  },
  {
    "id": 372,
    "input": "def check_is_none(val):\n    return val is None",
    "output": "Checks if a variable is None."
  },
  {
    "id": 373,
    "input": "text = 'hello'\ntext.endswith(('o', 'O'))",
    "output": "Checks if the string ends with 'o' or 'O' using a tuple of suffixes."
  },
  {
    "id": 374,
    "input": "def unpack_two(t):\n    a, b = t\n    return a, b",
    "output": "Unpacks a two-element tuple into separate variables."
  },
  {
    "id": 375,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2:\n        pass\n    print(item)",
    "output": "Iterates over a list, using 'pass' as a placeholder for a no-op action."
  },
  {
    "id": 376,
    "input": "def get_second_to_last(lst):\n    return lst[-2]",
    "output": "Returns the second to last element of the list using a negative index."
  },
  {
    "id": 377,
    "input": "def filter_by_index(lst, indices):\n    return [lst[i] for i in indices]",
    "output": "Creates a new list containing elements only at the specified indices."
  },
  {
    "id": 378,
    "input": "def print_nonlocal():\n    x = 1\n    def inner():\n        nonlocal x\n        x += 1\n        print(x)\n    inner()",
    "output": "Increments a variable in the enclosing scope using 'nonlocal'."
  },
  {
    "id": 379,
    "input": "def get_dict_keys_set(d):\n    return set(d.keys())",
    "output": "Returns a set of all keys in the dictionary."
  },
  {
    "id": 380,
    "input": "class Counter:\n    def __init__(self, start=0):\n        self.count = start\n    def __iter__(self):\n        return self\n    def __next__(self):\n        if self.count >= 5: raise StopIteration\n        self.count += 1\n        return self.count - 1",
    "output": "A simple class that implements the iterator protocol to count up to 5."
  },
  {
    "id": 381,
    "input": "def calculate_sum_of_even(lst):\n    return sum(x for x in lst if x % 2 == 0)",
    "output": "Calculates the sum of all even numbers in a list using a generator expression."
  },
  {
    "id": 382,
    "input": "def check_is_space(s):\n    return s.isspace()",
    "output": "Checks if the string contains only whitespace characters."
  },
  {
    "id": 383,
    "input": "data = [1, 2, 3]\ndata.insert(1, 99)\ndata.insert(1, 88)",
    "output": "Inserts 99 at index 1, then inserts 88 at the new index 1."
  },
  {
    "id": 384,
    "input": "def print_items_and_len(lst):\n    for item in lst:\n        print(item, len(lst))",
    "output": "Iterates over a list, printing each item along with the list's total length."
  },
  {
    "id": 385,
    "input": "def get_dict_values_set(d):\n    return set(d.values())",
    "output": "Returns a set of all unique values in the dictionary."
  },
  {
    "id": 386,
    "input": "import os\nif os.path.isdir('my_dir'):\n    print('Is a directory')",
    "output": "Checks if the path refers to an existing directory."
  },
  {
    "id": 387,
    "input": "def get_unique_elements(lst):\n    return sorted(list(set(lst)))",
    "output": "Returns a sorted list of unique elements from the original list."
  },
  {
    "id": 388,
    "input": "def check_length_less_than(lst, n):\n    return len(lst) < n",
    "output": "Checks if the length of a list is strictly less than 'n'."
  },
  {
    "id": 389,
    "input": "my_set = {1, 2, 3}\nother = {3, 4, 5}\nmy_set.symmetric_difference_update(other)",
    "output": "Updates 'my_set' with elements that are in either set, but not both (in-place)."
  },
  {
    "id": 390,
    "input": "def get_dict_value_by_key(d, key):\n    return d.get(key)",
    "output": "Safely retrieves a dictionary value using 'get' (defaults to None)."
  },
  {
    "id": 391,
    "input": "def combine_strings_f(s1, s2):\n    return f'{s1}{s2}'",
    "output": "Concatenates two strings using an f-string."
  },
  {
    "id": 392,
    "input": "def check_instance_of_int(var):\n    return isinstance(var, int)",
    "output": "Checks if a variable is an instance of the 'int' type (including subclasses)."
  },
  {
    "id": 393,
    "input": "def check_is_not_none_or_empty(val):\n    return val is not None and len(val) > 0",
    "output": "Checks if a variable is not None and not an empty sequence/container."
  },
  {
    "id": 394,
    "input": "def get_first_element_index(lst):\n    return lst.index(lst[0])",
    "output": "Finds the index of the first element (will always be 0)."
  },
  {
    "id": 395,
    "input": "def remove_by_value(lst, val):\n    try:\n        lst.remove(val)\n    except ValueError: pass",
    "output": "Removes the first occurrence of a value, suppressing ValueError if not found."
  },
  {
    "id": 396,
    "input": "def sum_list_with_reduce(lst):\n    from functools import reduce\n    return reduce(lambda x, y: x + y, lst)",
    "output": "Calculates the sum of a list using 'reduce' with a lambda function."
  },
  {
    "id": 397,
    "input": "def is_not_equal(a, b):\n    return not a == b",
    "output": "Checks if two values are not equal using the 'not' operator."
  },
  {
    "id": 398,
    "input": "class DataContainer:\n    def __getitem__(self, key):\n        return self.data[key]",
    "output": "Defines the '__getitem__' method, enabling indexing (e.g., obj[key])."
  },
  {
    "id": 399,
    "input": "def print_var_and_id(var):\n    print(var, id(var))",
    "output": "Prints the value of a variable along with its memory address (ID)."
  },
  {
    "id": 400,
    "input": "def calculate_average_weighted(data, weights):\n    return sum(d * w for d, w in zip(data, weights)) / sum(weights)",
    "output": "Calculates the weighted average of a list of data points."
  },
  {
    "id": 401,
    "input": "def is_subset(s1, s2):\n    return s1.issubset(s2)",
    "output": "Checks if all elements of set 's1' are present in set 's2'."
  },
  {
    "id": 402,
    "input": "def convert_to_lower(s):\n    return s.lower()",
    "output": "Converts all cased characters in the string to lowercase."
  },
  {
    "id": 403,
    "input": "data = [1, 2, 3]\nfor i in range(len(data) - 1, -1, -1):\n    print(data[i])",
    "output": "Iterates backward through the list using 'range' and indices."
  },
  {
    "id": 404,
    "input": "def remove_last_element(lst):\n    lst.pop()",
    "output": "Removes the last element from the list in-place."
  },
  {
    "id": 405,
    "input": "def create_tuple_with_one(val):\n    return (val,)",
    "output": "Creates a single-element tuple (note the required comma)."
  },
  {
    "id": 406,
    "input": "data = {'a': 1, 'b': 2}\nkey, value = data.popitem()",
    "output": "Removes and returns an arbitrary (usually last inserted) key-value pair as a tuple."
  },
  {
    "id": 407,
    "input": "def generator_expression_sum(n):\n    return sum(i for i in range(n))",
    "output": "Calculates the sum of numbers up to 'n-1' using a generator expression."
  },
  {
    "id": 408,
    "input": "def filter_less_than(lst, val):\n    return [x for x in lst if x < val]",
    "output": "Filters a list, keeping only elements strictly less than 'val'."
  },
  {
    "id": 409,
    "input": "import re\nmatch = re.fullmatch(r'\\d+', '123')",
    "output": "Checks if the entire string consists only of digits using regex full match."
  },
  {
    "id": 410,
    "input": "class Multiplier:\n    def __init__(self, factor):\n        self.factor = factor\n    def __call__(self, x):\n        return x * self.factor",
    "output": "A callable class that multiplies its input by a stored factor."
  },
  {
    "id": 411,
    "input": "def check_is_title(s):\n    return s.istitle()",
    "output": "Checks if the string follows title casing rules."
  },
  {
    "id": 412,
    "input": "def print_var_id(var):\n    print(id(var))",
    "output": "Prints the unique identity (memory address) of a variable."
  },
  {
    "id": 413,
    "input": "def check_is_int_instance(var):\n    return isinstance(var, int)",
    "output": "Checks if a variable is an instance of the 'int' type."
  },
  {
    "id": 414,
    "input": "data = [1, 2, 3]\ndata.insert(len(data), 4)\ndata.insert(0, 0)",
    "output": "Appends 4 to the end and inserts 0 at the beginning of the list."
  },
  {
    "id": 415,
    "input": "def get_all_kwargs(**kwargs):\n    return kwargs",
    "output": "Returns a dictionary containing all passed keyword arguments."
  },
  {
    "id": 416,
    "input": "def get_dict_view(d):\n    return d.items()",
    "output": "Returns a dynamic view object of the dictionary's key-value pairs."
  },
  {
    "id": 417,
    "input": "def is_not_alpha_only(s):\n    return not s.isalpha()",
    "output": "Checks if the string contains any non-alphabetic characters."
  },
  {
    "id": 418,
    "input": "def convert_to_upper(s):\n    return s.upper()",
    "output": "Converts all cased characters in the string to uppercase."
  },
  {
    "id": 419,
    "input": "my_set = {1, 2}\nmy_set.clear()",
    "output": "Removes all elements from the set."
  },
  {
    "id": 420,
    "input": "def generate_odd_numbers(n):\n    for i in range(1, n, 2):\n        yield i",
    "output": "A generator that yields odd numbers up to 'n-1'."
  },
  {
    "id": 421,
    "input": "def check_or_falsy(a, b):\n    return a or b",
    "output": "Returns 'a' if truthy, otherwise returns 'b'."
  },
  {
    "id": 422,
    "input": "def safe_type_convert(s, type_func):\n    try:\n        return type_func(s)\n    except ValueError:\n        return None",
    "output": "Tries to convert a string to a specified type, returning None on failure."
  },
  {
    "id": 423,
    "input": "def check_and_truthy(a, b):\n    return a and b",
    "output": "Returns 'a' if falsy, otherwise returns 'b'."
  },
  {
    "id": 424,
    "input": "def filter_by_lambda(lst, condition_func):\n    return list(filter(condition_func, lst))",
    "output": "Filters a list using a custom condition function applied to each element."
  },
  {
    "id": 425,
    "input": "data = [1, 2, 3]\ndata.insert(0, 5)\ndata.pop()",
    "output": "Inserts 5 at the start, then removes the last element."
  },
  {
    "id": 426,
    "input": "def get_dict_items_list(d):\n    return list(d.items())",
    "output": "Converts dictionary items (key-value tuples) to a list."
  },
  {
    "id": 427,
    "input": "def calculate_rounded_sum(a, b):\n    return round(a + b)",
    "output": "Calculates the sum of two numbers and rounds the result."
  },
  {
    "id": 428,
    "input": "def print_var_name(var):\n    # Simple variable name detection is complex, use f-string debug as proxy\n    name = 'var'\n    print(f'{name}={var}')",
    "output": "Prints the value of a variable, attempting to include its name (as a placeholder)."
  },
  {
    "id": 429,
    "input": "def is_type_int(var):\n    return type(var) is int",
    "output": "Checks if the exact type of a variable is 'int'."
  },
  {
    "id": 430,
    "input": "def get_tuple_slice(t, start, end):\n    return t[start:end]",
    "output": "Returns a slice of the tuple from 'start' up to 'end'."
  },
  {
    "id": 431,
    "input": "def check_is_digit(s):\n    return s.isdigit()",
    "output": "Checks if the string contains only digits."
  },
  {
    "id": 432,
    "input": "def check_none_or_empty(val):\n    return val is None or len(val) == 0",
    "output": "Checks if a variable is either None or an empty sequence/container."
  },
  {
    "id": 433,
    "input": "def remove_by_index_safe(lst, index):\n    if len(lst) > index: return lst.pop(index)",
    "output": "Removes and returns an element at a specific index only if the index is valid."
  },
  {
    "id": 434,
    "input": "def sum_list_with_generator(lst):\n    return sum(x for x in lst)",
    "output": "Calculates the sum of list elements using a generator expression inside 'sum'."
  },
  {
    "id": 435,
    "input": "def check_greater_equal(a, b):\n    return a >= b",
    "output": "Checks if 'a' is greater than or equal to 'b'."
  },
  {
    "id": 436,
    "input": "def check_less_equal(a, b):\n    return a <= b",
    "output": "Checks if 'a' is less than or equal to 'b'."
  },
  {
    "id": 437,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.union(other)",
    "output": "Calculates the union of the two sets."
  },
  {
    "id": 438,
    "input": "def get_dict_keys_list_sorted(d):\n    return sorted(list(d.keys()))",
    "output": "Returns a sorted list of all keys in the dictionary."
  },
  {
    "id": 439,
    "input": "def filter_dict_values(d, condition_func):\n    return {k: v for k, v in d.items() if condition_func(v)}",
    "output": "Creates a new dictionary, filtering key-value pairs based on a condition applied to the value."
  },
  {
    "id": 440,
    "input": "def is_superset(s1, s2):\n    return s1.issuperset(s2)",
    "output": "Checks if set 's1' contains all elements of set 's2'."
  },
  {
    "id": 441,
    "input": "def format_with_keywords(name, age):\n    return 'Name: {n}, Age: {a}'.format(n=name, a=age)",
    "output": "Formats a string using the 'str.format()' method with keyword arguments."
  },
  {
    "id": 442,
    "input": "def strip_all_whitespace(s):\n    return s.strip()",
    "output": "Removes all leading and trailing whitespace from the string."
  },
  {
    "id": 443,
    "input": "def reverse_order(lst):\n    lst.reverse()",
    "output": "Reverses the list in-place."
  },
  {
    "id": 444,
    "input": "def get_list_slice_to(lst, end):\n    return lst[:end]",
    "output": "Returns a slice from the beginning of the list up to the specified end index."
  },
  {
    "id": 445,
    "input": "data = [1, 2, 3]\ndata.insert(-1, 99)",
    "output": "Inserts the value 99 before the last element of the list."
  },
  {
    "id": 446,
    "input": "def is_type_string(var):\n    return type(var) is str",
    "output": "Checks if the exact type of a variable is 'str'."
  },
  {
    "id": 447,
    "input": "def print_var_local():\n    x = 10\n    print(locals()['x'])",
    "output": "Prints the value of a local variable using the 'locals()' function."
  },
  {
    "id": 448,
    "input": "def filter_non_alpha(lst):\n    return [x for x in lst if str(x).isalpha()]",
    "output": "Filters a list, keeping only elements whose string representation is alphabetic."
  },
  {
    "id": 449,
    "input": "def get_dict_values_list(d):\n    return list(d.values())",
    "output": "Converts dictionary values into a list."
  },
  {
    "id": 450,
    "input": "def calculate_median(lst):\n    n = len(lst)\n    s = sorted(lst)\n    if n % 2 == 1: return s[n // 2]\n    return (s[n // 2 - 1] + s[n // 2]) / 2",
    "output": "Calculates the median value of a list of numbers."
  },
  {
    "id": 451,
    "input": "def check_contains(container, val):\n    return val in container",
    "output": "Checks if a value is present in a container (list, tuple, set, dict keys)."
  },
  {
    "id": 452,
    "input": "def convert_to_title(s):\n    return s.title()",
    "output": "Converts the string to title case (first letter of each word capitalized)."
  },
  {
    "id": 453,
    "input": "def get_first_element_tuple(t):\n    return t[0]",
    "output": "Returns the first element of a tuple."
  },
  {
    "id": 454,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2:\n        continue",
    "output": "Iterates over a list, skipping the element '2'."
  },
  {
    "id": 455,
    "input": "def filter_by_index_set(lst, indices):\n    return [lst[i] for i in range(len(lst)) if i in indices]",
    "output": "Creates a new list containing elements only at the specified indices (using comprehension)."
  },
  {
    "id": 456,
    "input": "def check_length_equal(lst, n):\n    return len(lst) == n",
    "output": "Checks if the length of a list is exactly equal to 'n'."
  },
  {
    "id": 457,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.symmetric_difference(other)",
    "output": "Calculates the symmetric difference (elements in either set, but not both)."
  },
  {
    "id": 458,
    "input": "def get_dict_key_for_value(d, target_value):\n    for k, v in d.items():\n        if v == target_value: return k",
    "output": "Returns the key associated with a specific value (first one found)."
  },
  {
    "id": 459,
    "input": "def is_super_subset(s1, s2):\n    return s1 > s2",
    "output": "Checks if set 's1' is a proper superset of set 's2' (s1 contains s2, but s1 != s2)."
  },
  {
    "id": 460,
    "input": "def format_with_index(name, age):\n    return 'Name: {0}, Age: {1}'.format(name, age)",
    "output": "Formats a string using the 'str.format()' method with index-based arguments."
  },
  {
    "id": 461,
    "input": "def remove_by_value_all(lst, val):\n    return [x for x in lst if x != val]",
    "output": "Removes all occurrences of a specific value from a list using comprehension."
  },
  {
    "id": 462,
    "input": "def get_list_slice_step(lst, step):\n    return lst[::step]",
    "output": "Returns a slice with a step value (e.g., every second element)."
  },
  {
    "id": 463,
    "input": "def check_is_alpha_digit(s):\n    return s.isalnum()",
    "output": "Checks if the string contains only letters or numbers."
  },
  {
    "id": 464,
    "input": "def is_type_tuple(var):\n    return type(var) is tuple",
    "output": "Checks if the exact type of a variable is 'tuple'."
  },
  {
    "id": 465,
    "input": "def print_var_dir(obj):\n    print(dir(obj))",
    "output": "Prints a list of valid attributes for the object using 'dir()'."
  },
  {
    "id": 466,
    "input": "data = [1, 2, 3]\ndata.insert(1, 99)\ndata.pop(1)",
    "output": "Inserts 99 at index 1, then immediately removes the element at index 1."
  },
  {
    "id": 467,
    "input": "def generate_sequence_reverse(n):\n    for i in range(n - 1, -1, -1):\n        yield i",
    "output": "A generator that yields numbers counting down from 'n-1' to 0."
  },
  {
    "id": 468,
    "input": "def check_not_in_container(val, container):\n    return val not in container",
    "output": "Checks if a value is absent from a container."
  },
  {
    "id": 469,
    "input": "def filter_non_digit(lst):\n    return [x for x in lst if str(x).isdigit()]",
    "output": "Filters a list, keeping only elements whose string representation is all digits."
  },
  {
    "id": 470,
    "input": "class ImmutableValue:\n    def __init__(self, value):\n        object.__setattr__(self, 'value', value)\n    def __setattr__(self, name, value):\n        raise AttributeError('Cannot set attribute')",
    "output": "Creates an immutable class by restricting attribute setting after initialization."
  },
  {
    "id": 471,
    "input": "def calculate_sum_of_squares_list(lst):\n    return sum(x * x for x in lst)",
    "output": "Calculates the sum of the squares of all elements in the list."
  },
  {
    "id": 472,
    "input": "def convert_to_swapcase(s):\n    return s.swapcase()",
    "output": "Converts uppercase characters to lowercase and vice versa."
  },
  {
    "id": 473,
    "input": "def get_last_element_tuple(t):\n    return t[-1]",
    "output": "Returns the last element of a tuple."
  },
  {
    "id": 474,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 4:\n        break\n    print(item)",
    "output": "Iterates and prints elements until a value (4) not in the list is checked (does not stop)."
  },
  {
    "id": 475,
    "input": "def is_type_float_instance(var):\n    return isinstance(var, float)",
    "output": "Checks if a variable is an instance of the 'float' type."
  },
  {
    "id": 476,
    "input": "def get_dict_popitem(d):\n    return d.popitem()",
    "output": "Removes and returns an arbitrary key-value pair from the dictionary."
  },
  {
    "id": 477,
    "input": "my_set = {1, 2}\nmy_set.remove(1)\nmy_set.add(3)",
    "output": "Removes 1, then adds 3 to the set."
  },
  {
    "id": 478,
    "input": "def check_length_not_equal(lst, n):\n    return len(lst) != n",
    "output": "Checks if the length of a list is not equal to 'n'."
  },
  {
    "id": 479,
    "input": "def get_dict_keys_and_values_zip(d):\n    return list(zip(d.keys(), d.values()))",
    "output": "Creates a list of (key, value) tuples by zipping dictionary keys and values."
  },
  {
    "id": 480,
    "input": "def sort_list_case_insensitive(words):\n    return sorted(words, key=str.lower)",
    "output": "Sorts a list of strings alphabetically, ignoring case."
  },
  {
    "id": 481,
    "input": "def remove_last_n(lst, n):\n    del lst[-n:]",
    "output": "Removes the last 'n' elements from the list using 'del' with slicing."
  },
  {
    "id": 482,
    "input": "def get_list_slice_negative_step(lst):\n    return lst[::-1]",
    "output": "Returns a reversed copy of the list using a negative step slicing."
  },
  {
    "id": 483,
    "input": "def check_is_space_only(s):\n    return s.isspace()",
    "output": "Checks if the string consists only of whitespace characters."
  },
  {
    "id": 484,
    "input": "def is_type_list(var):\n    return type(var) is list",
    "output": "Checks if the exact type of a variable is 'list'."
  },
  {
    "id": 485,
    "input": "def print_var_type_name(var):\n    print(type(var).__name__)",
    "output": "Prints the string name of the variable's type."
  },
  {
    "id": 486,
    "input": "data = [1, 2, 3]\ndata.insert(len(data), 4)\ndata.pop(0)",
    "output": "Appends 4 to the end, then removes the first element."
  },
  {
    "id": 487,
    "input": "def filter_by_index_reverse(lst, indices):\n    return [lst[i] for i in sorted(indices, reverse=True)]",
    "output": "Creates a new list by selecting elements at specified indices and ordering them in reverse."
  },
  {
    "id": 488,
    "input": "def check_is_sub_subset(s1, s2):\n    return s1 < s2",
    "output": "Checks if set 's1' is a proper subset of set 's2' (s1 is contained in s2, but s1 != s2)."
  },
  {
    "id": 489,
    "input": "def check_not_in_dict_keys(d, key):\n    return key not in d",
    "output": "Checks if a key is not present in the dictionary."
  },
  {
    "id": 490,
    "input": "def remove_first_occurrence(lst, val):\n    try:\n        lst.remove(val)\n    except ValueError: pass",
    "output": "Removes the specified value from the list only if it is present."
  },
  {
    "id": 491,
    "input": "def combine_strings_plus(s1, s2):\n    return s1 + s2",
    "output": "Concatenates two strings using the '+' operator."
  },
  {
    "id": 492,
    "input": "def check_instance_of_str(var):\n    return isinstance(var, str)",
    "output": "Checks if a variable is an instance of the 'str' type."
  },
  {
    "id": 493,
    "input": "def check_is_none_or_falsy(val):\n    return val is None or not val",
    "output": "Checks if a variable is either None or falsy (e.g., empty, 0)."
  },
  {
    "id": 494,
    "input": "def get_dict_value_with_default(d, key, default):\n    return d.get(key, default)",
    "output": "Retrieves a dictionary value, using a specified default if the key is missing."
  },
  {
    "id": 495,
    "input": "def sort_dict_by_keys(d):\n    return dict(sorted(d.items()))",
    "output": "Returns a new dictionary sorted by its keys."
  },
  {
    "id": 496,
    "input": "def remove_first_n(lst, n):\n    del lst[:n]",
    "output": "Removes the first 'n' elements from the list using 'del' with slicing."
  },
  {
    "id": 497,
    "input": "def check_not_instance(obj, type_class):\n    return not isinstance(obj, type_class)",
    "output": "Checks if an object is not an instance of the specified type."
  },
  {
    "id": 498,
    "input": "def generate_sequence_step(start, end, step):\n    yield from range(start, end, step)",
    "output": "A generator that yields a sequence of numbers with a custom step."
  },
  {
    "id": 499,
    "input": "def check_is_lower_only(s):\n    return s.islower()",
    "output": "Checks if the string is composed entirely of lowercase cased characters."
  },
  {
    "id": 500,
    "input": "def calculate_mode(lst):\n    from collections import Counter\n    data = Counter(lst)\n    return data.most_common(1)[0][0]",
    "output": "Calculates the mode (most frequent item) of a list using 'Counter'."
  },
  {
    "id": 501,
    "input": "def generate_fizzbuzz(n):\n    for i in range(1, n + 1):\n        if i % 15 == 0: yield 'FizzBuzz'\n        elif i % 3 == 0: yield 'Fizz'\n        elif i % 5 == 0: yield 'Buzz'\n        else: yield i",
    "output": "A generator for the classic FizzBuzz sequence up to 'n'."
  },
  {
    "id": 502,
    "input": "names = ['Ali', 'Veli', 'Ayşe']\nages = [20, 30, 25]\npeople = sorted(zip(names, ages), key=lambda x: x[1])",
    "output": "Sorts a list of (name, age) tuples based on the 'age' (second element)."
  },
  {
    "id": 503,
    "input": "user_settings = {'theme': 'dark'}\nfont = user_settings.get('font', 'Arial')",
    "output": "Safely retrieves 'font' setting, defaulting to 'Arial' if not present."
  },
  {
    "id": 504,
    "input": "positive_numbers = [x for x in [-1, 0, 5, -2, 8] if x > 0]",
    "output": "Filters a list to include only positive numbers using list comprehension."
  },
  {
    "id": 505,
    "input": "url = 'www.example.com'\nif url.startswith('www.'):\n    domain = url[4:]",
    "output": "Removes the 'www.' prefix from a string if it exists."
  },
  {
    "id": 506,
    "input": "try:\n    with open('nonexistent.txt', 'r') as f: pass\nexcept FileNotFoundError:\n    print('File not found.')",
    "output": "Handles the 'FileNotFoundError' exception gracefully."
  },
  {
    "id": 507,
    "input": "with open('output.txt', 'w') as f:\n    f.write('Line 1\\nLine 2')",
    "output": "Opens 'output.txt' in write mode and writes two lines of text."
  },
  {
    "id": 508,
    "input": "def configure_app(host='localhost', port=8080):\n    return f'Running on {host}:{port}'",
    "output": "Returns configuration details using default keyword arguments."
  },
  {
    "id": 509,
    "input": "from collections import defaultdict\ncounts = defaultdict(int)\ncounts['a'] += 1",
    "output": "Initializes a 'defaultdict' where new keys default to integer 0."
  },
  {
    "id": 510,
    "input": "coords = (10, 20, 30)\nx, y, z = coords",
    "output": "Unpacks elements of a three-dimensional coordinate tuple."
  },
  {
    "id": 511,
    "input": "def recursive_multiply(a, b):\n    if b == 0: return 0\n    if b > 0: return a + recursive_multiply(a, b - 1)",
    "output": "Multiplies two numbers using recursive addition."
  },
  {
    "id": 512,
    "input": "def log_metrics(level='INFO', **data):\n    print(f'[{level}] Data: {data}')",
    "output": "Logs data dictionary with a default log level using keyword arguments (**kwargs)."
  },
  {
    "id": 513,
    "input": "data = [[1, 2], [3], [4, 5, 6]]\nflat = [i for sub in data for i in sub]",
    "output": "Flattens a list of lists into a single list using nested comprehension."
  },
  {
    "id": 514,
    "input": "class Shape:\n    def __init__(self, sides):\n        self.sides = sides",
    "output": "Defines a base class 'Shape' with a constructor for the number of sides."
  },
  {
    "id": 515,
    "input": "queue = ['task1', 'task2']\nqueue.append('task3')\ncurrent = queue.pop(0)",
    "output": "Adds 'task3' to the end and removes the first element (FIFO queue behavior)."
  },
  {
    "id": 516,
    "input": "import math\nsqrt_16 = math.sqrt(16)",
    "output": "Calculates the square root of 16 using the 'math' module."
  },
  {
    "id": 517,
    "input": "cities = ['Ankara', 'Izmir']\nfor idx, city in enumerate(cities, start=1):\n    print(f'{idx}. {city}')",
    "output": "Iterates over a list with a starting index of 1."
  },
  {
    "id": 518,
    "input": "chars = set('mississippi')\nunique_chars = len(chars)",
    "output": "Counts the number of unique characters in the string 'mississippi'."
  },
  {
    "id": 519,
    "input": "def require_positive(n):\n    assert n > 0, 'Value must be positive'",
    "output": "Enforces that the input 'n' is strictly greater than zero using 'assert'."
  },
  {
    "id": 520,
    "input": "password = input('Enter password: ')\nif len(password) < 8:\n    print('Weak password')",
    "output": "Prompts for input and checks if its length is less than 8."
  },
  {
    "id": 521,
    "input": "data_str = 'file_name.csv'\nfile_len = len(data_str)",
    "output": "Determines the total length of the string variable 'data_str'."
  },
  {
    "id": 522,
    "input": "numbers = [1, 2, 3]\nstr_numbers = ''.join(map(str, numbers))",
    "output": "Converts list of numbers to string and joins them."
  },
  {
    "id": 523,
    "input": "planets = ['Mars', 'Earth']\nplanets.insert(0, 'Mercury')",
    "output": "Inserts 'Mercury' at the start of the 'planets' list."
  },
  {
    "id": 524,
    "input": "def get_user_data(user_id, **details):\n    details['id'] = user_id\n    return details",
    "output": "Combines a required positional argument with flexible keyword arguments."
  },
  {
    "id": 525,
    "input": "items = [10, 20, 30, 40]\nfor item in items:\n    if item > 30:\n        break\n    print(item)",
    "output": "Prints items until one greater than 30 is found, then stops the loop."
  },
  {
    "id": 526,
    "input": "score = 75\nif score >= 90:\n    grade = 'A'\nelif score >= 70:\n    grade = 'B'\nelse:\n    grade = 'C'",
    "output": "Assigns a letter grade based on a numerical score using multi-way if-elif-else."
  },
  {
    "id": 527,
    "input": "parts = ['header', 'body', 'footer']\nhtml_content = '\\n'.join(parts)",
    "output": "Concatenates a list of strings using a newline character as a separator."
  },
  {
    "id": 528,
    "input": "def cube(x):\n    return x ** 3",
    "output": "Calculates the cube (third power) of a number."
  },
  {
    "id": 529,
    "input": "from datetime import date\ntoday = date.today()",
    "output": "Gets the current date object from the 'datetime' module."
  },
  {
    "id": 530,
    "input": "data_points = [9, 1, 5, 3]\ndata_points.sort()",
    "output": "Sorts the list of 'data_points' in ascending order in-place."
  },
  {
    "id": 531,
    "input": "settings = {'debug': True, 'mode': None}\nactive_settings = [k for k, v in settings.items() if v is not None]",
    "output": "Creates a list of keys for dictionary entries where the value is not None."
  },
  {
    "id": 532,
    "input": "config = {'env': 'prod'}\nif 'env' in config and config['env'] == 'prod':\n    print('Production mode')",
    "output": "Checks if a key exists in the dictionary and its value matches a specific string."
  },
  {
    "id": 533,
    "input": "def mock_function():\n    ...",
    "output": "A function body defined with ellipsis ('...') indicating future implementation."
  },
  {
    "id": 534,
    "input": "attempts = 0\nwhile attempts < 3:\n    print(f'Attempt {attempts + 1}')\n    attempts += 1",
    "output": "A while loop that executes and prints an attempt count exactly 3 times."
  },
  {
    "id": 535,
    "input": "def check_status(code):\n    return 'OK' if code == 200 else 'Error'",
    "output": "Returns 'OK' for status code 200, otherwise 'Error' (ternary operator)."
  },
  {
    "id": 536,
    "input": "users = [('user1', 45), ('user2', 12)]\nfor name, age in users:\n    print(f'{name} is {age}')",
    "output": "Iterates over a list of (name, age) pairs, unpacking them directly."
  },
  {
    "id": 537,
    "input": "import random\ncoin_flip = random.choice(['Heads', 'Tails'])",
    "output": "Randomly selects one element from a list, simulating a coin flip."
  },
  {
    "id": 538,
    "input": "address = '123 main street'\nformatted_address = address.title()",
    "output": "Converts a string to title case (capitalizes the first letter of each word)."
  },
  {
    "id": 539,
    "input": "colors = {'red', 'blue'}\ncolors.add('green')",
    "output": "Adds the string 'green' to the set 'colors'."
  },
  {
    "id": 540,
    "input": "def half(x):\n    return x / 2\nresult = half(50)",
    "output": "A simple function that divides its input by 2."
  },
  {
    "id": 541,
    "input": "def deprecated(func):\n    def wrapper(*args, **kwargs):\n        print(f'Warning: {func.__name__} is deprecated!')\n        return func(*args, **kwargs)\n    return wrapper",
    "output": "A decorator that prints a warning when a decorated function is called."
  },
  {
    "id": 542,
    "input": "class Vehicle:\n    def start(self):\n        raise NotImplementedError('Subclass must implement start method')",
    "output": "A base class method requiring subclasses to provide a concrete 'start' implementation."
  },
  {
    "id": 543,
    "input": "def connect(url, timeout=5, retries=3):\n    return f'Connecting to {url} with {timeout}s timeout and {retries} retries.'",
    "output": "Function with one required argument and two optional arguments with defaults."
  },
  {
    "id": 544,
    "input": "import os\ncurrent_dir = os.getcwd()",
    "output": "Gets the string path of the current working directory."
  },
  {
    "id": 545,
    "input": "user_profile = {'id': 101, 'status': 'active'}\nfor k in user_profile.keys():\n    print(f'Key: {k}')",
    "output": "Iterates over and prints only the keys of the 'user_profile' dictionary."
  },
  {
    "id": 546,
    "input": "raw_data = 'DATA\\t'\ndata = raw_data.strip()",
    "output": "Removes leading/trailing whitespace and tabs from the string."
  },
  {
    "id": 547,
    "input": "def read_log_lines(log_file):\n    with open(log_file) as f:\n        for line in f:\n            yield line.strip()",
    "output": "A generator that yields stripped lines one by one from a file."
  },
  {
    "id": 548,
    "input": "val = 10\nif val % 3 == 0:\n    print('Divisible by 3')\nelse:\n    print('Not divisible by 3')",
    "output": "Checks if the number is divisible by 3."
  },
  {
    "id": 549,
    "input": "data_in = [10, 20, 30]\nresult = list(map(str, data_in))",
    "output": "Uses 'map' to convert every integer in the list to a string."
  },
  {
    "id": 550,
    "input": "def update_setting(new_value):\n    global config_value\n    config_value = new_value",
    "output": "Modifies the value of a global variable 'config_value' within the function."
  },
  {
    "id": 551,
    "input": "import sys\nprint(sys.platform)",
    "output": "Prints the name of the operating system platform."
  },
  {
    "id": 552,
    "input": "color_code = ('#FF0000', 'Red')\nhex_code, color_name = color_code",
    "output": "Unpacks elements of a color tuple into specific variables."
  },
  {
    "id": 553,
    "input": "set_a = {1, 2, 3}\nset_b = {4, 5}\ncombined = set_a.union(set_b)",
    "output": "Calculates the union of two sets with no common elements."
  },
  {
    "id": 554,
    "input": "filename = 'document.pdf'\nif filename.endswith('.pdf'):\n    print('PDF document')",
    "output": "Checks if the string 'filename' ends with the file extension '.pdf'."
  },
  {
    "id": 555,
    "input": "def coords_2d(x, y):\n    return x, y",
    "output": "Returns two numerical inputs as an implicit tuple of coordinates."
  },
  {
    "id": 556,
    "input": "class Truck:\n    wheels = 6",
    "output": "A class 'Truck' with a class-level attribute 'wheels' set to 6."
  },
  {
    "id": 557,
    "input": "mixed_list = [True, False, True, None]\ntrue_count = mixed_list.count(True)",
    "output": "Counts how many times the boolean value 'True' appears in the list."
  },
  {
    "id": 558,
    "input": "for count in range(5):\n    if count == 2:\n        continue\n    print(count)",
    "output": "Prints numbers from 0 to 4, skipping the number 2."
  },
  {
    "id": 559,
    "input": "def check_flags(**flags):\n    if flags.get('verbose'):\n        print('Verbose logging enabled')",
    "output": "Safely checks for the presence of a 'verbose' flag in keyword arguments."
  },
  {
    "id": 560,
    "input": "with open('status.log', 'a') as f:\n    f.write('Task completed successfully\\n')",
    "output": "Appends a success message followed by a newline to 'status.log'."
  },
  {
    "id": 561,
    "input": "def get_safe_element(lst, index=0):\n    return lst[index] if len(lst) > index else None",
    "output": "Returns the element at a specific index, or None if the index is invalid."
  },
  {
    "id": 562,
    "input": "prices = [100, 200, 300]\ndiscounted = [p * 0.9 for p in prices]",
    "output": "Creates a new list with each price reduced by 10% (list comprehension)."
  },
  {
    "id": 563,
    "input": "try:\n    data = {'a': 1}['b']\nexcept KeyError:\n    data = 'Key not found'",
    "output": "Handles a 'KeyError' that occurs when accessing a missing dictionary key."
  },
  {
    "id": 564,
    "input": "import json\njson_data = '{\"user\": \"Jane\"}'\ndata = json.loads(json_data)",
    "output": "Parses a JSON formatted string into a Python dictionary."
  },
  {
    "id": 565,
    "input": "while True:\n    token = input('Enter token: ')\n    if len(token) == 16:\n        break",
    "output": "An infinite loop that requires a 16-character token to break."
  },
  {
    "id": 566,
    "input": "names_a = ['x', 'y']\nnames_b = ['z']\nall_names = names_a + names_b",
    "output": "Combines two small lists of names using the '+' operator."
  },
  {
    "id": 567,
    "input": "def filter_short_words(words, max_len):\n    return [w for w in words if len(w) <= max_len]",
    "output": "Filters a list of words, keeping only those shorter than or equal to 'max_len'."
  },
  {
    "id": 568,
    "input": "class BaseConfig:\n    def get_setting(self, key):\n        return self.settings.get(key)\nclass DevConfig(BaseConfig):\n    settings = {'db': 'sqlite'}",
    "output": "A subclass 'DevConfig' inheriting and using a method from 'BaseConfig'."
  },
  {
    "id": 569,
    "input": "code = 'A1B2C3'\nif code.isalnum():\n    print('Code is alphanumeric')",
    "output": "Checks if the string 'code' contains only letters and numbers."
  },
  {
    "id": 570,
    "input": "def calculate_n_squared(n):\n    return n ** 2",
    "output": "Calculates the square of the input number 'n'."
  },
  {
    "id": 571,
    "input": "numbers = [10, 20, 30]\npenultimate = numbers[-2]",
    "output": "Accesses and returns the second to last element of the list."
  },
  {
    "id": 572,
    "input": "config = {'max_users': 50}\nconfig.update({'max_users': 100})",
    "output": "Updates the existing 'max_users' key in the dictionary."
  },
  {
    "id": 573,
    "input": "import re\nreplaced = re.sub(r'\\s', '_', 'a b c')",
    "output": "Replaces all single whitespace characters with an underscore using regex."
  },
  {
    "id": 574,
    "input": "data = ['a', 'b']\ndata.clear()",
    "output": "Empties the list 'data' by removing all elements."
  },
  {
    "id": 575,
    "input": "def get_taxed_price(base_price, tax_rate=0.18):\n    return base_price * (1 + tax_rate)",
    "output": "Calculates the final price including a default tax rate."
  },
  {
    "id": 576,
    "input": "settings_tuple = ('strict', True)\nif 'strict' in settings_tuple:\n    print('Strict mode defined')",
    "output": "Checks for the presence of the string 'strict' within a tuple."
  },
  {
    "id": 577,
    "input": "def custom_len(container):\n    length = 0\n    for _ in container:\n        length += 1\n    return length",
    "output": "Computes the length of an iterable by manual iteration."
  },
  {
    "id": 578,
    "input": "array = [1, 2, 3, 4, 5]\nmiddle_segment = array[2:5]",
    "output": "Slices the array from index 2 up to the end (index 5 exclusive)."
  },
  {
    "id": 579,
    "input": "def validate_phone(number):\n    return len(number) > 5 and number.isdigit()",
    "output": "A basic check to validate if a string is a phone number (length > 5 and all digits)."
  },
  {
    "id": 580,
    "input": "class Utils:\n    @staticmethod\n    def get_version():\n        return 'v1.0'",
    "output": "A utility class with a static method to return a version string."
  },
  {
    "id": 581,
    "input": "miles = 100\nkilometers = miles * 1.60934",
    "output": "Converts a distance from miles to kilometers."
  },
  {
    "id": 582,
    "input": "def is_odd(n):\n    return n % 2 != 0",
    "output": "Checks if an integer 'n' is not divisible by 2 (odd)."
  },
  {
    "id": 583,
    "input": "log_entry = 'ERR: File not found'\nparts = log_entry.split(': ')",
    "output": "Splits a string based on the ': ' delimiter."
  },
  {
    "id": 584,
    "input": "def countdown(n):\n    while n > 0:\n        yield n\n        n -= 1",
    "output": "A generator that yields integers counting down from 'n' to 1."
  },
  {
    "id": 585,
    "input": "import time\nstart_time = time.monotonic()",
    "output": "Records a monotonically increasing time value (useful for duration measurement)."
  },
  {
    "id": 586,
    "input": "chars = ['a', 'b', 'c', 'b']\nfirst_b_index = chars.index('b')",
    "output": "Finds the index of the first occurrence of the character 'b' in the list."
  },
  {
    "id": 587,
    "input": "def handle_optional_id(id):\n    return f'ID: {id or \"N/A\"}'",
    "output": "Returns a formatted string using the ID, or 'N/A' if ID is falsy (e.g., 0 or None)."
  },
  {
    "id": 588,
    "input": "original = [1, 2]\ndup = original.copy()",
    "output": "Creates a new list 'dup' that is a shallow copy of 'original'."
  },
  {
    "id": 589,
    "input": "def count_consonants(s):\n    vowels = 'aeiou'\n    return sum(1 for char in s.lower() if char.isalpha() and char not in vowels)",
    "output": "Counts the total number of consonants in the input string 's' (case-insensitive)."
  },
  {
    "id": 590,
    "input": "class Rectangle:\n    def __init__(self, w, h):\n        self.w = w\n        self.h = h\n    def perimeter(self):\n        return 2 * (self.w + self.h)",
    "output": "A class 'Rectangle' with a method to calculate its perimeter."
  },
  {
    "id": 591,
    "input": "a, b = 10, 20\na, b = b, a",
    "output": "Swaps the values of variables 'a' and 'b' using simultaneous assignment."
  },
  {
    "id": 592,
    "input": "set_data = {1, 5}\nif 0 not in set_data:\n    print('0 is not a member')",
    "output": "Verifies that the element 0 is not contained within the set."
  },
  {
    "id": 593,
    "input": "d1 = {'x': 1}\nd2 = {'y': 2}\nmerged = {**d1, **d2}",
    "output": "Merges two non-overlapping dictionaries into a new one using unpacking."
  },
  {
    "id": 594,
    "input": "with open('report.log', 'w') as f:\n    f.write('Report generated')",
    "output": "Writes a short log message to a new file named 'report.log'."
  },
  {
    "id": 595,
    "input": "def print_greetings(greeting, person):\n    return f'{greeting}, {person}'",
    "output": "Returns a greeting string formatted with two positional arguments."
  },
  {
    "id": 596,
    "input": "import random\nchoices = ['A', 'B', 'C', 'D']\nselection = random.choice(choices)",
    "output": "Selects a random element from the list 'choices'."
  },
  {
    "id": 597,
    "input": "my_nums = [5, 6]\nfloat_val = 7.1\nmy_nums.append(float_val)",
    "output": "Adds a floating-point number to the end of the 'my_nums' list."
  },
  {
    "id": 598,
    "input": "phrase = 'tHIS IS A PHRASE'\nnormal_case = phrase.lower()",
    "output": "Converts the entire string to its lowercase equivalent."
  },
  {
    "id": 599,
    "input": "def outer():\n    counter = 0\n    def inner():\n        nonlocal counter\n        counter += 1\n        return counter\n    return inner()",
    "output": "Increments a variable in the outer function's scope using 'nonlocal'."
  },
  {
    "id": 600,
    "input": "while True:\n    try:\n        age = int(input('Enter age: '))\n        if 0 <= age <= 120: break\n        print('Invalid age range')",
    "output": "Repeats input until a valid integer age (between 0 and 120) is entered."
  },
  {
    "id": 601,
    "input": "from decimal import Decimal\na = Decimal('1.0')\nb = Decimal('3.0')\nresult = a / b",
    "output": "Performs precise division using Python's Decimal type."
  },
  {
    "id": 602,
    "input": "def validate_positive(x):\n    if x < 0:\n        raise ValueError('Negative numbers not allowed')\n    return x",
    "output": "Raises a 'ValueError' if the input 'x' is less than zero."
  },
  {
    "id": 603,
    "input": "pairs = [('name', 'John'), ('age', 30)]\ndata = dict(pairs)",
    "output": "Converts a list of key-value tuples into a dictionary."
  },
  {
    "id": 604,
    "input": "numbers = [2, 4, 6]\nsum_of_nums = 0\nfor num in numbers:\n    sum_of_nums += num",
    "output": "Calculates the total sum of all elements in the list iteratively."
  },
  {
    "id": 605,
    "input": "class Point:\n    @classmethod\n    def zero(cls):\n        return cls(0, 0)",
    "output": "A class method to create a new instance with default (0, 0) coordinates."
  },
  {
    "id": 606,
    "input": "def retry(attempts=3):\n    def decorator(func):\n        # ... retry logic ...\n        return func\n    return decorator",
    "output": "A decorator function factory that takes arguments (e.g., attempts) for retry logic."
  },
  {
    "id": 607,
    "input": "data = [1, 2, 3, 4, 5, 6]\nfirst_three = data[:3]",
    "output": "Gets the first three elements of the list using slicing."
  },
  {
    "id": 608,
    "input": "def square_root(x):\n    return x ** 0.5",
    "output": "Calculates the square root of 'x' using the exponentiation operator."
  },
  {
    "id": 609,
    "input": "def is_not_none(value):\n    return value is not None",
    "output": "Checks if a variable has a value and is not None."
  },
  {
    "id": 610,
    "input": "my_set = {1, 2, 3}\nmy_set.pop()",
    "output": "Removes and returns an arbitrary element from the set."
  },
  {
    "id": 611,
    "input": "import urllib.request\nwith urllib.request.urlopen('http://example.com') as response:\n    html = response.read()",
    "output": "Makes a basic HTTP request and reads the entire response body."
  },
  {
    "id": 612,
    "input": "products = [{'id': 1, 'price': 50}, {'id': 2, 'price': 100}]\nproducts.sort(key=lambda p: p['price'])",
    "output": "Sorts a list of dictionaries based on the value of the 'price' key using a lambda."
  },
  {
    "id": 613,
    "input": "email = 'user@domain.com'\nif email.endswith('.com'):\n    print('Commercial domain')",
    "output": "Checks if the string ends with the '.com' suffix."
  },
  {
    "id": 614,
    "input": "def check_instance(obj, type_class):\n    return isinstance(obj, type_class)",
    "output": "A utility function to check if an object belongs to a specified type/class."
  },
  {
    "id": 615,
    "input": "first, second, *remaining, last = [10, 20, 30, 40, 50]",
    "output": "Unpacks first, second, all middle elements to 'remaining', and the last element."
  },
  {
    "id": 616,
    "input": "try:\n    x = 1 / 0\nexcept (ZeroDivisionError, TypeError):\n    x = float('inf')",
    "output": "Handles multiple exceptions ('ZeroDivisionError' and 'TypeError') with one block."
  },
  {
    "id": 617,
    "input": "def infinite_zeroes():\n    while True:\n        yield 0",
    "output": "A simple generator that infinitely yields the value 0."
  },
  {
    "id": 618,
    "input": "tuple_data = (1, 2, 3)\nlist_data = list(tuple_data)",
    "output": "Converts an immutable tuple into a mutable list."
  },
  {
    "id": 619,
    "input": "def negate(n):\n    return -n",
    "output": "Returns the negative value of a number."
  },
  {
    "id": 620,
    "input": "def check_all_false(bools):\n    return not any(bools)",
    "output": "Checks if none of the elements in an iterable are truthy."
  },
  {
    "id": 621,
    "input": "csv_line = 'a;b;c'\nfields = csv_line.split(';')",
    "output": "Splits a string based on the semicolon (;) delimiter."
  },
  {
    "id": 622,
    "input": "user_data = {'id': 1}\nuser_name = user_data.pop('name', 'Default Name')",
    "output": "Removes 'name' key, returning its value or 'Default Name' if key is missing."
  },
  {
    "id": 623,
    "input": "for num in range(20):\n    if num % 5 == 0 and num != 0:\n        continue",
    "output": "Iterates from 0 to 19, skipping numbers divisible by 5 (excluding 0)."
  },
  {
    "id": 624,
    "input": "def print_range_inclusive(start, end):\n    for i in range(start, end + 1):\n        print(i)",
    "output": "Iterates and prints integers from a 'start' value up to an 'end' value."
  },
  {
    "id": 625,
    "input": "import datetime\ncurrent_time = datetime.datetime.now().time()",
    "output": "Gets only the time component (hour, minute, second) of the current date-time."
  },
  {
    "id": 626,
    "input": "data_list = [5]\ndata_list.insert(0, 4)\ndata_list.insert(2, 6)",
    "output": "Inserts 4 at the start and 6 at index 2 of the list."
  },
  {
    "id": 627,
    "input": "def initialize_config(keys, default_value=0):\n    return {key: default_value for key in keys}",
    "output": "Creates a dictionary from a list of keys, setting an optional default value for each."
  },
  {
    "id": 628,
    "input": "def print_variable(var):\n    print(f'Value: {var}')",
    "output": "Prints a formatted string containing the value of the input variable."
  },
  {
    "id": 629,
    "input": "def fib_iterative(n):\n    a, b = 0, 1\n    for _ in range(n):\n        a, b = b, a + b\n    return a",
    "output": "Calculates the nth Fibonacci number using an iterative approach."
  },
  {
    "id": 630,
    "input": "comment = 'This is a test comment'\nif 'test' in comment.lower():\n    print('Contains test')",
    "output": "Checks for the substring 'test' in the string, ignoring case."
  },
  {
    "id": 631,
    "input": "def min_of_three(a, b, c):\n    return min(a, b, c)",
    "output": "Returns the smallest of three given numbers."
  },
  {
    "id": 632,
    "input": "class User:\n    level = 1\n    def __init__(self, name):\n        self.name = name\n        User.level = max(User.level, 1) # Class variable usage",
    "output": "A class that updates a shared class variable based on instance creation (example usage)."
  },
  {
    "id": 633,
    "input": "data = ['a', 'b', 'c', 'd']\nfiltered = list(filter(lambda x: x != 'c', data))",
    "output": "Uses 'filter' to remove the element 'c' from the list."
  },
  {
    "id": 634,
    "input": "def pad_string(s):\n    return s.center(20, '-')",
    "output": "Pads a string on both sides with hyphens (-) to a total width of 20."
  },
  {
    "id": 635,
    "input": "def init_zeros(count):\n    return [0] * count",
    "output": "Creates a list of a specified length, initialized entirely with zeros."
  },
  {
    "id": 636,
    "input": "set_a = {1, 2, 3}\nset_b = {3, 4, 5}\nintersection = set_a.intersection(set_b)",
    "output": "Calculates the intersection (common elements) of two sets."
  },
  {
    "id": 637,
    "input": "def safe_get(d, key):\n    try:\n        return d[key]\n    except KeyError:\n        return None",
    "output": "Safely retrieves a dictionary value or returns None if the key is missing."
  },
  {
    "id": 638,
    "input": "import itertools\ncombos = list(itertools.combinations([1, 2, 3], 2))",
    "output": "Generates all unique combinations of 2 elements from the list."
  },
  {
    "id": 639,
    "input": "def print_kwargs(**kwargs):\n    for key, value in kwargs.items():\n        print(f'{key}={value}')",
    "output": "Iterates over and prints all key-value pairs from keyword arguments."
  },
  {
    "id": 640,
    "input": "user = {'id': 50}\nuser.pop('id')",
    "output": "Removes the 'id' key and its associated value from the dictionary."
  },
  {
    "id": 641,
    "input": "def check_is_alpha_or_space(s):\n    return s.replace(' ', '').isalpha()",
    "output": "Checks if a string contains only letters and spaces."
  },
  {
    "id": 642,
    "input": "data = [1, 2, 3, 4, 5]\nsubset = data[::2]",
    "output": "Slices the list to get every second element (starting from index 0)."
  },
  {
    "id": 643,
    "input": "def find_index_of_tuple(t, val):\n    return t.index(val)",
    "output": "Finds the index of a value within a tuple."
  },
  {
    "id": 644,
    "input": "text = 'example'\nif text.find('z') == -1:\n    print('z not found')",
    "output": "Checks if a substring ('z') is not present in the string."
  },
  {
    "id": 645,
    "input": "def check_instance_of_list(var):\n    return isinstance(var, list)",
    "output": "Checks if a variable is an instance of the 'list' type."
  },
  {
    "id": 646,
    "input": "def get_dict_default_set(key):\n    d = {}\n    return d.setdefault(key, [])",
    "output": "Gets the value for a key, setting the default to an empty list if missing."
  },
  {
    "id": 647,
    "input": "my_list = [1, 2, 3]\nmy_list.append([4, 5])",
    "output": "Appends another list as a single element to the end of the list."
  },
  {
    "id": 648,
    "input": "def check_not_instance_of_int(var):\n    return not isinstance(var, int)",
    "output": "Checks if a variable is not an instance of the 'int' type."
  },
  {
    "id": 649,
    "input": "def calculate_round_decimal(n, places=2):\n    return round(n, places)",
    "output": "Rounds a number to a specified number of decimal places (default 2)."
  },
  {
    "id": 650,
    "input": "class ImmutableList:\n    def __init__(self, data):\n        self._data = tuple(data)\n    def __len__(self):\n        return len(self._data)",
    "output": "A class that wraps a list to make it immutable by storing data as a tuple."
  },
  {
    "id": 651,
    "input": "def list_contains_all(lst, values):\n    return all(v in lst for v in values)",
    "output": "Checks if the list contains all of the values in the 'values' iterable."
  },
  {
    "id": 652,
    "input": "def convert_to_upper_title(s):\n    return s.title().upper()",
    "output": "Converts string to title case, then to all uppercase."
  },
  {
    "id": 653,
    "input": "def get_second_to_last_tuple(t):\n    return t[-2]",
    "output": "Returns the second to last element of a tuple."
  },
  {
    "id": 654,
    "input": "data = [1, 2, 3]\nfor i in range(len(data) - 1):\n    print(data[i], data[i+1])",
    "output": "Iterates over a list, printing pairs of consecutive elements."
  },
  {
    "id": 655,
    "input": "def is_type_list_instance(var):\n    return isinstance(var, list)",
    "output": "Checks if a variable is an instance of the 'list' type."
  },
  {
    "id": 656,
    "input": "def filter_dict_keys_by_value(d, condition_func):\n    return {k: v for k, v in d.items() if condition_func(v)}",
    "output": "Filters a dictionary based on a condition applied to its values."
  },
  {
    "id": 657,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.union(other)",
    "output": "Calculates the union of the two sets."
  },
  {
    "id": 658,
    "input": "def get_file_creation_time(filename):\n    import os\n    return os.path.getctime(filename)",
    "output": "Returns the system's ctime (creation time or last metadata change) of a file."
  },
  {
    "id": 659,
    "input": "def is_printable_only(s):\n    return s.isprintable()",
    "output": "Checks if all characters in the string are considered printable."
  },
  {
    "id": 660,
    "input": "def generate_geometric(a, r, n):\n    current = a\n    for _ in range(n):\n        yield current\n        current *= r",
    "output": "A generator that yields terms of a geometric sequence."
  },
  {
    "id": 661,
    "input": "def check_length_at_least(lst, n):\n    return len(lst) >= n",
    "output": "Checks if the length of a list is greater than or equal to 'n'."
  },
  {
    "id": 662,
    "input": "def format_with_positional(a, b):\n    return 'First: {}, Second: {}'.format(a, b)",
    "output": "Formats a string using the 'str.format()' method with implicit positional arguments."
  },
  {
    "id": 663,
    "input": "def print_var_type_and_id(var):\n    print(type(var), id(var))",
    "output": "Prints the type and the memory address of the variable."
  },
  {
    "id": 664,
    "input": "def is_type_set(var):\n    return type(var) is set",
    "output": "Checks if the exact type of a variable is 'set'."
  },
  {
    "id": 665,
    "input": "def get_dict_keys_list_desc(d):\n    return sorted(list(d.keys()), reverse=True)",
    "output": "Returns a list of dictionary keys sorted in descending order."
  },
  {
    "id": 666,
    "input": "def convert_to_list_from_set(s):\n    return list(s)",
    "output": "Converts a set back into a list (order is not guaranteed)."
  },
  {
    "id": 667,
    "input": "import random\nrandom.shuffle(my_list)\n# my_list is shuffled in place",
    "output": "Shuffles the elements of the list randomly (in-place)."
  },
  {
    "id": 668,
    "input": "def sort_by_last_char(words):\n    return sorted(words, key=lambda s: s[-1])",
    "output": "Sorts a list of strings based on their last character."
  },
  {
    "id": 669,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.update(other)",
    "output": "Adds all elements from 'other' set into 'my_set' (in-place union)."
  },
  {
    "id": 670,
    "input": "def list_contains_none(lst):\n    return None in lst",
    "output": "Checks if the list contains the value None."
  },
  {
    "id": 671,
    "input": "def get_first_element_pop(lst):\n    return lst.pop(0)",
    "output": "Removes and returns the first element of the list."
  },
  {
    "id": 672,
    "input": "def check_is_not_none_or_zero(val):\n    return val is not None and val != 0",
    "output": "Checks if a variable is not None and not equal to zero."
  },
  {
    "id": 673,
    "input": "text = 'hello'\ntext.endswith(('l', 'o'))",
    "output": "Checks if the string ends with either 'l' or 'o'."
  },
  {
    "id": 674,
    "input": "def unpack_three(t):\n    a, b, c = t\n    return a, b, c",
    "output": "Unpacks a three-element tuple into separate variables."
  },
  {
    "id": 675,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2: break",
    "output": "Iterates and stops when the value 2 is encountered."
  },
  {
    "id": 676,
    "input": "def get_last_n_slice(lst, n):\n    return lst[-n:]",
    "output": "Returns the last 'n' elements of the list using negative slicing."
  },
  {
    "id": 677,
    "input": "def filter_non_positive(lst):\n    return [x for x in lst if x > 0]",
    "output": "Filters a list, keeping only strictly positive numbers."
  },
  {
    "id": 678,
    "input": "def print_nonlocal_read():\n    x = 1\n    def inner():\n        nonlocal x\n        return x\n    return inner()",
    "output": "Reads a variable from the enclosing scope using 'nonlocal' (though 'nonlocal' is for writing)."
  },
  {
    "id": 679,
    "input": "def get_dict_items_set(d):\n    return set(d.items())",
    "output": "Returns a set of all unique key-value tuples from the dictionary."
  },
  {
    "id": 680,
    "input": "class Cacher:\n    def __init__(self, size):\n        self.cache = {}\n        self.size = size\n    def get(self, key):\n        return self.cache.get(key)",
    "output": "A basic class with a dictionary used for caching values."
  },
  {
    "id": 681,
    "input": "def calculate_sum_of_odd(lst):\n    return sum(x for x in lst if x % 2 != 0)",
    "output": "Calculates the sum of all odd numbers in a list."
  },
  {
    "id": 682,
    "input": "def convert_to_center(s, width=20, fill=' '):\n    return s.center(width, fill)",
    "output": "Centers a string within a specified width using a fill character."
  },
  {
    "id": 683,
    "input": "data = [1, 2, 3]\ndata.insert(0, 0)\ndata.insert(len(data), 4)",
    "output": "Inserts 0 at the start and 4 at the end of the list."
  },
  {
    "id": 684,
    "input": "def print_range_step(start, end, step):\n    for i in range(start, end, step):\n        print(i)",
    "output": "Iterates and prints integers within a range using a custom step value."
  },
  {
    "id": 685,
    "input": "def is_type_float(var):\n    return type(var) is float",
    "output": "Checks if the exact type of a variable is 'float'."
  },
  {
    "id": 686,
    "input": "def filter_dict_keys_list(d, keys):\n    return {k: d[k] for k in keys if k in d}",
    "output": "Creates a new dictionary, keeping only the key-value pairs whose keys are in the given list."
  },
  {
    "id": 687,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.intersection(other)",
    "output": "Calculates the intersection of the two sets."
  },
  {
    "id": 688,
    "input": "def get_file_modification_time(filename):\n    import os\n    return os.path.getmtime(filename)",
    "output": "Returns the last modification time of a file."
  },
  {
    "id": 689,
    "input": "def is_numeric_string(s):\n    return s.isnumeric()",
    "output": "Checks if the string contains only numeric characters (including unicode digits)."
  },
  {
    "id": 690,
    "input": "def generate_sequence_limit(start, limit):\n    i = start\n    while i < limit:\n        yield i\n        i += 1",
    "output": "A generator that yields numbers starting from 'start' up to 'limit-1'."
  },
  {
    "id": 691,
    "input": "def check_length_at_most(lst, n):\n    return len(lst) <= n",
    "output": "Checks if the length of a list is less than or equal to 'n'."
  },
  {
    "id": 692,
    "input": "def format_with_mix(a, b, c):\n    return '{a} then {1} then {0}'.format(c, b, a=a)",
    "output": "Formats a string using a mix of explicit keyword, positional, and implicit arguments."
  },
  {
    "id": 693,
    "input": "def print_var_attrs_safe(obj):\n    try:\n        print(vars(obj))\n    except TypeError: print('No __dict__')",
    "output": "Prints the attributes of an object, handling objects without a '__dict__'."
  },
  {
    "id": 694,
    "input": "def is_type_dict(var):\n    return type(var) is dict",
    "output": "Checks if the exact type of a variable is 'dict'."
  },
  {
    "id": 695,
    "input": "def get_dict_values_list_sorted(d):\n    return sorted(list(d.values()))",
    "output": "Returns a sorted list of all values in the dictionary."
  },
  {
    "id": 696,
    "input": "def convert_to_list_from_tuple(t):\n    return list(t)",
    "output": "Converts a tuple into a list."
  },
  {
    "id": 697,
    "input": "import random\nrandom.randint(10, 20)",
    "output": "Generates a random integer between 10 and 20 (inclusive)."
  },
  {
    "id": 698,
    "input": "def sort_by_desc_key(lst, key_func):\n    return sorted(lst, key=key_func, reverse=True)",
    "output": "Sorts a list in descending order using a custom key function."
  },
  {
    "id": 699,
    "input": "my_set = {1, 2}\nother = {3, 4}\nmy_set.isdisjoint(other)",
    "output": "Checks if the two sets have no common elements."
  },
  {
    "id": 700,
    "input": "def list_contains_type(lst, target_type):\n    return any(isinstance(x, target_type) for x in lst)",
    "output": "Checks if the list contains at least one element of the specified type."
  },
  {
    "id": 701,
    "input": "def get_first_element_default(lst, default=None):\n    return lst[0] if lst else default",
    "output": "Returns the first element of a list or a default value if the list is empty."
  },
  {
    "id": 702,
    "input": "def check_is_not_none_or_falsy(val):\n    return val is not None and bool(val)",
    "output": "Checks if a variable is explicitly not None and is truthy."
  },
  {
    "id": 703,
    "input": "text = 'hello'\nif text.startswith('h') and text.endswith('o'):\n    print('Start and End match')",
    "output": "Checks if the string starts with 'h' AND ends with 'o'."
  },
  {
    "id": 704,
    "input": "def unpack_tuple_star_middle(t):\n    a, *middle, b = t\n    return middle",
    "output": "Unpacks the first and last elements of a tuple, assigning the rest to a list."
  },
  {
    "id": 705,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2: continue\n    print(item)",
    "output": "Iterates over a list, skipping the element '2'."
  },
  {
    "id": 706,
    "input": "def get_list_slice_from_end(lst, start):\n    return lst[-start:]",
    "output": "Returns a slice starting from the 'start' element counting from the end."
  },
  {
    "id": 707,
    "input": "def filter_positive(lst):\n    return [x for x in lst if x > 0]",
    "output": "Filters a list, keeping only strictly positive numbers."
  },
  {
    "id": 708,
    "input": "def print_nested_nonlocal():\n    x = 1\n    def inner1():\n        x = 2\n        def inner2():\n            nonlocal x\n            x = 3\n        inner2()\n        return x\n    return inner1()",
    "output": "Modifies a variable in the 'inner1' scope from 'inner2' using 'nonlocal'."
  },
  {
    "id": 709,
    "input": "def get_dict_keys_view(d):\n    return d.keys()",
    "output": "Returns a dynamic view object of the dictionary's keys."
  },
  {
    "id": 710,
    "input": "class ReadWrite:\n    def __init__(self, value):\n        self.value = value\n    def __setattr__(self, name, value):\n        object.__setattr__(self, name, value)",
    "output": "Explicitly allows setting attributes by delegating to the base object method."
  },
  {
    "id": 711,
    "input": "def calculate_sum_of_squares_odd(lst):\n    return sum(x * x for x in lst if x % 2 != 0)",
    "output": "Calculates the sum of the squares of all odd numbers in the list."
  },
  {
    "id": 712,
    "input": "def convert_to_ljust(s, width=20, fill=' '):\n    return s.ljust(width, fill)",
    "output": "Left-justifies a string within a specified width using a fill character."
  },
  {
    "id": 713,
    "input": "data = [1, 2, 3]\ndata.insert(1, 99)\ndata.pop()",
    "output": "Inserts 99 at index 1, then removes the last element."
  },
  {
    "id": 714,
    "input": "def print_range_reverse(n):\n    for i in range(n, 0, -1):\n        print(i)",
    "output": "Iterates and prints integers counting down from 'n' to 1."
  },
  {
    "id": 715,
    "input": "def is_type_dict_instance(var):\n    return isinstance(var, dict)",
    "output": "Checks if a variable is an instance of the 'dict' type."
  },
  {
    "id": 716,
    "input": "def filter_dict_values_greater(d, threshold):\n    return {k: v for k, v in d.items() if v > threshold}",
    "output": "Filters a dictionary, keeping only pairs where the value is greater than a threshold."
  },
  {
    "id": 717,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.difference(other)",
    "output": "Calculates the difference (elements in 'my_set' but not 'other')."
  },
  {
    "id": 718,
    "input": "def get_file_access_time(filename):\n    import os\n    return os.path.getatime(filename)",
    "output": "Returns the last access time of a file."
  },
  {
    "id": 719,
    "input": "def is_ascii_only(s):\n    return s.isascii()",
    "output": "Checks if all characters in the string are ASCII characters."
  },
  {
    "id": 720,
    "input": "def generate_fibonacci_first(n):\n    a, b = 0, 1\n    for _ in range(n):\n        yield a\n        a, b = b, a + b",
    "output": "A generator that yields the first 'n' numbers of the Fibonacci sequence."
  },
  {
    "id": 721,
    "input": "def check_length_in_range(lst, min_len, max_len):\n    return min_len <= len(lst) <= max_len",
    "output": "Checks if the list length is within an inclusive range."
  },
  {
    "id": 722,
    "input": "def format_with_alignment(s, width=10):\n    return f'{s:>{width}}'",
    "output": "Formats a string to be right-aligned within a specified width using an f-string."
  },
  {
    "id": 723,
    "input": "def print_var_type_safe(var):\n    try:\n        print(type(var))\n    except: pass",
    "output": "Prints the type of a variable, handling potential errors gracefully."
  },
  {
    "id": 724,
    "input": "def is_type_set_instance(var):\n    return isinstance(var, set)",
    "output": "Checks if a variable is an instance of the 'set' type."
  },
  {
    "id": 725,
    "input": "def get_dict_values_view(d):\n    return d.values()",
    "output": "Returns a dynamic view object of the dictionary's values."
  },
  {
    "id": 726,
    "input": "def convert_to_list_from_iter(it):\n    return list(it)",
    "output": "Converts an arbitrary iterable into a list."
  },
  {
    "id": 727,
    "input": "import random\nrandom.randrange(1, 10, 2)",
    "output": "Generates a random odd integer between 1 and 9 (exclusive of 10)."
  },
  {
    "id": 728,
    "input": "def sort_by_custom_key_desc(lst, key_func):\n    return sorted(lst, key=key_func, reverse=True)",
    "output": "Returns a new list sorted in descending order based on a custom key function."
  },
  {
    "id": 729,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.issubset(other)",
    "output": "Checks if 'my_set' is a subset of 'other'."
  },
  {
    "id": 730,
    "input": "def list_contains_value_type(lst, value, type_class):\n    return any(x == value and isinstance(x, type_class) for x in lst)",
    "output": "Checks if the list contains a specific value that is also of a specific type."
  },
  {
    "id": 731,
    "input": "def get_list_slice_middle(lst):\n    mid = len(lst) // 2\n    return lst[mid-1:mid+1]",
    "output": "Returns a slice containing the middle two elements of an even-length list."
  },
  {
    "id": 732,
    "input": "def check_is_not_empty_list(lst):\n    return isinstance(lst, list) and len(lst) > 0",
    "output": "Checks if a variable is a list and is not empty."
  },
  {
    "id": 733,
    "input": "text = 'hello'\ntext.startswith('h') or text.startswith('H')",
    "output": "Checks if the string starts with 'h' OR 'H'."
  },
  {
    "id": 734,
    "input": "def unpack_dict_value(d, key):\n    return d[key]",
    "output": "Retrieves the value of a specific key from a dictionary."
  },
  {
    "id": 735,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item % 2 == 0:\n        continue",
    "output": "Iterates over a list, skipping even numbers."
  },
  {
    "id": 736,
    "input": "def filter_negative(lst):\n    return [x for x in lst if x < 0]",
    "output": "Filters a list, keeping only strictly negative numbers."
  },
  {
    "id": 737,
    "input": "def print_global_set_local():\n    global x\n    x = 10\n    y = 5\n    print(x)",
    "output": "Sets a global variable 'x' and prints it."
  },
  {
    "id": 738,
    "input": "def get_dict_keys_list_from_view(d):\n    return list(d.keys())",
    "output": "Converts the dictionary keys view to a list."
  },
  {
    "id": 739,
    "input": "class MyObject:\n    def __len__(self):\n        return 5",
    "output": "Defines the '__len__' method, allowing the object to be passed to the 'len()' function."
  },
  {
    "id": 740,
    "input": "def calculate_product_with_default(lst, initial=1):\n    return reduce(lambda x, y: x * y, lst, initial)",
    "output": "Calculates the product of a list with a specified initial value using 'reduce'."
  },
  {
    "id": 741,
    "input": "def check_is_superset_strict(s1, s2):\n    return s1 > s2",
    "output": "Checks if set 's1' is a proper superset of set 's2'."
  },
  {
    "id": 742,
    "input": "def convert_to_rjust(s, width=20, fill=' '):\n    return s.rjust(width, fill)",
    "output": "Right-justifies a string within a specified width using a fill character."
  },
  {
    "id": 743,
    "input": "data = [1, 2, 3]\ndata.insert(-1, 99)\ndata.insert(-1, 88)",
    "output": "Inserts 99 before the last element, then inserts 88 before the new last element."
  },
  {
    "id": 744,
    "input": "def print_range_inclusive_reverse(start, end):\n    for i in range(end, start - 1, -1):\n        print(i)",
    "output": "Iterates and prints integers counting down from 'end' to 'start' (inclusive)."
  },
  {
    "id": 745,
    "input": "def is_type_tuple_instance(var):\n    return isinstance(var, tuple)",
    "output": "Checks if a variable is an instance of the 'tuple' type."
  },
  {
    "id": 746,
    "input": "def filter_dict_keys_by_type(d, target_type):\n    return {k: v for k, v in d.items() if isinstance(k, target_type)}",
    "output": "Filters a dictionary, keeping only pairs where the key is of the specified type."
  },
  {
    "id": 747,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.issuperset(other)",
    "output": "Checks if 'my_set' is a superset of 'other'."
  },
  {
    "id": 748,
    "input": "def is_file(path):\n    import os\n    return os.path.isfile(path)",
    "output": "Checks if the path refers to an existing regular file."
  },
  {
    "id": 749,
    "input": "def is_title_or_upper(s):\n    return s.istitle() or s.isupper()",
    "output": "Checks if a string is either in title case or all uppercase."
  },
  {
    "id": 750,
    "input": "def generate_multiples(n, count):\n    return (n * i for i in range(1, count + 1))",
    "output": "A generator expression that yields the first 'count' multiples of 'n'."
  },
  {
    "id": 751,
    "input": "def check_length_at_least_one(lst):\n    return len(lst) >= 1",
    "output": "Checks if the list contains at least one element (is not empty)."
  },
  {
    "id": 752,
    "input": "def format_with_padding(n, width=5):\n    return f'{n:0{width}}'",
    "output": "Formats an integer with zero padding up to a specified width using an f-string."
  },
  {
    "id": 753,
    "input": "def print_var_class(var):\n    print(var.__class__)",
    "output": "Prints the class object of the variable."
  },
  {
    "id": 754,
    "input": "def is_type_list(var):\n    return type(var) is list",
    "output": "Checks if the exact type of a variable is 'list'."
  },
  {
    "id": 755,
    "input": "def get_dict_items_list_sorted_keys(d):\n    return sorted(d.items())",
    "output": "Returns a list of dictionary items sorted by their keys."
  },
  {
    "id": 756,
    "input": "def convert_to_tuple_from_list(lst):\n    return tuple(lst)",
    "output": "Converts a list into an immutable tuple."
  },
  {
    "id": 757,
    "input": "import random\nrandom.choice([1, 2, 3])",
    "output": "Selects a random element from the list."
  },
  {
    "id": 758,
    "input": "def sort_by_length_desc(words):\n    return sorted(words, key=len, reverse=True)",
    "output": "Sorts a list of strings by length in descending order."
  },
  {
    "id": 759,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.isdisjoint(other)",
    "output": "Checks if the two sets are disjoint (have no common elements)."
  },
  {
    "id": 760,
    "input": "def list_contains_at_least_one(lst):\n    return any(lst)",
    "output": "Checks if the list contains at least one truthy element."
  },
  {
    "id": 761,
    "input": "def get_list_slice_empty(lst):\n    return lst[1:1]",
    "output": "Returns an empty list by using a slice where start equals end."
  },
  {
    "id": 762,
    "input": "def check_is_not_empty_dict(d):\n    return isinstance(d, dict) and len(d) > 0",
    "output": "Checks if a variable is a dictionary and is not empty."
  },
  {
    "id": 763,
    "input": "text = 'hello'\ntext.startswith('H') and text.endswith('O')",
    "output": "Checks if the string starts with 'H' AND ends with 'O' (case-sensitive)."
  },
  {
    "id": 764,
    "input": "def unpack_tuple_first_last(t):\n    first, *_, last = t\n    return first, last",
    "output": "Unpacks only the first and last elements of a tuple, discarding the middle."
  },
  {
    "id": 765,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item % 2 == 1:\n        continue",
    "output": "Iterates over a list, skipping odd numbers (effectively only printing evens)."
  },
  {
    "id": 766,
    "input": "def filter_between(lst, min_val, max_val):\n    return [x for x in lst if min_val <= x <= max_val]",
    "output": "Filters a list, keeping only numbers within an inclusive range."
  },
  {
    "id": 767,
    "input": "def print_global_read_only():\n    global my_var\n    print(my_var)",
    "output": "Reads a global variable from within a function (no modification)."
  },
  {
    "id": 768,
    "input": "def get_dict_values_list_from_view(d):\n    return list(d.values())",
    "output": "Converts the dictionary values view to a list."
  },
  {
    "id": 769,
    "input": "class AttrAccess:\n    def __getattr__(self, name):\n        return f'Attribute {name} not found'",
    "output": "Defines '__getattr__' to handle attempts to access missing attributes."
  },
  {
    "id": 770,
    "input": "def calculate_sum_of_positive(lst):\n    return sum(x for x in lst if x > 0)",
    "output": "Calculates the sum of all strictly positive numbers in a list."
  },
  {
    "id": 771,
    "input": "def check_is_sub_or_equal(s1, s2):\n    return s1 <= s2",
    "output": "Checks if set 's1' is a subset of set 's2' (including equality)."
  },
  {
    "id": 772,
    "input": "def convert_to_center_fill(s, fill='-', width=20):\n    return s.center(width, fill)",
    "output": "Centers a string within a width, specifying a custom fill character."
  },
  {
    "id": 773,
    "input": "data = [1, 2, 3]\ndata.insert(1, 99)\ndata.pop(2)",
    "output": "Inserts 99 at index 1, then removes the element at the new index 2."
  },
  {
    "id": 774,
    "input": "def print_range_step_reverse(start, end, step):\n    for i in range(end - 1, start - 1, -step):\n        print(i)",
    "output": "Iterates and prints integers in reverse with a custom step."
  },
  {
    "id": 775,
    "input": "def is_type_string_instance(var):\n    return isinstance(var, str)",
    "output": "Checks if a variable is an instance of the 'str' type."
  },
  {
    "id": 776,
    "input": "def filter_dict_values_by_type(d, target_type):\n    return {k: v for k, v in d.items() if isinstance(v, target_type)}",
    "output": "Filters a dictionary, keeping only pairs where the value is of the specified type."
  },
  {
    "id": 777,
    "input": "my_set = {1, 2}\nother = {1}\nmy_set.issubset(other)",
    "output": "Checks if 'my_set' is a subset of 'other' (returns False)."
  },
  {
    "id": 778,
    "input": "def is_dir(path):\n    import os\n    return os.path.isdir(path)",
    "output": "Checks if the path refers to an existing directory."
  },
  {
    "id": 779,
    "input": "def is_upper_or_digit(s):\n    return s.replace(' ', '').isalnum() and s.isupper()",
    "output": "Checks if a string is composed of only uppercase letters and digits."
  },
  {
    "id": 780,
    "input": "def generate_numbers_with_condition(n):\n    return (i for i in range(n) if i % 2 == 0)",
    "output": "A generator expression that yields even numbers up to 'n-1'."
  },
  {
    "id": 781,
    "input": "def check_length_less_than_one(lst):\n    return len(lst) < 1",
    "output": "Checks if the list contains zero elements (is empty)."
  },
  {
    "id": 782,
    "input": "def format_with_scientific(n):\n    return f'{n:e}'",
    "output": "Formats a number using scientific notation in an f-string."
  },
  {
    "id": 783,
    "input": "def print_var_hash(var):\n    print(hash(var))",
    "output": "Prints the hash value of the variable (if the object is hashable)."
  },
  {
    "id": 784,
    "input": "def is_type_dict_instance(var):\n    return isinstance(var, dict)",
    "output": "Checks if a variable is an instance of the 'dict' type."
  },
  {
    "id": 785,
    "input": "def get_dict_items_list_sorted_values(d):\n    return sorted(d.items(), key=lambda item: item[1])",
    "output": "Returns a list of dictionary items sorted by their values."
  },
  {
    "id": 786,
    "input": "def convert_to_list_from_keys(d):\n    return list(d.keys())",
    "output": "Converts dictionary keys into a list."
  },
  {
    "id": 787,
    "input": "import random\nrandom.shuffle(my_list)\nprint(my_list)",
    "output": "Shuffles the list in-place and prints the result."
  },
  {
    "id": 788,
    "input": "def sort_by_length_and_alpha(words):\n    return sorted(words, key=lambda s: (len(s), s))",
    "output": "Sorts a list of strings primarily by length, then alphabetically for ties."
  },
  {
    "id": 789,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.difference_update(other)",
    "output": "Updates 'my_set' by removing common elements (in-place difference)."
  },
  {
    "id": 790,
    "input": "def list_contains_not_none(lst):\n    return any(x is not None for x in lst)",
    "output": "Checks if the list contains at least one element that is not None."
  },
  {
    "id": 791,
    "input": "def get_list_slice_reverse_middle(lst):\n    return lst[-2:1:-1]",
    "output": "Returns a reversed slice of the list excluding the first and last two elements."
  },
  {
    "id": 792,
    "input": "def check_is_not_empty_tuple(t):\n    return isinstance(t, tuple) and len(t) > 0",
    "output": "Checks if a variable is a tuple and is not empty."
  },
  {
    "id": 793,
    "input": "text = 'hello'\nif text.startswith('H') or text.endswith('O'):\n    print('Partial case match')",
    "output": "Checks for a starting 'H' or an ending 'O' (case-sensitive)."
  },
  {
    "id": 794,
    "input": "def unpack_dict_key_value(d):\n    for k, v in d.items():\n        return k, v",
    "output": "Unpacks and returns the key and value of the first item in the dictionary."
  },
  {
    "id": 795,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2: print('Found 2')\n    else: print('Not 2')",
    "output": "Iterates over a list, printing a message based on whether the element is 2 or not."
  },
  {
    "id": 796,
    "input": "def filter_non_zero(lst):\n    return [x for x in lst if x != 0]",
    "output": "Filters a list, keeping only non-zero values."
  },
  {
    "id": 797,
    "input": "def print_global_modify():\n    global my_var\n    my_var = 5\n    print(my_var)",
    "output": "Modifies a global variable 'my_var' from within a function."
  },
  {
    "id": 798,
    "input": "def get_dict_items_list_from_view(d):\n    return list(d.items())",
    "output": "Converts the dictionary items view to a list of tuples."
  },
  {
    "id": 799,
    "input": "class CustomError(Exception):\n    pass\ntry:\n    raise CustomError('Test')\nexcept CustomError as e:\n    print(e)",
    "output": "Defines a custom exception, raises it, and catches it."
  },
  {
    "id": 800,
    "input": "try:\n    result = 10 / 2\nexcept ZeroDivisionError:\n    result = 0\nelse:\n    print('Division successful')",
    "output": "Executes code in 'else' block only if no exception was raised in 'try'."
  },
  {
    "id": 801,
    "input": "def lazy_range(n):\n    i = 0\n    while i < n:\n        yield i\n        i += 1",
    "output": "A generator that mimics the behavior of the built-in 'range' function."
  },
  {
    "id": 802,
    "input": "import hashlib\npassword = 'secure'\nhash_obj = hashlib.sha256(password.encode())\nhex_digest = hash_obj.hexdigest()",
    "output": "Calculates the SHA256 hash of a password string."
  },
  {
    "id": 803,
    "input": "data = {'a': 1, 'b': 2}\nitems = list(data.items())",
    "output": "Converts dictionary key-value pairs into a list of tuples."
  },
  {
    "id": 804,
    "input": "def reverse_string(s):\n    return s[::-1]",
    "output": "Reverses a string using extended slice syntax."
  },
  {
    "id": 805,
    "input": "from functools import reduce\nnumbers = [1, 2, 3, 4]\nproduct = reduce(lambda x, y: x * y, numbers)",
    "output": "Uses 'reduce' to calculate the product of all numbers in the list."
  },
  {
    "id": 806,
    "input": "def power_decorator(p):\n    def decorator(func):\n        def wrapper(x):\n            return func(x) ** p\n        return wrapper\n    return decorator",
    "output": "A decorator factory that raises the function's result to the power of 'p'."
  },
  {
    "id": 807,
    "input": "text = 'hello world'\ntext.capitalize()",
    "output": "Capitalizes the first letter of the string and converts the rest to lowercase."
  },
  {
    "id": 808,
    "input": "matrix = [[1, 2], [3, 4]]\nfor row in matrix:\n    print(row[0])",
    "output": "Iterates over a 2D list and prints the first element of each inner list."
  },
  {
    "id": 809,
    "input": "def get_defaults_with_kwargs(a, b=1, **kwargs):\n    return a + b + len(kwargs)",
    "output": "Function accepting one required, one default, and variable keyword arguments."
  },
  {
    "id": 810,
    "input": "class MyContext:\n    def __enter__(self):\n        print('Entering context')\n        return self\n    def __exit__(self, exc_type, exc_val, exc_tb):\n        print('Exiting context')",
    "output": "Defines a basic context manager using '__enter__' and '__exit__' methods."
  },
  {
    "id": 811,
    "input": "def check_type_and_value(data):\n    if type(data) is int and data > 10:\n        print('Large integer')",
    "output": "Checks both the exact type of a variable and its value simultaneously."
  },
  {
    "id": 812,
    "input": "data = [1, 2, 3]\nfor i in reversed(data):\n    print(i)",
    "output": "Iterates over the elements of a list in reverse order."
  },
  {
    "id": 813,
    "input": "my_tuple = (10, 20)\nidx = my_tuple.index(20)",
    "output": "Finds the index of the value 20 in the tuple."
  },
  {
    "id": 814,
    "input": "def get_list_slice(lst, start, end):\n    return lst[start:end]",
    "output": "Returns a slice of the list from 'start' index up to 'end' index."
  },
  {
    "id": 815,
    "input": "list1 = [1, 2]\nlist2 = [1, 2]\nif list1 == list2:\n    print('Lists are equal in content')",
    "output": "Compares two lists for equality of content."
  },
  {
    "id": 816,
    "input": "def calculate_net_salary(gross, tax):\n    return gross - (gross * tax)",
    "output": "Calculates net salary by subtracting tax from gross salary."
  },
  {
    "id": 817,
    "input": "text = 'hello world'\nif 'world' in text:\n    print('Substring found')",
    "output": "Checks if one string is a substring of another."
  },
  {
    "id": 818,
    "input": "def apply_two_functions(x, f1, f2):\n    return f2(f1(x))",
    "output": "Applies two functions sequentially to an input value."
  },
  {
    "id": 819,
    "input": "data = [1, 2, 3]\nmy_iter = iter(data)\nnext(my_iter)",
    "output": "Gets an iterator from a list and retrieves the first element."
  },
  {
    "id": 820,
    "input": "def list_sum_with_reduce_default(lst):\n    from functools import reduce\n    return reduce(lambda x, y: x + y, lst, 0)",
    "output": "Calculates the sum of a list using 'reduce' with an initial value of 0."
  },
  {
    "id": 821,
    "input": "try:\n    raise ValueError('Test value error')\nexcept Exception as e:\n    print(f'Caught generic exception: {type(e).__name__}')",
    "output": "Raises a 'ValueError' but catches it with a generic 'Exception' handler."
  },
  {
    "id": 822,
    "input": "def check_is_alpha_or_numeric(s):\n    return s.isalnum()",
    "output": "Checks if the string consists only of letters or numbers."
  },
  {
    "id": 823,
    "input": "data = [1, 2, 3]\nimport copy\ndeep_copy = copy.deepcopy(data)",
    "output": "Creates a deep copy of the list."
  },
  {
    "id": 824,
    "input": "def get_dict_keys_list_sorted_desc(d):\n    return sorted(d.keys(), reverse=True)",
    "output": "Returns a list of dictionary keys sorted in descending order."
  },
  {
    "id": 825,
    "input": "class ValueHolder:\n    def __init__(self, value):\n        self.value = value\n    def __lt__(self, other):\n        return self.value < other.value",
    "output": "Defines the 'less than' comparison operator for a class using '__lt__'."
  },
  {
    "id": 826,
    "input": "def simple_generator():\n    yield 1\n    yield 2\nlist(simple_generator())",
    "output": "Converts the results of a simple generator function into a list."
  },
  {
    "id": 827,
    "input": "import random\nrandom_float = random.random()",
    "output": "Generates a random float number between 0.0 and 1.0 (exclusive of 1.0)."
  },
  {
    "id": 828,
    "input": "def check_is_sub_and_superset(s1, s2):\n    return s1 == s2",
    "output": "Checks if two sets are equal by checking if each is a subset/superset of the other."
  },
  {
    "id": 829,
    "input": "data = [1, 2, 3]\ndata.insert(0, 0)\ndata.insert(0, -1)",
    "output": "Inserts 0 at the start, then inserts -1 at the new start of the list."
  },
  {
    "id": 830,
    "input": "def filter_multiples(lst, n):\n    return [x for x in lst if x % n == 0]",
    "output": "Filters a list, keeping only numbers that are perfect multiples of 'n'."
  },
  {
    "id": 831,
    "input": "def check_length_odd(lst):\n    return len(lst) % 2 != 0",
    "output": "Checks if the length of a list is odd."
  },
  {
    "id": 832,
    "input": "def format_with_left_align(s, width=10):\n    return f'{s:<{width}}'",
    "output": "Formats a string to be left-aligned within a specified width."
  },
  {
    "id": 833,
    "input": "def print_var_class_name(var):\n    print(var.__class__.__name__)",
    "output": "Prints the string name of the variable's class."
  },
  {
    "id": 834,
    "input": "def is_type_float_only(var):\n    return type(var) is float",
    "output": "Checks if the exact type of a variable is 'float'."
  },
  {
    "id": 835,
    "input": "def get_dict_values_list_sorted_desc(d):\n    return sorted(d.values(), reverse=True)",
    "output": "Returns a list of dictionary values sorted in descending order."
  },
  {
    "id": 836,
    "input": "def convert_to_list_from_values(d):\n    return list(d.values())",
    "output": "Converts dictionary values into a list."
  },
  {
    "id": 837,
    "input": "import os\nif os.access('file.txt', os.R_OK):\n    print('File is readable')",
    "output": "Checks if a file is readable using 'os.access'."
  },
  {
    "id": 838,
    "input": "def sort_by_desc_length_alpha(words):\n    return sorted(words, key=lambda s: (-len(s), s))",
    "output": "Sorts strings primarily by length (descending), then alphabetically (ascending) for ties."
  },
  {
    "id": 839,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.intersection_update(other)",
    "output": "Updates 'my_set' to the intersection of the two sets (in-place)."
  },
  {
    "id": 840,
    "input": "def list_contains_all_none(lst):\n    return all(x is None for x in lst)",
    "output": "Checks if all elements in the list are None."
  },
  {
    "id": 841,
    "input": "def get_list_slice_from_end_to_start(lst):\n    return lst[-3::-1]",
    "output": "Returns a reversed slice starting from the third element from the end to the beginning."
  },
  {
    "id": 842,
    "input": "def check_is_not_empty_set(s):\n    return isinstance(s, set) and len(s) > 0",
    "output": "Checks if a variable is a set and is not empty."
  },
  {
    "id": 843,
    "input": "text = 'hello'\nif text.lower().startswith('h'):\n    print('Case-insensitive start')",
    "output": "Checks if the string starts with 'h', ignoring case."
  },
  {
    "id": 844,
    "input": "def unpack_dict_key(d):\n    for k in d.keys():\n        return k",
    "output": "Returns the key of the first item in the dictionary."
  },
  {
    "id": 845,
    "input": "data = [1, 2, 3]\nfor item in data:\n    print(f'Item: {item}', end=' ')",
    "output": "Iterates over a list, printing each item on the same line using 'end' argument."
  },
  {
    "id": 846,
    "input": "def filter_range(lst, min_val, max_val):\n    return [x for x in lst if x >= min_val and x <= max_val]",
    "output": "Filters a list, keeping only numbers within a closed interval [min_val, max_val]."
  },
  {
    "id": 847,
    "input": "def print_nonlocal_multi_level():\n    x = 1\n    def inner1():\n        def inner2():\n            nonlocal x\n            x = 10\n        inner2()\n        return x\n    return inner1()",
    "output": "Modifies a variable two scopes up using nested 'nonlocal'."
  },
  {
    "id": 848,
    "input": "def get_dict_keys_view_list(d):\n    return list(d.keys())",
    "output": "Converts the dictionary keys view to a list."
  },
  {
    "id": 849,
    "input": "class PropertySetter:\n    def __init__(self, value):\n        self._value = value\n    @property\n    def value(self):\n        return self._value\n    @value.setter\n    def value(self, new_value):\n        self._value = new_value",
    "output": "Defines a read-write property using the '@property' and '@setter' decorators."
  },
  {
    "id": 850,
    "input": "def calculate_sum_of_negative(lst):\n    return sum(x for x in lst if x < 0)",
    "output": "Calculates the sum of all strictly negative numbers in a list."
  },
  {
    "id": 851,
    "input": "def check_is_sup_or_equal(s1, s2):\n    return s1 >= s2",
    "output": "Checks if set 's1' is a superset of set 's2' (including equality)."
  },
  {
    "id": 852,
    "input": "def convert_to_ljust_fill(s, fill='.', width=20):\n    return s.ljust(width, fill)",
    "output": "Left-justifies a string, padding with a custom fill character."
  },
  {
    "id": 853,
    "input": "data = [1, 2, 3]\ndata.insert(0, 0)\ndata.pop(1)",
    "output": "Inserts 0 at index 0, then removes the element at the new index 1 (which was the original 1)."
  },
  {
    "id": 854,
    "input": "def print_range_start_stop(start, stop):\n    for i in range(start, stop):\n        print(i)",
    "output": "Iterates and prints integers from 'start' up to 'stop-1'."
  },
  {
    "id": 855,
    "input": "def is_type_int_instance(var):\n    return isinstance(var, int)",
    "output": "Checks if a variable is an instance of the 'int' type."
  },
  {
    "id": 856,
    "input": "def filter_dict_keys_less(d, threshold):\n    return {k: v for k, v in d.items() if k < threshold}",
    "output": "Filters a dictionary, keeping only pairs where the key is less than a threshold."
  },
  {
    "id": 857,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.symmetric_difference(other)",
    "output": "Calculates the symmetric difference of the two sets."
  },
  {
    "id": 858,
    "input": "def is_absolute_path(path):\n    import os\n    return os.path.isabs(path)",
    "output": "Checks if the path is an absolute path."
  },
  {
    "id": 859,
    "input": "def is_lower_or_digit(s):\n    return s.replace(' ', '').isalnum() and s.islower()",
    "output": "Checks if a string is composed of only lowercase letters and digits."
  },
  {
    "id": 860,
    "input": "def generate_sequence_filter(n):\n    return (i for i in range(n) if i % 3 == 0)",
    "output": "A generator expression that yields numbers divisible by 3 up to 'n-1'."
  },
  {
    "id": 861,
    "input": "def check_length_in_list(lst, lengths):\n    return len(lst) in lengths",
    "output": "Checks if the length of the list is one of the values in the 'lengths' iterable."
  },
  {
    "id": 862,
    "input": "def format_with_comma_thousands(n):\n    return f'{n:,}'",
    "output": "Formats a number with a thousands separator (comma) in an f-string."
  },
  {
    "id": 863,
    "input": "def print_var_class_safe(var):\n    try:\n        print(var.__class__)\n    except: pass",
    "output": "Prints the class of a variable, handling potential errors gracefully."
  },
  {
    "id": 864,
    "input": "def is_type_set_only(var):\n    return type(var) is set",
    "output": "Checks if the exact type of a variable is 'set'."
  },
  {
    "id": 865,
    "input": "def get_dict_items_list_sorted_desc_keys(d):\n    return sorted(d.items(), reverse=True)",
    "output": "Returns a list of dictionary items sorted in descending order by keys."
  },
  {
    "id": 866,
    "input": "def convert_to_tuple_from_items(d):\n    return tuple(d.items())",
    "output": "Converts dictionary items (key-value tuples) into a tuple."
  },
  {
    "id": 867,
    "input": "import random\nrandom.sample(range(1, 10), 3)",
    "output": "Selects 3 unique random integers between 1 and 9 (inclusive)."
  },
  {
    "id": 868,
    "input": "def sort_by_custom_key_alpha_desc(lst, key_func):\n    return sorted(lst, key=lambda x: (key_func(x), x), reverse=True)",
    "output": "Sorts a list by a custom key (descending), then by the original value (descending) for ties."
  },
  {
    "id": 869,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.symmetric_difference_update(other)",
    "output": "Updates 'my_set' to the symmetric difference of the two sets (in-place)."
  },
  {
    "id": 870,
    "input": "def list_contains_at_least_one_falsy(lst):\n    return any(not x for x in lst)",
    "output": "Checks if the list contains at least one falsy element."
  },
  {
    "id": 871,
    "input": "def get_list_slice_from_end_n(lst, n):\n    return lst[-n:]",
    "output": "Returns a slice containing the last 'n' elements of the list."
  },
  {
    "id": 872,
    "input": "def check_is_not_empty_container(container):\n    return len(container) > 0",
    "output": "Checks if any container (list, tuple, dict, etc.) is not empty."
  },
  {
    "id": 873,
    "input": "text = 'hello'\nif text.lower().endswith('o'):\n    print('Case-insensitive end')",
    "output": "Checks if the string ends with 'o', ignoring case."
  },
  {
    "id": 874,
    "input": "def unpack_tuple_first_n(t, n):\n    return t[:n]",
    "output": "Returns the first 'n' elements of a tuple."
  },
  {
    "id": 875,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2: break\nelse: print('Loop finished')",
    "output": "Iterates and breaks at 2, so the 'else' block is not executed."
  },
  {
    "id": 876,
    "input": "def filter_non_multiples(lst, n):\n    return [x for x in lst if x % n != 0]",
    "output": "Filters a list, keeping only numbers that are not perfect multiples of 'n'."
  },
  {
    "id": 877,
    "input": "def print_nonlocal_shadowing():\n    x = 1\n    def inner1():\n        x = 2\n        def inner2():\n            nonlocal x\n            x = 3\n        inner2()\n        return x\n    return x",
    "output": "Demonstrates 'nonlocal' only affecting the immediate outer scope ('inner1'), not the outermost ('outer')."
  },
  {
    "id": 878,
    "input": "def get_dict_values_view_list(d):\n    return list(d.values())",
    "output": "Converts the dictionary values view to a list."
  },
  {
    "id": 879,
    "input": "class AttrSet:\n    def __setattr__(self, name, value):\n        self.__dict__[name] = value.upper()",
    "output": "Overwrites '__setattr__' to force all string attribute values to uppercase."
  },
  {
    "id": 880,
    "input": "def calculate_sum_of_range(start, end):\n    return sum(range(start, end))",
    "output": "Calculates the sum of integers within a specified range (exclusive of 'end')."
  },
  {
    "id": 881,
    "input": "def check_is_sub_or_superset_strict(s1, s2):\n    return s1 > s2 or s1 < s2",
    "output": "Checks if one set is a proper subset or proper superset of the other."
  },
  {
    "id": 882,
    "input": "def convert_to_rjust_fill(s, fill='0', width=5):\n    return s.rjust(width, fill)",
    "output": "Right-justifies a string, padding with '0' up to a width of 5."
  },
  {
    "id": 883,
    "input": "data = [1, 2, 3]\ndata.insert(0, 0)\ndata.pop(0)",
    "output": "Inserts 0 at index 0, then immediately removes the element at index 0."
  },
  {
    "id": 884,
    "input": "def print_range_end_step(end, step):\n    for i in range(0, end, step):\n        print(i)",
    "output": "Iterates and prints integers starting from 0 up to 'end-1' with a custom step."
  },
  {
    "id": 885,
    "input": "def is_type_list_only(var):\n    return type(var) is list",
    "output": "Checks if the exact type of a variable is 'list'."
  },
  {
    "id": 886,
    "input": "def filter_dict_keys_by_list(d, keys):\n    return {k: d[k] for k in keys if k in d}",
    "output": "Creates a new dictionary containing only the keys specified in the input list."
  },
  {
    "id": 887,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.isdisjoint(other)",
    "output": "Checks if the two sets share no elements (returns False)."
  },
  {
    "id": 888,
    "input": "def is_symlink(path):\n    import os\n    return os.path.islink(path)",
    "output": "Checks if the path refers to a symbolic link."
  },
  {
    "id": 889,
    "input": "def is_alpha_or_space(s):\n    return s.replace(' ', '').isalpha()",
    "output": "Checks if a string contains only letters and spaces."
  },
  {
    "id": 890,
    "input": "def generate_sequence_sum(n):\n    total = 0\n    for i in range(n):\n        total += i\n        yield total",
    "output": "A generator that yields the cumulative sum of numbers up to 'n-1'."
  },
  {
    "id": 891,
    "input": "def check_length_at_most_zero(lst):\n    return len(lst) <= 0",
    "output": "Checks if the length of the list is zero (is empty)."
  },
  {
    "id": 892,
    "input": "def format_with_percentage(n):\n    return f'{n:.2%}'",
    "output": "Formats a float number as a percentage with two decimal places."
  },
  {
    "id": 893,
    "input": "def print_var_hash_safe(var):\n    try:\n        print(hash(var))\n    except TypeError: print('Unhashable')",
    "output": "Prints the hash of a variable, handling unhashable types gracefully."
  },
  {
    "id": 894,
    "input": "def is_type_tuple_only(var):\n    return type(var) is tuple",
    "output": "Checks if the exact type of a variable is 'tuple'."
  },
  {
    "id": 895,
    "input": "def get_dict_items_list_sorted_desc_values(d):\n    return sorted(d.items(), key=lambda item: item[1], reverse=True)",
    "output": "Returns a list of dictionary items sorted in descending order by values."
  },
  {
    "id": 896,
    "input": "def convert_to_tuple_from_values(d):\n    return tuple(d.values())",
    "output": "Converts dictionary values into a tuple."
  },
  {
    "id": 897,
    "input": "import random\nrandom.getstate()",
    "output": "Gets an object representing the current internal state of the random number generator."
  },
  {
    "id": 898,
    "input": "def sort_by_custom_key_desc_alpha_desc(lst, key_func):\n    return sorted(lst, key=lambda x: (key_func(x), x), reverse=True)",
    "output": "Sorts by a custom key (desc), then by original value (desc) for ties."
  },
  {
    "id": 899,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.update(other)",
    "output": "Updates 'my_set' with all elements from 'other' (in-place union)."
  },
  {
    "id": 900,
    "input": "def list_contains_all_falsy(lst):\n    return all(not x for x in lst)",
    "output": "Checks if all elements in the list are falsy (e.g., 0, '', None)."
  },
  {
    "id": 901,
    "input": "def get_list_slice_odd_indices(lst):\n    return lst[1::2]",
    "output": "Returns a slice containing elements at odd indices (1, 3, 5, ...)."
  },
  {
    "id": 902,
    "input": "def check_is_not_empty_container_falsy(container):\n    return bool(container)",
    "output": "Checks if any container is non-empty (is truthy)."
  },
  {
    "id": 903,
    "input": "text = 'hello'\nif text.lower().endswith('world'):\n    print('Case-insensitive wrong end')",
    "output": "Checks for a substring end match, ignoring case (returns False)."
  },
  {
    "id": 904,
    "input": "def unpack_tuple_last_n(t, n):\n    return t[-n:]",
    "output": "Returns the last 'n' elements of a tuple."
  },
  {
    "id": 905,
    "input": "data = [1, 2, 3]\nfor item in data:\n    if item == 2:\n        pass\n    print(item)",
    "output": "Iterates over a list, explicitly doing nothing with 'pass' when item is 2."
  },
  {
    "id": 906,
    "input": "def filter_non_positive_or_zero(lst):\n    return [x for x in lst if x >= 0]",
    "output": "Filters a list, keeping only non-negative numbers (0 and positives)."
  },
  {
    "id": 907,
    "input": "def print_nonlocal_multi_var():\n    x, y = 1, 1\n    def inner():\n        nonlocal x, y\n        x += 1\n        y += 1\n        return x, y\n    return inner()",
    "output": "Increments multiple variables in the enclosing scope using one 'nonlocal' statement."
  },
  {
    "id": 908,
    "input": "def get_dict_values_view_list(d):\n    return list(d.values())",
    "output": "Converts the dictionary values view to a list."
  },
  {
    "id": 909,
    "input": "class AttrDelete:\n    def __delattr__(self, name):\n        if name in self.__dict__:\n            del self.__dict__[name]",
    "output": "Defines '__delattr__' to allow deletion of attributes if they exist."
  },
  {
    "id": 910,
    "input": "def calculate_sum_of_range_inclusive(start, end):\n    return sum(range(start, end + 1))",
    "output": "Calculates the sum of integers within a specified inclusive range."
  },
  {
    "id": 911,
    "input": "def check_is_sub_and_superset(s1, s2):\n    return s1 <= s2 and s1 >= s2",
    "output": "Checks if two sets are identical (by checking both subset and superset)."
  },
  {
    "id": 912,
    "input": "def convert_to_center_fill_custom(s, width=10, fill='='):\n    return s.center(width, fill)",
    "output": "Centers a string within width 10, padding with '='."
  },
  {
    "id": 913,
    "input": "data = [1, 2, 3]\ndata.insert(1, 99)\ndata.remove(1)",
    "output": "Inserts 99 at index 1, then removes the first occurrence of the value 1."
  },
  {
    "id": 914,
    "input": "def print_range_step_reverse_start_end(start, end, step):\n    for i in range(end - 1, start - 1, -step):\n        print(i)",
    "output": "Iterates and prints integers in reverse, starting from 'end-1' with a custom step."
  },
  {
    "id": 915,
    "input": "def is_type_float_instance(var):\n    return isinstance(var, float)",
    "output": "Checks if a variable is an instance of the 'float' type."
  },
  {
    "id": 916,
    "input": "def filter_dict_keys_greater(d, threshold):\n    return {k: v for k, v in d.items() if k > threshold}",
    "output": "Filters a dictionary, keeping only pairs where the key is greater than a threshold."
  },
  {
    "id": 917,
    "input": "my_set = {1, 2}\nother = {2, 3}\nmy_set.issuperset(other)",
    "output": "Checks if 'my_set' is a superset of 'other' (returns False)."
  },
  {
    "id": 918,
    "input": "def get_file_stats(path):\n    import os\n    return os.stat(path)",
    "output": "Returns a stat result object containing file system information about the path."
  },
  {
    "id": 919,
    "input": "def is_identifier_valid(s):\n    return s.isidentifier()",
    "output": "Checks if the string is a valid Python identifier (e.g., variable name)."
  },
  {
    "id": 920,
    "input": "def generate_sequence_limit_step(start, limit, step):\n    for i in range(start, limit, step):\n        yield i",
    "output": "A generator that yields numbers within a range with custom start, limit, and step."
  },
  {
    "id": 921,
    "input": "def check_length_even(lst):\n    return len(lst) % 2 == 0",
    "output": "Checks if the length of a list is even."
  },
  {
    "id": 922,
    "input": "def format_with_center_align(s, width=20):\n    return f'{s:^{width}}'",
    "output": "Formats a string to be center-aligned within a specified width."
  }
]