【Python】括弧無しで関数を呼び出す

def greet(name):
    return f"Hello, {name}!"
# 関数を変数に代入
greeting = greet
# 変数を使って関数を呼び出す
print(greeting("Alice"))  # 出力: Hello, Alice!

def add(a, b):
    return a + b
# 関数オブジェクトの属性を取得
print(add.__name__)  # 出力: add

def apply_function(func, x, y):
    return func(x, y)
# 関数を引数として渡す
result = apply_function(add, 2, 3)
print(result)  # 出力: 5

def square(x):
    return x * x
numbers = [1, 2, 3, 4, 5]
# map関数を使ってリストの各要素に関数を適用
squared_numbers = list(map(square, numbers))
print(squared_numbers)  # 出力: [1, 4, 9, 16, 25]

def greet(name):
    return f"Hello, {name}!"
# 関数を変数に代入
greeting = greet

# 代入した関数を呼び出す
print(greeting("Alice"))  # 出力: Hello, Alice!

def add(x, y):
    return x + y
def subtract(x, y):
    return x - y
# 関数をリストに格納
operations = [add, subtract]
# リスト内の関数を呼び出す
for operation in operations:
    print(operation(10, 5))

def multiply(x, y):
    return x * y
def divide(x, y):
    if y != 0:
        return x / y
    else:
        return "Cannot divide by zero"
# 関数を辞書に格納
operations = {
    "add": add,
    "subtract": subtract,
    "multiply": multiply,
    "divide": divide
}
# 辞書内の関数を呼び出す
print(operations["multiply"](10, 5))  # 出力: 50
print(operations["divide"](10, 0))    # 出力: Cannot divide by zero

# 例: map関数を使った高階関数
def square(x):
    return x * x
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(square, numbers)
print(list(squared_numbers))  # 出力: [1, 4, 9, 16, 25]

# 例: コールバック関数を使った高階関数
def process_list(items, callback):
    for item in items:
        callback(item)
def print_item(item):
    print(f"Item: {item}")
items = [1, 2, 3, 4, 5]
process_list(items, print_item)
# 出力:
# Item: 1
# Item: 2
# Item: 3
# Item: 4
# Item: 5

# 例: 高階関数とコールバック関数の実例
def apply_operation(items, operation):
    results = []
    for item in items:
        results.append(operation(item))
    return results
def double(x):
    return x * 2
def square(x):
    return x * x
numbers = [1, 2, 3, 4, 5]
# 倍にする操作を適用
doubled_numbers = apply_operation(numbers, double)
print(doubled_numbers)  # 出力: [2, 4, 6, 8, 10]
# 二乗する操作を適用
squared_numbers = apply_operation(numbers, square)
print(squared_numbers)  # 出力: [1, 4, 9, 16, 25]

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper
@my_decorator
def say_hello():
    print("Hello!")
say_hello()

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before the function is called.")
        result = func(*args, **kwargs)
        print("After the function is called.")
        return result
    return wrapper
@my_decorator
def greet(name):
    print(f"Hello, {name}!")
greet("Alice")

Before the function is called.
Hello, Alice!
After the function is called.

import time
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time:.4f} seconds to execute.")
        return result
    return wrapper
@timer_decorator
def slow_function():
    time.sleep(2)
    print("Function complete.")
slow_function()

Function complete.
Function slow_function took 2.0001 seconds to execute.

lambda 引数: 式

add = lambda x, y: x + y

# ラムダ関数の定義
add = lambda x, y: x + y
# ラムダ関数の呼び出し
result = add(3, 5)
print(result)  # 出力: 8

# リストの各要素を2倍にする
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 出力: [2, 4, 6, 8, 10]
# リストの偶数のみをフィルタリングする
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 出力: [2, 4]

# 文字列のリスト
words = ["apple", "banana", "cherry", "date"]
# 文字数が5文字以上の単語をフィルタリングする
long_words = list(filter(lambda word: len(word) >= 5, words))
print(long_words)  # 出力: ['apple', 'banana', 'cherry']

class MyClass:
    def __init__(self, value):
        self.value = value
    def display_value(self):
        print(f"The value is: {self.value}")
# クラスのインスタンスを作成
obj = MyClass(10)
# メソッドを呼び出す
obj.display_value()

class MyClass:
    class_variable = 0
    def __init__(self, value):
        self.value = value
    def display_value(self):
        print(f"The value is: {self.value}")
    @classmethod
    def increment_class_variable(cls):
        cls.class_variable += 1
        print(f"Class variable is now: {cls.class_variable}")
# クラスのインスタンスを作成
obj1 = MyClass(10)
obj2 = MyClass(20)
# インスタンスメソッドを呼び出す
obj1.display_value()
obj2.display_value()
# クラスメソッドを呼び出す
MyClass.increment_class_variable()
MyClass.increment_class_variable()

class MyClass:
    def __init__(self, value):
        self.value = value
    def display_value(self):
        print(f"The value is: {self.value}")
# クラスのインスタンスを作成
obj = MyClass(10)
# メソッドを変数に代入
method = obj.display_value
# 変数を使ってメソッドを呼び出す
method()

def my_function():
    print("Hello, World!")
# 関数に属性を追加
my_function.description = "This is a simple greeting function."
# 関数の属性を表示
print(my_function.description)

def add(a, b):
    return a + b
# 関数に属性を追加
add.description = "This function adds two numbers."
add.version = "1.0"
add.author = "John Doe"
# 関数の属性を表示
print(f"Description: {add.description}")
print(f"Version: {add.version}")
print(f"Author: {add.author}")

def multiply(a, b):
    return a * b
# 関数に属性を追加
multiply.description = "This function multiplies two numbers."
multiply.version = "1.0"
multiply.author = "Jane Doe"
# 関数属性を使った関数の呼び出し
def call_function_with_info(func, *args):
    print(f"Calling function: {func.__name__}")
    print(f"Description: {func.description}")
    print(f"Version: {func.version}")
    print(f"Author: {func.author}")
    result = func(*args)
    print(f"Result: {result}")
# 関数を呼び出す
call_function_with_info(multiply, 3, 4)

Calling function: multiply
Description: This function multiplies two numbers.
Version: 1.0
Author: Jane Doe
Result: 12