次のメソッドの定義では、何がない*と**のために何param2？

def foo(param1, *param2):
def bar(param1, **param2):

*argsそして**kwargsセクションで説明したように機能する任意の数の引数を可能にする一般的なイディオムである機能の定義の詳細 Pythonドキュメントに。

これ*argsは、すべての関数パラメーターをタプルとして提供します。

def foo(*args):
    for a in args:
        print(a)        

foo(1)
# 1

foo(1,2,3)
# 1
# 2
# 3

**kwargsあなたにすべて与える キーワード引数を辞書として仮パラメータに対応するものを除き。

def bar(**kwargs):
    for a in kwargs:
        print(a, kwargs[a])  

bar(name='one', age=27)
# age 27
# name one

両方のイディオムを通常の引数と混合して、固定引数といくつかの可変引数のセットを許可できます。

def foo(kind, *args, **kwargs):
   pass

これを逆に使用することもできます：

def foo(a, b, c):
    print(a, b, c)

obj = {'b':10, 'c':'lee'}

foo(100,**obj)
# 100 10 lee

*lイディオムのもう1つの使用法は、関数を呼び出すときに引数リストをアンパックすることです。

def foo(bar, lee):
    print(bar, lee)

l = [1,2]

foo(*l)
# 1 2

Python 3では*l、割り当ての左側（Extended Iterable Unpacking）を使用できますが、このコンテキストではタプルの代わりにリストが表示されます。

first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]

また、Python 3は新しいセマンティックを追加します（PEP 3102を参照）：

def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
    pass

このような関数は3つの位置引数のみを受け入れ、その後のすべて*はキーワード引数としてのみ渡すことができます。

それはまた、あなたが使用できることは注目に値します*と**、同様の機能を呼び出すとき。これは、リスト/タプルまたは辞書のいずれかを使用して、関数に複数の引数を直接渡すことができるショートカットです。たとえば、次の関数があるとします。

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

次のようなことができます。

>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

注：のキーにmydictは、functionのパラメーターとまったく同じ名前を付ける必要がありますfoo。それ以外の場合はTypeError：

>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'

単一の*は、追加の位置引数がいくつでも存在できることを意味します。foo()のように呼び出すことができますfoo(1,2,3,4,5)。foo（）の本体では、param2は2-5を含むシーケンスです。

二重**は、追加の名前付きパラメーターがいくつでも存在できることを意味します。bar()のように呼び出すことができますbar(1, a=2, b=3)。bar（）の本文では、param2は{'a'：2、 'b'：3}を含む辞書です。

次のコードで：

def foo(param1, *param2):
    print(param1)
    print(param2)

def bar(param1, **param2):
    print(param1)
    print(param2)

foo(1,2,3,4,5)
bar(1,a=2,b=3)

出力は

1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}

何を**（ダブルスター）及び*（スター）のパラメータのために行います

それらは、関数が受け入れられるように定義され、ユーザーが任意の数の引数、位置（*）およびキーワード（**）を渡すことを可能にします。

関数の定義

*argsという名前のタプルに割り当てられる、任意の数のオプションの位置引数（パラメーター）を許可しますargs。

**kwargsという名前のdictにあるオプションのキーワード引数（パラメーター）をいくつでも使用できますkwargs。

任意の適切な名前を選択できます（選択する必要があります）が、引数が非特定のセマンティクスでargsありkwargs、標準の名前であることが意図されている場合。

拡張、任意の数の引数を渡す

使用することもできます*argsし、**kwargsそれぞれのリスト（または任意の反復可能）とdicts（または任意のマッピング）からパラメータに渡します。

パラメータを受け取る関数は、それらが展開されていることを知る必要はありません。

たとえば、Python 2のxrangeは明示的にを期待していません*argsが、引数として3つの整数を取るためです。

>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x)    # expand here
xrange(0, 2, 2)

別の例として、次のようにdict拡張を使用できますstr.format。

>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'

Python 3の新機能：キーワードのみの引数を持つ関数の定義

次の後にキーワードのみの引数を指定できます*args-たとえば、ここでは、kwarg2位置ではなくキーワード引数として指定する必要があります。

def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs): 
    return arg, kwarg, args, kwarg2, kwargs

使用法：

>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})

また、*単独で使用して、キーワードのみの引数が続くことを示すことができます。無制限の位置引数は許可されません。

def foo(arg, kwarg=None, *, kwarg2=None, **kwargs): 
    return arg, kwarg, kwarg2, kwargs

ここkwarg2でも、明示的に名前が付けられたキーワード引数である必要があります。

>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})

また、次のものがないため、無制限の位置引数を受け入れることはできません*args*。

>>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes from 1 to 2 positional arguments 
    but 5 positional arguments (and 1 keyword-only argument) were given

繰り返しますが、より簡単に言うと、ここkwargでは位置ではなく名前で指定する必要があります。

def bar(*, kwarg=None): 
    return kwarg

この例では、kwarg位置を渡そうとするとエラーが発生することがわかります。

>>> bar('kwarg')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given

kwargパラメータをキーワード引数として明示的に渡す必要があります。

>>> bar(kwarg='kwarg')
'kwarg'

Python 2互換のデモ

*args（通常、「スター引数」と**kwargs呼ばれます）および（スターは「クワーグス」と言うことで暗示されますが、「ダブルスタークワーグス」で明示的にできます）は、*および**表記を使用するPythonの一般的な慣用句です。これらの特定の変数名は必須ではありませんが（例：*foosおよびを使用できます**bars）、規則からの脱却は、仲間のPythonプログラマーを激怒させる可能性があります。

通常、これらは、関数が受け取るものや渡す引数の数がわからない場合に使用します。また、すべての変数に個別に名前を付けると、非常に面倒で冗長になる場合もあります（ただし、通常は明示的に暗黙よりも優れています）。

例1

次の関数は、それらの使用方法を説明し、動作を示します。名前付きb引数は、前の2番目の位置引数によって消費されることに注意してください。

def foo(a, b=10, *args, **kwargs):
    '''
    this function takes required argument a, not required keyword argument b
    and any number of unknown positional arguments and keyword arguments after
    '''
    print('a is a required argument, and its value is {0}'.format(a))
    print('b not required, its default value is 10, actual value: {0}'.format(b))
    # we can inspect the unknown arguments we were passed:
    #  - args:
    print('args is of type {0} and length {1}'.format(type(args), len(args)))
    for arg in args:
        print('unknown arg: {0}'.format(arg))
    #  - kwargs:
    print('kwargs is of type {0} and length {1}'.format(type(kwargs),
                                                        len(kwargs)))
    for kw, arg in kwargs.items():
        print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))
    # But we don't have to know anything about them 
    # to pass them to other functions.
    print('Args or kwargs can be passed without knowing what they are.')
    # max can take two or more positional args: max(a, b, c...)
    print('e.g. max(a, b, *args) \n{0}'.format(
      max(a, b, *args))) 
    kweg = 'dict({0})'.format( # named args same as unknown kwargs
      ', '.join('{k}={v}'.format(k=k, v=v) 
                             for k, v in sorted(kwargs.items())))
    print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(
      dict(**kwargs), kweg=kweg))

私たちは、関数のシグネチャのオンラインヘルプを確認することができますhelp(foo)を教えてくれるています、

foo(a, b=10, *args, **kwargs)

この関数を呼び出してみましょう foo(1, 2, 3, 4, e=5, f=6, g=7)

印刷する：

a is a required argument, and its value is 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args) 
4
e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns: 
{'e': 5, 'g': 7, 'f': 6}

例2

別の関数を使用して呼び出すこともできます。その関数に提供するのはa次のとおりです。

def bar(a):
    b, c, d, e, f = 2, 3, 4, 5, 6
    # dumping every local variable into foo as a keyword argument 
    # by expanding the locals dict:
    foo(**locals()) 

bar(100) プリント：

a is a required argument, and its value is 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args) 
100
e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns: 
{'c': 3, 'e': 5, 'd': 4, 'f': 6}

例3：デコレーターでの実際の使用法

OK、多分私達はまだユーティリティを見ていません。したがって、差別化コードの前または後に冗長コードを持ついくつかの関数があると想像してください。次の名前付き関数は、説明のための単なる擬似コードです。

def foo(a, b, c, d=0, e=100):
    # imagine this is much more code than a simple function call
    preprocess() 
    differentiating_process_foo(a,b,c,d,e)
    # imagine this is much more code than a simple function call
    postprocess()

def bar(a, b, c=None, d=0, e=100, f=None):
    preprocess()
    differentiating_process_bar(a,b,c,d,e,f)
    postprocess()

def baz(a, b, c, d, e, f):
    ... and so on

これは別の方法で処理できるかもしれませんが、デコレータを使用して冗長性を確実に抽出できるため、以下の例はその方法を示し*args、**kwargs非常に便利です。

def decorator(function):
    '''function to wrap other functions with a pre- and postprocess'''
    @functools.wraps(function) # applies module, name, and docstring to wrapper
    def wrapper(*args, **kwargs):
        # again, imagine this is complicated, but we only write it once!
        preprocess()
        function(*args, **kwargs)
        postprocess()
    return wrapper

そして、冗長性を除外したので、すべてのラップされた関数をより簡潔に書くことができます。

@decorator
def foo(a, b, c, d=0, e=100):
    differentiating_process_foo(a,b,c,d,e)

@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
    differentiating_process_bar(a,b,c,d,e,f)

@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
    differentiating_process_baz(a,b,c,d,e,f, g)

@decorator
def quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):
    differentiating_process_quux(a,b,c,d,e,f,g,h)

そして、私たちのコードを分解することによって、それ*argsを**kwargs可能にし、コードの行を減らし、可読性と保守性を改善し、プログラム内のロジックのための唯一の標準的な場所を持っています。この構造のいずれかの部分を変更する必要がある場合、それぞれの変更を行う場所が1つあります。

まず、位置引数とキーワード引数について理解しましょう。以下は、位置引数を使用した関数定義の例です。

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(1,2,3)
#output:
1
2
3

したがって、これは位置引数を持つ関数定義です。キーワード/名前付き引数でそれを呼び出すこともできます：

def test(a,b,c):
     print(a)
     print(b)
     print(c)

test(a=1,b=2,c=3)
#output:
1
2
3

次に、キーワード引数を使用した関数定義の例を見てみましょう。

def test(a=0,b=0,c=0):
     print(a)
     print(b)
     print(c)
     print('-------------------------')

test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------

位置引数を指定してこの関数を呼び出すこともできます。

def test(a=0,b=0,c=0):
    print(a)
    print(b)
    print(c)
    print('-------------------------')

test(1,2,3)
# output :
1
2
3
---------------------------------

これで、位置引数とキーワード引数を持つ関数定義がわかりました。

次に、「*」演算子と「**」演算子について検討します。

これらの演算子は2つの領域で使用できます。

a）関数呼び出し

b）関数定義

関数呼び出しでの「*」演算子と「**」演算子の使用。

例を見て、それについて説明しましょう。

def sum(a,b):  #receive args from function calls as sum(1,2) or sum(a=1,b=2)
    print(a+b)

my_tuple = (1,2)
my_list = [1,2]
my_dict = {'a':1,'b':2}

# Let us unpack data structure of list or tuple or dict into arguments with help of '*' operator
sum(*my_tuple)   # becomes same as sum(1,2) after unpacking my_tuple with '*'
sum(*my_list)    # becomes same as sum(1,2) after unpacking my_list with  '*'
sum(**my_dict)   # becomes same as sum(a=1,b=2) after unpacking by '**' 

# output is 3 in all three calls to sum function.

だから覚えて

「*」または「**」演算子が関数呼び出しで使用されている場合 -

'*'演算子は、リストやタプルなどのデータ構造を関数定義に必要な引数にアンパックします。

'**'演算子は、関数定義に必要な引数に辞書をアンパックします。

次に、関数定義での '*'演算子の使用法を調べます。例：

def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))
    sum = 0
    for a in args:
        sum+=a
    print(sum)

sum(1,2,3,4)  #positional args sent to function sum
#output:
10

関数定義では、「*」演算子は受け取った引数をタプルにパックします。

次に、関数定義で使用される「**」の例を見てみましょう。

def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})
    sum=0
    for k,v in args.items():
        sum+=v
    print(sum)

sum(a=1,b=2,c=3,d=4) #positional args sent to function sum

関数定義内 '**'演算子は、受け取った引数を辞書にパックします。

覚えておいてください：

で関数を呼び出す「*」アンパック関数定義によって受信されるように、位置やキーワード引数にタプルやリストのデータ構造を。

では、関数呼び出し「**」アンパック関数定義が受信する位置やキーワード引数に辞書のデータ構造。

では関数定義「*」パックタプルに位置引数。

では関数定義「**」パック辞書にキーワード引数。

このテーブルには、使用に便利である*と**、関数内の建設と機能の呼び出し：

            In function construction         In function call
=======================================================================
          |  def f(*args):                 |  def f(a, b):
*args     |      for arg in args:          |      return a + b
          |          print(arg)            |  args = (1, 2)
          |  f(1, 2)                       |  f(*args)
----------|--------------------------------|---------------------------
          |  def f(a, b):                  |  def f(a, b):
**kwargs  |      return a + b              |      return a + b
          |  def g(**kwargs):              |  kwargs = dict(a=1, b=2)
          |      return f(**kwargs)        |  f(**kwargs)
          |  g(a=1, b=2)                   |
-----------------------------------------------------------------------

これは本当にLorin Hochsteinの答えを要約するのに役立ちますが、私はそれが役に立ちます。

関連して：star / splat演算子の使用がPython 3で拡張されました

*そして**関数の引数リストに特別な使い方があります。* 引数がリストである**ことを意味し、引数が辞書であることを意味します。これにより、関数は任意の数の引数を取ることができます

例で学ぶあなたのために！

1. の目的は* 、リストとして提供される任意の数の引数を取ることができる関数を定義できるようにすることf(*myList)です（例：）。
2. の目的は**、ディクショナリ（例：）を提供することにより、関数の引数をフィードできるようにすることですf(**{'x' : 1, 'y' : 2})。

私たちは2つの通常の変数を取る関数を定義することによって、これをお見せしましょうx、yとのように複数の引数を受け入れることができmyArgs、そしてとしてさらに多くの引数を受け取ることができますmyKW。後で、をy使用してフィードする方法を示しますmyArgDict。

def f(x, y, *myArgs, **myKW):
    print("# x      = {}".format(x))
    print("# y      = {}".format(y))
    print("# myArgs = {}".format(myArgs))
    print("# myKW   = {}".format(myKW))
    print("# ----------------------------------------------------------------------")

# Define a list for demonstration purposes
myList    = ["Left", "Right", "Up", "Down"]
# Define a dictionary for demonstration purposes
myDict    = {"Wubba": "lubba", "Dub": "dub"}
# Define a dictionary to feed y
myArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}

# The 1st elem of myList feeds y
f("myEx", *myList, **myDict)
# x      = myEx
# y      = Left
# myArgs = ('Right', 'Up', 'Down')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# y is matched and fed first
# The rest of myArgDict becomes additional arguments feeding myKW
f("myEx", **myArgDict)
# x      = myEx
# y      = Why?
# myArgs = ()
# myKW   = {'y0': 'Why not?', 'q': 'Here is a cue!'}
# ----------------------------------------------------------------------

# The rest of myArgDict becomes additional arguments feeding myArgs
f("myEx", *myArgDict)
# x      = myEx
# y      = y
# myArgs = ('y0', 'q')
# myKW   = {}
# ----------------------------------------------------------------------

# Feed extra arguments manually and append even more from my list
f("myEx", 4, 42, 420, *myList, *myDict, **myDict)
# x      = myEx
# y      = 4
# myArgs = (42, 420, 'Left', 'Right', 'Up', 'Down', 'Wubba', 'Dub')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# Without the stars, the entire provided list and dict become x, and y:
f(myList, myDict)
# x      = ['Left', 'Right', 'Up', 'Down']
# y      = {'Wubba': 'lubba', 'Dub': 'dub'}
# myArgs = ()
# myKW   = {}
# ----------------------------------------------------------------------

注意事項

1. ** 辞書専用に予約されています。
2. オプションではない引数の割り当てが最初に行われます。
3. オプションではない引数を2回使用することはできません。
4. 該当する場合、常にの**後*に来る必要があります。

Pythonのドキュメントから：

仮パラメータースロットよりも位置引数が多い場合、構文 "* identifier"を使用する仮パラメーターが存在しない限り、TypeError例外が発生します。この場合、その仮パラメーターは、余分な位置引数を含むタプル（または、余分な位置引数がなかった場合は空のタプル）を受け取ります。

キーワード引数が仮パラメーター名に対応していない場合、構文「** identifier」を使用する仮パラメーターが存在しない限り、TypeError例外が発生します。この場合、その仮パラメーターは、過剰なキーワード引数（キーワードとしてキーを使用し、引数値を対応する値として使用）を含むディクショナリー、または過剰なキーワード引数がない場合は（新しい）空のディクショナリーを受け取ります。

* 変数引数をタプルとして受け取ることを意味します

** 変数引数を辞書として受け取ることを意味します

次のように使用します：

1）シングル*

def foo(*args):
    for arg in args:
        print(arg)

foo("two", 3)

出力：

two
3

2）今 **

def bar(**kwargs):
    for key in kwargs:
        print(key, kwargs[key])

bar(dic1="two", dic2=3)

出力：

dic1 two
dic2 3

他の人が言及していない例を挙げたい

* ジェネレーターをアンパックすることもできます

Python3ドキュメントの例

x = [1, 2, 3]
y = [4, 5, 6]

unzip_x, unzip_y = zip(*zip(x, y))

unzip_xは[1、2、3]、unzip_yは[4、5、6]になります。

zip（）は複数のiretable引数を受け取り、ジェネレータを返します。

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))

Pythonの3.5で、あなたもこの構文を使用することができlist、dict、tuple、とset表示されます（また時にはリテラルと呼ばれます）。PEP 488：Additional Unpacking Generalizationsを参照してください。

>>> (0, *range(1, 4), 5, *range(6, 8))
(0, 1, 2, 3, 5, 6, 7)
>>> [0, *range(1, 4), 5, *range(6, 8)]
[0, 1, 2, 3, 5, 6, 7]
>>> {0, *range(1, 4), 5, *range(6, 8)}
{0, 1, 2, 3, 5, 6, 7}
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> e = {'six': 6, 'seven': 7}
>>> {'zero': 0, **d, 'five': 5, **e}
{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}

また、単一の関数呼び出しで複数のイテラブルをアンパックすることもできます。

>>> range(*[1, 10], *[2])
range(1, 10, 2)

（PEPリンクについてmgilsonに感謝します。）

関数呼び出しに加えて、* argsと** kwargsはクラス階層で役立ち__init__、Pythonでメソッドを記述する必要もありません。Djangoコードのようなフレームワークでも同様の使い方が見られます。

例えば、

def __init__(self, *args, **kwargs):
    for attribute_name, value in zip(self._expected_attributes, args):
        setattr(self, attribute_name, value)
        if kwargs.has_key(attribute_name):
            kwargs.pop(attribute_name)

    for attribute_name in kwargs.viewkeys():
        setattr(self, attribute_name, kwargs[attribute_name])

次に、サブクラスは

class RetailItem(Item):
    _expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']

class FoodItem(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['expiry_date']

次に、サブクラスは次のようにインスタンス化されます

food_item = FoodItem(name = 'Jam', 
                     price = 12.0, 
                     category = 'Foods', 
                     country_of_origin = 'US', 
                     expiry_date = datetime.datetime.now())

また、そのサブクラスインスタンスに対してのみ意味を持つ新しい属性を持つサブクラスは、Baseクラス__init__を呼び出して属性設定をオフロードできます。これは* argsと** kwargsを介して行われます。kwargsは主に、名前付き引数を使用してコードを読み取れるように使用されます。例えば、

class ElectronicAccessories(RetailItem):
    _expected_attributes = RetailItem._expected_attributes +  ['specifications']
    # Depend on args and kwargs to populate the data as needed.
    def __init__(self, specifications = None, *args, **kwargs):
        self.specifications = specifications  # Rest of attributes will make sense to parent class.
        super(ElectronicAccessories, self).__init__(*args, **kwargs)

これは次のように初期化できます

usb_key = ElectronicAccessories(name = 'Sandisk', 
                                price = '$6.00', 
                                category = 'Electronics',
                                country_of_origin = 'CN',
                                specifications = '4GB USB 2.0/USB 3.0')

完全なコードはこちら

ニックの答えをもとに ...

def foo(param1, *param2):
    print(param1)
    print(param2)


def bar(param1, **param2):
    print(param1)
    print(param2)


def three_params(param1, *param2, **param3):
    print(param1)
    print(param2)
    print(param3)


foo(1, 2, 3, 4, 5)
print("\n")
bar(1, a=2, b=3)
print("\n")
three_params(1, 2, 3, 4, s=5)

出力：

1
(2, 3, 4, 5)

1
{'a': 2, 'b': 3}

1
(2, 3, 4)
{'s': 5}

基本的に、任意の数の位置引数で * argsを使用でき、任意の名前付き引数（またはkwargs別名キーワード引数）で** kwargsを使用できます。

*argsand **kwargs：可変数の引数を関数に渡すことができます。

*args：キーワードなしの可変長引数リストを関数に送信するために使用されます。

def args(normal_arg, *argv):
    print("normal argument:", normal_arg)

    for arg in argv:
        print("Argument in list of arguments from *argv:", arg)

args('animals', 'fish', 'duck', 'bird')

生成されます：

normal argument: animals
Argument in list of arguments from *argv: fish
Argument in list of arguments from *argv: duck
Argument in list of arguments from *argv: bird

**kwargs*

**kwargsキーワード付きの可変長の引数を関数に渡すことができます。**kwargs関数で名前付き引数を処理する場合に使用する必要があります。

def who(**kwargs):
    if kwargs is not None:
        for key, value in kwargs.items():
            print("Your %s is %s." % (key, value))

who(name="Nikola", last_name="Tesla", birthday="7.10.1856", birthplace="Croatia")  

生成されます：

Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.

この例では、あなたが覚えて役立つだろう*args、**kwargsとさえsuper一度にPythonで、継承。

class base(object):
    def __init__(self, base_param):
        self.base_param = base_param


class child1(base): # inherited from base class
    def __init__(self, child_param, *args) # *args for non-keyword args
        self.child_param = child_param
        super(child1, self).__init__(*args) # call __init__ of the base class and initialize it with a NON-KEYWORD arg

class child2(base):
    def __init__(self, child_param, **kwargs):
        self.child_param = child_param
        super(child2, self).__init__(**kwargs) # call __init__ of the base class and initialize it with a KEYWORD arg

c1 = child1(1,0)
c2 = child2(1,base_param=0)
print c1.base_param # 0
print c1.child_param # 1
print c2.base_param # 0
print c2.child_param # 1

関数で両方を使用する良い例は次のとおりです。

>>> def foo(*arg,**kwargs):
...     print arg
...     print kwargs
>>>
>>> a = (1, 2, 3)
>>> b = {'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(*a,**b)
(1, 2, 3)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,**b) 
((1, 2, 3),)
{'aa': 11, 'bb': 22}
>>>
>>>
>>> foo(a,b) 
((1, 2, 3), {'aa': 11, 'bb': 22})
{}
>>>
>>>
>>> foo(a,*b)
((1, 2, 3), 'aa', 'bb')
{}

TL; DR

下記のための6つのユースケースである*と**Pythonプログラミングでは：

1. *args：を使用して任意の数の位置引数を 受け入れるにはdef foo(*args): pass、ここでfoo任意の数の位置引数を受け入れます。つまり、次の呼び出しは有効ですfoo(1)。foo(1, 'bar')
2. を使用して任意の数のキーワード引数を受け入れるには **kwargs： def foo(**kwargs): pass受け入れるには、ここで 'foo'は任意の数のキーワード引数を受け入れます。つまり、次の呼び出しは有効ですfoo(name='Tom')。foo(name='Tom', age=33)
3. を使用して任意の数の位置引数とキーワード引数を受け入れるには*args, **kwargs： def foo(*args, **kwargs): passfoo受け入れるには、ここで任意の数の位置受け入れます。つまり、次の呼び出しは有効ですfoo(1,name='Tom')。foo(1, 'bar', name='Tom', age=33)
4. を使用してキーワードのみの引数を強制するには*： def foo(pos1, pos2, *, kwarg1): pass*するには、ここではfooがpos2の後でキーワード引数のみを受け入れるためfoo(1, 2, 3)、TypeErrorが発生しますが、問題ありませんfoo(1, 2, kwarg1=3)。
5. *_（注：これは規則にすぎません）を使用して、これ以上の位置引数に関心を示さないようにするには： def foo(bar, baz, *_): pass意味し規則により）動作中の引数と引数fooのみを使用しbar、baz他のものは無視します。
6. \**_（注：これは規則のみです）を使用して、キーワード引数にこれ以上関心がないことを表すには、 def foo(bar, baz, **_): pass（規則により）fooのみを使用しますbarbaz動作中の引数と引数、他のものは無視します。

ボーナス： python 3.8以降では/、関数定義で使用して位置のみのパラメーターを強制できます。次の例では、パラメーターaとbは位置のみですが、cまたはdは位置またはキーワードで、eまたはfはキーワードである必要があります。

def f(a, b, /, c, d, *, e, f):
    pass

TL; DR

これは、関数に渡された引数を関数本体の内部listとdict内部にそれぞれパックします。次のような関数シグネチャを定義すると、

def func(*args, **kwds):
    # do stuff

任意の数の引数とキーワード引数で呼び出すことができます。非キーワード引数argsは関数本体の内部で呼び出されるリストにパックされ、キーワード引数kwdsは関数本体の内部で呼び出されるdictにパックされます。

func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])

関数本体の内部で、関数が呼び出されると、2つのローカル変数がargsあります。これは、値["this", "is a list of", "non-keyword", "arguments"]を持つリストkwdsであり、dictた値は、{"keyword" : "ligma", "options" : [1,2,3]}

これも逆に、つまり呼び出し側から機能します。たとえば、次のように定義された関数があるとします。

def f(a, b, c, d=1, e=10):
    # do stuff

呼び出しスコープ内にあるイテラブルまたはマッピングをアンパックすることで、それを呼び出すことができます。

iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)

環境

• python 3.x
• 開梱 **
• 文字列フォーマットで使用する

文字列フォーマットで使用

このスレッドでの回答に加えて、他の場所で言及されていない別の詳細があります。これは、ブラッド・ソロモンの答えを

開梱**のpythonを使用する場合にも便利ですstr.format。

これはpython f-stringでできることと多少似ていますf-strings 、変数を保持するためにdictを宣言するオーバーヘッドが追加されています（f-stringはdictを必要としません）。

簡単な例

  ## init vars
  ddvars = dict()
  ddcalc = dict()
  pass
  ddvars['fname']     = 'Huomer'
  ddvars['lname']     = 'Huimpson'
  ddvars['motto']     = 'I love donuts!'
  ddvars['age']       = 33
  pass
  ddcalc['ydiff']     = 5
  ddcalc['ycalc']     = ddvars['age'] + ddcalc['ydiff']
  pass
  vdemo = []

  ## ********************
  ## single unpack supported in py 2.7
  vdemo.append('''
  Hello {fname} {lname}!

  Today you are {age} years old!

  We love your motto "{motto}" and we agree with you!
  '''.format(**ddvars)) 
  pass

  ## ********************
  ## multiple unpack supported in py 3.x
  vdemo.append('''
  Hello {fname} {lname}!

  In {ydiff} years you will be {ycalc} years old!
  '''.format(**ddvars,**ddcalc)) 
  pass

  ## ********************
  print(vdemo[-1])

• def foo(param1, *param2):は、メソッドの任意の数の値を受け入れることができるメソッドです*param2。
• def bar(param1, **param2): メソッドは、キーを持つ任意の数の値を受け入れることができます *param2
• param1 単純なパラメータです。

たとえば、Javaで可変引数を実装するための構文は次のとおりです。

accessModifier methodName(datatype… arg) {
    // method body
}