I am learning Python and creating a database connection. While trying to add to the DB, I am thinking of creating tuples out of information and then add them to the DB.
What I am Doing: I am taking information from the user and store it in variables. Can I add these variables into a tuple? Can you please help me with the syntax?
Also if there is an efficient way of doing this, please share...
EDIT Let me edit this question a bit...I only need the tuple to enter info into the DB. Once the information is added to the DB, should I delete the tuple? I mean I don't need the tuple anymore.
Nathan
7,5146 gold badges46 silver badges70 bronze badges
asked Sep 4, 2009 at 18:36
Tuples are immutable; you can't change which variables they contain after construction. However, you can concatenate or slice them to form new tuples:
a = [1, 2, 3]
b = a + [4, 5, 6] # [1, 2, 3, 4, 5, 6]
c = b[1:] # [2, 3, 4, 5, 6]
And, of course, build them from existing values:
name = "Joe"
age = 40
location = "New York"
joe = [name, age, location]
John R Perry
3,6832 gold badges35 silver badges59 bronze badges
answered Sep 4, 2009 at 18:39
John MillikinJohn Millikin
193k39 gold badges211 silver badges222 bronze badges
5
You can start with a blank tuple with something like t = []
. You can add with +
, but you have to add another tuple. If you want to add a single element, make it a singleton: t = t + [element,]
. You can add a tuple of multiple elements with or without that trailing comma.
>>> 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]
phoenix
6,3684 gold badges36 silver badges44 bronze badges
answered Dec 16, 2011 at 18:43
DanielDaniel
2,8662 gold badges14 silver badges12 bronze badges
5
In Python 3, you can use *
to create a new tuple of
elements from the original tuple along with the new element.
>>> tuple1 = ["foo", "bar"]
>>> tuple2 = [*tuple1, "baz"]
>>> tuple2
['foo', 'bar', 'baz']
The byte code is almost the same as 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
The only difference is BUILD_TUPLE_UNPACK
vs BINARY_ADD
. The exact performance depends on the Python interpreter implementation, but it's natural to implement BUILD_TUPLE_UNPACK
faster than BINARY_ADD
because BINARY_ADD
is a polymorphic operator, requiring additional type calculation and implicit conversion.
answered Jun 22, 2018 at 10:34
Yang BoYang Bo
3,4403 gold badges21 silver badges33 bronze badges
4
Another tactic not yet mentioned is using appending to a list, and then converting the list to a tuple at the end:
mylist = []
for x in range[5]:
mylist.append[x]
mytuple = tuple[mylist]
print mytuple
returns
[0, 1, 2, 3, 4]
I sometimes use this when I have to pass a tuple as a function argument, which is often necessary for the numpy functions.
answered May 7, 2014 at 23:20
ehontzehontz
1,06010 silver badges7 bronze badges
2
It's as easy as the following:
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"]
However, tuples in Python are immutable, so you cannot append variables to a tuple once it is created.
answered Sep 4, 2009 at 18:39
mipadimipadi
385k88 gold badges515 silver badges475 bronze badges
" once the info is added to the DB, should I delete the tuple? i mean i dont need the tuple anymore."
No.
Generally, there's no reason to delete anything. There are some special cases for deleting, but they're very, very rare.
Simply define a narrow scope [i.e., a function definition or a method function in a class] and the objects will be garbage collected at the end of the scope.
Don't worry about deleting anything.
[Note. I worked with a guy who -- in addition to trying to delete objects -- was always writing "reset" methods to clear them out. Like he was going to save them and reuse them. Also a silly conceit. Just ignore the objects you're no longer using. If you define your functions in small-enough blocks of code, you have nothing more to think about.]
answered Sep 4, 2009 at 20:06
S.LottS.Lott
376k78 gold badges503 silver badges771 bronze badges
As other answers have noted, you cannot change an existing tuple, but you can always create a new tuple [which may take some or all items from existing tuples and/or other sources].
For example, if all the items of interest are in scalar variables and you know the names of those variables:
def maketuple[variables, names]:
return tuple[variables[n] for n in names]
to be used, e.g, as in this example:
def example[]:
x = 23
y = 45
z = 67
return maketuple[vars[], 'x y z'.split[]]
of course this one case would be more simply expressed as [x, y, z]
[or even foregoing the names altogether, [23, 45, 67]
], but the maketuple
approach might be useful in some more complicated cases [e.g. where the names to use are also determined dynamically and appended to a list during the computation].
answered Sep 4, 2009 at 18:47
Alex MartelliAlex Martelli
823k163 gold badges1202 silver badges1379 bronze badges
I'm pretty sure the syntax for this in python is:
user_input1 = raw_input["Enter Name: "]
user_input2 = raw_input["Enter Value: "]
info = [user_input1, user_input2]
once set, tuples cannot be changed.
answered Sep 4, 2009 at 18:39
Jon WJon W
15.2k6 gold badges36 silver badges47 bronze badges