{"id":159,"date":"2025-04-21T07:08:34","date_gmt":"2022-03-21T06:34:54","guid":{"rendered":""},"modified":"2022-03-21T08:34:54","modified_gmt":"2022-03-21T06:34:54","slug":"overview-python-object-types","status":"publish","type":"post","link":"https:\/\/www.spss-tutorials.com\/overview-python-object-types\/","title":{"rendered":"Quick Overview Python Object Types"},"content":{"rendered":"\n

In our examples, you'll encounter terms such as a Python list or dict object. So which object types do we find in Python and what are their basic properties? The table below presents a quick overview.<\/p>\n\n\n

Quick Overview Python Object Types<\/h2>\n\n
\n \n
Type<\/th>Meaning<\/th>Iterable?<\/th>Mutable?<\/th>Looks like<\/th>What is it?<\/th><\/tr>\n
str<\/a> <\/td>String<\/td>Yes<\/td>No<\/td>apple<\/td>Sequence of 0 or more characters<\/td><\/tr>\n
list<\/a> <\/td>List<\/td>Yes<\/td>Yes<\/td>[1,2,3]<\/td>Sequence of objects that are referenced by their positions<\/td><\/tr>\n
tuple<\/a> <\/td>Python tuple<\/td>Yes<\/td>No<\/td>('apple','banana')<\/td>Sequence of objects that are referenced by their positions<\/td><\/tr>\n
dict<\/a> <\/td>Dictionary<\/td>Yes<\/td>Yes<\/td>{1:'apple',2:'banana'}<\/td>Unordered set of (unique) keys, each of which has some value<\/td><\/tr>\n
int<\/a> <\/td>Integer number<\/td>No<\/td>No<\/td>1<\/td>Number that has no decimal places<\/td><\/tr>\n
float<\/a> <\/td>Floating point number<\/td>No<\/td>No<\/td>1.0<\/td>Number that has decimal places<\/td><\/tr>\n
function<\/a> <\/td>Python function<\/td>No<\/td>No<\/td>def myfunction():<\/td>Named amount of code that takes zero or more arguments and executes something<\/td><\/tr>\n
module<\/a> <\/td>Python module<\/td>No<\/td>No<\/td>(Text file with .py extension)<\/td>One or more Python files that define functions and\/or other objects.<\/td><\/tr>\n
bool<\/a> <\/td>Boolean<\/td>No<\/td>No<\/td>True \/ False<\/td>Object that can only indicate True or False<\/td><\/tr>\n
range<\/a> <\/td>Python range<\/td>Yes<\/td>No<\/td>range(0, 10)<\/td>Sequence of integer numbers<\/td><\/tr>\n
NoneType<\/a> <\/td>Empty object<\/td>No<\/td>No<\/td>None<\/td>Empty object without type<\/td><\/tr>\n <\/table>\n<\/div>\n\n\n

What Does “Iterable” Mean in Python?<\/h2>\n\n

\nPython objects are iterable if you can loop over them.<\/span>\nFor instance, you can loop over (the characters contained in) a Python string object. However, you can't loop over a Python int object.<\/p>\n\n

Whether you can (not) loop over an object only depends on the type of object, not its contents. Like so, you can loop over an empty list as shown below.<\/p>\n\n

*CREATE STRING OBJECT (ITERABLE) AND LOOP OVER ITS CHARACTERS.
<\/strong>
begin program python3.
myString = '13579'
for char in myString:
    print(char)
end program.

*INT OBJECT IS NOT ITERABLE.
<\/strong>
begin program python3.
myInt = 13579
for char in myInt:
    print(char) # TypeError: 'int' object is not iterable
<\/strong>\nend program.

*PYTHON LIST IS ITERABLE, EVEN IF EMPTY.
<\/strong>
begin program python3.
myList = []
for elem in myList:
    print(elem)
end program.<\/div>\n\n

What Does “Mutable” Mean in Python?<\/h2>\n\n

\nPython objects are mutable if their values can be changed.<\/span>\nConfusingly, it seems<\/em> you can change the value of, for instance, a string object. Doing so, however, simply creates an entirely new string object with the same name but a (possibly) different value than the original string object.<\/p>\n\n

The examples below demonstrate this by inspecting the Python IDs before and after modifying some string object.<\/p>\n\n

*CHANGING VALUE OF STRING OBJECT CREATES NEW STRING OBJECT.
<\/strong>
begin program python3.
myString = 'apple'
print(myString) # apple
<\/strong>\nprint(id(myString)) # 51135968
<\/strong>\nmyString += 's'
print(myString) # apples
<\/strong>\nprint(id(myString)) # 51043720
<\/strong>\nend program.

*CHANGING ELEMENTS OF LIST OBJECT DOES NOT RESULT IN NEW LIST OBJECT.
<\/strong>
begin program python3.
myList = ['apple','banana','cherry']
print(myList) # ['apple', 'banana', 'cherry']
<\/strong>\nprint(id(myList)) # 45378824
<\/strong>\nmyList.append('durian')
print(myList) # ['apple', 'banana', 'cherry', 'durian']
<\/strong>\nprint(id(myList)) # 45378824
<\/strong>\nend program.<\/div>\n\n\n

Python String Object<\/h2> \n\n

A Python string simply consists of 0 or (usually) more characters. For a detailed overview of Python string methods, read up on Overview Python String Methods<\/a>. The syntax below demonstrates some minimal basics.<\/p>\n\n

*CREATE PYTHON STRING OBJECT AND INSPECT IT.
<\/strong>
begin program python3.
myString = 'apple'
print(type(myString)) # <type 'str'>
<\/strong>\nprint(myString) # apple
<\/strong>\nend program.

*RETRIEVE LAST ELEMENT (CHARACTER) FROM STRING.
<\/strong>
begin program python3.
print(myString[-1]) # e
<\/strong>\nend program.<\/div>\n

Why are Python string objects so important? Well, a main goal of using Python in SPSS is creating (large amounts of) SPSS syntax<\/a> to accomplish several tasks. Such syntax is created as one or many Python string objects which are then passed on to be run in SPSS.<\/p>\n\n\n

Python List Object<\/h2> \n\n

Python list objects consist of 0 or (usually) more elements separated by commas and enclosed by square brackets.<\/p>\n\n

*CREATE PYTHON LIST OBJECT.
<\/strong>
begin program python3.
myList = ['apple','banana','cherry']
print(type(myList)) # <class 'list'>
<\/strong>\nprint(myList) # ['apple','banana','cherry']
<\/strong>\nend program.

*RETRIEVE ITEM FROM LIST BY INDEX.
<\/strong>
begin program python3.
print(myList[0]) # apple
<\/strong>\nend program.<\/div>\n

List objects are similar to tuples except that they are editable (“mutable”). As a consequence, many methods are available for lists. We may present a quick overview of those in a future tutorial.<\/p>\n\n\n\n

Python Tuple Object<\/h2> \n\n

Python tuples consist of 0 or more elements enclosed by parentheses and separated by commas. The syntax below demonstrates a handful of basics.<\/p>\n\n

*CREATE AND INSPECT TUPLE.
<\/strong>
begin program python3.
myTuple = ('apple','banana','cherry')
print(type(myTuple)) # <class 'tuple'>
<\/strong>\nprint(myTuple) # ('apple','banana','cherry')
<\/strong>\nend program.

*EXTRACT LAST ELEMENT FROM TUPLE.
<\/strong>
begin program python3.
print(myTuple[-1]) # cherry
<\/strong>\nend program.<\/div>\n

Python tuples are similar to Python list objects, except that they are not editable (“immutable”). We usually just extract elements from them with square brackets.<\/p>\n\n\n

Python Dictionary Object<\/h2> \n\n

A Python dict object consists of 0 or (usually) more key-value pairs. Value can only be retrieved from their keys, not from any indices as shown below.<\/p>\n\n

Python dict keys (but not values) must be unique. Both keys and values are usually Python string or integer objects but they can technically be any type including<\/p>\n\n