Mastering List Comprehensions in Python

List comprehensions offer a concise and elegant way to create lists in Python. They allow you to generate new lists based on existing iterables, applying transformations and filters with significantly less code than traditional for loops. This challenge will test your understanding and ability to effectively utilize list comprehensions for various data manipulation tasks.

Problem Description

Your task is to implement several functions, each designed to produce a new list using list comprehensions, based on a given input list. You will need to apply different logic within your comprehensions, including element transformation, conditional filtering, and combinations of both.

Key requirements:

• Each function must use a list comprehension for its core logic.
• The output must be a new list, not a modification of the input list.
• The functions should handle various data types and potential edge cases gracefully.

Expected behavior:

• square_numbers(numbers): Takes a list of numbers and returns a new list containing the square of each number.
• filter_even_numbers(numbers): Takes a list of numbers and returns a new list containing only the even numbers from the input.
• capitalize_strings(strings): Takes a list of strings and returns a new list where each string is capitalized.
• filter_and_transform(items): Takes a list of mixed data types. Return a new list containing only the strings from the input list, and for each string, return its uppercase version if it has more than 5 characters, otherwise return the string in lowercase.

Edge cases to consider:

• Empty input lists.
• Lists containing non-numeric or non-string elements where applicable.

Examples

Example 1: square_numbers

Input: [1, 2, 3, 4, 5]
Output: [1, 4, 9, 16, 25]
Explanation: Each number in the input list is squared.

Example 2: filter_even_numbers

Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Output: [2, 4, 6, 8, 10]
Explanation: Only the even numbers from the input list are included in the output.

Example 3: capitalize_strings

Input: ["apple", "banana", "cherry"]
Output: ["APPLE", "BANANA", "CHERRY"]
Explanation: Each string in the input list is converted to uppercase.

Example 4: filter_and_transform

Input: ["hello", 123, "world", "python", "code", True, "challenge"]
Output: ["hello", "WORLD", "PYTHON", "code", "CHALLENGE"]
Explanation:
- "hello" has 5 characters, so it's lowercased (already lowercase).
- 123 is ignored as it's not a string.
- "world" has 5 characters, so it's lowercased (already lowercase).
- "python" has 6 characters, so it's uppercased to "PYTHON".
- "code" has 4 characters, so it's lowercased (already lowercase).
- True is ignored as it's not a string.
- "challenge" has 9 characters, so it's uppercased to "CHALLENGE".

Example 5: Empty Input

Input: []
Output: []
Explanation: An empty input list results in an empty output list for all functions.

Constraints

• The input lists will contain elements of various data types, but the specific functions are designed to handle them as described.
• The maximum length of any input list will be 1000 elements.
• The values within the lists (numbers, strings) will be within standard Python limits.

Notes

• Remember the general syntax for list comprehensions: [expression for item in iterable if condition].
• You can omit the if condition part if you only need to transform elements.
• For filter_and_transform, you will need to combine a type check, a length check, and conditional transformation within your comprehension.
• Consider how to handle potential TypeError exceptions if you were to apply string methods to non-string types, although the problem statement implies inputs will be handled appropriately by the intended logic of each function.