Python data types

Yep its true.

Besides designing a container, regular lists can hold several types

>>> myList = [1, 3.14, 'string', {'key1':'value1'}, frozenset([5,2,2,3]), [1,2,3],(5+2j),(4.0,5.0), True, type(5)] >>> myList [1, 3.1400000000000001, 'string', {'key1': 'value1'}, frozenset([2, 3, 5]), [1, 2, 3], (5+2j), (4.0, 5.0), True, <type 'int'>] >>> [type(x) for x in myList] [<type 'int'>, <type 'float'>, <type 'str'>, <type 'dict'>, <type 'frozenset'>, <type 'list'>, <type 'complex'>, <type 'tuple'>, <type 'bool'>, <type 'type'>] 

Even type is a type

As the other answers note, this is certainly true of python. I would also like to point out that this is a feature of several high-level languages including Ruby and even JavaScript (iirc). As far as Java goes it is technically possible to design a container that will hold multiple types but it requires those types to be derived from the same type, and then the types must be cast to be used as usual. For example in Java one could write:

Object[] mObjArr = new Object[2]; String mString = "This is a String"; Double mDouble = 3.1415; void assignElements() { mObject[0] = (Object) mString; mObject[1] = (Double) mDouble; } String getString() { if (mObject[0] instanceof String) return (String) mObject[0]; else return null; // or empty string or throw exception etc. } Double getDouble() { if (mObject[1] instanceof Double) return (Double) mObjects[1]; else return null; // or Double.NaN or throw exception etc. } 

A similar solution in C/C++ using pointers to void is possible but type checking becomes hairy to say the least.

In Python everything is an object:

>>> id("hello world") 4312841696 

Here, you can see how even a literal (an string in this case) has a memory space reserved for it.

>>> class Foo(object): ... pass ... >>> id(Foo) 4297723600 

Even the Classes are instances of an object. So, considering this, a list/dict/set just contains references to objects, no matter instances of what classes they are.

>>> a = [40L, "test", Foo, Foo()] >>> a[0] 40L >>> a[1] 'test' >>> a[2] <class '__main__.Foo'> >>> a[3] <__main__.Foo object at 0x1010e8710> 

Good luck!

1. Standard containers are untyped: you can store any value in a list or mapping, and use almost any value as a key in a mapping. Java has untyped containers, too, but usually people enforce static type checking by using generics.
2. You can implement interface of a container (not explicitly, you just define a set of methods with right names) and your class will work as a container. You may do what you please, including type checking, having default values, efficient storage, etc.
3. Lists (arrays) in Python have rich subscript semantics, e.g. you can get one- and multi-dimensional slices using simple expressions. Both built-in and third-party special containers (e.g. from numpy) use it to great effect.