filter(function, iterable)

number=[1,2,3,4,5,6]
filtered=filter(lambda x: x%2==0,number)
print(list(filtered))
#輸出：[2, 4, 6]

data = [1, " ", None, False, True, 0, "hello"]
filtered = filter(None, data)
print(list(filtered))  # 輸出：[1, ' ', True, 'hello']

numbers = [1, 2, 3, 4, 5, 6]
filtered = filter(lambda x: x % 2 == 0, numbers)
print(list(filtered))  # 輸出：[2, 4, 6]

numbers = [1, 2, 3, 4, 5, 6]
filtered = [x for x in numbers if x % 2 == 0]
print(filtered)  # 輸出：[2, 4, 6]

numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4, 6]

words = ["hello", " ", "", "world", "python"]
non_empty = filter(lambda x: x.strip(), words)
print(list(non_empty))  # ['hello', 'world', 'python']

data = [1, None, "hello", 0, False, True]
valid = filter(lambda x: x is not None, data)
print(list(valid))  # [1, "hello", 0, False, True]

def is_prime(n):
    if n < 2:
        return False
    if n in (2, 3):
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            return False
    return True
numbers = range(1, 21)
primes = filter(is_prime, numbers)
print(list(primes))  # [2, 3, 5, 7, 11, 13, 17, 19]

# 不會(huì)立即執(zhí)行計(jì)算
filtered = filter(lambda x: x > 5, [3, 6, 7, 2, 9])
# 只有在轉(zhuǎn)換為列表或迭代時(shí)才會(huì)計(jì)算
print(list(filtered))  # [6, 7, 9]

from functools import reduce
numbers = range(1, 11)
# 過(guò)濾偶數(shù)后求和
result = reduce(lambda x, y: x + y, filter(lambda x: x % 2 == 0, numbers))
print(result)  # 30 (2+4+6+8+10)

def is_valid_user(user):
    return user.active and user.age >= 18 and not user.banned
valid_users = filter(is_valid_user, users)

import timeit
# 測(cè)試數(shù)據(jù)
large_data = range(1, 1000000)
# filter() 性能
filter_time = timeit.timeit(
    'list(filter(lambda x: x % 2 == 0, large_data))',
    setup='from __main__ import large_data',
    number=10
)
# 列表推導(dǎo)式性能
list_comp_time = timeit.timeit(
    '[x for x in large_data if x % 2 == 0]',
    setup='from __main__ import large_data',
    number=10
)
print(f"filter() 耗時(shí): {filter_time:.3f}秒")
print(f"列表推導(dǎo)式耗時(shí): {list_comp_time:.3f}秒")

# 使用邏輯運(yùn)算符組合多個(gè)條件
numbers = range(1, 21)
filtered = filter(lambda x: x % 2 == 0 and x % 3 == 0, numbers)
print(list(filtered))  # [6, 12, 18] (同時(shí)能被2和3整除的數(shù))
# 更復(fù)雜的條件組合
users = [{'name': 'Alice', 'age': 25, 'active': True},
         {'name': 'Bob', 'age': 17, 'active': True},
         {'name': 'Charlie', 'age': 30, 'active': False}]
active_adults = filter(lambda u: u['active'] and u['age'] >= 18, users)
print(list(active_adults))  # [{'name': 'Alice', 'age': 25, 'active': True}]

from functools import partial
def greater_than(threshold, x):
    return x > threshold
# 創(chuàng)建特定閾值的過(guò)濾器
filter_above_10 = partial(greater_than, 10)
numbers = [5, 12, 8, 15, 3, 20]
print(list(filter(filter_above_10, numbers)))  # [12, 15, 20]
# 可配置的過(guò)濾器工廠
def make_length_filter(min_len, max_len):
    return lambda s: min_len <= len(s) <= max_len
words = ["python", "is", "awesome", "for", "data", "analysis"]
length_filter = make_length_filter(3, 6)
print(list(filter(length_filter, words)))  # ['python', 'awesome', 'data']

# 清洗混合數(shù)據(jù)中的有效數(shù)字
mixed_data = [1, "2", 3.14, "hello", "5.6", None, "7", 8.9, ""]
def is_convertible_to_float(x):
    try:
        float(x)
        return True
    except (ValueError, TypeError):
        return False
cleaned = map(float, filter(is_convertible_to_float, mixed_data))
print(list(cleaned))  # [1.0, 2.0, 3.14, 5.6, 7.0, 8.9]

# 模擬API返回的JSON數(shù)據(jù)
api_response = {
    "users": [
        {"id": 1, "name": "Alice", "email": "alice@example.com", "active": True},
        {"id": 2, "name": "Bob", "email": None, "active": True},
        {"id": 3, "name": "Charlie", "email": "charlie@example.com", "active": False},
        {"id": 4, "name": "David", "email": "david@example.com", "active": True}
    ]
}
# 獲取所有活躍且郵箱有效的用戶
valid_users = filter(
    lambda u: u['active'] and u['email'] is not None,
    api_response['users']
)
print(list(valid_users))
# 輸出: [{'id': 1, 'name': 'Alice', ...}, {'id': 4, 'name': 'David', ...}]

# 讀取文件并處理內(nèi)容
with open('data.txt') as f:
    # 過(guò)濾空行和注釋行(以#開(kāi)頭)，并去除每行首尾空白
    lines = filter(
        lambda line: line.strip() and not line.lstrip().startswith('#'),
        f
    )
    processed_lines = map(str.strip, lines)
    for line in processed_lines:
        print(line)  # 處理后的有效內(nèi)容

# 對(duì)于簡(jiǎn)單操作，生成器表達(dá)式可能更高效
numbers = range(1, 1000000)
# filter + map
result1 = map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers))
# 生成器表達(dá)式
result2 = (x**2 for x in numbers if x % 2 == 0)
# 測(cè)試顯示生成器表達(dá)式通常稍快

import re
# 對(duì)于需要正則匹配的過(guò)濾，提前編譯模式
pattern = re.compile(r'^[A-Za-z]+$')  # 只包含字母的字符串
strings = ["hello", "123", "world", "python3", "data"]
# 不好的做法：每次迭代都重新編譯
filtered1 = filter(lambda s: re.match(r'^[A-Za-z]+$', s), strings)
# 好的做法：使用預(yù)編譯的模式
filtered2 = filter(pattern.fullmatch, strings)
print(list(filtered2))  # ['hello', 'world', 'data']

from itertools import filterfalse, compress
# filterfalse 獲取不滿足條件的元素
numbers = [1, 2, 3, 4, 5]
odds = filterfalse(lambda x: x % 2 == 0, numbers)
print(list(odds))  # [1, 3, 5]
# compress 基于布爾序列過(guò)濾
data = ['a', 'b', 'c', 'd']
selectors = [True, False, 1, 0]  # 1也視為T(mén)rue
selected = compress(data, selectors)
print(list(selected))  # ['a', 'c']

# 過(guò)濾嵌套列表/字典中的元素
nested_data = [
    {'id': 1, 'tags': ['python', 'web']},
    {'id': 2, 'tags': ['java', 'data']},
    {'id': 3, 'tags': ['python', 'data']},
    {'id': 4, 'tags': ['javascript']}
]
# 過(guò)濾包含'python'標(biāo)簽的項(xiàng)
python_items = filter(lambda item: 'python' in item['tags'], nested_data)
print(list(python_items))
# 輸出: [{'id': 1, 'tags': ['python', 'web']}, {'id': 3, 'tags': ['python', 'data']}]

# 使用 enumerate 保留原始位置信息
data = ['a', 'b', None, 'c', '', 'd']
# 過(guò)濾掉假值但保留索引
filtered_with_index = filter(
    lambda pair: pair[1] is not None and pair[1] != '',
    enumerate(data)
)
for index, value in filtered_with_index:
    print(f"Index {index}: {value}")
# 輸出:
# Index 0: a
# Index 1: b
# Index 3: c
# Index 5: d

class FilterableCollection:
    def __init__(self, items):
        self.items = items
    def filter(self, predicate=None):
        if predicate is None:
            return filter(bool, self.items)
        return filter(predicate, self.items)
    def __iter__(self):
        return iter(self.items)
# 使用示例
collection = FilterableCollection([1, 0, 'a', '', None, True])
print(list(collection.filter()))  # [1, 'a', True]
print(list(collection.filter(lambda x: isinstance(x, str))))  # ['a', '']

def debug_filter(predicate, iterable):
    for item in iterable:
        result = predicate(item)
        print(f"Testing {item}: {'Keep' if result else 'Discard'}")
        if result:
            yield item
numbers = [1, 2, 3, 4, 5]
filtered = debug_filter(lambda x: x % 2 == 0, numbers)
print(list(filtered))
# 輸出:
# Testing 1: Discard
# Testing 2: Keep
# Testing 3: Discard
# Testing 4: Keep
# Testing 5: Discard
# [2, 4]

import unittest
def is_positive(x):
    return x > 0
class TestFilterFunctions(unittest.TestCase):
    def test_positive_filter(self):
        test_cases = [
            ([1, -2, 3, -4], [1, 3]),
            ([], []),
            ([-1, -2, -3], [])
        ]
        for input_data, expected in test_cases:
            with self.subTest(input=input_data):
                result = list(filter(is_positive, input_data))
                self.assertEqual(result, expected)
if __name__ == '__main__':
    unittest.main()

// JavaScript 的 filter
const numbers = [1, 2, 3, 4, 5];
const evens = numbers.filter(x => x % 2 === 0);
console.log(evens); // [2, 4]

// Java 8+ 的 Stream filter
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evens = numbers.stream()
                            .filter(x -> x % 2 == 0)
                            .collect(Collectors.toList());
System.out.println(evens); // [2, 4]

-- SQL 的 WHERE 子句
SELECT * FROM numbers WHERE value % 2 = 0;

from functools import reduce, partial
# 函數(shù)組合工具
def compose(*funcs):
    return reduce(lambda f, g: lambda x: f(g(x)), funcs)
# 創(chuàng)建可組合的過(guò)濾器
is_even = lambda x: x % 2 == 0
is_positive = lambda x: x > 0
greater_than = lambda threshold: lambda x: x > threshold
# 組合多個(gè)過(guò)濾條件
complex_filter = compose(is_even, greater_than(10))
numbers = range(1, 21)
print(list(filter(complex_filter, numbers)))  # [12, 14, 16, 18, 20]

from operator import not_, attrgetter, methodcaller
# 使用 operator 模塊簡(jiǎn)化操作
data = [True, False, True, False]
print(list(filter(not_, data)))  # [False, False]
# 對(duì)象屬性過(guò)濾
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
users = [User("Alice", 25), User("Bob", 17), User("Charlie", 30)]
adults = filter(attrgetter('age') >= 18, users)  # 需要配合 functools.partial
print([u.name for u in adults])  # ['Alice', 'Charlie']
# 方法調(diào)用過(guò)濾
strings = ["hello", "world", "python", "code"]
print(list(filter(methodcaller('startswith', 'p'), strings)))  # ['python']

def dynamic_filter_factory(**conditions):
    """根據(jù)輸入條件動(dòng)態(tài)生成過(guò)濾器"""
    def predicate(item):
        return all(
            getattr(item, attr) == value if not callable(value) else value(getattr(item, attr))
            for attr, value in conditions.items()
        )
    return predicate
# 使用示例
class Product:
    def __init__(self, name, price, category):
        self.name = name
        self.price = price
        self.category = category
products = [
    Product("Laptop", 999, "Electronics"),
    Product("Shirt", 29, "Clothing"),
    Product("Phone", 699, "Electronics"),
    Product("Shoes", 89, "Clothing")
]
# 動(dòng)態(tài)創(chuàng)建過(guò)濾器
electronics_under_1000 = dynamic_filter_factory(
    category=lambda x: x == "Electronics",
    price=lambda x: x < 1000
)
print([p.name for p in filter(electronics_under_1000, products)])  # ['Laptop', 'Phone']

import operator
def create_filter_from_string(condition_str):
    """從字符串創(chuàng)建過(guò)濾函數(shù)"""
    ops = {
        '>': operator.gt,
        '<': operator.lt,
        '>=': operator.ge,
        '<=': operator.le,
        '==': operator.eq,
        '!=': operator.ne
    }
    # 簡(jiǎn)單解析邏輯，實(shí)際應(yīng)用可能需要更復(fù)雜的解析器
    field, op, value = condition_str.split()
    op_func = ops[op]
    value = int(value) if value.isdigit() else value
    return lambda x: op_func(getattr(x, field), value)
# 使用示例
price_filter = create_filter_from_string("price < 100")
print([p.name for p in filter(price_filter, products)])  # ['Shirt', 'Shoes']

from multiprocessing import Pool
def parallel_filter(predicate, iterable, chunksize=None):
    """并行過(guò)濾大數(shù)據(jù)集"""
    with Pool() as pool:
        # 使用map實(shí)現(xiàn)filter，因?yàn)镻ool沒(méi)有直接的filter方法
        results = pool.map(predicate, iterable, chunksize=chunksize)
        return (item for item, keep in zip(iterable, results) if keep)
# 示例：在大數(shù)據(jù)集中查找質(zhì)數(shù)
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
large_numbers = range(1_000_000, 1_001_000)
primes = parallel_filter(is_prime, large_numbers)
print(list(primes))  # 顯示1000000到1001000之間的質(zhì)數(shù)

import asyncio
async def async_filter(predicate, async_iterable):
    """異步過(guò)濾"""
    async for item in async_iterable:
        if await predicate(item):
            yield item
# 示例使用
async def is_positive(x):
    await asyncio.sleep(0.01)  # 模擬IO操作
    return x > 0
async def main():
    async def async_data():
        for x in [-2, -1, 0, 1, 2]:
            yield x
            await asyncio.sleep(0.01)
    positives = async_filter(is_positive, async_data())
    print([x async for x in positives])  # [1, 2]
asyncio.run(main())

import numpy as np
# 創(chuàng)建大型數(shù)值數(shù)組
data = np.random.randint(0, 100, size=1_000_000)
# 向量化過(guò)濾 - 比Python filter快100倍以上
evens = data[data % 2 == 0]
print(evens[:10])  # 顯示前10個(gè)偶數(shù)
# 多條件過(guò)濾
condition = (data > 50) & (data % 3 == 0)
filtered = data[condition]
print(filtered[:10])

# 文件: fast_filter.pyx
# cython: language_level=3
def cython_is_prime(int n):
    if n < 2:
        return False
    cdef int i
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
# 編譯后使用：
# from fast_filter import cython_is_prime
# list(filter(cython_is_prime, range(1, 1000)))

import matplotlib.pyplot as plt
def visualize_filter(predicate, iterable, title="Filter Process"):
    kept = []
    discarded = []
    for i, item in enumerate(iterable):
        if predicate(item):
            kept.append(i)
        else:
            discarded.append(i)
    plt.figure(figsize=(10, 2))
    plt.scatter(kept, [1]*len(kept), color='green', label='Kept')
    plt.scatter(discarded, [0]*len(discarded), color='red', label='Discarded')
    plt.title(title)
    plt.yticks([0, 1], ['Discarded', 'Kept'])
    plt.xlabel('Item Index')
    plt.legend()
    plt.show()
# 示例使用
numbers = range(1, 101)
visualize_filter(lambda x: x % 3 == 0, numbers, "Multiples of 3 Filter")

import time
from functools import wraps
def profile_filter(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} took {end-start:.6f} seconds")
        return result
    return wrapper
@profile_filter
def filtered_sum(numbers):
    return sum(filter(lambda x: x % 3 == 0, numbers))
filtered_sum(range(1, 1_000_000))

import html
def safe_input_filter(inputs):
    """過(guò)濾并清理用戶輸入"""
    # 1. 過(guò)濾掉None和空字符串
    filtered = filter(None, inputs)
    # 2. 去除兩端空格
    stripped = map(str.strip, filtered)
    # 3. HTML轉(zhuǎn)義防止XSS
    cleaned = map(html.escape, stripped)
    return list(cleaned)
user_inputs = ["  hello ", None, "<script>alert('xss')</script>", ""]
print(safe_input_filter(user_inputs))  # ['hello', '<script>alert(&#x27;xss&#x27;)</script>']

from itertools import islice
def fibonacci():
    """無(wú)限斐波那契數(shù)列生成器"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
# 安全過(guò)濾無(wú)限序列 - 必須配合islice使用
even_fib = filter(lambda x: x % 2 == 0, fibonacci())
first_10_even_fib = list(islice(even_fib, 10))
print(first_10_even_fib)  # [0, 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418]

import pandas as pd
from sklearn.ensemble import IsolationForest
# 使用機(jī)器學(xué)習(xí)模型進(jìn)行異常值過(guò)濾
data = pd.DataFrame({'values': [1.1, 1.2, 1.1, 1.4, 10.5, 1.2, 1.3, 9.8, 1.1]})
clf = IsolationForest(contamination=0.1)
clf.fit(data[['values']])
data['is_inlier'] = clf.predict(data[['values']]) == 1
# 過(guò)濾掉異常值
normal_data = filter(lambda x: x[1], zip(data['values'], data['is_inlier']))
print([x[0] for x in normal_data])  # 過(guò)濾掉10.5和9.8

import rx
from rx import operators as ops
# 使用RxPY進(jìn)行響應(yīng)式流過(guò)濾
source = rx.from_iterable(range(1, 11))
filtered = source.pipe(
    ops.filter(lambda x: x % 2 == 0),
    ops.map(lambda x: x * 10)
)
filtered.subscribe(
    on_next=lambda x: print(f"Got: {x}"),
    on_completed=lambda: print("Done")
)
# 輸出: Got: 20, Got: 40, ..., Got: 100, Done

# 概念演示：量子比特過(guò)濾模擬
class Qubit:
    def __init__(self, state):
        self.state = state  # (probability_0, probability_1)
    def measure(self):
        return 0 if random.random() < self.state[0] else 1
def quantum_filter(predicate, qubits):
    """模擬量子過(guò)濾 - 測(cè)量后應(yīng)用經(jīng)典過(guò)濾"""
    measured = (q.measure() for q in qubits)
    return filter(predicate, measured)
# 示例使用
import random
random.seed(42)
qubits = [Qubit((0.3, 0.7)) for _ in range(1000)]
filtered = quantum_filter(lambda x: x == 1, qubits)
print(sum(filtered)/1000)  # 接近0.7