Aynı anda birden çok değişkeni bildirmenin daha zarif yolu

"Aynı anda" birden çok değişken bildirmek için yapardım:

a, b = True, False

Ama çok daha fazla değişken beyan etmek zorunda kalsaydım, daha az zarifleşir:

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

Bunu yapmanın daha iyi / zarif / uygun bir yolu var mı?

Bu çok temel olmalı, ancak değişkenleri saklamak için bir liste veya bir demet kullandığımda, aşağıdaki gibi yardımcı olabilmek için nasıl yaklaşmalıyım:

aList = [a,b]

Geçerli değil, yapmak zorundayım:

a, b = True, True

Ya da neyi özlüyorum?

Diğerlerinin de belirttiği gibi, Boole değerleriyle 10 farklı yerel değişken kullanmanın rutininizi yazmanın en iyi yolu olması pek olası değildir (özellikle gerçekten bir harfli isimler varsa :)

Ne yaptığınıza bağlı olarak, sözlük kullanmak mantıklı olabilir. Örneğin, tek harfli bir bayrak kümesi için Boole önayar değerlerini ayarlamak istiyorsanız, bunu yapabilirsiniz:

>>> 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}

İsterseniz, bunu tek bir atama ifadesiyle de yapabilirsiniz:

>>> 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}

İkinci parametre dicttamamen bunun için tasarlanmamıştır: gerçekten, anahtar kelime bağımsız değişkenlerini kullanarak sözlüğün tek tek öğelerini geçersiz kılmanıza izin vermeyi amaçlamaktadır d=False. Yukarıdaki kod, ifadenin sonucunu , çağrılan işleve iletilen **bir dizi anahtar kelime bağımsız değişkenine üfler . Bu kesinlikle sözlük oluşturmanın güvenilir bir yoludur ve insanlar en azından bu deyimi kabul ediyor gibi görünmektedir, ancak bazılarının bunu Unpythonic olarak kabul edebileceğinden şüpheleniyorum. </disclaimer>

Bu kalıbı sık sık kullanacak olursanız, muhtemelen en sezgisel olan başka bir yaklaşım, verilerinizi bayrak adlarıyla (tek karakter dizeleri) eşlenen bayrak değerleri ( True, False) listesi olarak tanımlamaktır . Daha sonra bu veri tanımını, bayrak adlarını bayrak değerleriyle eşleyen ters çevrilmiş bir sözlüğe dönüştürürsünüz. Bu, iç içe geçmiş bir liste kavrayışı ile oldukça kısa bir sürede yapılabilir, ancak işte çok okunabilir bir uygulama:

>>> 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}

Fonksiyon invert_dictbir jeneratör fonksiyonudur . Bu oluşturur , ya da verimi - bu, yani art arda değerlerini döner anahtar-değer çiftleri -. Bu anahtar / değer çiftleri, ilk flagssözlüğün iki öğesinin içeriğinin tersidir . Yapıcıya beslenirler dict. Bu durumda dictyapıcı yukarıdakinden farklı çalışır çünkü argüman olarak bir sözlük yerine bir yineleyici ile beslenir .

@Chris Lutz'un yorumu üzerine çizim: Bunu gerçekten tek karakterli değerler için kullanacaksanız,

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

Bu çalışır, çünkü Python dizeleri yinelenebilir , yani değere göre değere göre hareket ettirilebilir. Bir dize durumunda, değerler dizedeki ayrı karakterlerdir. Yani yinelenebilir olarak yorumlandıklarında, bu durumda bir for döngüsünde kullanıldıkları ['a', 'b', 'c']ve 'abc'etkili bir şekilde eşdeğer oldukları gibi. Başka bir örnek, yinelenebilir bir işlev alan bir işleve geçirildikleri zaman olabilir tuple.

Kişisel olarak bunu yapmazdım çünkü sezgisel olarak okumaz: Bir dize gördüğümde, bir liste yerine tek bir değer olarak kullanılmasını beklerim. Bu yüzden ilk satıra bakıyorum ve "Tamam, bir Gerçek bayrak ve bir Yanlış bayrak var" diye düşünüyorum. Bu bir olasılık olmasına rağmen, bunun bir yol olduğunu düşünmüyorum. Üstte, tekrarlanabilir ve tekrarlayıcı kavramlarını daha açık bir şekilde açıklamaya yardımcı olabilir.

İşlevi invert_dictgerçekte bir sözlük döndürecek şekilde tanımlamak da kötü bir fikir değildir; Çoğunlukla bunu yapmadım çünkü rutinin nasıl çalıştığını açıklamak gerçekten yardımcı olmuyor.

Görünüşe göre Python 2.7, bu işlevi uygulamak için son derece özlü bir yol sağlayacak sözlük kavrayışına sahiptir. Bu, Python 2.7 yüklü olmadığından okuyucuya bir alıştırma olarak bırakıldı :)

Ayrıca, çok yönlü itertools modülünden bazı işlevleri de birleştirebilirsiniz . Dedikleri gibi, Bunu Yapmanın Birden Fazla Yolu Var . Bekle, Python halkı bunu söylemiyor. Bazı durumlarda bu doğrudur. Guido'nun bize sözlük kavrayışları verdiğini, böylece bunu yapmanın Tek Açık Yolu olacağını tahmin ediyorum .

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

Tanımladığınız şeyleri özetlemek için bir liste / sözlük kullanın veya kendi sınıfınızı tanımlayın, ancak tüm bu değişkenlere ihtiyacınız varsa şunları yapabilirsiniz:

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

Bu @ Jeff M ve yorumlarım hakkında bir ayrıntı .

Bunu yaptığınızda:

a, b = c, d

Tuple paketleme ve açma ile çalışır. Paketleme ve paketleme adımlarını ayırabilirsiniz:

_ = c, d
a, b = _

İlk satır _, birincisi değeri cve ikincisi değeri olan iki öğeye sahip denilen bir demet oluşturur d. İkinci satır ise _tuple değişkenini ave b. Bu büyük bir çizginizi yıkıyor:

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

İki küçük satıra:

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

Size ilk satırla aynı sonucu verir (bir bölüme değer veya değişken ekler ancak diğerini güncellemeyi unutursanız aynı istisna dahil). Ancak, bu özel durumda, yan cevabı belki de en iyisidir.

Değerler listeniz varsa, bunları yine de açabilirsiniz. Sadece önce bir tuple dönüştürmek gerekir. Örneğin, aşağıdaki her bir için 0 ile 9 arasında bir değer atar athrough jsırasıyla:

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

EDIT: 5 (değişken f) öğesi dışında hepsini doğru olarak atamak için düzgün hile :

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

İnsanlar "bir liste veya grup veya başka bir veri yapısı kullan" önerdiklerinde, önem verdiğiniz birçok farklı değere sahip olduğunuzda, bunları yerel değişkenler olarak ayrı ayrı adlandırmanın en iyi yolu olmayabileceği söylenir. bir şeyler yapmak.

Bunun yerine, bunları tek bir yerel değişkende saklanabilecek daha büyük bir veri yapısında bir araya getirmek isteyebilirsiniz.

sezgisel olarak bunun için bir sözlüğü nasıl kullanabileceğinizi ve Chris Lutz ayrı değişkenlere açmadan önce geçici depolama için bir tuple nasıl kullanılacağını gösterdi, ancak dikkate alınması gereken başka bir seçenek collections.namedtuplede değerleri daha kalıcı bir şekilde paketlemek için kullanmaktır .

Yani şöyle bir şey yapabilirsiniz:

# 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)

Gerçek kod, umarım "DataHolder" ve alfabenin harflerinden daha anlamlı isimler kullanır.

Aslında sorun ne?

Gerçekten ihtiyacınız yoksa istiyorsanız 10 a , b , c , d , e , f , g , h , i , j , yazmaya, bir kez ya da başka, başka bir olanağı yok olacak bir ve yazma b ve yazma c . ....

Değerlerin hepsi farklıysa, örnek için yazmak zorunda kalacaksınız

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]

yani "değişkenlerin" ayrı ayrı tanımlanmasıdır.

Veya başka bir yazı kullanarak aşağıdakileri kullanmanıza gerek yoktur _:

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]

veya

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])

.

Bazılarının aynı değere sahip olması gerekiyorsa, yazmak için çok uzun olan sorun

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

?

Sonra yazabilirsiniz:

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

.

Senin sorununun tam olarak ne olduğunu anlamıyorum. Bir kod yazmak istiyorsanız, talimatların ve tanımların yazılması için gereken karakterleri kullanmak zorundasınız. Başka ?

Sorunuzun bir şeyi yanlış anladığınızın işareti olup olmadığını merak ediyorum.

Birisi yazdığında a = 10, "değeri değişebilen bellek yığını" anlamında bir değişken yaratmaz . Bu talimat:

• integer10 türü ve değeri olan bir nesnenin oluşturulmasını ve 'a' adının geçerli ad alanında bu nesneyle bağlanmasını tetikler

• veya ad alanındaki 'a' adını 10 nesnesine yeniden atayın (çünkü 'a' daha önce başka bir nesneye bağlanmıştır)

Bunu söylüyorum çünkü Yanlış, Doğru işaret eden 10 tanımlayıcı a, b, c ... tanımlayan yardımcı programı göremiyorum. Bu değerler yürütme sırasında değişmezse, neden 10 tanımlayıcı? Ve eğer değişirlerse, neden önce tanımlayıcıları tanımlamak gerekir?

Sorunuz bana garip geliyor

Görünüşe göre problemin bana yanlış yaklaşıyor.

Bir demet kullanmak için kodunuzu yeniden yazın veya tüm verileri saklamak için bir sınıf yazın.

En çok oy alan yanıtı beğendim; ancak, gösterildiği gibi liste ile ilgili sorunları var.

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

Bu büyük ayrıntılarda tartışılmaktadır (burada) , ama özü budur ave geri dönen (aynı ) bolan aynı nesnedir . Eğer bir dizin değiştirmek nedenle eğer, her iki dizinini değişiyor ve onlar birbirine bağlı olduğundan,. Bunu çözmek için yapabilirsiniz (kaynak)a is bTrueid(a) == id(b)ab

>> 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]

Bu daha sonra "istenen" sezgisel sonuçlara sahip olan üst cevabın bir varyantı olarak kullanılabilir

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

Senin durumunda, YAML kullanırdım.

Bu, çoklu parametrelerle uğraşmak için zarif ve profesyonel bir standarttır. Değerler ayrı bir dosyadan yüklenir. Bu bağlantıda bazı bilgiler görebilirsiniz:

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

Ancak Google için daha kolay, standart olduğu için, yüzlerce bilgi var, anlayışınıza en uygun olanı bulabilirsiniz. ;)

Saygılarımla.

JavaScript gibi , python'daki bir satırda birden çok ifade kullanabilirsiniza = 1; b = "Hello World"; c += 3