Extract String From Enclosing Tuple

[rshepard]

I'm a bit embarrassed to have to ask for help on this, but I'm not finding
the solution in the docs I have here.

Data are assembled for writing to a database table. A representative tuple
looks like this:

('eco', "(u'Roads', )", 0.0739698873013 48305)

Pysqlite doesn't like the format of the middle term:
pysqlite2.dbapi 2.InterfaceErro r: Error binding parameter 1 - probably
unsupported type.

I want to extract the 'Roads', part from the double-quoted enclosing
tuple. The unicode part should be automatically removed when the string is
printed, but I suspect it's the double quotes and extra parentheses that are
the problem. I know that tuples are immutable, but I thought that I could
slice it. If so, I'm not doing it correctly, because each attempt results in
TypeError: unsubscriptable object

Even when I assign that middle term to a variable before assembling the
tuple for insertion in the database, I just cannot get the job done. Whether
in the tuple of three terms or by itself, I haven't applied the proper
technique.

Insight appreciated.

Rich

[rshepard]

On 2007-02-28, at************* @gmail.com <at************ *@gmail.comwrot e:

>>>import itertools
tuple(iterto ols.chain((t[0], t2[0].encode('ascii' )), t[2:]))

('eco', 'Roads', 0.0739698873013 48305)

Steven,

As suggested in the previous article, I handled it where the values are
read from the list retrieved from the database. By adding an additional
index of [0] the format is correct.

Thank you all very much,

Rich

[MonkeeSage]

On Mar 1, 5:02 am, bearophileH...@ lycos.com wrote:

I don't know Ruby, but I think it allows such purposes with a freezing
function.

In ruby all objects can be frozen (freeze is a method on Object, from
which all other objects derive), not just Arrays (Arrays == lists in
python; ruby has no built-in container equiv. to tuple). But that's
more of an implementation detail rather than anthing to do with the
structure/semantics of a certain type of object (e.g., a String can be
frozen, a Hash can be frozen, &c).

Regards,
Jordan

[Ben Finney]

"George Sakkis" <ge***********@ gmail.comwrites :

On Feb 28, 10:45 pm, Ben Finney wrote:

Tuples are intended for use as heterogeneous data structures [...]
Lists are intended for use as homogeneous sequences [...]

Nice, that's a good summary of the straw man arguments about the
"true" distinction between tuples and lists.

I'm not sure why you say it's a "straw man argument". I'm presenting
*my* understanding of a position that I also share, in order to defend
it; a straw man argument is a misrepresentati on of *another party's*
position for the purpose of appearing to attack that party's position.

http://www.fallacyfiles.org/strawman.html

Whose position have I misrepresented and attacked?

Now can you please explain why an "heterogene ous data structure":

1) does not support __setitem__, changing the value of an existing
item from 3 to 4,

In the case of a tuple, because the "value" is conceptually the entire
tuple. To change one of its items would be to create a new value -- so
that's what is supported.

2) supports iteration over its ("heterogeneneo us") elements, but not
an index() method

An index() method would imply that the index of an item has some
meaning, such that extracting a single item is meaningful. Since a
tuple represents a single conceptual structural value, to extract one
item is something to be done at the same time as extracting all the
others.

3) why using indices rather than names for implied semantics is a
good idea anyway.

You've already shown that one *doesn't* use an index for accessing
items in a tuple.

As for addition/removal/insertion of elements not making sense for a
heterogeneous data structure, have you heard of database schema
change ?

A database schema change is not an operation one performs with the
expectation that the tuples will remain the same. Thus, one would
expect to discard the old tuples as obsolete and retrieve them from
the relation again, getting new tuples.

Heterogeneous data structures are well known for several decades
now; they are commonly spelled "records" though, not tuples, and
have a more reasonable API to support their semantics.

Python doesn't natively support relational schema operations. It does
natively support tuples. I never professed that the two were the same,
and don't accept that they should be.

--
\ "I have never made but one prayer to God, a very short one: 'O |
`\ Lord, make my enemies ridiculous!' And God granted it." -- |
_o__) Voltaire |
Ben Finney