Ik ben Python aan het leren en maak een databaseverbinding.
Terwijl ik probeer toe te voegen aan de DB, denk ik erover om tuples uit informatie te maken en deze vervolgens aan de DB toe te voegen.
Wat ik doe:
Ik neem informatie van de gebruiker en sla deze op in variabelen.
Kan ik deze variabelen in een tuple toevoegen? Kun je me alsjeblieft helpen met de syntaxis?
Ook als er een efficiënte manier is om dit te doen, deel het dan…
BEWERKEN
Laat me deze vraag een beetje bewerken … Ik heb alleen de tuple nodig om informatie in de DB in te voeren. Als de informatie aan de DB is toegevoegd, moet ik de tuple dan verwijderen? Ik bedoel, ik heb de tuple niet meer nodig.
Antwoord 1, autoriteit 100%
Tuples zijn onveranderlijk; je kunt na de constructie niet wijzigen welke variabelen ze bevatten. U kunt ze echter samenvoegen of in plakjes snijden om nieuwe tuples te vormen:
a = (1, 2, 3)
b = a + (4, 5, 6) # (1, 2, 3, 4, 5, 6)
c = b[1:] # (2, 3, 4, 5, 6)
En, natuurlijk, bouw ze op vanuit bestaande waarden:
name = "Joe"
age = 40
location = "New York"
joe = (name, age, location)
Antwoord 2, autoriteit 56%
Je kunt beginnen met een lege tuple met zoiets als t = (). Je kunt toevoegen met +, maar je moet nog een tuple toevoegen. Als je een enkel element wilt toevoegen, maak er dan een singleton van: t = t + (element,). Je kunt een tupel van meerdere elementen toevoegen met of zonder die komma aan het einde.
>>> t = ()
>>> t = t + (1,)
>>> t
(1,)
>>> t = t + (2,)
>>> t
(1, 2)
>>> t = t + (3, 4, 5)
>>> t
(1, 2, 3, 4, 5)
>>> t = t + (6, 7, 8,)
>>> t
(1, 2, 3, 4, 5, 6, 7, 8)
Antwoord 3, autoriteit 12%
In Python 3 kun je * gebruiken om een nieuwe tuple van elementen te maken van de originele tuple, samen met het nieuwe element.
>>> tuple1 = ("foo", "bar")
>>> tuple2 = (*tuple1, "baz")
>>> tuple2
('foo', 'bar', 'baz')
De bytecode is bijna hetzelfde als tuple1 + ("baz",)
Python 3.7.5 (default, Oct 22 2019, 10:35:10)
[Clang 10.0.1 (clang-1001.0.46.4)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def f():
... tuple1 = ("foo", "bar")
... tuple2 = (*tuple1, "baz")
... return tuple2
...
>>> def g():
... tuple1 = ("foo", "bar")
... tuple2 = tuple1 + ("baz",)
... return tuple2
...
>>> from dis import dis
>>> dis(f)
2 0 LOAD_CONST 1 (('foo', 'bar'))
2 STORE_FAST 0 (tuple1)
3 4 LOAD_FAST 0 (tuple1)
6 LOAD_CONST 3 (('baz',))
8 BUILD_TUPLE_UNPACK 2
10 STORE_FAST 1 (tuple2)
4 12 LOAD_FAST 1 (tuple2)
14 RETURN_VALUE
>>> dis(g)
2 0 LOAD_CONST 1 (('foo', 'bar'))
2 STORE_FAST 0 (tuple1)
3 4 LOAD_FAST 0 (tuple1)
6 LOAD_CONST 2 (('baz',))
8 BINARY_ADD
10 STORE_FAST 1 (tuple2)
4 12 LOAD_FAST 1 (tuple2)
14 RETURN_VALUE
Het enige verschil is BUILD_TUPLE_UNPACK versus BINARY_ADD. De exacte prestaties zijn afhankelijk van de implementatie van de Python-interpreter, maar het is normaal om BUILD_TUPLE_UNPACK sneller te implementeren dan BINARY_ADD omdat BINARY_ADD een polymorfe operator is, waarvoor extra type nodig is berekening en impliciete conversie.
Antwoord 4, autoriteit 11%
Een andere nog niet genoemde tactiek is het toevoegen van een lijst aan een lijst en aan het einde de lijst omzetten in een tuple:
mylist = []
for x in range(5):
mylist.append(x)
mytuple = tuple(mylist)
print mytuple
retouren
(0, 1, 2, 3, 4)
Ik gebruik dit soms als ik een tuple als functieargument moet doorgeven, wat vaak nodig is voor de numpy-functies.
Antwoord 5, autoriteit 2%
” zodra de informatie aan de DB is toegevoegd, moet ik de tuple dan verwijderen? Ik bedoel, ik heb de tuple niet meer nodig.”
Nee.
Over het algemeen is er geen reden om iets te verwijderen. Er zijn enkele speciale gevallen voor het verwijderen, maar ze zijn zeer, zeer zeldzaam.
Definieer eenvoudig een smal bereik (d.w.z. een functiedefinitie of een methodefunctie in een klasse) en de objecten worden aan het einde van het bereik verzameld.
Maak je geen zorgen over het verwijderen van iets.
[Opmerking. Ik werkte met een man die — naast het verwijderen van objecten — altijd “reset”-methoden schreef om ze te wissen. Alsof hij ze ging redden en hergebruiken. Ook een dwaze opvatting. Negeer gewoon de objecten die u niet meer gebruikt. Als u uw functies definieert in blokken code die klein genoeg zijn, hoeft u nergens meer aan te denken.]
Antwoord 6, autoriteit 2%
Het is zo eenvoudig als het volgende:
info_1 = "one piece of info"
info_2 = "another piece"
vars = (info_1, info_2)
# 'vars' is now a tuple with the values ("info_1", "info_2")
Tuples in Python zijn echter onveranderlijk, dus je kunt geen variabelen toevoegen aan een tuple als deze eenmaal is gemaakt.
Antwoord 7
Zoals andere antwoorden al hebben opgemerkt, kunt u een bestaande tuple niet wijzigen, maar u kunt altijd een nieuwe tuple maken (die sommige of alle items uit bestaande tupels en/of andere bronnen kan nemen).
Als bijvoorbeeld alle interessante items in scalaire variabelen staan en u de namen van die variabelen kent:
def maketuple(variables, names):
return tuple(variables[n] for n in names)
te gebruiken, bijv. zoals in dit voorbeeld:
def example():
x = 23
y = 45
z = 67
return maketuple(vars(), 'x y z'.split())
natuurlijk zou dit ene geval eenvoudiger worden uitgedrukt als (x, y, z) (of zelfs helemaal afzien van de namen, (23, 45, 67) ), maar de maketuple-benadering kan nuttig zijn in sommige meer gecompliceerde gevallen (bijv. wanneer de te gebruiken namen ook dynamisch worden bepaald en tijdens de berekening aan een lijst worden toegevoegd).
Antwoord 8
Ik ben er vrij zeker van dat de syntaxis hiervoor in python is:
user_input1 = raw_input("Enter Name: ")
user_input2 = raw_input("Enter Value: ")
info = (user_input1, user_input2)
eenmaal ingesteld, kunnen tuples niet meer worden gewijzigd.