python可读性好吗,Python的可读性问题

Python is supposed to be readable, but after programming in Python for

a while I find my Python programs can be more obfuscated than their C/C

++ counterparts sometimes. Part of the reason is that with

heterogeneous lists/tuples at hand, I tend to stuff many things into

the list and *assume* a structure of the list or tuple, instead of

declaring them explicitly as one will do with C structs. So, what used

to be

struct nameval {

char * name;

int val;

} a;

a.name = ...

a.val = ...

becomes cryptic

a[0] = ...

a[1] = ...

Python Tutorial says an empty class can be used to do this. But if

namespaces are implemented as dicts, wouldn''t it incur much overhead

if one defines empty classes as such for some very frequently used

data structures of the program?

Any elegant solutions?

解决方案Licheng Fang wrote:

Python is supposed to be readable, but after programming in Python for

a while I find my Python programs can be more obfuscated than their C/C

++ counterparts sometimes. Part of the reason is that with

heterogeneous lists/tuples at hand, I tend to stuff many things into

the list and *assume* a structure of the list or tuple, instead of

declaring them explicitly as one will do with C structs. So, what used

to be

struct nameval {

char * name;

int val;

} a;

a.name = ...

a.val = ...

becomes cryptic

a[0] = ...

a[1] = ...

Python Tutorial says an empty class can be used to do this. But if

namespaces are implemented as dicts, wouldn''t it incur much overhead

if one defines empty classes as such for some very frequently used

data structures of the program?

Any elegant solutions?

You can use __slots__ to make objects consume less memory and have

slightly better attribute-access performance. Classes for objects that

need such performance tweaks should start like::

class A(object):

__slots__ = ''name'', ''val''

The recipe below fills in the obvious __init__ method for such classes

so that the above is pretty much all you need to write:

http://aspn.activestate.com/ASPN/Coo.../Recipe/502237

STeVe

Licheng Fang a écrit :

Python is supposed to be readable, but after programming in Python for

a while I find my Python programs can be more obfuscated than their C/C

++ counterparts sometimes. Part of the reason is that with

heterogeneous lists/tuples at hand, I tend to stuff many things into

the list and *assume* a structure of the list or tuple, instead of

declaring them explicitly as one will do with C structs. So, what used

to be

struct nameval {

char * name;

int val;

} a;

a.name = ...

a.val = ...

becomes cryptic

a[0] = ...

a[1] = ...

Use dicts, not lists or tuples:

a = dict(name=''yadda'', val=42)

print a[''name'']

print a[''val'']

Python Tutorial says an empty class can be used to do this. But if

namespaces are implemented as dicts, wouldn''t it incur much overhead

if one defines empty classes as such for some very frequently used

data structures of the program?

If you do worry about overhead, then C is your friend !-)

More seriously: what do you use this ''nameval'' struct for ? If you

really have an overhead problem, you may want to use a real class using

__slots__ to minimize this problem, but chances are you don''t need it.

Licheng Fang wrote:

struct nameval {

char * name;

int val;

} a;

a.name = ...

a.val = ...

becomes cryptic

a[0] = ...

a[1] = ...

?!

(1)

a = {}

a["name"] = ...

a["val"] = ...

(2)

NAME = 0

VAL = 1

a=[]

a[NAME] = ...

a[VAL] = ...

Python Tutorial says an empty class can be used to do this. But if

namespaces are implemented as dicts, wouldn''t it incur much

overhead if one defines empty classes as such for some very

frequently used data structures of the program?

Measure first, optimize later. How many million of instances and/or

accesses per second do you have?

Regards,

Bj?rn

--

BOFH excuse #20:

divide-by-zero error