DEV Community: sachin soman

Python Tuples and List

sachin soman — Thu, 28 Oct 2021 12:28:51 +0000

Python tuple and list are really interesting, if we don't keep a keen eye
on the documentation, we may miss several important fine prints.
I will in this page not include the common stuff only those things I see as stuff that I may forget will be presented.

First lets initialize a list

x = [1,2,3,4]

list is mutable
it is dynamic
it is ordered
have any type of objects as elements eg an int element and some user defined object in same list

we can retrieve the last element in a list without knowing its length by negative index slicing

last_element_x = x[-1]
Output:4

Lets have an another negative index slicing

x = [1,2,3,4,5]
last_element_x = x[-5:-1]
Output:[1, 2, 3, 4]

We can slice in steps

x = [1,2,3,4,5]
slice_in_steps_x = x[len(x):0:-2]
Output:[6, 4, 2]

So we can do same for reversing the string

x = [1,2,3,4,5]
reversed_x = x[::-1]
Output:[5, 4, 3, 2, 1]

Other things in list include mutability , nested lists and all the functions associated with list object which I can use docs to access and
nothing new there

Tuples

Tuples are really interesting and I have some important observations which I would like to share including how kwargs in functions work.

Tuple has a lot of similarity with a list as in data can be accessed, sliced and of course, like data in list it is ordered; The major difference between list and tuple
is that tuple is immutable and is much faster than a list. The access times will only matter in large data and in most trivial situations the access time shouldn't matter much.

Tuple defined by use of parenthesis

x = (1,2,3,)
type(x)
Output:tuple

However look at this example

x = (1)
type(x)
Output:int

Here we expected to get type tuple but python interprets it as a simple int. So what happens here is that remember we use () in other stuff like
in if condition etc. So python thinks that the () used here is for something like if(1) and thinks that x = (1) is just an int.Instead, if
we define x as shown below.

x = (1,)
type(x)
Output:tuple

Here we added a comma after which the interpreter has identified the variable to be of type tuple. One thing to note is that this quirk occurs only when we
define a single items

Tuple Unpacking

When we define a tuple with multiple items its as if the object is packed and we can subsequently assign different items in the tuple to different
variables this is an important concept to remember as we dive into some interesting stuff now.
Ignore my crude drawings

Lets try to to unpack the tuple x = [1,2,3] to variables a, b, c:

x = (1,2,3)
type(x)
Output:tuple
a,b,c = x
print(a)
Output:1
print(b)
Output:2
print(c)
Output:3

Unpacking in action

So here we can see that each item in tuple gets assigned to each variable.
An interesting thing to note is that

x = (1,2,3)
a,b,c = x
is same as 
(a,b,c) = x

In such situations python doesn't care for the () parentheses. This is an important observation when we discuss
stuff later in the section.
With this new found observation lets look at one more example

x = 1,2,3,4
type(x)
Output:tuple

So here we assigned a tuple without the need for a parantheses. With that we might be able recognize the the famous example
everyone gives to show how easy python is. swapping elements without a temporary variable

x1 , x2 = 1 , 2
x1 , x2 = x2 , x1
print(x1)
Output: 2
print(x2)
Output: 1

This is because we used tuples without parentheses and tuple unpacking. I know MIND == BLOWN!!

*args

Now I need to show one more thing before I conclude this blog. Infact it all come down to this

insert drumrolls...

Remember that in python there are functions where we can enter as many paramenters as we want like max(1,2,3,4,5,6,7) and get a result.
How does the function know how many arguments were passed?
Before we go into details here some examples we need to see

x = 1,2,3,4,5
type(x)
Output:tuple
a,b,c = x
Output: ValueError: too many values to unpack

Here we see that when I try to unpack tuple x to variables a,b,c since I only have 3 variables and for unpacking I have 5 values we get a ValueError
in such cases we can do the following

x = 1,2,3,4,5
type(x)
Output:tuple
a,b,*c = x
print(a)
Output: 1
print(b)
Output: 2
print(c)
Output: [3,4,5]

Here we see that when I used * on variable c the tuple elements gets added to c as a list and I can now iterate through it. Pretty neat!.
This is known as unpacking of tuple.
lets look at some more examples

x = 1,2,3,4,5
type(x)
Output:tuple
a,*b,c = x
print(a)
Output: 1
print(b)
Output: [2,3,4]
print(c)
Output: 5

This is self explanatory the interpreter does its best to assign values by dividing them.

x = 1,2,3,4,5
type(x)
Output:tuple
*a,*b,c = x
Output: SyntaxError: two starred expressions in assignment

Here the interpretor doesn't know how to split data so it throws a SyntaxError

Now lets look at an example code

def test_function(*args):
    for x in args:
        print(x," ")

test_function(1,2,3,4,5)
Output: 1 2 3 4 5

So what happened here. Like our previous examples, the arguments 1,2,3,4,5 get passed to *args which will be an unpacked tuple
and therefore we can iterate through the args like we would on a normal tuple or a list.
With this information, we can now make methods which can have a varying number of parameters.

These are some of the interesting observations I had while studying about tuples and list. If I made some egregious mistakes do send me a mail
or put a pull request on my repo. Also do check out my other blogs as well links in About section :)

Reference

RealPython
PythonDocs
UCD Python programing class

str() and repr()

sachin soman — Wed, 10 Mar 2021 00:44:52 +0000

Most of the time beginners and seasoned veterans of python try to debug their code using the trusty old print() statement,especially, to peek into contents of an object. This is particularly true when we are working in an interactive environment like a jupyter notebook. An example of this may be to see the contents of a list after an append operation. Let’s take a very simple example where we try to see what happens when we append elements to a list and try to see it using print()

lst = list()
    for x in range(3):
    lst.append(x)
    print(lst)
>>[0]
>>[0, 1]
>>[0, 1, 2]

We see that we get a user understandable output for the list object when we print the list object. Now let’s try to do something similar again. But this time we will try to print a user-defined object. We start by defining a simple class ‘Bike’

class Bike:
    def __init__(self,brand,size):
        self.brand = brand
        self.size = size

object_bike = Bike("Fixie","Medium")
print(object_bike)

>> <__main__.Bike object at 0x7fda39054e50>

We see that we get a user understandable output for the list object when we print the list object. Now let's try to do something similar again. But this time we will try to print a user-defined object. We start by defining a simple class 'Bike'

Here when we defined our own object and tried a print statement. We get a rather esoteric output <__main__.Bike object at 0x7fda39054e50>. Now, this output is not useful to end-user or a developer.

This is where __str__ and __repr__ comes to the play. These are special functions that can be overridden to make our objects more understandable. Developers who use java have used something similar called toString() to achieve the same.

If we go to python documentation we get a cryptic explanation as shown below

__str__() and __repr__() allows us to make a string representation of the objects. Now the more confusing aspect is why have two different methods to achieve the same thing? well both the functions are aimed at providing string interpretation of the objects. But for different audiences. The __str__ function is aimed at users who want an informal definition of the object which is understandable. While __repr__ is used to give a more formal definition of the object. This will make much more sense when we implement them in our previous 'Bike' class.

class Bike:
    def __init__(self,brand,size):
        self.brand = brand
        self.size = size

    def __str__(self):
        return f" ----Bike object----\n     brand:{self.brand} \n     size:{self.size} "

object_bike = Bike("Fixie","Medium")
print(object_bike)

>>  ---- Bike object ----
        brand: Fixie 
        size: Medium

Here now when we use print() on the object instance we get a more useful output that explains what the object is about. Now let's look at __repr__ implementation for this object.

class Bike:
    def __init__(self,brand,size):
        self.brand = brand
        self.size = size

    def __str__(self):
        return f" ----Bike object----\n     brand:{self.brand} \n     size:{self.size} "

    def __repr__(self):
        return f"Bike({self.brand!r},{self.size!r})"

object_bike = Bike("Fixie","Medium")
repr(object_bike)

>> "Bike('Fixie','Medium')"

Note: we will discuss why we used "!r" in the f-string in the "details on implementation" section

Now here we use repr(object) and we get a different output. This is aimed towards a developer and this provides much formal definition like how the object needs to be initialized. In fact we can use the output of repr to recreate the object. Also notice that repr outputs will have quotes indicating that its a string. We will learn why repr gives a string output in the following example.


class Bike:
    def __init__(self,brand,size):
        self.brand = brand
        self.size = size

    def __str__(self):
        return f" ----Bike object----\n     brand:{self.brand} \n     size:{self.size} "

    def __repr__(self):
        return f"Bike({self.brand!r},{self.size!r})"

object_bike = Bike("Fixie","Medium")
repr(object_bike)
# notice that the output is encased as a string
>> "Bike('Fixie','Medium')"

new_object = eval(repr(object_bike))
new_object.brand
>> "Fixie"
new_object.size
>> "Medium"

Here when we used repr a developer can understand how the object was created and the developer can use the eval() function to recreate the object. One thing to note is that if we use __str__ to create the same output it will not create the string equivalent hence cannot be used with eval.


class Bike:
    def __init__(self,brand,size):
        self.brand = brand
        self.size = size

    def __str__(self):
        return f"Bike({self.brand},{self.size})"

    def __repr__(self):
        return f"Bike({self.brand!r},{self.size!r})"

y = Bike("Fixie","Medium")
str(y)
# notice its not a string
>> Bike(Fixie,Medium)
repr(y)
# a string representation 
>> "Bike('Fixie','Medium')"

Now if we look closely with repr we used !r this is used with f-strings in python and it will wrap the output in a '' indicating its a string for example if we didn't use !r in above example our output will be


repr(y)
>> "Bike(Fixie,Medium)"
{% endhighlight %}

instead we want

{% highlight python %}

repr(y)
>> "Bike('Fixie','Medium')"

One thing to add is that repr() need not be always a strict definition of a function. We can have whatever output we want. But its a general convention to have __repr__to have a formal object definition while __str__to be the understandable output to an object.

Details on implimentation

When using a print() on an object. The object will first look for its __str__ implementation and if that is not there it will fallback to __repr__ output.
If we look more closely at the output of __str__ and __repr__ we notice that the output from __repr__ will be in string format which is enclosed in "". This allows us to use the output from __repr__ on functions like eval() which requires a string as an argument. This is why when we returned the f-string for __repr__ we used !r this will automatically add escape sequence characters output to make a proper string representation of the object.
It is always advisable to implement a __repr__ on a class
Its not possible to give a formal definition for all the classes we make and it is perfectly acceptable as well.

These are some of the interesting observations I had while studying about __str__ and __repr__. If I made some egregious mistakes do send me a mail.

DEV Community: sachin soman

Python Tuples and List

Tuples

Tuple Unpacking

*args

Reference

__str__() and __repr__()

Details on implimentation

Reference

str() and repr()