วิธีที่สวยงามกว่าในการประกาศตัวแปรหลายตัวในเวลาเดียวกัน

หากต้องการประกาศหลายตัวแปรใน "เวลาเดียวกัน" ฉันจะทำ:

a, b = True, False

แต่ถ้าฉันต้องประกาศตัวแปรมากขึ้นมันจะเปลี่ยนไปน้อยลงและสง่างามน้อยลง:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True

มีวิธีที่ดีกว่า / หรูหรา / สะดวกในการทำเช่นนี้?

สิ่งนี้จะต้องเป็นพื้นฐาน แต่ถ้าฉันใช้รายการหรือทูเปิลสำหรับเก็บตัวแปรฉันจะต้องเข้าหาอย่างไรเพื่อที่ฉันจะได้มีประโยชน์ตั้งแต่:

aList = [a,b]

ไม่ถูกต้องฉันจะต้องทำ:

a, b = True, True

หรือฉันจะพลาดอะไร

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

คุณอาจต้องใช้พจนานุกรมแทนทั้งนี้ขึ้นอยู่กับสิ่งที่คุณทำ ตัวอย่างเช่นถ้าคุณต้องการตั้งค่าที่ตั้งไว้ล่วงหน้าบูลีนสำหรับชุดของธงหนึ่งตัวอักษรคุณสามารถทำได้:

>>> flags = dict.fromkeys(["a", "b", "c"], True)
>>> flags.update(dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

หากคุณต้องการคุณสามารถทำได้ด้วยคำสั่งการมอบหมายงานเดียว:

>>> flags = dict(dict.fromkeys(["a", "b", "c"], True),
...              **dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

พารามิเตอร์ที่สองจะไม่ได้ถูกออกแบบอย่างสิ้นเชิงสำหรับนี้มันมีความหมายมากที่จะช่วยให้คุณสามารถแทนที่แต่ละองค์ประกอบของพจนานุกรมใช้อาร์กิวเมนต์คำหลักเช่นdict d=Falseโค้ดด้านบนทำให้เกิดผลลัพธ์ของนิพจน์ที่ตาม**มาในชุดอาร์กิวเมนต์ของคำหลักที่ส่งไปยังฟังก์ชันที่เรียกว่า นี่เป็นวิธีที่เชื่อถือได้ในการสร้างพจนานุกรมและผู้คนดูเหมือนจะยอมรับสำนวนนี้อย่างน้อยที่สุด แต่ฉันคิดว่าบางคนอาจคิดว่ามันเป็นเสียงไพเราะ </disclaimer>

อีกวิธีหนึ่งซึ่งน่าจะใช้งานได้ง่ายที่สุดหากคุณจะใช้รูปแบบนี้บ่อยครั้งคือการกำหนดข้อมูลของคุณเป็นรายการค่าธง ( True, False) ที่แมปกับชื่อธง (สตริงอักขระเดี่ยว) จากนั้นคุณแปลงนิยามข้อมูลนี้เป็นพจนานุกรมกลับด้านซึ่งแมปชื่อค่าสถานะกับค่าสถานะ สิ่งนี้สามารถทำได้ค่อนข้างรัดกุมพร้อมกับความเข้าใจในรายการแบบซ้อน แต่นี่เป็นการใช้งานที่อ่านง่ายมาก:

>>> def invert_dict(inverted_dict):
...     elements = inverted_dict.iteritems()
...     for flag_value, flag_names in elements:
...         for flag_name in flag_names:
...             yield flag_name, flag_value
... 
>>> flags = {True: ["a", "b", "c"], False: ["d", "e"]}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

ฟังก์ชั่นinvert_dictเป็นฟังก์ชั่นเครื่องกำเนิดไฟฟ้า มันสร้างหรือผลตอบแทน - หมายความว่ามันส่งกลับค่าของ - คู่ค่าคีย์ คู่คีย์ - ค่าเหล่านั้นเป็นสิ่งที่ตรงกันข้ามของเนื้อหาของสององค์ประกอบของflagsพจนานุกรมเริ่มต้น พวกมันจะถูกป้อนเข้าสู่ตัวdictสร้าง ในกรณีนี้ตัวdictสร้างทำงานแตกต่างจากด้านบนเพราะมันถูกป้อนตัววนซ้ำมากกว่าพจนานุกรมเป็นอาร์กิวเมนต์

การเขียนความคิดเห็นของ @Chris Lutz: หากคุณจะใช้สิ่งนี้กับค่าอักขระเดี่ยวคุณสามารถทำได้จริง ๆ

>>> flags = {True: 'abc', False: 'de'}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

วิธีนี้ใช้งานได้เพราะสตริง Python สามารถทำซ้ำได้ซึ่งหมายความว่าพวกมันสามารถเคลื่อนย้ายผ่านค่าตามมูลค่า ในกรณีของสตริงค่าเป็นอักขระแต่ละตัวในสตริง ดังนั้นเมื่อพวกเขาถูกตีความว่าเป็น iterables เช่นในกรณีที่พวกเขากำลังถูกนำมาใช้ในการสำหรับวง['a', 'b', 'c']และ'abc'จะเทียบเท่าได้อย่างมีประสิทธิภาพ อีกตัวอย่างหนึ่งคือเมื่อพวกมันถูกส่งผ่านไปยังฟังก์ชั่นที่ทำซ้ำได้เช่นtupleเช่น

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

การกำหนดฟังก์ชั่นinvert_dictเพื่อให้มันส่งคืนพจนานุกรมจริง ๆ ก็ไม่ได้เป็นความคิดที่ไม่ดีเช่นกัน ฉันส่วนใหญ่ก็ไม่ได้ทำเช่นนั้นเพราะมันไม่ได้ช่วยอธิบายวิธีการทำงานประจำ

เห็นได้ชัดว่า Python 2.7 มีความเข้าใจในพจนานุกรมซึ่งจะทำให้เกิดความรัดกุมอย่างยิ่งในการใช้ฟังก์ชันนั้น นี่เป็นแบบฝึกหัดสำหรับผู้อ่านเนื่องจากฉันไม่ได้ติดตั้ง Python 2.7 :)

คุณยังสามารถรวมฟังก์ชั่นบางอย่างจากโมดูลitertoolsอเนกประสงค์ได้ พวกเขากล่าวว่ามีมากกว่าหนึ่งวิธีที่จะทำมัน เดี๋ยวก่อนคน Python ไม่ได้พูดอย่างนั้น ในบางกรณีมันก็เป็นความจริงอยู่ดี ฉันเดาว่ากุยโดให้ความเข้าใจในพจนานุกรมกับเราเพื่อที่จะมีวิธีหนึ่งที่ชัดเจนในการทำเช่นนี้

a, b, c, d, e, g, h, i, j = (True,)*9
f = False

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

a = b = c = d = e = g = h = i = j = True
f = False

นี่เป็นการอธิบายอย่างละเอียดของ @ Jeff Mและความคิดเห็นของฉัน

เมื่อคุณทำสิ่งนี้:

a, b = c, d

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

_ = c, d
a, b = _

บรรทัดแรกสร้าง tuple ที่เรียกว่า_ซึ่งมีสององค์ประกอบแรกที่มีค่าของและครั้งที่สองที่มีค่าของc dบรรทัดที่สอง unpacks _tuple ลงในตัวแปรและa bนี่จะเป็นการแบ่งย่อยบรรทัดใหญ่ของคุณ:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True, True, True, True

เป็นสองบรรทัดย่อย:

_ = True, True, True, True, True, False, True, True, True, True
a, b, c, d, e, f, g, h, i, j = _

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

หากคุณมีรายการค่าคุณยังสามารถแยกค่าได้ คุณต้องแปลงมันเป็น tuple ก่อน ตัวอย่างเช่นต่อไปนี้จะกำหนดค่าระหว่าง 0 และ 9 ให้กับแต่ละaถึงผ่านjตามลำดับ:

a, b, c, d, e, f, g, h, i, j = tuple(range(10))

แก้ไข: เคล็ดลับเรียบร้อยเพื่อกำหนดทั้งหมดเป็นจริงยกเว้นองค์ประกอบ 5 (ตัวแปรf):

a, b, c, d, e, f, g, h, i, j = tuple(x != 5 for x in range(10))

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

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

intuited แสดงให้เห็นว่าคุณอาจใช้พจนานุกรมสำหรับสิ่งนี้ได้อย่างไรและ Chris Lutz แสดงวิธีใช้ tuple สำหรับการจัดเก็บชั่วคราวก่อนที่จะแตกออกเป็นตัวแปรแยก แต่ตัวเลือกอื่นที่ควรพิจารณาคือการใช้ collections.namedtupleเพื่อรวมค่าอย่างถาวร

ดังนั้นคุณอาจทำสิ่งที่ชอบ:

# Define the attributes of our named tuple
from collections import namedtuple
DataHolder = namedtuple("DataHolder", "a b c d e f g")

# Store our data
data = DataHolder(True, True, True, True, True, False, True)

# Retrieve our data
print(data)
print(data.a, data.f)

รหัสจริงหวังว่าจะใช้ชื่อที่มีความหมายมากกว่า "DataHolder" และตัวอักษรของตัวอักษรแน่นอน

ปัญหาคืออะไรในความเป็นจริง?

ถ้าคุณต้องการจริงๆหรือต้องการ 10 , B , C , D , E , F , G , H , I , J , จะไม่มีความเป็นไปได้อื่น ๆ ที่เวลาหรืออื่นที่จะเขียนและเขียนขและเขียนค ....

หากค่าต่างกันทั้งหมดคุณจะต้องเขียนเพื่อเป็นตัวอย่าง

a = 12
b= 'sun'
c = A() #(where A is a class)
d = range(1,102,5)
e = (line in filehandler if line.rstrip())
f = 0,12358
g = True
h = random.choice
i = re.compile('^(!=  ab).+?<span>')
j = [78,89,90,0]

กล่าวคือการกำหนด "ตัวแปร" ทีละรายการ

หรือใช้การเขียนอื่นไม่จำเป็นต้องใช้_:

a,b,c,d,e,f,g,h,i,j =\
12,'sun',A(),range(1,102,5),\
(line for line in filehandler if line.rstrip()),\
0.12358,True,random.choice,\
re.compile('^(!=  ab).+?<span>'),[78,89,90,0]

หรือ

a,b,c,d,e,f,g,h,i,j =\
(12,'sun',A(),range(1,102,5),
 (line for line in filehandler if line.rstrip()),
 0.12358,True,random.choice,
 re.compile('^(!=  ab).+?<span>'),[78,89,90,0])

.

หากบางส่วนของพวกเขาจะต้องมีค่าเดียวกันเป็นปัญหาที่มันยาวเกินไปที่จะเขียน

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True 

?

จากนั้นคุณสามารถเขียน:

a=b=c=d=e=g=h=i=k=j=True
f = False

.

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

ฉันสงสัยว่าคำถามของคุณไม่ใช่สัญญาณที่คุณเข้าใจผิดบางอย่าง

เมื่อหนึ่งเขียนa = 10, หนึ่งไม่สร้างตัวแปรในความรู้สึกของ "หน่วยความจำอันมีค่าที่สามารถเปลี่ยนที่" คำสั่งนี้:

• เรียกการสร้างวัตถุประเภทintegerและค่า 10 และการเชื่อมโยงชื่อ 'a' กับวัตถุนี้ในเนมสเปซปัจจุบัน

• หรือกำหนดชื่อ 'a' อีกครั้งในเนมสเปซให้กับวัตถุ10 (เพราะ 'a' ถูกผูกไว้กับวัตถุอื่นก่อนหน้านี้)

ฉันบอกว่าเพราะฉันไม่เห็นยูทิลิตี้เพื่อกำหนดตัวระบุ 10 ตัวคือ a, b, c ... ชี้ไปที่ False หรือ True หากค่าเหล่านี้ไม่เปลี่ยนแปลงระหว่างการดำเนินการเหตุใดจึงต้องมีตัวระบุ 10 ตัว และหากพวกเขาเปลี่ยนทำไมต้องกำหนดตัวระบุก่อนล่ะพวกเขาจะถูกสร้างเมื่อจำเป็นหากไม่ได้กำหนดไว้ก่อนหน้านี้

คำถามของคุณดูแปลกสำหรับฉัน

ดูเหมือนว่าคุณกำลังใกล้ถึงปัญหาของคุณในทางที่ผิดกับฉัน

เขียนโค้ดของคุณอีกครั้งเพื่อใช้ tuple หรือเขียนคลาสเพื่อเก็บข้อมูลทั้งหมด

ฉันชอบคำตอบที่ได้รับคะแนนสูงสุด; อย่างไรก็ตามมีปัญหากับรายการตามที่แสดง

  >> a, b = ([0]*5,)*2
  >> print b
  [0, 0, 0, 0, 0]
  >> a[0] = 1
  >> print b
  [1, 0, 0, 0, 0]

สิ่งนี้ถูกกล่าวถึงในรายละเอียดที่ดี(ที่นี่)แต่ส่วนสำคัญคือสิ่งนั้นaและbเป็นวัตถุเดียวกันกับการa is bส่งคืนTrue(เหมือนกันid(a) == id(b)) ดังนั้นหากคุณเปลี่ยนดัชนีคุณจะเปลี่ยนดัชนีของทั้งสองaและbเนื่องจากมีการเชื่อมโยง เพื่อแก้ปัญหานี้คุณสามารถทำได้(แหล่งที่มา)

>> a, b = ([0]*5 for i in range(2))
>> print b
[0, 0, 0, 0, 0]
>> a[0] = 1
>> print b
[0, 0, 0, 0, 0]

ซึ่งสามารถใช้เป็นคำตอบยอดนิยมซึ่งมีผลลัพธ์ที่เข้าใจได้ง่าย "ที่ต้องการ"

>> a, b, c, d, e, g, h, i = (True for i in range(9))
>> f = (False for i in range(1)) #to be pedantic

ในกรณีของคุณฉันจะใช้ YAML

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

https://keleshev.com/yaml-quick-introduction

แต่ Google จะง่ายกว่าเพราะเป็นมาตรฐานมีข้อมูลนับร้อยเกี่ยวกับเรื่องนี้คุณสามารถค้นหาสิ่งที่เหมาะกับความเข้าใจของคุณมากที่สุด ;)

ขอแสดงความนับถืออย่างสูง.

เช่นเดียวกับJavaScriptคุณสามารถใช้หลายประโยคในหนึ่งบรรทัดในไพ ธ อนa = 1; b = "Hello World"; c += 3