Saya ingin menunjukkan fungsi yang tidak melakukan apa-apa:

def identity(*args)
    return args

kasus penggunaan saya adalah sesuatu seperti ini

try:
    gettext.find(...)
    ...
    _ = gettext.gettext
else:
    _ = identity

Tentu saja, saya bisa menggunakan yang identitydidefinisikan di atas, tetapi built-in pasti akan berjalan lebih cepat (dan menghindari bug yang diperkenalkan oleh saya sendiri).

Tampaknya, mapdan filterdigunakan Noneuntuk identitas, tetapi ini khusus untuk implementasi mereka.

>>> _=None
>>> _("hello")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable

Melakukan penelitian lebih lanjut, tidak ada, fitur ditanya dalam edisi 1673203 Dan dari Raymond Hettinger mengatakan tidak akan ada :

Lebih baik membiarkan orang menulis pass-through sepele mereka sendiri dan berpikir tentang tanda tangan dan biaya waktu.

Jadi cara yang lebih baik untuk melakukannya sebenarnya adalah (lambda menghindari penamaan fungsi):

_ = lambda *args: args

• Keuntungan: mengambil sejumlah parameter
• Kerugian: hasilnya adalah versi kotak parameter

ATAU

_ = lambda x: x

• Keuntungan: tidak mengubah jenis parameter
• Kerugian: mengambil tepat 1 parameter posisi

Fungsi identitas, sebagaimana didefinisikan dalam https://en.wikipedia.org/wiki/Identity_function , mengambil satu argumen dan mengembalikannya tidak berubah:

def identity(x):
    return x

Apa yang Anda minta ketika Anda mengatakan Anda ingin tanda tangan def identity(*args)itu bukan semata-mata fungsi identitas, karena Anda ingin mengambil beberapa argumen. Itu bagus, tapi kemudian Anda menemukan masalah karena fungsi Python tidak mengembalikan banyak hasil, jadi Anda harus menemukan cara untuk menjejalkan semua argumen itu menjadi satu nilai balik.

Cara biasa mengembalikan "nilai ganda" dengan Python adalah dengan mengembalikan tupel nilai - secara teknis itu adalah satu nilai balik tetapi dapat digunakan dalam sebagian besar konteks seolah-olah nilai ganda. Tetapi melakukan itu di sini berarti Anda mendapatkannya

>>> def mv_identity(*args):
...     return args
...
>>> mv_identity(1,2,3)
(1, 2, 3)
>>> # So far, so good. But what happens now with single arguments?
>>> mv_identity(1)
(1,)

Dan memperbaiki yang masalah cepat memberikan isu-isu lain, seperti berbagai jawaban di sini telah menunjukkan.

Jadi, secara ringkas, tidak ada fungsi identitas yang didefinisikan dalam Python karena:

1. Definisi formal (fungsi argumen tunggal) tidak begitu berguna, dan sepele untuk ditulis.
2. Memperluas definisi ke beberapa argumen tidak secara umum didefinisikan dengan baik, dan Anda jauh lebih baik mendefinisikan versi Anda sendiri yang berfungsi seperti yang Anda inginkan untuk situasi khusus Anda.

Untuk kasus Anda yang tepat,

def dummy_gettext(message):
    return message

hampir pasti apa yang Anda inginkan - fungsi yang memiliki konvensi pemanggilan dan pengembalian yang sama dengan gettext.gettext, yang mengembalikan argumennya tidak berubah, dan secara jelas dinamai untuk menggambarkan apa yang dilakukannya dan di mana ia dimaksudkan untuk digunakan. Saya akan sangat terkejut jika kinerja menjadi pertimbangan penting di sini.

milikmu akan bekerja dengan baik. Ketika jumlah parameter diperbaiki, Anda dapat menggunakan fungsi anonim seperti ini:

lambda x: x

Tidak ada fungsi identitas bawaan di Python. Tiruan dari Haskell idfungsi akan menjadi:

identity = lambda x, *args: (x,) + args if args else x

Contoh penggunaan:

identity(1)
1
identity(1,2)
(1, 2)

Karena identitytidak melakukan apa pun kecuali mengembalikan argumen yang diberikan, saya tidak berpikir bahwa itu lebih lambat daripada implementasi asli.

Tidak, tidak ada.

Perhatikan bahwa Anda identity:

1. setara dengan lambda * args: args

2. Akan kotak argumennya - yaitu

   In [6]: id = lambda *args: args
   
   In [7]: id(3)
   Out[7]: (3,)

Jadi, Anda mungkin ingin menggunakan lambda arg: argjika Anda ingin fungsi identitas yang sebenarnya.

NB: Contoh ini akan membayangi idfungsi bawaan (yang mungkin tidak akan Anda gunakan).

Jika kecepatan tidak masalah, ini harus menangani semua kasus:

def identity(*args, **kwargs):
    if not args:
        if not kwargs:
            return None
        elif len(kwargs) == 1:
            return  next(iter(kwargs.values()))
        else:
            return (*kwargs.values(),)
    elif not kwargs:
        if len(args) == 1:
            return args[0]
        else:
            return args
    else:
        return (*args, *kwargs.values())

Contoh penggunaan:

print(identity())
None
$identity(1)
1
$ identity(1, 2)
(1, 2)
$ identity(1, b=2)
(1, 2)
$ identity(a=1, b=2)
(1, 2)
$ identity(1, 2, c=3)
(1, 2, 3)

Rintisan fungsi argumen tunggal

gettext.gettext(contoh penggunaan OP kasus) menerima satu argumen message,. Jika seseorang membutuhkan sebuah rintisan untuk itu, tidak ada alasan untuk kembali [message]daripada message( def identity(*args): return args). Demikian keduanya

_ = lambda message: message

def _(message):
    return message

pas sekali.

... tapi built-in pasti akan berjalan lebih cepat (dan menghindari bug yang diperkenalkan oleh saya sendiri).

Bug dalam kasus sepele seperti itu hampir tidak relevan. Untuk argumen tipe standar, katakanlah str, kita dapat menggunakan str()dirinya sebagai fungsi identitas (karena string yang menggunakannya bahkan mempertahankan identitas objek, lihat idcatatan di bawah) dan membandingkan kinerjanya dengan solusi lambda:

$ python3 -m timeit -s "f = lambda m: m" "f('foo')"
10000000 loops, best of 3: 0.0852 usec per loop
$ python3 -m timeit "str('foo')"
10000000 loops, best of 3: 0.107 usec per loop

Optimalisasi mikro dimungkinkan. Misalnya, kode Cython berikut :

test.pyx

cpdef str f(str message):
    return message

Kemudian:

$ pip install runcython3
$ makecython3 test.pyx
$ python3 -m timeit -s "from test import f" "f('foo')"
10000000 loops, best of 3: 0.0317 usec per loop

Fungsi identitas objek bawaan

Jangan bingung fungsi identitas dengan idfungsi bawaan yang mengembalikan 'identitas' suatu objek (yang berarti pengidentifikasi unik untuk objek tertentu daripada nilai objek itu, dibandingkan dengan ==operator), alamat memorinya dalam CPython.

Utasnya cukup lama. Tapi tetap ingin memposting ini.

Dimungkinkan untuk membangun metode identitas untuk argumen dan objek. Dalam contoh di bawah ini, ObjOut adalah identitas untuk ObjIn. Semua contoh lain di atas belum membahas dikt ** kwargs.

class test(object):
    def __init__(self,*args,**kwargs):
        self.args = args
        self.kwargs = kwargs
    def identity (self):
        return self

objIn=test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n')
objOut=objIn.identity()
print('args=',objOut.args,'kwargs=',objOut.kwargs)

#If you want just the arguments to be printed...
print(test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n').identity().args)
print(test('arg-1','arg-2','arg-3','arg-n',key1=1,key2=2,key3=3,keyn='n').identity().kwargs)

$ py test.py
args= ('arg-1', 'arg-2', 'arg-3', 'arg-n') kwargs= {'key1': 1, 'keyn': 'n', 'key2': 2, 'key3': 3}
('arg-1', 'arg-2', 'arg-3', 'arg-n')
{'key1': 1, 'keyn': 'n', 'key2': 2, 'key3': 3}