Explained: How skilling can offset automation threat

If skilling is scaled up, we would be able to adapt to any and all changes

Sitakanta Panda

AI, robotics and Big Data are the facets of the digital revolution in which automation is the central theme. There are many aspects to the phenomenon, which most people perceive as a problem. When seen as a problem, there are many aspects to it too. For instance, on social media platforms like Twitter, “bots” are used to inflate the numbers of followers of celebrities or politicians, and also for trolling. Automation and digital revolution has led to anxiety for its disruptive possibilities, including on the future human labour.
Automation in manufacturing and services sectors in G20 (and other developed) countries has increased a lot, as self-optimising, self-correcting machines are substituting human labour. These machines with fed-in algorithms are doing the work that comprises not just repetitive tasks but also cognitive tasks involving subtle and non-routine judgement. Carl Frey and Michael Osborne in a famous 2017 study “The future of employment: How susceptible are jobs to computerisation?” classify 702 occupations on their susceptibility to automation. They conclude that over the next two decades 47% of the US workers are at risk of automation. According to World Bank estimates stated in the 2016 World Development Report, 57% of jobs in OECD countries could be automated over the next two decades.

The composition of the employment structure is changing and the share of labour in overall income is declining in the developed world. Yiqun Gloria Chen in a 2016 study found that employment and income shares of routine-intensive occupations have declined significantly relative to non-routine occupations. Wage and income inequalities are widening as the gap between the returns to labour and returns to capital is rising.
On the other hand, benefits of automation are appealing to producers—greater penetration of robots has reduced production costs and, consequently, wages and employment decline because of displacement effects (displacing workers from tasks) and a spurt in the productivity effect (as other industries and/or tasks increase their demand for labour).
In their 2017 study “Robots and jobs: Evidence from US labor markets”, Daron Acemoglu and Pascual Restrepo find that introduction of one more robot per 1,000 workers reduces employment-to-population ratio by 0.18 to 0.34 percentage points and wages by 0.25-0.5%. Digital revolution has created completely new jobs and industries (web designer, software developer, data security expert), though these demand high-skilled labour.

Societies that are able to offset the negative effects of increasing automation and digital technologies that replace humans would stand to gain the most in terms of sustainable economic progress. Aggregate societal welfare would increase upon rapid tech advances that effectively substitute cheap and abundant capital for previously expensive and wilful labour. But economists like David Autor opine that eking out a living for those who own labour but do not own capital would be more difficult. Thus, the distributional effects of increasing automation are worrisome.

A few salient narratives characterise how global labour markets are responding to the current technological change. First, according to a 2010 study by Autor, in an ongoing phenomenon called ‘job polarisation’, the highest and lowest ends of the skills spectrum have seen the most robust employment growth and two distinct sets of workforce have emerged—one with high-skilled, high-wage jobs, and the other with low-skilled, low-wage jobs.
The jobs that need middle-level skills, in contrast, contain highest concentration of routine tasks and are relatively easy to automate and run the risk of disappearance. Second, tech progress has enabled machines to do manual tasks that are more complex and non-routine—self-driving cars could possibly replace jobs in the trucking and logistics industry and Big Data and machine learning algorithms have the potential of replacing service occupations like administrative and clerical office staff.

Two competing effects of such tech progress are at work: technology replaces human labour requiring workers to reallocate their labour elsewhere, and it increases demand for other goods and services as new digital economy jobs and industries are created.
The extent to which tech will substitute or complement human labour depends on the tasks automation will take over and whether it can perform them with a comparable level of skill.
Studies show that sufficiently complex tasks require advanced skills that current automation technologies cannot perform. As increased digitalisation coincides with changes in the work environment and tasks expected to be carried out by workers, certain skills will be obsolete and new skills will find demand. The magnitude will vary by occupations and sectors.
In some sectors, new skill-sets will supplement and not supplant existing skill-sets—many future jobs will be defined by workers’ ability to analyse and work with data, and make data-based decisions. With future prevalence of automation and AI, a number of tasks involving technical skills like troubleshooting machine problems and resource management skills would be eliminated over time. But the demand for essentially human jobs (such as technicians with skills for repairing and maintenance) will increase.

Studies indicate that different countries will experience the labour market impact of automation differently. Developed countries use more technology at work and are experiencing faster changes in skill requirements, so their labour markets could witness larger disruptions in the near future. Out there, a smaller share of the workforce is employed in routine occupations susceptible to automation, but higher wages for human labour make automation a rational option.
Developing and low-income countries have a large number of workers in routine occupations. As these economies adopt automation faster, their labour markets will be substantially affected, albeit with a time lag. But labour markets in less developed countries suffer from huge skill deficit and this will exacerbate the problem of labour-capital and labour-machine conflicts.
To address labour market challenges, economists have mooted solutions such as skilling and training, taxation policies, social safety nets. Promoting faster skill development of the workforce is a policy priority since the higher the skill level of a job, the less likely it is for a machine to replace a human. Matthias Oschinski and Rosalie Wyonch in a 2017 study find that occupations high in abstract, complex decision-making skills with a strong focus on creativity and ideas, critical thinking and interpersonal social skills are at low risk of being automated.

Jobs that involve human interaction, heuristics of communication, persuasion and negotiation (like management, business and finance), along with jobs that require coming up with novel ideas and creativity (like those in the arts, media, engineering and science), are relatively safer jobs.
As India has abundant labour segregated in the informal sector that thrive on low-skill, low-wage jobs and occupations and a paucity of skilled labour, adoption of automation in the near future is expected to be sluggish despite huge presence of ICT-enabled industries and services in some pockets. The 2017 World Robotics Report states that India purchased 2,627 industrial robots in 2016 (comprising just 0.89% of global shipment). But the looming prospect of rising automation in manufacturing and services sectors offers a big opportunity for India, especially for skilling workforce. If skilling is scaled up, we would be able to adapt to the change.

The Basics of NumPy Arrays

Data manipulation in Python is nearly synonymous with NumPy array manipulation: even newer tools like Pandas (Chapter 3) are built around the NumPy array. This section will present several examples of using NumPy array manipulation to access data and subarrays, and to split, reshape, and join the arrays. While the types of operations shown here may seem a bit dry and pedantic, they comprise the building blocks of many other examples used throughout the book. Get to know them well!
We'll cover a few categories of basic array manipulations here:

• Attributes of arrays: Determining the size, shape, memory consumption, and data types of arrays
• Indexing of arrays: Getting and setting the value of individual array elements
• Slicing of arrays: Getting and setting smaller subarrays within a larger array
• Reshaping of arrays: Changing the shape of a given array
• Joining and splitting of arrays: Combining multiple arrays into one, and splitting one array into many

NumPy Array Attributes¶

First let's discuss some useful array attributes. We'll start by defining three random arrays, a one-dimensional, two-dimensional, and three-dimensional array. We'll use NumPy's random number generator, which we will seed with a set value in order to ensure that the same random arrays are generated each time this code is run:

In [1]:

import numpy as np
np.random.seed(0)  # seed for reproducibility

x1 = np.random.randint(10, size=6)  # One-dimensional array
x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array
x3 = np.random.randint(10, size=(3, 4, 5))  # Three-dimensional array

Each array has attributes ndim (the number of dimensions), shape (the size of each dimension), and size (the total size of the array):

In [2]:

print("x3 ndim: ", x3.ndim)
print("x3 shape:", x3.shape)
print("x3 size: ", x3.size)

x3 ndim:  3
x3 shape: (3, 4, 5)
x3 size:  60

Another useful attribute is the dtype, the data type of the array (which we discussed previously in Understanding Data Types in Python):

In [3]:

print("dtype:", x3.dtype)

dtype: int64

Other attributes include itemsize, which lists the size (in bytes) of each array element, and nbytes, which lists the total size (in bytes) of the array:

In [4]:

print("itemsize:", x3.itemsize, "bytes")
print("nbytes:", x3.nbytes, "bytes")

itemsize: 8 bytes
nbytes: 480 bytes

In general, we expect that nbytes is equal to itemsize times size.

Array Indexing: Accessing Single Elements¶

If you are familiar with Python's standard list indexing, indexing in NumPy will feel quite familiar. In a one-dimensional array, the i th  $i^{th}$ value (counting from zero) can be accessed by specifying the desired index in square brackets, just as with Python lists:

In [5]:

x1

Out[5]:

array([5, 0, 3, 3, 7, 9])

In [6]:

x1[0]

Out[6]:

5

In [7]:

x1[4]

Out[7]:

7

To index from the end of the array, you can use negative indices:

In [8]:

x1[-1]

Out[8]:

9

In [9]:

x1[-2]

Out[9]:

7

In a multi-dimensional array, items can be accessed using a comma-separated tuple of indices:

In [10]:

x2

Out[10]:

array([[3, 5, 2, 4],
       [7, 6, 8, 8],
       [1, 6, 7, 7]])

In [11]:

x2[0, 0]

Out[11]:

3

In [12]:

x2[2, 0]

Out[12]:

1

In [13]:

x2[2, -1]

Out[13]:

7

Values can also be modified using any of the above index notation:

In [14]:

x2[0, 0] = 12
x2

Out[14]:

array([[12,  5,  2,  4],
       [ 7,  6,  8,  8],
       [ 1,  6,  7,  7]])

Keep in mind that, unlike Python lists, NumPy arrays have a fixed type. This means, for example, that if you attempt to insert a floating-point value to an integer array, the value will be silently truncated. Don't be caught unaware by this behavior!

In [15]:

x1[0] = 3.14159  # this will be truncated!
x1

Out[15]:

array([3, 0, 3, 3, 7, 9])

Array Slicing: Accessing Subarrays¶

Just as we can use square brackets to access individual array elements, we can also use them to access subarrays with the slice notation, marked by the colon (:) character. The NumPy slicing syntax follows that of the standard Python list; to access a slice of an array x, use this:

x[start:stop:step]

If any of these are unspecified, they default to the values start=0, stop=size of dimension, step=1. We'll take a look at accessing sub-arrays in one dimension and in multiple dimensions.

One-dimensional subarrays¶

In [16]:

x = np.arange(10)
x

Out[16]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [17]:

x[:5]  # first five elements

Out[17]:

array([0, 1, 2, 3, 4])

In [18]:

x[5:]  # elements after index 5

Out[18]:

array([5, 6, 7, 8, 9])

In [19]:

x[4:7]  # middle sub-array

Out[19]:

array([4, 5, 6])

In [20]:

x[::2]  # every other element

Out[20]:

array([0, 2, 4, 6, 8])

In [21]:

x[1::2]  # every other element, starting at index 1

Out[21]:

array([1, 3, 5, 7, 9])

A potentially confusing case is when the step value is negative. In this case, the defaults for start and stop are swapped. This becomes a convenient way to reverse an array:

In [22]:

x[::-1]  # all elements, reversed

Out[22]:

array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

In [23]:

x[5::-2]  # reversed every other from index 5

Out[23]:

array([5, 3, 1])

Multi-dimensional subarrays¶

Multi-dimensional slices work in the same way, with multiple slices separated by commas. For example:

In [24]:

x2

Out[24]:

array([[12,  5,  2,  4],
       [ 7,  6,  8,  8],
       [ 1,  6,  7,  7]])

In [25]:

x2[:2, :3]  # two rows, three columns

Out[25]:

array([[12,  5,  2],
       [ 7,  6,  8]])

In [26]:

x2[:3, ::2]  # all rows, every other column

Out[26]:

array([[12,  2],
       [ 7,  8],
       [ 1,  7]])

Finally, subarray dimensions can even be reversed together:

In [27]:

x2[::-1, ::-1]

Out[27]:

array([[ 7,  7,  6,  1],
       [ 8,  8,  6,  7],
       [ 4,  2,  5, 12]])

Accessing array rows and columns¶

One commonly needed routine is accessing of single rows or columns of an array. This can be done by combining indexing and slicing, using an empty slice marked by a single colon (:):

In [28]:

print(x2[:, 0])  # first column of x2

[12  7  1]

In [29]:

print(x2[0, :])  # first row of x2

[12  5  2  4]

In the case of row access, the empty slice can be omitted for a more compact syntax:

In [30]:

print(x2[0])  # equivalent to x2[0, :]

[12  5  2  4]

Subarrays as no-copy views¶

One important–and extremely useful–thing to know about array slices is that they return views rather than copies of the array data. This is one area in which NumPy array slicing differs from Python list slicing: in lists, slices will be copies. Consider our two-dimensional array from before:

In [31]:

print(x2)

[[12  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

Let's extract a 2×2 $2\times 2$ subarray from this:

In [32]:

x2_sub = x2[:2, :2]
print(x2_sub)

[[12  5]
 [ 7  6]]

Now if we modify this subarray, we'll see that the original array is changed! Observe:

In [33]:

x2_sub[0, 0] = 99
print(x2_sub)

[[99  5]
 [ 7  6]]

In [34]:

print(x2)

[[99  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

This default behavior is actually quite useful: it means that when we work with large datasets, we can access and process pieces of these datasets without the need to copy the underlying data buffer.

Creating copies of arrays¶

Despite the nice features of array views, it is sometimes useful to instead explicitly copy the data within an array or a subarray. This can be most easily done with the copy() method:

In [35]:

x2_sub_copy = x2[:2, :2].copy()
print(x2_sub_copy)

[[99  5]
 [ 7  6]]

If we now modify this subarray, the original array is not touched:

In [36]:

x2_sub_copy[0, 0] = 42
print(x2_sub_copy)

[[42  5]
 [ 7  6]]

In [37]:

print(x2)

[[99  5  2  4]
 [ 7  6  8  8]
 [ 1  6  7  7]]

Reshaping of Arrays¶

Another useful type of operation is reshaping of arrays. The most flexible way of doing this is with the reshape method. For example, if you want to put the numbers 1 through 9 in a 3×3 $3\times 3$ grid, you can do the following:

In [38]:

grid = np.arange(1, 10).reshape((3, 3))
print(grid)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

Note that for this to work, the size of the initial array must match the size of the reshaped array. Where possible, the reshape method will use a no-copy view of the initial array, but with non-contiguous memory buffers this is not always the case.
Another common reshaping pattern is the conversion of a one-dimensional array into a two-dimensional row or column matrix. This can be done with the reshape method, or more easily done by making use of the newaxis keyword within a slice operation:

In [39]:

x = np.array([1, 2, 3])

# row vector via reshape
x.reshape((1, 3))

Out[39]:

array([[1, 2, 3]])

In [40]:

# row vector via newaxis
x[np.newaxis, :]

Out[40]:

array([[1, 2, 3]])

In [41]:

# column vector via reshape
x.reshape((3, 1))

Out[41]:

array([[1],
       [2],
       [3]])

In [42]:

# column vector via newaxis
x[:, np.newaxis]

Out[42]:

array([[1],
       [2],
       [3]])

We will see this type of transformation often throughout the remainder of the book.

Array Concatenation and Splitting¶

All of the preceding routines worked on single arrays. It's also possible to combine multiple arrays into one, and to conversely split a single array into multiple arrays. We'll take a look at those operations here.

Concatenation of arrays¶

Concatenation, or joining of two arrays in NumPy, is primarily accomplished using the routines np.concatenate, np.vstack, and np.hstack. np.concatenate takes a tuple or list of arrays as its first argument, as we can see here:

In [43]:

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
np.concatenate([x, y])

Out[43]:

array([1, 2, 3, 3, 2, 1])

You can also concatenate more than two arrays at once:

In [44]:

z = [99, 99, 99]
print(np.concatenate([x, y, z]))

[ 1  2  3  3  2  1 99 99 99]

It can also be used for two-dimensional arrays:

In [45]:

grid = np.array([[1, 2, 3],
                 [4, 5, 6]])

In [46]:

# concatenate along the first axis
np.concatenate([grid, grid])

Out[46]:

array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])

In [47]:

# concatenate along the second axis (zero-indexed)
np.concatenate([grid, grid], axis=1)

Out[47]:

array([[1, 2, 3, 1, 2, 3],
       [4, 5, 6, 4, 5, 6]])

For working with arrays of mixed dimensions, it can be clearer to use the np.vstack (vertical stack) and np.hstack (horizontal stack) functions:

In [48]:

x = np.array([1, 2, 3])
grid = np.array([[9, 8, 7],
                 [6, 5, 4]])

# vertically stack the arrays
np.vstack([x, grid])

Out[48]:

array([[1, 2, 3],
       [9, 8, 7],
       [6, 5, 4]])

In [49]:

# horizontally stack the arrays
y = np.array([[99],
              [99]])
np.hstack([grid, y])

Out[49]:

array([[ 9,  8,  7, 99],
       [ 6,  5,  4, 99]])

Similary, np.dstack will stack arrays along the third axis.

Splitting of arrays¶

The opposite of concatenation is splitting, which is implemented by the functions np.split, np.hsplit, and np.vsplit. For each of these, we can pass a list of indices giving the split points:

In [50]:

x = [1, 2, 3, 99, 99, 3, 2, 1]
x1, x2, x3 = np.split(x, [3, 5])
print(x1, x2, x3)

[1 2 3] [99 99] [3 2 1]

Notice that N split-points, leads to N + 1 subarrays. The related functions np.hsplit and np.vsplit are similar:

In [51]:

grid = np.arange(16).reshape((4, 4))
grid

Out[51]:

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

In [52]:

upper, lower = np.vsplit(grid, [2])
print(upper)
print(lower)

[[0 1 2 3]
 [4 5 6 7]]
[[ 8  9 10 11]
 [12 13 14 15]]

In [53]:

left, right = np.hsplit(grid, [2])
print(left)
print(right)

[[ 0  1]
 [ 4  5]
 [ 8  9]
 [12 13]]
[[ 2  3]
 [ 6  7]
 [10 11]
 [14 15]]

Similarly, np.dsplit will split arrays along the third axis.

Python Dictionary

Dictionaries are another example of a data structure. A dictionary is used to map or associate things you want to store the keys you need to get them. A dictionary in Python is just like a dictionary in the real world. Python Dictionary are defined into two elements Keys and Values.

Keys will be a single element
Values can be a list or list within a list, numbers, etc.
In this tutorial, we are going to learn,

Python Dictionary Methods
Copying dictionary
Updating Dictionary
Delete Keys from the dictionary
Dictionary items() Method
Sorting the Dictionary
Python Dictionary in-built Functions
Dictionary len() Method
Variable Types
Python List cmp() Method
Dictionary Str(dict)

Syntax for Python Dictionary:

  Dict = { ' Tim': 18,  xyz,.. }
Dictionary is listed in curly brackets, inside these curly brackets, keys and values are declared. Each key is separated from its value by a colon (:) while each element is separated by commas.

Properties of Dictionary Keys

There are two important points while using dictionary keys

More than one entry per key is not allowed ( no duplicate key is allowed)
The values in the dictionary can be of any type while the keys must be immutable like numbers, tuples or strings.
Dictionary keys are case sensitive- Same key name but with the different case are treated as different keys in Python dictionaries.
Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print (Dict['Tiffany'])
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print((Dict['Tiffany']))
In code, we have dictionary name "Dict"
We declared the name and age of the person in the dictionary, where name is "Keys" and age is the"value"
Now run the code
It retrieves the age of tiffany from the dictionary.
Python Dictionary Methods
Copying dictionary
You can also copy the entire dictionary to new dictionary. For example, here we have copied our original dictionary to new dictionary name "Boys" and "Girls".

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
studentX=Boys.copy()
studentY=Girls.copy()
print studentX
print studentY
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
studentX=Boys.copy()
studentY=Girls.copy()
print(studentX)
print(studentY)
We have the original dictionary (Dict) with the name and age of the boys and girls together
But we want boys list separate from girls list, so we defined the element of boys and girls in a separate dictionary name "Boys" and "Girls."
Now again we have created new dictionary name "studentX" and "studentY", where all the keys and values of boy dictionary are copied into studentX, and the girls will be copied in studentY
So now you don't have to look into the whole list in main dictionary( Dict) to check who is boy and who is girl, you just have to print studentX if you want boys list and StudentY if you want girls list
So, when you run the studentX and studentY dictionary, it will give all the element present in the dictionary of "boys" and "girls" separately
Updating Dictionary
You can also update a dictionary by adding a new entry or a key-value pair to an existing entry or by deleting an existing entry. Here in the example we will add another name "Sarah" to our existing dictionary.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Dict.update({"Sarah":9})
print Dict
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Dict.update({"Sarah":9})
print(Dict)
Our existing dictionary "Dict" does not have the name "Sarah."
We use the method Dict.update to add Sarah to our existing dictionary
Now run the code, it adds Sarah to our existing dictionary
Delete Keys from the dictionary
Python dictionary gives you the liberty to delete any element from the dictionary list. Suppose you don't want the name Charlie in the list, so you can delete the key element by following code.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
del Dict ['Charlie']
print Dict
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
del Dict ['Charlie']
print(Dict)
When you run this code, it should print the dictionary list without Charlie.

We used the code del Dict
When code executed, it has deleted the Charlie from the main dictionary
Dictionary items() Method
The items() method returns a list of tuple pairs (Keys, Value) in the dictionary.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print "Students Name: %s" % Dict.items()
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print("Students Name: %s" % list(Dict.items()))
We use the code items() method for our Dict.
When code was executed, it returns a list of items ( keys and values) from the dictionary
Check if a given key already exists in a dictionary

For a given list, you can also check whether our child dictionary exists in a main dictionary or not. Here we have two sub-dictionaries "Boys" and "Girls", now we want to check whether our dictionary Boys exist in our main "Dict" or not. For that, we use the forloop method with else if method.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
for key in Dict.keys():
    if key in Boys.keys():
        print True
    else:      
        print False
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
for key in list(Dict.keys()):
    if key in list(Boys.keys()):
        print(True)
    else:      
        print(False)
The forloop in code checks each key in the main dictionary for Boys keys
If it exists in the main dictionary, it should print true or else it should print false
When you execute the code, it will print "True" for three times, as we got three elements in our "Boys" dictionary
So it indicates that the "Boys" exist in our main dictionary (Dict)
Sorting the Dictionary
In the dictionary, you can also sort the elements. For example, if we want to print the name of the elements of our dictionary alphabetically we have to use the forloop. It will sort each element of dictionary accordingly.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
Students = Dict.keys()
Students.sort()
for S in Students:
      print":".join((S,str(Dict[S])))
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
Students = list(Dict.keys())
Students.sort()
for S in Students:
      print(":".join((S,str(Dict[S]))))
We declared the variable students for our dictionary "Dict."
Then we use the code Students.sort, which will sort the element inside our dictionary
But to sort each element in dictionary, we run the forloop by declaring variable S
Now, when we execute the code the forloop will call each element from the dictionary, and it will print the string and value in an order
Python Dictionary in-built Functions
Dictionary len() Method
The len() function gives the number of pairs in the dictionary.

For example,

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print "Length : %d" % len (Dict)
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print("Length : %d" % len (Dict))
When len (Dict) function is executed it gives the output at "4" as there are four elements in our dictionary

Variable Types
Python does not require to explicitly declare the reserve memory space; it happens automatically. The assign values to variable "=" equal sign are used. The code to determine the variable type is " %type (Dict)."

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print "variable Type: %s" %type (Dict)
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print("variable Type: %s" %type (Dict))
Use the code %type to know the variable type
When code was executed, it tells a variable type is a dictionary
Python List cmp() Method
The compare method cmp() is used in Python to compare values and keys of two dictionaries. If method returns 0 if both dictionaries are equal, 1 if dic1 > dict2 and -1 if dict1 < dict2.

Python 2 Example

Boys = {'Tim': 18,'Charlie':12,'Robert':25}
Girls = {'Tiffany':22}
print cmp(Girls, Boys)
Python 3 Example

cmp is not supported in Python 3
We have two dictionary name "Boys" and "Girls."
Which ever you declare first in code "cmp(Girls, Boys)" will be considered as dictionary 1. In our case, we declared "Girls" first, so it will be considered as dictionary 1 and boys as dictionary 2
When code is executed it prints out -1, It indicates that our dictionary 1 is less than dictionary 2.
Dictionary Str(dict)
With Str() method, you can make a dictionary into a printable string format.

Python 2 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print "printable string:%s" % str (Dict)
Python 3 Example

Dict = {'Tim': 18,'Charlie':12,'Tiffany':22,'Robert':25}
print("printable string:%s" % str (Dict))
Use the code % str (Dict)
It will return the dictionary elements into a printable string format
Here is the list of all Dictionary Methods

Method Description Syntax
copy() Copy the entire dictionary to new dictionary dict.copy()
update() Update a dictionary by adding a new entry or a key-value pair to an
existing entry or by deleting an existing entry. Dict.update([other])
items() Returns a list of tuple pairs (Keys, Value) in the dictionary. dictionary.items()
sort() You can sort the elements dictionary.sort()
len() Gives the number of pairs in the dictionary. len(dict)
cmp() Compare values and keys of two dictionaries cmp(dict1, dict2)
Str() Make a dictionary into a printable string format Str(dict)

Job Salary Hike 2018-2019