私の個人的なブログのホームページ: If '' が本当にエスケープできる場合 1️⃣ Say 1️⃣ ブログのホームページ(1) Python の基本文法の学習について ----> 私のブログ「VScode で Python を学ぶ」
を参照してください(2) pip が必要ですPython の重要性を学ぶために---->> Python 言語を学習する過程での PiP

この記事は「VScodeでPythonを学ぶ」の内容を補足したものです。

記事ディレクトリ

Py関数
Python パラメータの使用方法は次のとおりです。
無名関数 (ラムダ関数):
- 無名関数と通常の定義の比較:
Pythonモジュール

Py関数

def user_info(name, age, gender="未知"):
    print(f"您的名字是: {
      
      name}，年龄是: {
      
      age}，性别是: {
      
      gender}")
print(type(user_info))

ここに画像の説明を挿入

関数は、特定のタスクを実行するか、特定の操作を完了する再利用可能なコードブロックです。関数は入力パラメータを受け取り、それらを処理し、出力結果を返すことができます。

関数はモジュラープログラミングにおける重要な概念であり、複雑なプログラムを小さな独立した部分に分割し、それぞれが独自の仕事を実行できるようにします。関数を使用すると、コードの読みやすさ、保守性、再利用性が向上します。

Python では、関数は、他の関数に渡したり、他の関数内でネストしたり、変数に割り当てたりできるオブジェクトのクラスです。Python の関数は、デフォルトパラメーター、変数パラメーター、キーワードパラメーターなどの高度な機能もサポートしており、さまざまなニーズにより柔軟に対応できます。

チャット：

Python では、関数は第一級市民です。これは、関数を他のデータ型 (整数、文字列、リストなど) と同様に、他の関数に引数として渡すことができることを意味します。関数をパラメータとして他の関数に渡すことは、コードをより柔軟でモジュール化し、抽象化と再利用をより適切にサポートできるようにする一般的な関数プログラミング手法です。

関数をパラメータとして渡す概念を説明する例を見てみましょう。apply_operation演算子関数と 2 つのオペランドの 2 つのパラメーターを取り、これら 2 つのオペランドを処理のために演算子関数に渡す関数があるとします。

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def apply_operation(operation, x, y):
    return operation(x, y)

result_add = apply_operation(add, 3, 5)
result_subtract = apply_operation(subtract, 8, 3)

print(result_add)      # Output: 8 (3 + 5)
print(result_subtract) # Output: 5 (8 - 3)

この例では、加算と減算をそれぞれ実行する 2 つの関数を定義しaddますsubtract。apply_operation次に、演算関数と 2 つのオペランドを受け取る関数を定義し、これらの 2 つのオペランドを渡して演算関数を呼び出し、演算の結果を返します。

apply_operation関数を呼び出すときは、関数addとsubtract関数をパラメーターとしてapply_operation関数に渡します。このように、apply_operation入力された操作機能に応じて異なる動作を行うことができ、戦略パターン（Strategy Pattern）の適用を実現します。

関数を引数として渡すことにより、apply_operation関数を変更することなく、さまざまな操作関数を通じてさまざまな動作を実現できます。この手法により、コードの柔軟性が高まり、コードの繰り返しが減り、コードの可読性と保守性が向上します。

問題を解決します [リスト内の条件を満たすすべてのメンバーの組み合わせと、それに対応する添え字の組み合わせを見つけます]:

リスト内の条件を満たすすべてのメンバーの組み合わせと、それに対応する添字の組み合わせを検索します。
入力: nums = [2, 2, 7, 6, 1, 7, 3, 6, 2, 3], target = 9 出力: all
Member組み合わせ: [(2,7)、(2,7)、(2,7)、(2,7)、(7,2)、(6,3)、(6,3)、(7,2 ) 、(3, 6)、(6, 3)]
メンバーの添え字の組み合わせ: [(0, 2)、(0, 5)、(1, 2)、(1, 5)、(2, 8)、(3) 、6)、(3、9)、(5、8)、(6、7)、(7、9)]
説明: 条件を満たす 2 つのメンバーを結合します。

ここに画像の説明を挿入

コード

def find_combinations(nums, target):

    member_combinations = []
    index_combinations = []
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                member_combinations.append((nums[i], nums[j]))
                index_combinations.append((i, j))
    return member_combinations, index_combinations
nums = [2, 2, 7, 6, 1, 7, 3, 6, 2, 3]
target = 9
member_combinations, index_combinations = find_combinations(nums, target)
print("所有成员组合:", member_combinations)
print("成员下标组合:", index_combinations)

Py関数の定義

Pythonの関数定義形式は以下のとおりです。

def function_name(parameters):
    """docstring"""
    # function body
    return [expression]

このうち、defキーワードは関数の定義に使用され、function_nameは関数名、parametersは括弧で囲まれた関数のパラメーターリスト (空でも可) です。

関数本体の先頭の文字列はドキュメント文字列で、関数と関数の使用法を説明するために使用されます (オプション)。関数本体には、関数のメインロジックが含まれます。returnステートメントは、関数の結果を返すために使用されます (null の場合もあります)。

Py関数の呼び出し方法

Python では、関数を呼び出すには、関数名と、パラメーターを渡すための 1 対のかっこが必要です。たとえば、次のような sum 関数があります。

def add(x, y):
    return x + y

この関数は次のようにして呼び出すことができます。

result = add(3, 5)
print(result)  # 输出8

関数を呼び出すときは、パラメーターを関数に渡す必要があります。上記の例では、add 関数にパラメータとして 3 と 5 を渡し、関数の戻り値を変数 result に代入して結果を出力します。

関数が None を返した場合、戻り値を何もせずに関数を直接呼び出すことができます。次に例を示します。

def print_hello():
    print("Hello")
    
print_hello()  # 输出Hello

関数を呼び出すときは、関数にパラメータを渡し、その後の処理のために関数の戻り値を目的の変数に格納することを忘れないでください。

ネストされた呼び出し

関数のネストされた呼び出しは、1 つの関数の実行中に別の関数が呼び出されることを意味します。具体的な実装は関数のコード内で行うことができ、呼び出される関数の後にかっこを直接追加し、関数に渡す必要があるパラメーターをかっこ内のパラメーターとして渡します。例えば：

def function_a(x):
    result = x * 2
    return result

def function_b(y):
    result = y + 1
    return result

def function_c(z):
    result_a = function_a(z)
    result_b = function_b(result_a)
    return result_b

print(function_c(3))  # 输出结果为 7

上記のコードでは、関数はfunction_cfunctionfunction_aと function を呼び出しfunction_b、一方の関数の戻り値をもう一方の関数のパラメーターとして渡し、最後にのfunction_b結果を返します。この方法により、プログラムの構造がより明確になり、ロジックがより単純になり、コードの再利用性も向上します。

Python 関数を使用する場合は、注意すべき点がいくつかあります。

関数名は、Python の組み込み関数またはキーワードと同じにすることはできません。名前が同じ場合、プログラムが正しく実行されません。
関数定義では、パラメーター名は説明的なものでなければならず、一貫した命名規則が存在する必要があります。たとえば、関数が文字列パラメータを取る場合、パラメータ名は「str」で終わる必要があります。
関数に渡されるパラメータは、位置パラメータ (定義の順序で渡される) またはキーワードパラメータ (パラメータ名を使用して渡される) にすることができますが、キーワードパラメータを使用した後は、後続のすべてのパラメータでキーワードパラメータを使用する必要があります。
関数定義では、パラメータにデフォルト値がある場合、それを最後のパラメータにする必要があります。そうしないとエラーが発生します。
Python の関数は複数の値を返すことができ、それらの値はタプルとして返されます。
関数の内部実行が完了すると、ローカル変数は自動的に破棄されます。関数間で変数を共有する必要がある場合は、変数をグローバル変数として定義できます。
関数はできるだけ簡潔にし、1 つのことを実行し、それが適切に実行されるようにする必要があります。
ユーザーがそのプロパティとその使用方法をよりよく理解できるように、関数を文書化する必要があります。関数アノテーションを使用すると、関数の入力パラメータと出力パラメータ、および関数の目的と動作を説明できます。
Python では、関数を入れ子にして定義できます。つまり、1 つの関数を別の関数の中に定義できます。ネストされた関数は、親関数の変数とパラメーターにアクセスできます。

Python 関数のパラメータを呼び出す方法はいくつかあります。

位置パラメータ: 関数が定義されている順序でパラメータを関数に渡すだけです。例えば：

def greet(name, message):
    print(message, name)

greet('Alice', 'Hello')  # 输出：Hello Alice

キーワード引数: パラメータ名を使用して、渡されるパラメータ値を指定します。例えば：

def greet(name, message):
    print(message, name)

greet(message='Hello', name='Alice')  # 输出：Hello Alice

デフォルトのパラメータ: 関数定義でデフォルトのパラメータ値を指定します。このパラメータが関数呼び出しで指定されていない場合は、デフォルト値が使用されます。例えば：

def greet(name, message='Hello'):
    print(message, name)

greet('Alice')        # 输出：Hello Alice
greet('Alice', 'Hi')  # 输出：Hi Alice

*args可変引数: 任意の数の位置引数を受け入れ、それらをタプルに配置できる関数定義で使用されます。例えば：

def greet(*names):
    for name in names:
        print('Hello', name)

greet('Alice', 'Bob', 'Charlie')  # 输出：Hello Alice，Hello Bob，Hello Charlie

キーワード可変長引数: 関数定義で使用すると、**kwargs任意の数のキーワード引数を受け入れて辞書に入れることができます。例えば：

def greet(**kwargs):
    for name, message in kwargs.items():
        print(message, name)

greet(Alice='Hello', Bob='Hi', Charlie='Hey')  # 输出：Hello Alice，Hi Bob，Hey Charlie

なお、パラメータの呼び出し方法は関数定義内の順序や名前と一致し、パラメータの数も関数定義内のパラメータと一致する必要があります。

知らせ：

関数定義時のパラメータは、関数の定義内にのみ存在するため仮パラメータと呼ばれ、関数呼び出し時に渡す必要のあるパラメータの種類と数量を示すために使用されます。仮パラメータは通常、関数定義の中で関数シグネチャの一部として指定されます。

関数の呼び出し時に関数に渡されるパラメータは、実パラメータと呼ばれます。実パラメータの数と型は、関数定義の仮パラメータと一致する必要があります。一致しない場合、コンパイルエラーが発生します。

Python では、関数の引数の数に制限はなく、カンマで区切られます。関数を呼び出す場合、渡される実パラメータは仮パラメータに 1 つずつ対応し、それらをカンマで区切る必要があります。関数に複数のパラメーターがある場合、パラメーターは関数定義内のパラメーターの順序で渡される必要があります。たとえば、関数がとして定義されている場合def my_function(a, b, c):、関数呼び出しはとなる必要がありますmy_function(value_for_a, value_for_b, value_for_c)。ここでvalue_for_a、value_for_bとはvalue_for_c関数に渡される実際の引数です。

戻り値 [関数の実行後に呼び出し元に返される結果]

return が発生すると関数本体が終了するため、return 後に記述されたコードは実行されません。

Python 関数の戻り値は、関数の実行後に返される結果を指します。関数本体では、キーワード return を使用して関数の戻り値を指定できます。関数が呼び出されると、関数はその中のコードを実行し、return 文に続く式で計算された値を戻り値として呼び出し元に返します。関数で return ステートメントが明示的に指定されていない場合、または return ステートメントで戻り値が指定されていない場合は、デフォルトで None が返されます。戻り値のある関数の場合、呼び出し元は戻り値を受け取り、後続の操作でその戻り値を使用できます。

None の値: [タイプが <class NoneType'> である特別なリテラル。戻り値のない関数は、実際にはリテラル値 None を返します。

定义变量，但暂时不需要变量有具体值，可以用None来代替

NonePython では、null または欠損値を表す特別なオブジェクトです。これは、関数が明示的に値を返さない場合のデフォルトの戻り値としてよく使用されます。

None次の用途と価値があります。

関数に戻り値がないことを示します。関数でreturnステートメントが指定されていない場合、またはreturnステートメントで戻り値が指定されていない場合、デフォルトで戻り値が返されますNone。これにより、関数の実行が終了し、結果が返されなかったことが呼び出し元に通知されます。
変数の初期化: 変数をに初期化してNone、変数に現在特定の値がないことを示すことができます。必要に応じて、後で変数に他の値を割り当てることができます。
判定条件：None変数にNone有効な値があるかどうかなどの条件判定に使用できます。
パラメータのデフォルト値: パラメータのデフォルト値は関数の定義時に指定でき、一般的なデフォルト値はですNone。このように、関数の呼び出し時に対応するパラメータが指定されていない場合は、デフォルト値が使用されますNone。
プレースホルダー: 開発では、最初に変数またはプレースホルダーを宣言する必要がある場合がありますが、特定の値や計算結果はまだありません。このとき、Noneto を使用してエラーや例外を回避できます。

つまり、NonePython で欠損値、null 値、または未定義の状態を表すために使用される特別なオブジェクトであり、一定の実用的価値があります。

コード：

当一个函数没有明确的返回值时，它会默认返回`None`。以下是一个简单的例子：

```python
def greet(name):
    print("Hello, " + name)

result = greet("Alice")
print(result)

出力：

Hello, Alice
None

上の例では、greet関数は 1 つのパラメーターを受け取りname、挨拶を出力します。ただし、この関数は戻り値を指定していないため、デフォルトで戻り値を返しますNone。呼び出し後greet("Alice")、それが出力されHello, Alice、戻り値が変数に代入されますresult。最後に、を印刷することでresultその値を確認できますNone。これは、関数が実行後に特定の結果を返さないことを示します。

はNonePython の定数であり、null 値を表し、通常は存在しないまたは無効な状況を表すために使用されます。

複数の戻り値:

Python はどのようにして複数の戻り値を受け入れるのですか?
Python で複数の戻り値を受け入れるには、タプルを使用できます。関数が複数の値を返す場合、これらの値はタプルにパッケージ化され、解凍することで複数の変数に割り当てることができます。

def get_values():
    return 1, 2, 3

a, b, c = get_values()

print(a)  # 输出: 1
print(b)  # 输出: 2
print(c)  # 输出: 3

アンパックすると、変数 a、b、c にそれぞれ値が代入されます。最後に、これら 3 つの変数の値を個別に出力しました。

Python パラメータの使用方法は次のとおりです。

Python では、パラメーターは次の方法で使用されます。

1. 位置引数: これはパラメータを渡す最も一般的な方法です。関数を呼び出すと、パラメータは定義された順序で関数に渡されます。例えば：

一対一の対応

def greet(name, greeting):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John", "Hello")  # Output: Hello, John!

2. キーワードパラメータ [キーワード引数] (キーワード引数): 関数呼び出し時に、パラメータ名と値を指定してパラメータが渡されます。== このようにすると、パラメータを順番に渡すことができなくなり、コードの可読性が向上します。== たとえば:

def greet(name, greeting):
    print(f"{
      
      greeting}, {
      
      name}!")

greet(greeting="Hello", name="John")  # Output: Hello, John!

キーワードを使用してパラメータを渡すと、固定順序なしでパラメータを渡すことができるため、関数呼び出しがより柔軟で明確になります。コード例は次のとおりです。

より柔軟な関数呼び出しを実装するには、デフォルト引数とキーワード引数を使用します。これにより、関数呼び出しがより明確かつ使いやすくなり、パラメーターの順序付けの要件がなくなりました。

def user_info(name, age, gender="未知"):
    print(f"您的名字是: {
      
      name}，年龄是: {
      
      age}，性别是: {
      
      gender}")

# 使用关键字传参，不需要按照固定顺序
user_info(name="小明", age=20, gender="男")

# 也可以不指定性别参数，将使用缺省参数的默认值
user_info(name="小红", age=25)

# 可以和位置参数混用，但位置参数必须在前，且匹配参数顺序
user_info("小刚", age=18, gender="男")

ここに画像の説明を挿入

この例では、user_info 関数の性別パラメータにデフォルト値「unknown」を設定します。このように、関数が呼び出されたときに、性別パラメータが指定されていない場合は、デフォルト値が使用されます。同時に、キーワードを使用してパラメーターを渡すと、固定順序なしでパラメーターを渡すことができるため、関数呼び出しがより柔軟かつ明確になります。

キーワードを使用してパラメータを渡す場合、位置パラメータを前に配置し、関数で定義されたパラメータの順序に従って一致させる必要があることに注意してください。これにより、キーワードパラメータの受け渡しの柔軟性を活用できるだけでなく、位置パラメータの使用と互換性を持たせることもできます。

3. デフォルトパラメータ (デフォルト引数): 関数を定義するときに、特定のパラメータのデフォルト値を指定できます。関数呼び出し時にこれらのパラメーターの値が指定されていない場合は、デフォルト値が使用されます。例えば：

def greet(name, greeting="Hello"):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John")  # Output: Hello, John!
greet("Jane", "Hi")  # Output: Hi, Jane!

4. 可変長パラメータ: Python には 2 種類の可変長パラメータがあります。

*args: 任意の数の位置パラメータを受け取るために使用され、パラメータをタプルにパックします。
**kwargs: 任意の数のキーワード引数を受け取るために使用され、引数を辞書 (dict) にパックします。

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4))  # Output: 10

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{
      
      key}: {
      
      value}")

print_info(name="John", age=30, city="New York")
# Output:
# name: John
# age: 30
# city: New York

5 つのデフォルトの引数:

デフォルトパラメーターを使用すると、関数の定義時に一部のパラメーターのデフォルト値を指定できるため、関数が呼び出されたときに、対応するパラメーターの値が指定されていない場合は、デフォルト値が使用されます。これにより、関数の呼び出しが簡素化され、関数の柔軟性が向上します。関数を定義するときは、デフォルト値にしたいパラメータをパラメータリストの最後に配置します。

def greet(name, greeting="Hello"):
    print(f"{
      
      greeting}, {
      
      name}!")

greet("John")          # Output: Hello, John! (默认使用"greeting"参数的默认值)
greet("Jane", "Hi")    # Output: Hi, Jane! (使用指定的"greeting"参数值)

6 不定長パラメータ (可変長パラメータ):

不定引数を使用すると、任意の数の引数を受け取ることができる関数を定義できます。Python には、2 種類の可変長パラメーターがあります。

*args: 任意の数の位置引数を受け取るために使用され、これらの引数をタプルにパックします。
**kwargs: 任意の数のキーワード引数を受け取るために使用され、これらの引数を辞書 (dict) にパックします。

可変長パラメーターを使用すると、未知の数のパラメーターの受け渡しを処理できるため、関数がより柔軟になります。関数を定義するときは、「*args」と「**kwargs」を使用して可変長パラメータを宣言します。

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_numbers(1, 2, 3, 4))  # Output: 10

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{
      
      key}: {
      
      value}")

print_info(name="John", age=30, city="New York")
# Output:
# name: John
# age: 30
# city: New York

関数を使用する場合、デフォルトのパラメーターと可変長パラメーターを組み合わせて、関数呼び出しをより簡潔にし、さまざまなパラメーター受け渡しの状況に対処できます。

可変長パラメーターに関しては、Python では、可変位置パラメーター (*args) と可変キーワードパラメーター (**kwargs) の 2 つの方法が提供されます。

不定の位置引数 (*args):
不定の位置引数を使用すると、関数は任意の数の位置引数を受け入れ、それらをタプルにパックできます。関数定義で、*args不定の位置パラメータを宣言するために使用します。このようにして、関数が呼び出されるときに、任意の数の位置パラメーターを関数に渡すことができ、それらは自動的にタプルにパックされます。
```
def print_arguments(*args):
    for arg in args:
        print(arg)

print_arguments("apple", "banana", "orange")
# Output:
# apple
# banana
# orange
```
この例では、print_arguments関数は可変数の位置引数を受け取り、これらの引数をタプルにパックします。関数が呼び出されるとき、出力用にタプルにパックされる 3 つの位置パラメータを渡します。
不定のキーワード引数 (**kwargs):
不定のキーワード引数により、関数は任意の数のキーワード引数を受け入れ、それらを辞書 (dict) にパックできます。関数定義で、**kwargs不定のキーワード引数を宣言するために使用します。関数を呼び出すとき、任意の数のキーワード引数を関数に渡すことができ、それらは自動的に辞書にパックされます。
```
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{
        
        key}: {
        
        value}")

print_info(name="John", age=30, city="New York")
# Output:
# name: John
# age: 30
# city: New York
```
この例では、print_info関数は可変数のキーワード引数を受け入れ、これらの引数を辞書にパックします。関数が呼び出されるとき、3 つのキーワード引数を渡し、出力用に辞書にパックされます。

不定の位置引数と不定のキーワード引数の混合:
関数が任意の数の位置引数とキーワード引数を同時に受け入れる必要がある場合は、混合*argsして一致させることができます**kwargs。

def mixed_arguments(*args, **kwargs):
    print("Positional arguments:")
    for arg in args:
        print(arg)

    print("Keyword arguments:")
    for key, value in kwargs.items():
        print(f"{
        
        key}: {
        
        value}")

mixed_arguments("apple", "banana", "orange", country="USA", city="New York")
# Output:
# Positional arguments:
# apple
# banana
# orange
# Keyword arguments:
# country: USA
# city: New York

この例では、mixed_arguments関数は可変数の位置引数とキーワード引数を受け入れます。位置引数をタプルに、キーワード引数を辞書にパックし、それらをさまざまな型で出力します。

不定の位置パラメータと不定のキーワードパラメータにより、大きな柔軟性が得られ、関数がさまざまな数やタイプのパラメータを処理できるようになり、より一般的でさまざまなシナリオに適用できるようになります。

無名関数 (ラムダ関数):

匿名関数は、プログラミングで一般的に使用される単純な形式の関数であり、ラムダ関数 (ラムダ式) とも呼ばれます。これは、名前を付ける必要のない小さな一時的な関数を作成する方法です。通常の関数定義 (def ステートメント) とは異なり、匿名関数は lambda キーワードを使用して定義され、通常は単純な関数が必要だが完全な関数が定義されていない場合に使用されます。

無名関数の構文は次のとおりです。

lambda arguments: expression

ここでarguments、は関数パラメータのリストであり、expressionは関数本体の単純な式です。匿名関数は、明示的な return ステートメントなしで式の結果を返します。

無名関数を使用して 2 つの数値の合計を計算する例を次に示します。

add = lambda x, y: x + y
result = add(3, 5)
print(result)  # Output: 8

この例では、2 つの引数 x と y を受け取り、それらの合計を返す無名関数を定義しますadd。次に、無名関数を呼び出しますadd(3, 5)。この関数は 8 を返します。

匿名関数は、短時間のみ使用する必要がある単純な関数のシナリオに適しており、その単純さのため、関数型プログラミングや特定の状況でよく使用されます。匿名関数の使用は、適切なシナリオと適切な規模に従う必要があることに注意してください。複雑すぎる場合、または複数行のコードロジックが必要な場合は、通常の名前付き関数 (def ステートメント) を使用する必要があります。

無名関数と通常の定義の比較:

匿名関数 (ラムダ関数) と通常の関数 (defステートメントを使用して定義された関数) は、Python で関数を定義する 2 つの異なる方法です。これらには、使用シナリオ、構文、機能にいくつかの違いがあります。それらを比較してみましょう:

文法：
- 通常の関数:defステートメントによって定義され、関数名、パラメーターリスト、関数本体を含めることができます。
- 匿名関数:lambdaキーワードを使用して定義され、式を 1 つだけ含めることができ、関数名はなく、単純な関数シナリオでのみ使用されます。
可読性:
- 通常の関数: 関数名と比較的完全な文法構造により、通常は理解しやすく読みやすくなります。
- 匿名関数: 関数名がなく、単純な式のみを含めることができるため、可読性は比較的低くなります。通常、短くて単純な機能要件に使用されます。
パラメータの数:
- 通常の関数: パラメータはいくつでも指定でき、デフォルトパラメータと可変長パラメータを使用できます。
- 匿名関数: 限られたパラメーターのみを受け入れることができます。通常は、いくつかの単純なパラメーターのみを使用するシナリオで使用されます。
使用するシーン:
- 通常の関数: 複雑な関数ロジック、高い可読性要件、および複数回呼び出しまたは再利用する必要がある場合に適しています。
- 匿名関数: 特に関数が他の関数に引数として渡される場合、または関数プログラミングで使用される場合に、1 回限りまたは一時的な使用に適した単純な関数です。

通常の関数と匿名関数の使用を比較する例を次に示します。

# 普通函数
def add(x, y):
    return x + y

# 调用普通函数
result1 = add(3, 5)
print(result1)  # Output: 8

# 匿名函数
add_lambda = lambda x, y: x + y

# 调用匿名函数
result2 = add_lambda(3, 5)
print(result2)  # Output: 8

この例では、同じ機能を持つ通常の関数addと無名関数を定義し、両方とも加算演算を実装します。add_lambda単純な関数は、匿名関数を使用するとより簡潔に定義できますが、通常の関数よりも若干読みにくくなる可能性があります。

要約すると、匿名関数は関数定義の単純化された形式であり、単純な 1 回限りの関数要件に適していますが、通常の関数は複数の呼び出しや再利用が必要な複雑な関数ロジックに適しています。適切な関数定義方法の選択は、特定のプログラミングシナリオと要件によって異なります。

Pythonモジュール

Python モジュールはコードを整理して再利用する方法であり、Python の定義とステートメントを含むファイルです。モジュールには、他の Python プログラムにインポートして使用できる関数、変数、クラスなどを含めることができます。モジュールを使用する利点の 1 つは、コードを論理ユニットに分割してコードの保守性と再利用性を向上できることです。

モジュールをインポートする方法

[from 模块名] import [模块 类 变量函数] [as 别名]

import 模块名:
これは最も基本的なインポート方法であり、モジュール全体を現在の名前空間にインポートします。モジュール内の関数を使用するには、模块名.功能名アクセスメソッドを使用する必要があります。例: import math、その後、をmath.sqrt()使用して平方根関数を呼び出します。

import math
print(math.sqrt(16))  # 调用math模块的sqrt()函数计算平方根

from 模块名 import 类、变量、方法等:
このメソッドを使用すると、モジュール全体ではなく、モジュール内の特定のクラス、変数、またはメソッドを現在の名前空間に選択的にインポートできます。インポートされた名前は、モジュール名を先頭に付けずに直接使用できます。例: の場合、とをfrom math import sqrt, pi使用できます。sqrt()pi

from math import sqrt, pi
print(sqrt(16))  # 直接调用sqrt()函数计算平方根
print(pi)        # 直接输出导入的pi常量的值

from 模块名 import *:
このメソッドは、モジュール内のすべてのパブリック名 (先頭ではない) を_現在の名前空間にインポートします。アクセスが容易になりますが、名前の競合が発生しやすく、コードの保守が容易ではないため、運用コードにはお勧めできません。

from math import *
print(sqrt(16))  # 直接调用sqrt()函数计算平方根
print(pi)        # 直接输出导入的pi常量的值

import 模块名 as 别名:キーワード
を使用してasモジュールのエイリアスを指定すると、そのエイリアスを使用してコード内でモジュールを参照できます。これは、名前の衝突を回避したり、モジュール名を簡略化する場合に役立ちます。例: import numpy as np、これを使用してnp.array()NumPy の配列関数を呼び出すことができます。

import numpy as np
arr = np.array([1, 2, 3])  # 使用别名np调用NumPy模块的array()函数创建数组

from 模块名 import 功能名 as 别名:
このメソッドは、モジュール内の特定の関数をインポートし、それらにエイリアスを与えます。これらの関数は、元の名前やモジュール名を接頭辞として付けずに、エイリアスを使用して直接呼び出すことができます。例: の場合は、代わりにをfrom math import sqrt as square_root使用できます。square_root()sqrt()

from math import sqrt as square_root
print(square_root(16))  # 使用别名square_root调用sqrt()函数计算平方根

import 模块名注: 実際のプログラミングでは、 orの形式を使用し、後者は予期せぬ問題を引き起こす可能性があるため、from 模块名 import 功能名使用しないことをお勧めします。from 模块名 import *同時に、コードの読みやすさと保守性を考慮して、インポートされたモジュールと関数には意味のあるエイリアスを使用することをお勧めします。

比較:

1と3

違いは次のとおりです。

import 模块名:
このインポートメソッドは、モジュール全体を現在の名前空間にインポートします。模块名.功能名モジュール内の関数にアクセスする方法を使用する必要があります。たとえば、モジュールimport mathは import されmath、math.sqrt()平方根関数はで呼び出されます。
from 模块名 import *:
このインポートメソッドは、モジュール内のすべてのパブリック名 (先頭ではない) を_現在の名前空間にインポートします。_パブリックとは、で始まるプライベートメンバーを除く、モジュール内のすべての変数、関数、クラスなどを意味します。こうすることで、インポートされた名前を、モジュール名を接頭辞として付けずに直接使用できます。たとえば、モジュール内のすべてのパブリックメンバーはfrom math import *import され、とを記述する代わりに直接使用できます。mathsqrt()pimath.sqrt()math.pi

主な違い:

1 つ目の方法では、模块名.功能名メソッドを使用してモジュール内の関数にアクセスする必要があります。3 つ目の方法では、モジュール名のプレフィックスの使用を避け、インポートされた名前を直接使用して関数にアクセスできます。
モジュール内のすべてのパブリックメンバーが 3 番目の方法でインポートされるため、1 番目の方法は 3 番目の方法より安全です。3 番目の方法では名前の競合が発生しやすく、運用コードでの使用はお勧めできません。最初の方法では、モジュール全体のみをインポートし、名前の競合の問題を避けるためにモジュール名のプレフィックスを使用します。

したがって、コードの読みやすさと保守性を考慮すると、 3 番目の方法ではなく、1 番目の方法 ( import 模块名) または 2 番目の方法 ( )を使用することをお勧めします。from 模块名 import 功能名

モジュールのインポート速度に関しては、通常、2 番目のインポート方法 ( `from 模块名 import 类、变量、方法等`) の方が 3 番目のインポート方法 ( ) よりも高速になります`from 模块名 import *`。

その理由は次のとおりです。

2 番目の方法では、インポートするクラス、変数、またはメソッドを明確に指定するため、Python インタープリターは指定されたコンテンツのみをインポートし、インポートのワークロードとメモリ使用量を削減します。
3 番目の方法では、モジュール内のすべてのパブリックメンバーをインポートします。これにより、モジュールが大きい場合や多くの機能がある場合、メモリ使用量と読み込み時間が増加する可能性があります。
2 番目の方法では、明示的に指定された関数のみが現在の名前空間にインポートされます。これにより、不要な関数のインポートが回避され、コードの明確さと保守性が向上します。

速度の点では 2 番目の方法の方が速いかもしれませんが、実際には、インポート速度は通常、主なパフォーマンスのボトルネックではありません。コードの明瞭さと読みやすさに適したインポートを選択することがより重要です。したがって、運用コードでは 2 番目の方法を使用し、インポートする関数を明示的に指定し、すべてをインポートする 3 番目の方法の使用を避けることをお勧めします。これにより、コードがクリーンかつパフォーマンス的に保たれます。

利点と欠点の全体的な分析。

これら 5 つのインポート方法を比較してみましょう。

import 模块名：
- モジュール全体をインポートするには、モジュール内の関数にアクセスするためにモジュール名にプレフィックスを付ける必要があります。
- このメソッドをコード内で複数回使用すると、競合を引き起こすことなく同じモジュールをインポートできます。
- モジュールが大きい場合や多機能が必要な場合に適しています。
from 模块名 import 类、变量、方法等：
- モジュール内の特定の関数を選択的にインポートします。モジュール名にプレフィックスを付けずに、インポートされた名前を使用して直接アクセスできます。
- コードを簡素化するために、複数の関数を一度にインポートできます。
- モジュール名のプレフィックスの使用を避けることは、少数の関数のみが必要な状況に適しています。
from 模块名 import *：
- モジュール内のすべてのパブリック名をインポートします。実稼働コードには推奨されません。
- 名前の競合やコードのメンテナンスが困難になる可能性が高いため、この方法の使用は避けてください。
import 模块名 as 别名：
- モジュールにエイリアスを割り当て、そのエイリアスを使用してモジュール内の関数を参照します。
- モジュール名が長い場合、または名前の衝突を避ける必要がある場合に便利です。
from 模块名 import 功能名 as 别名：
- 特定の関数をモジュールにインポートし、エイリアスを指定して、そのエイリアスを使用して関数を直接呼び出します。
- 元の名前またはモジュール名のプレフィックスを避けることにより、コードを簡素化できます。

全体として、1 番目と 2 番目の方法が最もよく使用されます。最初の方法はモジュール全体をインポートするのに適しており、2 番目の方法は特定の機能を選択的にインポートするのに適しています。3 番目の方法は、潜在的な問題を引き起こす可能性があるため、お勧めできません。4 番目と 5 番目の方法は、エイリアスが必要な状況に適しており、コードの読みやすさと簡潔さを向上させることができます。一般に、適切なインポート方法の選択は、特定の状況とコードの要件によって異なります。

カスタムモジュール:

カスタムモジュールは、ユーザーが作成した Python コードを含むファイルを指します。このファイルには、関数、クラス、変数などの再利用可能なコードブロックを含めることができます。カスタムモジュールの主な目的は、コードを論理ユニットに編成して、さまざまな Python プログラムにインポートして使用できるようにし、コードの保守性と再利用性を向上させることです。

カスタムモジュールを作成する手順は次のとおりです。

Python コードを記述し、拡張子のファイル.pyとして、そのファイル名がモジュールの名前になります。
保存したファイルを、現在の作業ディレクトリや Python 標準ライブラリの検索パスなど、Python インタープリタが見つけられるディレクトリに置きます。

カスタムモジュールの例を次に示します。

my_utils.pyいくつかの便利な関数を含むというカスタムモジュールを作成するとします。

# my_utils.py

def square(x):
    """计算一个数的平方"""
    return x * x

def add(a, b):
    """计算两个数的和"""
    return a + b

PI = 3.14159

その後、このカスタムモジュールを他の Python プログラムにインポートして使用できます。

# 导入整个模块
import my_utils

print(my_utils.square(5))  # 输出：25
print(my_utils.add(3, 7))  # 输出：10
print(my_utils.PI)         # 输出：3.14159

# 导入特定的函数和变量
from my_utils import square, PI

print(square(8))   # 输出：64
print(PI)          # 输出：3.14159

予防：

カスタムモジュールのファイル名は、.pyたとえばで終わる必要がありますmy_utils.py。
カスタムモジュールが、それを使用する Python プログラムと同じディレクトリまたは正しい Python 検索パスの下にあることを確認してください。
ステートメントを使用してモジュール全体をインポートする場合import、モジュール名の接頭辞を使用してモジュール内の関数および変数にアクセスする必要があります。
from 模块名 import 功能名フォームを使用して特定の関数と変数をインポートする場合、モジュール名のプレフィックスを使用せずに関数名を直接使用できます。

予防：

複数のモジュールをインポートし、これらのモジュール内に同じ名前の関数、クラス、または変数がある場合、名前の競合が発生する可能性があります。現時点では、Python インタープリターは同じ名前の関数を使用するモジュールを区別できない可能性があり、コードエラーや予期しない結果が発生する可能性があります。
Python では、異なるモジュールが同じ名前の関数 (関数、クラスなど) をインポートし、これらのモジュールが同じスクリプトに正常にインポートされた場合、後でインポートされたモジュールが、以前にインポートされたモジュール内の同じ名前の関数を上書きします。この動作を「名前の競合」（名前の競合）といいます。

名前の競合がある場合、後でインポートされたモジュール内の同じ名前の関数が、前にインポートされたモジュール内の同じ名前の関数をオーバーライドします。これは、スクリプトで関数を使用する場合、最後にインポートされたモジュールのバージョンが実際に使用されることを意味します。

この概念を例を挙げて説明しましょう。module_a.py2 つのモジュールとがありmodule_b.py、どちらも同じ名前の関数を定義しているとしますcommon_function。

# module_a.py
def common_function():
    print("This is common function from module_a")

# module_b.py
def common_function():
    print("This is common function from module_b")

ここで、両方のモジュールを 1 つのスクリプトにインポートし、以下を呼び出しますcommon_function。

from module_a import common_function
from module_b import common_function

common_function()

出力は次のようになります。

This is common function from module_b

module_b.pyこれは最後にインポートされ、内の同じ名前の関数common_functionをオーバーライドするためです。module_a.pyこれは、後でインポートされたモジュールが、以前にインポートされたモジュールの同じ名前のメンバーを上書きするためです。

この名前の衝突の問題を回避するには、次のようなベストプラクティスが推奨されます。

エイリアスを使用する: 同じ名前の関数をインポートする場合、名前の競合を避けるために 1 つ以上の関数にエイリアスを割り当てることができます。例: from module_a import common_function as a_function。
明示的なインポート: この方法の使用は避けfrom module import *、必要な関数を明示的にインポートします。例:from module_a import common_functionとfrom module_b import common_function。
名前空間: モジュールの名前が一般的で、他のモジュールと競合する可能性がある場合は、モジュールの名前空間を使用してモジュール内の関数を呼び出すことができます。例: import module_aand import module_b、その後、module_a.common_function()and を使用してmodule_b.common_function()対応する関数を呼び出します。

この状況を回避するには、次のことを実行できます。

完全なモジュール名を使用する:
同じ名前で関数を呼び出す場合、完全なモジュール名をプレフィックスとして使用して、競合を避けるためにどのモジュールで使用する関数を明確に指定できます。

例：

import module1
import module2

print(module1.some_function())  # 调用module1中的函数
print(module2.some_function())  # 调用module2中的函数

エイリアスを使用する (エイリアスとして):
インポートされたモジュールまたは関数のエイリアスを同じ名前で指定し、そのエイリアスを使用して、異なるモジュール内の同じ名前の関数を区別します。

例：

import module1 as m1
import module2 as m2

print(m1.some_function())  # 调用module1中的函数
print(m2.some_function())  # 调用module2中的函数

from-import ステートメントを使用する:
一部の関数のみをインポートする必要があり、それらの関数の名前が同じである場合は、from-import ステートメントを使用して、インポートされた関数の別名を指定できます。

例：

from module1 import some_function as func1
from module2 import some_function as func2

print(func1())  # 调用module1中的函数
print(func2())  # 调用module2中的函数

上記の方法のいずれかを使用すると、モジュール間の名前の競合を回避し、コードが正しく実行され、期待どおりの結果が得られることを確認できます。実際のプログラミングでは、コードの可読性とメンテナンスの容易性を高めるために、インポートされたモジュールと関数に意味のあるエイリアスを使用することをお勧めします。

main 変数:

Pythonでは、__main__現在実行しているスクリプトがメインプログラム（メインプログラム）であるかどうかを示すために使用される特別な組み込み変数（組み込み変数）です。Python インタープリターはスクリプトを実行するときに、スクリプトにを含む特定の変数を設定します__name__。Python スクリプトが直接実行される場合、__name__変数の値はに設定されます__main__。それ以外の場合、このスクリプトがモジュールとして他のスクリプトにインポートされる場合、__name__変数の値はモジュールの名前になります。

具体的には、Python スクリプトをコマンドラインで直接実行すると、Python インタープリターはスクリプトの__name__変数をに設定し__main__、スクリプトがメインプログラムであることを示します。このようにして、__name__値を確認することで特定のコードブロックを実行できます。これは、異なるコンテキストで異なるコードを実行できるため、再利用可能なモジュールやスクリプトを構築するときに非常に役立ちます。

例として、example.py次のような名前のスクリプトがあるとします。

def do_something():
    print("Doing something!")

print("This will always be executed!")

if __name__ == "__main__":
    print("This will only be executed when the script is run directly.")
    do_something()

コマンドラインで実行するとpython example.py、次の出力が得られます。

This will always be executed!
This will only be executed when the script is run directly.
Doing something!

ただし、別のスクリプトにインポートするとexample.py、if __name__ == "__main__":ブロック内のコードは実行されません。たとえば、main.py次の内容の名前のスクリプトがあるとします。

import example

print("This is the main program.")

を実行するとpython main.py、次の出力が得られます。

This will always be executed!
This is the main program.

ご覧のとおり、のブロックexample.py内のコードは、のモジュールとしてインポートされるif __name__ == "__main__":ため、実行されません。main.py

要約すると、__main__変数は Python の特別な組み込み変数であり、現在のスクリプトがメインプログラムであるかどうかを判断するために使用されます。値をチェックすると__name__、スクリプトがメインプログラムとして実行されるときに特定のコードブロックを実行し、モジュールとしてインポートされるときにこれらのコードブロックを実行しないようにできます。

全員：

__all__Python の別の特殊変数です。from module import *これは、ステートメントを使用するときにモジュールのどのメンバー (変数、関数、クラスなど) をインポートする必要があるかを定義するオプションのリストです。この機能は主に、モジュールのパブリックインターフェイスを制御して、不要なメンバーが誤ってインポートされることを避けるために使用されます。

__all__モジュール内で変数を定義すると、 from module import *import ステートメントの使用時にインポートされるものが制限されます。__all__変数が定義されていない場合from module import *、モジュール内のアンダースコアで始まらないすべてのグローバル名 (つまり、パブリックメンバー) がインポートされますが、これはお勧めできません。これは、不要なコンテンツが多すぎるため、名前の競合や望ましくない内容がインポートされる可能性があります。効果。

例を確認するには、example_module.py次の内容を含むという名前のモジュールがあるとします。

# example_module.py

def function_a():
    print("Function A")

def function_b():
    print("Function B")

def _private_function():
    print("Private Function")

__all__ = ["function_a", "function_b"]

上の例では、__all__変数は 2 つの文字列要素を含むリストに設定され"function_a"ます"function_b"。これは、from example_module import *ステートメントを使用してモジュールをインポートする場合、関数function_aとfunction_b, のみがインポートされますが、_private_functionこの関数はアンダースコアで始まりプライベート関数とみなされているため、インポートされないことを意味します。

別のスクリプトでは、次のように使用できますexample_module。

from example_module import *

function_a()  # Output: Function A
function_b()  # Output: Function B
_private_function()  # NameError: name '_private_function' is not defined

を使用すると__all__インポートされる内容を制限できますが、それはfrom module import *ステートメントを使用する場合にのみ有効であることに注意してください。from example_module import function_a, function_b推奨される方法は、を使用するのではなく、必要なメンバー (例: ) を明示的にインポートすることですfrom example_module import *。これにより、名前の競合が回避され、コードがより明確になり、保守しやすくなります。

Python パッケージをインポートする方法:

Python では、パッケージをインポートするには、importステートメントを使用します。パッケージは複数のモジュールを含むディレクトリであり、これを使用して関連する機能モジュールを整理および管理できます。パッケージディレクトリには、__init__.pyという名前のファイルが含まれている必要があります。このファイルは空であっても、パッケージの初期化コードが含まれていてもかまいません。

my_package次のディレクトリ構造を持つ名前のパッケージがあるとします。

my_package/
    __init__.py
    module_a.py
    module_b.py
    subpackage/
        __init__.py
        module_c.py

次に、このパッケージとその中のモジュールをインポートする方法を見てみましょう。

パッケージ全体またはサブパッケージをインポートするには:

import my_package

# 使用包中的模块
my_package.module_a.some_function()
my_package.subpackage.module_c.another_function()

特定のモジュールをインポートします。

from my_package import module_a, subpackage.module_c

# 使用特定的模块
module_a.some_function()
subpackage.module_c.another_function()

キーワードを使用してas、インポートされたパッケージまたはモジュールに別名を付けます。

import my_package as mp

mp.module_a.some_function()
mp.subpackage.module_c.another_function()

次の構文を使用して、from ... import ...パッケージまたはモジュールの特定のメンバーをインポートします。

from my_package.module_a import some_function
from my_package.subpackage.module_c import another_function

some_function()
another_function()

実際のニーズに応じて、適切なインポート方法を選択してください。パッケージを使用すると、コードをより適切に整理し、名前の競合を防ぎ、より高いレベルのモジュール管理を提供できます。

VScodeでPythonを学習しています（Python関数、Pythonモジュールのインポート）

記事ディレクトリ

Py関数

チャット：

問題を解決します [リスト内の条件を満たすすべてのメンバーの組み合わせと、それに対応する添え字の組み合わせを見つけます]:

コード

Py関数の定義

Py関数の呼び出し方法

ネストされた呼び出し

Python 関数を使用する場合は、注意すべき点がいくつかあります。

Python 関数のパラメータを呼び出す方法はいくつかあります。

知らせ：

戻り値 [関数の実行後に呼び出し元に返される結果]

None の値: [タイプが <class NoneType'> である特別なリテラル。戻り値のない関数は、実際にはリテラル値 None を返します。

コード：

複数の戻り値:

Python パラメータの使用方法は次のとおりです。

1. 位置引数: これはパラメータを渡す最も一般的な方法です。関数を呼び出すと、パラメータは定義された順序で関数に渡されます。例えば：

キーワードを使用してパラメータを渡すと、固定順序なしでパラメータを渡すことができるため、関数呼び出しがより柔軟で明確になります。コード例は次のとおりです。

4. 可変長パラメータ: Python には 2 種類の可変長パラメータがあります。

5 つのデフォルトの引数:

6 不定長パラメータ (可変長パラメータ):

可変長パラメーターに関しては、Python では、可変位置パラメーター (*args) と可変キーワードパラメーター (**kwargs) の 2 つの方法が提供されます。

無名関数 (ラムダ関数):

無名関数と通常の定義の比較:

Pythonモジュール

モジュールをインポートする方法

比較:

1と3

モジュールのインポート速度に関しては、通常、2 番目のインポート方法 ( `from 模块名 import 类、变量、方法等`) の方が 3 番目のインポート方法 ( ) よりも高速になります`from 模块名 import *`。

利点と欠点の全体的な分析。

カスタムモジュール:

カスタムモジュールの例を次に示します。

予防：

この状況を回避するには、次のことを実行できます。

main 変数:

全員：

Python パッケージをインポートする方法:

おすすめ

VScodeでPythonを学習しています（Python関数、Pythonモジュールのインポート）

記事ディレクトリ

Py関数

チャット：

問題を解決します [リスト内の条件を満たすすべてのメンバーの組み合わせと、それに対応する添え字の組み合わせを見つけます]:

コード

Py関数の定義

Py関数の呼び出し方法

ネストされた呼び出し

Python 関数を使用する場合は、注意すべき点がいくつかあります。

Python 関数のパラメータを呼び出す方法はいくつかあります。

知らせ：

戻り値 [関数の実行後に呼び出し元に返される結果]

None の値: [タイプが <class NoneType'> である特別なリテラル。戻り値のない関数は、実際にはリテラル値 None を返します。

コード：

複数の戻り値:

Python パラメータの使用方法は次のとおりです。

1. 位置引数: これはパラメータを渡す最も一般的な方法です。関数を呼び出すと、パラメータは定義された順序で関数に渡されます。例えば：

キーワードを使用してパラメータを渡すと、固定順序なしでパラメータを渡すことができるため、関数呼び出しがより柔軟で明確になります。コード例は次のとおりです。

4. 可変長パラメータ: Python には 2 種類の可変長パラメータがあります。

5 つのデフォルトの引数:

6 不定長パラメータ (可変長パラメータ):

可変長パラメーターに関しては、Python では、可変位置パラメーター (*args) と可変キーワード パラメーター (**kwargs) の 2 つの方法が提供されます。

無名関数 (ラムダ関数):

無名関数と通常の定義の比較:

Pythonモジュール

モジュールをインポートする方法

比較:

1と3

モジュールのインポート速度に関しては、通常、2 番目のインポート方法 ( from 模块名 import 类、变量、方法等) の方が 3 番目のインポート方法 ( ) よりも高速になりますfrom 模块名 import *。

利点と欠点の全体的な分析。

カスタムモジュール:

カスタム モジュールの例を次に示します。

予防：

この状況を回避するには、次のことを実行できます。

__main__ 変数:

全員：

Python パッケージをインポートする方法:

おすすめ

可変長パラメーターに関しては、Python では、可変位置パラメーター (*args) と可変キーワードパラメーター (**kwargs) の 2 つの方法が提供されます。

モジュールのインポート速度に関しては、通常、2 番目のインポート方法 ( `from 模块名 import 类、变量、方法等`) の方が 3 番目のインポート方法 ( ) よりも高速になります`from 模块名 import *`。

カスタムモジュールの例を次に示します。

main 変数: