วิธีที่เป็นที่ยอมรับในการส่งคืนค่าหลายค่าในภาษาที่สนับสนุนมักจะส่งเสียงซ้ำ

ตัวเลือก: การใช้ tuple

ลองพิจารณาตัวอย่างเล็ก ๆ น้อย ๆ นี้:

def f(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return (y0, y1, y2)

อย่างไรก็ตามสิ่งนี้จะได้รับปัญหาอย่างรวดเร็วเนื่องจากจำนวนของค่าที่ส่งคืนเพิ่มขึ้น ถ้าคุณต้องการคืนค่าสี่หรือห้าค่า แน่นอนว่าคุณสามารถติดตามพวกเขาได้ แต่มันก็ง่ายที่จะลืมคุณค่าที่เป็นอยู่ นอกจากนี้ยังค่อนข้างน่าเกลียดที่จะแกะกล่องพวกเขาทุกที่ที่คุณต้องการรับ

ตัวเลือก: การใช้พจนานุกรม

ขั้นตอนตรรกะถัดไปน่าจะเป็นการแนะนำ 'สัญกรณ์บันทึก' บางประเภท dictในหลามวิธีที่ชัดเจนที่จะทำเช่นนี้คือโดยวิธีการของ

พิจารณาสิ่งต่อไปนี้:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0': y0, 'y1': y1 ,'y2': y2}

(เพื่อให้ชัดเจน, y0, y1 และ y2 นั้นมีความหมายเป็นตัวบ่งชี้เชิงนามธรรมอย่างที่ทราบแล้วในทางปฏิบัติคุณจะต้องใช้ตัวระบุที่มีความหมาย)

ตอนนี้เรามีกลไกที่เราสามารถฉายสมาชิกเฉพาะของวัตถุที่ส่งคืน ตัวอย่างเช่น,

result['y0']

ตัวเลือก: การใช้คลาส

อย่างไรก็ตามมีตัวเลือกอื่น เราสามารถส่งคืนโครงสร้างพิเศษแทน ฉันใส่กรอบนี้ในบริบทของ Python แต่ฉันแน่ใจว่ามันใช้ได้กับภาษาอื่นเช่นกัน แน่นอนถ้าคุณทำงานใน C นี่อาจเป็นทางเลือกเดียวของคุณ ไปที่นี่:

class ReturnValue:
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return ReturnValue(y0, y1, y2)

ในหลามก่อนหน้านี้สองอาจจะคล้ายกันมากในแง่ของการประปา - หลังจากทั้งหมด{ y0, y1, y2 }เพียงแค่จบลงด้วยการรายการในภายในของ__dict__ReturnValue

มีหนึ่งคุณสมบัติเพิ่มเติมที่จัดทำโดย Python แต่สำหรับวัตถุขนาดเล็ก__slots__คุณลักษณะ ชั้นสามารถแสดงเป็น:

class ReturnValue(object):
  __slots__ = ["y0", "y1", "y2"]
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

จากคู่มืออ้างอิง Python :

การ__slots__ประกาศใช้ลำดับของตัวแปรอินสแตนซ์และสำรองพื้นที่เพียงพอในแต่ละอินสแตนซ์เพื่อเก็บค่าสำหรับแต่ละตัวแปร ประหยัดพื้นที่เนื่องจาก__dict__ไม่ได้สร้างสำหรับแต่ละอินสแตนซ์

ตัวเลือก: การใช้ดาต้าคลาส (Python 3.7+)

การใช้ดาต้าคลาสใหม่ของ Python 3.7 ให้ส่งคืนคลาสด้วยวิธีพิเศษการพิมพ์และเครื่องมือที่มีประโยชน์อื่น ๆ โดยอัตโนมัติ:

@dataclass
class Returnvalue:
    y0: int
    y1: float
    y3: int

def total_cost(x):
    y0 = x + 1
    y1 = x * 3
    y2 = y0 ** y3
    return ReturnValue(y0, y1, y2)

ตัวเลือก: การใช้รายการ

ข้อเสนอแนะอีกข้อที่ฉันมองข้ามมาจาก Bill the Lizard:

def h(x):
  result = [x + 1]
  result.append(x * 3)
  result.append(y0 ** y3)
  return result

นี่เป็นวิธีที่ฉันชอบน้อยที่สุด ฉันคิดว่าฉันเสียเปรียบจากการสัมผัสกับ Haskell แต่ความคิดของรายการประเภทผสมมักจะรู้สึกไม่สบายสำหรับฉัน ในตัวอย่างนี้ลิสต์เป็นแบบไม่ผสม แต่อาจเป็นไปได้

รายการที่ใช้ในวิธีนี้จริง ๆ แล้วไม่ได้อะไรเลยเกี่ยวกับ tuple เท่าที่ฉันสามารถบอกได้ ความแตกต่างที่แท้จริงระหว่างรายการและสิ่งอันดับใน Python คือรายการนั้นไม่แน่นอนในขณะที่สิ่งอันดับจะไม่

ฉันมักจะดำเนินการตามอนุสัญญาจากการเขียนโปรแกรมการทำงาน: ใช้รายการสำหรับองค์ประกอบจำนวนใด ๆ ของประเภทเดียวกันและ tuples สำหรับองค์ประกอบจำนวนคงที่ของประเภทที่กำหนดไว้ล่วงหน้า

คำถาม

หลังจากการเริ่มนำที่มีความยาวมาเป็นคำถามที่หลีกเลี่ยงไม่ได้ วิธีใดที่คุณคิดว่าดีที่สุด?

tuples ที่มีชื่อถูกเพิ่มใน 2.6 เพื่อจุดประสงค์นี้ ดูos.statสำหรับตัวอย่าง builtin ที่คล้ายกัน

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

ในเวอร์ชันล่าสุดของ Python 3 (3.6+ ฉันคิดว่า) typingห้องสมุดใหม่มีNamedTupleคลาสเพื่อให้การสร้างชื่อ tuples ง่ายขึ้นและมีประสิทธิภาพยิ่งขึ้น การรับช่วงจากtyping.NamedTupleช่วยให้คุณใช้เอกสารประกอบ, ค่าเริ่มต้นและคำอธิบายประกอบประเภท

ตัวอย่าง (จากเอกสาร):

class Employee(NamedTuple):  # inherit from typing.NamedTuple
    name: str
    id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

สำหรับโครงการขนาดเล็กฉันพบว่าการทำงานกับ tuples ง่ายที่สุด เมื่อมันยากเกินกว่าที่จะจัดการ (และไม่ใช่ก่อนหน้านี้) ฉันเริ่มจัดกลุ่มสิ่งต่าง ๆ ลงในโครงสร้างเชิงตรรกะ แต่ฉันคิดว่าการใช้พจนานุกรมและReturnValueวัตถุที่คุณแนะนำนั้นผิด (หรือง่ายเกินไป)

กลับพจนานุกรมด้วยปุ่ม"y0", "y1", "y2"และอื่น ๆ ไม่ได้มีประโยชน์ใด ๆ ในช่วง tuples กลับReturnValueอินสแตนซ์ที่มีคุณสมบัติ.y0, .y1, .y2ฯลฯ ไม่ได้ให้ประโยชน์ใด ๆ ในช่วง tuples อย่างใดอย่างหนึ่ง คุณต้องเริ่มตั้งชื่อสิ่งต่าง ๆ ถ้าคุณต้องการไปไหนมาไหนและคุณสามารถทำได้โดยใช้สิ่งอันดับ:

def get_image_data(filename):
    [snip]
    return size, (format, version, compression), (width,height)

size, type, dimensions = get_image_data(x)

IMHO เทคนิคที่ดีเท่านั้นเกิน tuples คือการกลับวัตถุจริงด้วยวิธีการที่เหมาะสมและคุณสมบัติเช่นคุณได้รับจากหรือre.match()open(file)

คำตอบจำนวนมากแนะนำให้คุณต้องส่งคืนคอลเลกชันบางประเภทเช่นพจนานุกรมหรือรายการ คุณสามารถละทิ้งไวยากรณ์เพิ่มเติมและเพียงแค่เขียนค่าส่งคืนคั่นด้วยเครื่องหมายจุลภาค หมายเหตุ: เทคนิคนี้ส่งคืน tuple

def f():
    return True, False
x, y = f()
print(x)
print(y)

ให้:

True
False

ฉันลงคะแนนให้พจนานุกรม

ฉันพบว่าถ้าฉันสร้างฟังก์ชั่นที่คืนค่าอะไรมากกว่า 2-3 ตัวแปรฉันจะพับมันในพจนานุกรม มิฉะนั้นฉันมักจะลืมคำสั่งซื้อและเนื้อหาของสิ่งที่ฉันกลับมา

นอกจากนี้การแนะนำโครงสร้าง 'พิเศษ' จะทำให้โค้ดของคุณติดตามยากขึ้น (คนอื่นจะต้องค้นหารหัสเพื่อค้นหาว่ามันคืออะไร)

หากคุณกังวลเกี่ยวกับประเภทการค้นหาให้ใช้คีย์พจนานุกรมอธิบายเช่น 'รายการค่า x'

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

ตัวเลือกอื่นจะใช้กำเนิด:

>>> def f(x):
        y0 = x + 1
        yield y0
        yield x * 3
        yield y0 ** 4


>>> a, b, c = f(5)
>>> a
6
>>> b
15
>>> c
1296

แม้ว่า IMHO tuples มักจะดีที่สุดยกเว้นในกรณีที่ค่าที่ส่งคืนเป็นตัวเลือกสำหรับการห่อหุ้มในคลาส

ฉันชอบที่จะใช้สิ่งอันดับเมื่อใดก็ตามที่สิ่งอันดับความรู้สึก "ธรรมชาติ"; พิกัดเป็นตัวอย่างทั่วไปที่วัตถุแยกต่างหากสามารถยืนได้ด้วยตนเองเช่นในการคำนวณการปรับขนาดแบบแกนเดียวเท่านั้นและลำดับนั้นมีความสำคัญ หมายเหตุ: ถ้าฉันสามารถเรียงลำดับหรือสับเปลี่ยนรายการโดยไม่มีผลกระทบต่อความหมายของกลุ่มฉันก็อาจไม่ควรใช้สิ่งอันดับ

ฉันใช้พจนานุกรมเป็นค่าตอบแทนเฉพาะเมื่อวัตถุที่จัดกลุ่มไม่เหมือนกันเสมอไป คิดว่าส่วนหัวอีเมลที่เป็นตัวเลือก

สำหรับส่วนที่เหลือของกรณีที่วัตถุที่จัดกลุ่มมีความหมายโดยธรรมชาติภายในกลุ่มหรือวัตถุที่เต็มเปี่ยมด้วยวิธีการของตัวเองเป็นสิ่งที่จำเป็นฉันใช้ชั้นเรียน

ฉันชอบ:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

ดูเหมือนว่าทุกอย่างเป็นเพียงรหัสเสริมเพื่อทำสิ่งเดียวกัน

>>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3

โดยทั่วไป "โครงสร้างพิเศษ" ที่จริงแล้วเป็นสถานะปัจจุบันที่เหมาะสมของวัตถุด้วยวิธีการของตัวเอง

class Some3SpaceThing(object):
  def __init__(self,x):
    self.g(x)
  def g(self,x):
    self.y0 = x + 1
    self.y1 = x * 3
    self.y2 = y0 ** y3

r = Some3SpaceThing( x )
r.y0
r.y1
r.y2

ฉันชอบที่จะหาชื่อสำหรับโครงสร้างที่ไม่ระบุชื่อที่เป็นไปได้ ชื่อที่มีความหมายทำให้สิ่งต่าง ๆ ชัดเจนยิ่งขึ้น

Tuples, dicts, และวัตถุของ Python ช่วยให้โปรแกรมเมอร์ทำการแลกเปลี่ยนอย่างราบรื่นระหว่างพิธีการและความสะดวกสบายสำหรับโครงสร้างข้อมูลขนาดเล็ก ("สิ่งของ") สำหรับฉันการเลือกวิธีที่จะเป็นตัวแทนของสิ่งนั้นส่วนใหญ่จะกำหนดโดยวิธีที่ฉันจะใช้โครงสร้าง ใน C ++ เป็นวิธีการทั่วไปที่ใช้structสำหรับไอเท็มข้อมูลอย่างเดียวและclassสำหรับออบเจ็กต์ที่มีเมธอดถึงแม้ว่าคุณจะสามารถวางเมธอดบน a struct; นิสัยของฉันคือที่คล้ายกันในหลามด้วยdictและในสถานที่ของtuplestruct

สำหรับชุดพิกัดฉันจะใช้จุดtupleมากกว่าclassหรือ a dict(และโปรดทราบว่าคุณสามารถใช้ a tupleเป็นคีย์พจนานุกรมดังนั้นdictสร้างอาร์เรย์หลายมิติที่กระจัดกระจาย)

ถ้าฉันจะทำซ้ำในรายการของสิ่งต่าง ๆ ฉันชอบที่จะเอาออกtupleในการทำซ้ำ:

for score,id,name in scoreAllTheThings():
    if score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(score,id,name)

... เนื่องจากเวอร์ชันของวัตถุอ่านรกรุงรังมากขึ้น:

for entry in scoreAllTheThings():
    if entry.score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry.score,entry.id,entry.name)

... dictให้อยู่คนเดียว

for entry in scoreAllTheThings():
    if entry['score'] > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry['score'],entry['id'],entry['name'])

หากสิ่งนี้มีการใช้กันอย่างแพร่หลายและคุณพบว่าตัวเองกำลังทำสิ่งที่คล้าย ๆ กันในหลาย ๆ ที่ในรหัสก็มักจะคุ้มค่าที่จะทำให้มันเป็นคลาสวัตถุด้วยวิธีการที่เหมาะสม

ท้ายที่สุดถ้าฉันจะแลกเปลี่ยนข้อมูลกับส่วนประกอบของระบบที่ไม่ใช่งูใหญ่ฉันจะเก็บไว้ในdictเพราะส่วนใหญ่เหมาะกับอนุกรม JSON

+1 ตามคำแนะนำของ S.Lott เกี่ยวกับคลาสคอนเทนเนอร์ที่ระบุชื่อ

สำหรับ Python 2.6 ขึ้นไปtuple ที่มีชื่อจะให้วิธีที่มีประโยชน์ในการสร้างคลาสคอนเทนเนอร์เหล่านี้ได้อย่างง่ายดายและผลลัพธ์นั้น "เบาและไม่ต้องใช้หน่วยความจำมากกว่า tuples ปกติ"

ในภาษาอย่าง Python ฉันมักจะใช้พจนานุกรมเนื่องจากมีค่าใช้จ่ายน้อยกว่าการสร้างคลาสใหม่

อย่างไรก็ตามหากฉันพบว่าตัวเองคืนค่าตัวแปรชุดเดิมอย่างต่อเนื่องนั่นอาจเกี่ยวข้องกับคลาสใหม่ที่ฉันจะแยกตัวออก

ฉันจะใช้ dict เพื่อส่งผ่านและคืนค่าจากฟังก์ชัน:

ใช้แบบฟอร์มตัวแปรที่กำหนดไว้ในแบบฟอร์ม

form = {
    'level': 0,
    'points': 0,
    'game': {
        'name': ''
    }
}


def test(form):
    form['game']['name'] = 'My game!'
    form['level'] = 2

    return form

>>> print(test(form))
{u'game': {u'name': u'My game!'}, u'points': 0, u'level': 2}

นี่เป็นวิธีที่มีประสิทธิภาพที่สุดสำหรับฉันและหน่วยการประมวลผล

คุณต้องผ่านตัวชี้เพียงตัวเดียวและส่งกลับตัวชี้เพียงตัวเดียว

คุณไม่จำเป็นต้องเปลี่ยนฟังก์ชั่น '(พันของพวกเขา) ขัดแย้งเมื่อใดก็ตามที่คุณทำการเปลี่ยนแปลงในรหัสของคุณ

"ดีที่สุด" เป็นการตัดสินใจแบบอัตนัยบางส่วน ใช้สิ่งอันดับสำหรับชุดผลตอบแทนขนาดเล็กในกรณีทั่วไปที่ยอมรับได้ไม่เปลี่ยนรูป tuple นั้นนิยมใช้ในรายการเสมอเมื่อความไม่แน่นอนนั้นไม่จำเป็นต้องมี

สำหรับค่าส่งคืนที่ซับซ้อนมากขึ้นหรือสำหรับกรณีที่เป็นทางการมีค่า (เช่นรหัสมูลค่าสูง) ชื่อ tuple จะดีกว่า สำหรับกรณีที่ซับซ้อนที่สุดวัตถุมักจะดีที่สุด อย่างไรก็ตามมันเป็นสถานการณ์ที่สำคัญจริงๆ ถ้ามันสมเหตุสมผลที่จะคืนค่าวัตถุเพราะนั่นคือสิ่งที่คุณมีในตอนท้ายของฟังก์ชั่น (เช่นรูปแบบโรงงาน) จากนั้นส่งคืนวัตถุ

ในฐานะที่เป็นคนฉลาดกล่าวว่า:

การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากของความชั่วร้ายทั้งหมด (หรืออย่างน้อยที่สุดของมัน) ในการเขียนโปรแกรม