Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Re: len() on mutables vs. immutables

Reply
Thread Tools

Re: len() on mutables vs. immutables

 
 
Demian Brecht
Guest
Posts: n/a
 
      02-08-2013
So, it's taken me a little while longer than I figured to actually get the
time to dig around for the question that I had (added to the bottom of
this message for context).. Pretty mundane stuff, but I did the digging
(3.4.0a). Hopefully the results will help anyone else with the same
questions.

http://demianbrecht.github.com/posts...rstanding-len/


However, my research brought up a question (I'm assuming someone here can
answer this):

If a memoryview is representing a non-continuguous block of memory (> 1
ndim), will len(obj) not return incorrect results? It seems to be
reporting the shape of the 0th dim at the moment.. Or is there something
that I'm missing altogether?

Thanks,

Demian Brecht
http://demianbrecht.github.com



On 2012-10-18 5:26 PM, "Terry Reedy" <(E-Mail Removed)> wrote:

>On 10/18/2012 2:42 PM, Demian Brecht wrote:
>
>> Awesome. Pretty much what I figured. Of course, I'll have to dig around
>> the source just to confirm this with my own eyes (more just curiosity
>> than anything),

>
>If you do, please followup with a report.
>
>--
>Terry Jan Reedy
>
>--
>http://mail.python.org/mailman/listinfo/python-list


** Quote for context on a necro'd post **

I'm curious as to the implementation (I'd be happy to dig through the
source, just don't have the time right now). I've seen various
implementations across interpreters in the past (some which have been
rather shocking) and I'd like to get some insight into Python (well,
CPython at this point anyway).

When len() is called passing an immutable built-in type (such as a
string), I'd assume that the overhead in doing so is simply a function
call and there are no on-call calculations done. Is that correct?

I'd also assume that mutable built-in types (such as a bytearray) would
cache their size internally as a side effect of mutation operations. Is
that correct? If so, is it safe to assume that at least all built-in
types observe this behavior, or are there some that incur an O(n) cost
on every len() call?

Obviously this can't be controlled with custom types that implement
their own __len__, I'm only asking about Python's built-ins.

Thanks,
Demian


 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: len() on mutables vs. immutables Demian Brecht Python 0 10-18-2012 06:42 PM
Re: len() on mutables vs. immutables Demian Brecht Python 0 10-18-2012 06:38 PM
Re: len() on mutables vs. immutables Terry Reedy Python 0 10-18-2012 06:29 PM
RE: len() on mutables vs. immutables Nick Cash Python 0 10-18-2012 06:28 PM
len() on mutables vs. immutables Demian Brecht Python 0 10-18-2012 05:23 PM



Advertisments