Lesson 08: Data Types or Objects in Python: Part 2

Python represents each “Data Type” by a class; So each data is a sample or object of a specific class. Although the programmer can also define the class of his choice, in this lesson we want to talk about that part of the data types or object types (Object Types) that are provided (Built-in) to the Python interpreter. Is to talk.

This lesson follows some of the other Python types, such as List, Tupel, Dictionary, and Collection.

Headlines

Lesson 08: Data Types or Objects in Python: Part 2

the list tuple dictionary Collection NoneType Grouping

the list

The “List” type is the most flexible ready-made type in Python. This type is like a “sequence” like a string, but unlike it is a “mutable” type. The list object is created using parentheses [] and can have members – of any type – separated by commas; The list type is actually a place to store various objects:

>>> L = [1, 2, 3]
>>> type(L)
<class 'list'>
>>> L
[1, 2, 3]
>>> print(L)
[1, 2, 3]
>>> import sys
>>> sys.getsizeof(L)
88

>>> L = [] # An empty list
>>> L
[]

List members can be of any type; Even a list:

>>> L = [15, 3.14, 'string', [1, 2]]

The list object is a type of Python sequence and can be accessed by members based on their position index:

>>> L = [1, 2, 3]
>>> L[0]
1
>>> L[-1]
3

Also obtained the number of members of each list object by the len () function [Python Documents]:

>>> L1 = []
>>> len(L1)
0
>>> L2 = ['python', 12.06]
>>> len(L2)
2
>>> len(L2[0])
6
>>> L3 = ['a', [1, 2], 'b']
>>> len(L3)
3
>>> len(L3[1])
2

If a sequence is a member of the object list, using the pattern seq [i] [j], its members can also be obtained, where i is an index that points to a member of the object list, and j also refers to the internal index of member i has it; This pattern can continue in the following way:

>>> L = ['python', 2.56]
>>> L[0]
'python'
>>> L[0][:2]
'py'
>>> L = ['python', 2.56, [128, ['a', 'z']]]
>>> L[2][1][0]
'a'

A common example of a list object is a simulation of a matrix structure:

>>> L = [[1, 2, 3],
... [4, 5, 6],
... [7, 8, 9]]
>>>
>>> L
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> L[0][1]
2

The list object is one of the mutable types of Python and its members can be changed; This change can take the form of deleting, inserting a new member, or replacing one or more members. Python has many practical methods for manipulating and changing the list object, which we will discuss in the following, but in this section we want to examine how to make a change using the assignment operator:

• Replace:

• Inserting – i in the pattern seq [i: i] refers to the position of the object seq where we want to insert it; In this way, note that the object you want to insert in the list must be a sequence:

• Delete – Simply assign an empty list object ([]) to one or more members of the list object:

>>> L = [0, 1, 2, 3, 4, 5, 6]
>>> L[2:5] = []
>>> L
[0, 1, 5, 6]

Command del You can also delete a member or a piece of the list object using the del [Python Documents] command:

>>> L = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> del L[2]
>>> L
['a', 'b', 'd', 'e', 'f', 'g']
>>> del L[1:4]
>>> L
['a', 'f', 'g']

We can also use this command to delete a variable completely. By targeting a variable, its reference to the object is also deleted, and if there is no other reference to that object, the object to which the variable was referenced is also deleted:

>>> a = 5
>>> a
5
>>> del a
>>> a
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

Multiple assignments A list object – or a whole sequence object – can be assigned to a number of names and separate variables can be created; This is called unpacking. In this case, the Python interpreter assigns each member of the sequence to one of the letters in order, which normally should be equal to the number of letters in the sequence:

>>> L = [1.1, 2.2, 3.3, 4.4]
>>> a, b, c, d = L
>>> a
1.1
>>> b
2.2
>>> c
3.3
>>> d
4.4

>>> a, b = [1.1, 2.2, 3.3, 4.4]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

But one of the letters can be marked with a * symbol; In this case, the Python interpreter creates a balance between the sequence members and the letters, in which case all the extra members – in the form of a list object – are assigned to the marked name. Of course, it should be noted that the order of the sequence members will be observed in all circumstances; Note the sample codes below:

>>> L = [1.1, 2.2, 3.3, 4.4]
>>> a, b, *c = L
>>> a
1.1
>>> b
2.2
>>> c
[3.3, 4.4]

>>> *a, b = [1.1, 2.2, 3.3, 4.4]
>>> a
[1.1, 2.2, 3.3]
>>> b
4.4

>>> a, *b, c = [1.1, 2.2, 3.3, 4.4]
>>> a
1.1
>>> b
[2.2, 3.3]
>>> c
4.4

>>> a, b, c, *d = [1.1, 2.2, 3.3, 4.4]
>>> a
1.1
>>> b
2.2
>>> c
3.3
>>> d
[4.4]

Copy As with other objects, another variable of this object type can be created by assigning an existing variable from the list object to a new name. Of course, as stated earlier; In this case, the object is not copied and only a new reference of this new name is given to the variable object. This can be tested using the id () function [Python Documents]; The output of this function is equal to the address of the object in memory, and obviously two identical id values for two variables indicate that their object is the same:

>>> L1 = [1, 2, 3]
>>> L2 = L1
>>> L2
[1, 2, 3]
>>> id(L1)
140254551721800
>>> id(L2)
140254551721800

The members of a list object are variable, and we should note that now that both variables point to the same object, if one of the variables changes the members of the object, our expected value of the object of the second variable will also change:

>>> L1 = [1, 2, 3]
>>> L2 = L1
>>> L1[0] = 7
>>> L1
[7, 2, 3]
>>> L2
[7, 2, 3]

If we consider this a problem, to solve it we can make a copy of the variable object and attribute this copy to the new variable; In this case, both variables will point to separate objects in different locations of memory. Normally no new work is needed to copy a list object and you can use indexing [:] – meaning all members -:

>>> L1
[7, 2, 3]
>>> L2 = L1[:]
>>> L1
[7, 2, 3]
>>> L2
[7, 2, 3]
>>> id(L1)
140254551721928
>>> id(L2)
140254551721800
>>> L1[0] = 5
>>> L1
[5, 2, 3]
>>> L2
[7, 2, 3]

>>> L1 = [1, 2, [7, 8]]
>>> L2 = L1[:]
>>> L2
[1, 2, [7, 8]]
>>> L1[2][1] = 5
>>> L1
[1, 2, [7, 5]]
>>> L2
[1, 2, [7, 5]]
>>> id(L1)
140402644179400
>>> id(L2)
140402651379720
>>> id(L1[2])
140402644179080
>>> id(L2[2])
140402644179080

>>> L1 = [1, 2, [7, 8]]
>>> import copy
>>> L2 = copy.copy(L1) # Shallow Copy
>>> L1[2][1] = 5
>>> L1
[1, 2, [7, 5]]
>>> L2
[1, 2, [7, 5]]

>>> L1 = [1, 2, [7, 8]]
>>> import copy
>>> L2 = copy.deepcopy(L1) # Deep Copy
>>> L1[2][1] = 5
>>> L1
[1, 2, [7, 5]]
>>> L2
[1, 2, [7, 8]]
>>> id(L1)
140402651379656
>>> id(L2)
140402644179400
>>> id(L1[2])
140402644106312
>>> id(L2[2])
140402651379080

Operators for lists You can use the + operators (to link lists) and * (to repeat list members):

>>> [1, 2] + [2, 3] + [3, 4]
[1, 2, 2, 3, 3, 4]
>>> ['python'] * 3
['python', 'python', 'python']

To check the equality of the values of the two objects in the list, like other objects, the == operator can be used:

Membership operators can also be used to check for an object in the list:

>>> L = ['a', [1, 2]]
>>> 'b' not in L
True
>>> 2 in L
False
>>> [1, 2] in L
True

Difference between == and is operators

The point that was not made in the previous lessons is to express the difference between the equality operator and the identity operator. Before giving an explanation, pay attention to the sample code below:

>>> a = 5
>>> b = a
>>> a == b
True
>>> a is b
True
>>> L1 = [1, 2, 3]
>>> L2 = L1
>>> L1 == L2
True
>>> L1 is L2
True
>>> L2 = L1[:]
>>> L1 == L2
True
>>> L1 is L2 # False!
False

Lesson 5 We remember that every object in Python contains an “identity”, a “type” and a “value”. The == operator examines two objects for the same “value”, while the is operator examines two objects for identical “identities” (output of the (id) function) or their address in memory.

It has already been stated that the Python interpreter avoids rebuilding existing “correct” objects and small “strings” to save time and memory, and only gives them a new reference. But this is not the case with other objects, and the Python interpreter creates and references a new object for each variable defined for this type of object:

>>> a = 5
>>> b = 5
>>> a == b
True
>>> a is b
True
>>> m = 'python'
>>> n = 'python'
>>> m == n
True
>>> m is n
True
>>> L1 = [1, 2, 3]
>>> L2 = [1, 2, 3]
>>> L1 == L2
True
>>> L1 is L2 # False!
False

Become a list object

Using the list () class [Python Documents], you can create a list object or convert sequential objects to a list object:

>>> a = 'python'
>>> type(a)
<class 'str'>
>>> b = list(a)
>>> type(b)
<class 'list'>
>>> b
['p', 'y', 't', 'h', 'o', 'n']

>>> L = list()
>>> L
[]

Application methods of a list object

The list object is changeable, and its methods, unlike the string object, do not return a new modified object, but make changes to the same object.

• append (x – adds the x object to the end of the list:

>>> L = [1, 2, 3]
>>> L.append(4)
>>> L
[1, 2, 3, 4]
>>> L.append(['a', 'b'])
>>> L
[1, 2, 3, 4, ['a', 'b']]

The function of this method L. append (x))) is the same as the operation L +[x]:

>>> L = [1, 2, 3]
>>> L + [4]
[1, 2, 3, 4]

• extend (s) adds the members of the s sequence object to the end of the list:

>>> L = [1, 2, 3]
>>> L.extend(['a', 'b'])
>>> L
[1, 2, 3, 'a', 'b']

>>> L = [1, 2, 3]
>>> L.extend('py')
>>> L
[1, 2, 3, 'p', 'y']

• insert (i, x) – puts a new member (such as x) in a position on the list with the desired index (such as i):

>>> L = [1, 2, 3]
>>> L.insert(0, 'python')
>>> L
['python', 1, 2, 3]

• remove (x) – Looks for object x in the list on the left and removes the first item found from the list. If no member equal to object x is found, it reports an error:

>>> L = [1, 2, 3, 5, 2 , 6 , 1]
>>> L.remove(2)
>>> L
[1, 3, 5, 2, 6, 1]
>>> L.remove(0)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

Attention In cases where you want to remove a specific index from the list; Use the del command.

• pop ([i]) – delete the corresponding member of the i index from the list and return it as output. If the index is not sent to the method, it will delete and return the last member of the list by default:

>>> L = ['a', 'b', 'c', 'd']
>>> L.pop(2)
'c'
>>> L
['a', 'b', 'd']
>>> L.pop()
'd'
>>> L
['a', 'b']

Attention The [] symbol in the methods template is the only way to express the optionality of the expression inside it and is not part of the method.

• index (x [, n]) – In the list, look for the object x on the left and return the index of the first item found. This method also has an optional argument (n) that can be used to specify the index of several items. Returns found.If no member equals object x is found it reports an error:

>>> L = ['s', 'b', 'c', 'a', 's', 'b']
>>> L.index('b')
1
>>> L.index('b', 2)
5
>>> L.index('z')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: 'z' is not in list

• count (x) – Returns the number of occurrences of object x in the list:

>>> L = ['a', 'b', 'c', 'a', 'a', 'b']
>>> L.count('a')
3
>>> L.count(5)
0

• clear () – deletes all members of the list. The function of this method is equivalent to the [:] del L command:

>>> L = [0, 1, 2, 3, 4, 5]
>>> L.clear()
>>> L
[]

>>> L = [0, 1, 2, 3, 4, 5]
>>> del L[:]
>>> L
[]

• reverse () – inverts the members of the list:

>>> L = ['a', 'b', 'c', 'd']
>>> L.reverse()
>>> L
['d', 'c', 'b', 'a']

• sort () – Sorts members of a list:

>>> L = [4, 6, 2, 1, 5, 0, 3]
>>> L.sort()
>>> L
[0, 1, 2, 3, 4, 5, 6]

>>> L = ['g', 'e', 'h', 'f', 'd']
>>> L.sort()
>>> L
['d', 'e', 'f', 'g', 'h']

By default, this method sorts in ascending order, but you can change the descending order by sending a True value to the optional reverse argument:

>>> L = [4, 6, 2, 1, 5, 0, 3]
>>> L.sort(reverse=True)
>>> L
[6, 5, 4, 3, 2, 1, 0]

The sort () method has another optional argument called key, which can be passed to each member of the list before comparing and sorting by sending a single argument function to it. Of course, it should be noted that only the function name should be sent to the method argument and not its complete template; For example, a function with a pattern (func (x) must be passed as key = func. If the key argument is passed, this method sends the list members to the specified function and finally considers their output for sorting. For example, code Note below:

>>> L = ['a', 'D', 'c', 'B', 'e', 'f', 'G', 'h']
>>> L.sort()
>>> L
['B', 'D', 'G', 'a', 'c', 'e', 'f', 'h']

As you can see, the uppercase letters are at the top of the sorted list; In fact, the uppercase letters in the list are evaluated to a smaller value, and if you pay attention to the ASCII code of these letters, you will understand the reason for this evaluation. To solve this problem, we can convert all letters to uppercase or lowercase before the comparison operation is performed by sorting the list members so that the letters are at the same level for comparison:

>>> L = ['a', 'D', 'c', 'B', 'e', 'f', 'G', 'h']
>>> L.sort(key=str.lower)
>>> L
['a', 'B', 'c', 'D', 'e', 'f', 'G', 'h']

What does str.lower mean in the example code above? In the previous lesson, we learned about the str () class, which was used to create a string object, and we also worked on some of its methods that were available for a string object (such as join). In the future, we will learn by the lesson about classes that methods can be called using the class name without creating an object; The same thing happened here, and lower (s) is a single-argument method inside the str class called by the name of this class.

>>> str
<class 'str'>
>>> str.lower
<method 'lower' of 'str' objects>
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__getnewargs__',
'__gt__', '__hash__', '__init__', '__iter__', '__le__',
'__len__', '__lt__', '__mod__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmod__', '__rmul__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__', 'capitalize', 'casefold',
'center', 'count', 'encode', 'endswith', 'expandtabs',
'find', 'format', 'format_map', 'index', 'isalnum',
'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower',
'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper',
'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition',
'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

tip Using the ready (dir) function [Python Documents] we can get a list of all available attributes and methods of an object.

Instead of the sort () method, you can use the ready sorted () function [Python Documents] with the same explanation:

>>> L = ['a', 'D', 'c', 'B', 'e', 'f', 'G', 'h']
>>> sorted(L)
['B', 'D', 'G', 'a', 'c', 'e', 'f', 'h']
>>> sorted(L, key=str.lower, reverse=True)
['h', 'G', 'f', 'e', 'D', 'c', 'B', 'a']

Create a stack A “stack” is a structure for temporarily storing data in such a way that the last data it contains will be the first data to be output; This is called LIFO or Last In, First Out. The stack only supports two operations (or methods): push, which puts data on top of all the data in it, and pop, which extracts the highest data. Stack structure can be easily implemented using the list type in Python; For a list object, the append () method is equivalent to push and the pop () method is equivalent to pop:

>>> stack = []
>>> stack.append(1)
>>> stack.append(2)
>>> stack.append(3)
>>> stack
[1, 2, 3]
>>> stack.pop()
3
>>> stack.pop()
2
>>> stack
[1]

Tuple

The “Tuple” type is the same as the list type, except that it is not changeable and its members are enclosed in parentheses ():

>>> t = (1, 2, 3)
>>> type(t)
<class 'tuple'>
>>> t
(1, 2, 3)
>>> print(t)
(1, 2, 3)
>>> import sys
>>> sys.getsizeof(t)
72

>>> t = () # An empty tuple
>>> t
()