Search

Series List Filter

How to use sorted() and sort() in Python

Whenever you visit a pharmacy and ask for a particular medicine, have you noticed something? It hardly takes any time for the pharmacist to find it among several medicines. This is because all the items are arranged in a certain fashion which helps them know the exact place to look for. They may be arranged in alphabetical order or according to their category such as ophthalmics or neuro or gastroenterology and so on. A proper arrangement not only saves time but also make operations simple and easy, hence sorting is essential.At some point or the other, every programmer needs to learn one of the most essential skills,  Sorting. Python sorting functions comprise of a lot of features to perform basic sorting or customize ordering according to the programmer’s needs.Basically, sorting is a technique that is used to arrange data in an increasing and decreasing fashion according to some linear relationship among the data elements. You can sort numbers, or names or records of any kind in any fashion according to your needs. Sorting techniques can be used to arrange a list of mail recipients in an alphabetical manner.There are a number of sorting algorithms in Python starting from Bubble Sort, Insertion Sort, Quick Sort, Merge Sort, Selection Sort and so on. In this article we will look into how to use sorted() and sort() in Python. To learn more about other concepts of Python, go through our Python Tutorials.What is the need for Sorting?In simple terms, sorting means arranging data systematically. If the data you want to work with  is not sorted you will face problems in finding your desired element.The main advantages of sorting elements in Python are:When you work with sorting modules, you will get to know about a large number of language components.Sorting Algorithms provide an abstract way of learning about the accuracy of your program without worrying about system developments or dependencies.It will help you in understanding the program complexity and speed and how to increase the efficiency.How to order values using sorted()?sorted() is a built-in function that accepts an iterable and returns the sorted values in ascending order by default which contains the iterable items.Sorting Numbers using sorted()Let us define a list of integers called num_list and pass it as an argument to sorted():>>> num_list = [4, 10, 1, 7] >>> sorted(num_list) [1, 4, 7, 10] >>> num_list [4, 10, 1, 7]Some of the insights we gain from the code above are:sorted() is a built-in function found in the Python Standard Library. It cannot be defined.sorted() orders the values in num_list in ascending order by default, i.e. smallest to largest.The original values of num_list are not changed.sorted() being called, returns an ordered list of values.Since sorted() function returns the list in order, we can assign the returned list to another variable:>>> num_list = [4, 10, 1, 7] >>> sorted_list = sorted(num_list) >>> sorted_list [1, 4, 7, 10] >>> num_list [4, 10, 1, 7]A new variable sorted_list is created which holds the output of sorted().You can also use sorted() to sort tuples and sets just like numbers:>>> tuples = (4, 10, 1, 7) >>> sets = {10, 5, 10, 0, 2} >>> sorted_tuples = sorted(numbers_tuple) >>> sorted_sets = sorted(numbers_set) >>> sorted_tuples [1, 4, 7, 10] >>> sorted_sets [0, 2, 5, 10]The definition of sorted() states that it will return a new list whatever the input may be. So even if the input variables are tuples and sets, sorted() always returns a list.You can also perform type casting in cases where you need to match the returned object with the input type:>>> tuples = (4, 10, 1, 7) >>> sets = {10, 5, 10, 0, 2} >>> sorted_tuples = sorted(numbers_tuple) >>> sorted_sets = sorted(numbers_set) >>> sorted_tuples [1, 4, 7, 10] >>> sorted_sets [0, 2, 5, 10] >>> tuples(sorted_tuples) (1, 4, 7, 10) >>> sets(sorted_sets) {0, 2, 5, 10}In the code above, you can see the sorted_tuples when cast to tuples is retained in an ordered manner whereas sorted_sets when casted does not return an order list since it is unordered by definition.Sorting Strings using sorted()Sorting of strings is just like sorting tuples and sets. sorted() iterates across each character of the input and returns a string order.An example of sorting str type using sorted():>>> num_string = '98765' >>> char_string = 'sorting is fun' >>> sorted_num_string = sorted(num_string) >>> sorted_char_string = sorted(char_string) >>> sorted_num_string ['5', '6', '7', '8', '9'] >>> sorted_char_string ['', '','f', 'g', 'i', 'i', 'n', 'n', 'o', 'r', 's', 's', 't','u']The str is treated as a list and sorted() iterates through each character including spaces.You can use .split() to change the behavior and clean the output and .join() to rejoin them together:>>> string = 'sorting is fun' >>> sorted_string = sorted(string.split()) >>> sorted_string ['fun', 'is', 'sorting'] >>> ' '.join(sorted_string) 'fun is sorting'The actual string is converted into a list of words using .split() and then it is sorted with sorted() and then again joined together using .join().How to use sorted() with a reverse Argument?The syntax of the sorted() function is sorted(iterable, /, *, key=None, reverse=False).The built-in function sorted() comprises of three parameters:iterable — Required. A sequence such as string, tuple or list and collection such as set or dictionary.key — Optional. A function that serves as a key or to customize the sort order. The argument is set to None by default.reverse — Optional. A boolean flag that reverses the order of sorting. If True, the sorted list is reversed. The default argument is False.reverse is an optional keyword argument that changes the sorting order according to the Boolean value assigned to it. The default value is False, which performs sorting in ascending order. However, if the value is given as True, descending sort occurs:>>> name_list = ['Markian', 'Alex', 'Suzzane', 'Harleen'] >>> sorted(name_list) ['Alex', 'Harleen', 'Markian', 'Suzzane'] >>> sorted(name_list, reverse=True) ['Suzzane', 'Markian', 'Harleen', 'Alex']In the example above, the sorting is done on the basis of the first alphabet. However, when sorted() encounters the reverse keyword with a True argument, the output is reversed.Another example to understand the behavior of the reverse keyword:>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen'] >>> sorted(case_sensitive_names, reverse=True) ['harleen', 'alex', 'Suzzane', 'Markian'] >>> values_to_sort = [False, 1, 'A' == 'B', 1 <= 0] >>> sorted(values_to_sort, reverse=True) [1, False, False, False] >>> num_list = [7, 10, 0, 4] >>> sorted(num_list, reverse=False) [0, 4, 7, 10]How to use sorted() with a key Argument?The keyword argument key accepts a function and this function determines the resulting order by implementing itself in each value of the list.An example to illustrate sorting of a list using the function len(), which returns the length of the string, and providing the key argument as len:>>> word = 'pencil' >>> len(word) 6 >>> word_list = ['cherry', 'donut', 'Michigan', 'transcipt'] >>> sorted(word_list, key=len) ['donut', 'cherry', 'Michigan', 'transcript']The len() function determines the length of each item in the list and returns the list in ascending order (shortest to longest).Let us sort the earlier example using key where the first alphabet with different case was considered for the order:>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen'] >>> sorted(case_sensitive_names, reverse=True) ['Markian', 'Suzzane', 'alex', 'harleen'] >>> sorted(case_sensitive_names, key=str.lower) ['alex', 'harleen', 'Markian', 'Suzzane']The key cannot make any changes to the original values in the list. So the final output will be the original sorted elements.Though key is considered as one of the most powerful components of sorted(), it has a number of limitations.The first limitation is that key accepts only single argument functions.An example of a function addition that accepts two arguments:>>> def addition(a, b):       return a + b >>> number_to_add = [1, 3, 5] >>> sorted(number_to_add , key=addition) Traceback (most recent call last):   File "stdin", line 5, in <module>     sorted(number_to_add, key=addition) TypeError: addition() missing 1 required positional argument: 'b'The program fails because whenever addition() is called during sorting, it receives only one element from the list at a time. The second argument is always missing.The second limitation is that the key function that is used must be able to handle all types of iterable values.An example to illustrate the second limitation:>>> cast_values = ['4', '5', '6', 'seven'] >>> sorted(cast_values, key=int) Traceback (most recent call last):   File "<stdin>", line 1, in <module> ValueError: invalid literal for int() with base 10: 'seven'The example above contains a list of numbers to be used by sorted() as strings. The key will try to convert the numbers to int. Each of the numbers represented as strings can be converted to int, but four cannot be. So a ValueError gets raised since four is not valid to cast into an int.Let us see an example to arrange an iterable by the last letter of each string:>>> def reverse(word):       return word[::-1] >>> words = ['cherry', 'cake', 'Michigan', 'transcript'] >>> sorted(words, key=reverse) ['cake', 'Michigan', 'transcript', 'cherry']The function reverse is defined to reverse the input string and then the function is used as the key argument. The slice syntax word[::-1] reverses the string and then the function reverse() takes all the elements one at a time and sorts the list according to the last alphabet.You can also use lambda function in the key argument instead of defining a regular function. A lambda is an anonymous function that does not have a name and executes just like normal functions. Lambda functions do not contain any statements.An example to show the previous code using a lambda function:>>> words = ['cherry', 'cake', 'Michigan', 'transcript'] >>> sorted(words, key = lambda x: x[::-1]) ['cake', 'Michigan', 'transcript', 'cherry']Here, the key is defined with lambda with no name and x is the argument. The slice syntax word[::-1] reverses each of the element and the reversed output is then used for sorting.An example to use key along with reverse argument:>>> words = ['cherry', 'cake', 'Michigan', 'transcript'] >>> sorted(words, key = lambda x: x[::-1], reverse = True) ['cherry', 'transcript', 'Michigan', 'cake']In this example, the order is reversed into a descending manner.Lambda functions can also be used to sort class objects according to their properties.An example to sort a group of students based on their grade in descending order:>>> from collections import namedtuple >>> Student = namedtuple('Student', 'name grade') >>> alex = Student('Alex', 95) >>> bob = Student('Bob', 87) >>> charlie = Student('Charlie', 91) >>> students = [alex, bob, charlie] >>> sorted(students, key=lambda x: getattr(x, 'grade'), reverse=True) [Student(name='Alex', grade=95), Student(name='Charlie', grade=91), Student(name='Bob', grade=87)]The namedtuple is used to produce classes with name and grade attributes. The lambda is used to get the grade property of each student and reverse is used to reverse the output into descending order so that the highest grades are arranged first.There are a lot of possible techniques to arrange elements using sorted() with key and reverse arguments. Lambda functions can also be helpful during sorting by making your code simple and clean.You can also use operator module functions like itemgetter() and attrgetter() to make your sorting program simpler and faster. The operator module is used to export a set of accessor functions in correspondence to the operators of Python.An example to illustrate operator module functions using key:>>> tuples = [      ('alex', 'B', 13),      ('bob', 'A', 12),      ('charles', 'B', 10),      ]>>> from operator import itemgetter>>> sorted(tuples, key=itemgetter(2))>>>[('charles', 'B', 10), ('bob', 'B', 12), ('alex', 'A', 13)]tuples is declared with the name, grade and age of three persons. The function itemgetter is imported from the module operator and then it is sorted by age and the output displayed in ascending order.How to order values using sort()?The .sort() which is quite similar to sorted() in naming has few differences than sorted(). The help documentation of Python will clear out the two critical differences between .sort() and sorted():>>> help(sorted) Help on built-in function sorted in module builtins: sorted(iterable, /, *, key=None, reverse=False)     Return a new list containing all items from the iterable in ascending order.     A custom key function can be supplied to customize the sort order, and the     reverse flag can be set to request the result in descending order. >>> help(list.sort) Help on method_descriptor: sort(self, /, *, key=None, reverse=False)     Stable sort *IN PLACE*.Firstly, .sort() is not a built-in function unlike sorted(). It is a method of list class and works only with lists. You cannot pass iterables to .sort().Secondly, .sort()  returns None and changes the values.Let us see the differences of code for .sort() and what impact it has on the code:>>> sort_numbers = [10, 2, 7, 3] >>> sort(sort_numbers) Traceback (most recent call last):   File "<stdin>", line 1, in <module> NameError: name 'sort' is not defined >>> sort_tuples = (10, 2, 7, 3) >>> sort_tuple.sort()>>> sort_tuples = (10, 2, 7, 3) >>> sort_tuple.sort() Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'tuple' object has no attribute 'sort' >>> sorted_values = sort_numbers.sort() >>> print(sorted_values) None >>> sorted_values = sort_numbers.sort() >>> print(sorted_values)int(sort_numbers) [1, 2, 5, 6]The code above highlights some operational differences between .sort() and sorted():When any assignment is done to a new variable, it returns a None type. This is because .sort() function has no ordered output. The original order of sort_numbers is not maintained and is changed in place..sort() also contains the key and reverse optional keyword arguments just like sorted() which produces the same functionality.An example of .sort() using lambda to sort a list of phrases by the first letter of the third word:>>> sort_phrases = ['welcome to python',       'python is fun',       'python is easy'       ] >>> sort_phrases.sort(key=lambda x: x.split()[2][1], reverse=False) >>> sort_phrases ['python is easy', 'python is fun', 'welcome to python']Here, lambda is used to split each phrase into a list of words and then find the second letter of the third element for each phrase.Disadvantages of  Python SortingPython has some limitations when you try to sort values besides integers.Non-Comparable Data TypesYou cannot use sort data types that are different from each other. Python raises an error when sorted() is used on non-comparable data.An example to illustrate sorting of values of different data types:>>> mixed_values = [None, 5] >>> sorted(mixed_values) Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: '<' not supported between instances of 'int' and 'NoneType'Python raises a TypeError because it cannot sort None and int in the same list because of their incompatibility. It uses the less than operator ( < ) to determine the lower value in the order of the sort.If you try to compare the same values manually without using sorted(), it will still raise a TypeError because of non-comparable data types:>> None < 5 Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: '<' not supported between instances of 'NoneType' and 'int'However, if your list contains a combination of integers and strings that are all numbers, Python will cast them to comparable types using a list comprehension:>>> num_mix = [10, "5", 200, "11"] >>> sorted(num_mix) Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: '<' not supported between instances of 'str' and 'int' >>> # List comprehension to cast all values to integers >>> [int(z) for z in num_mix] [10, 5, 200, 11] >>> sorted([int(z) for z in num_mix]) [5, 10, 11, 200]int() converts all the string values in num_mix to integers and then sorted() compares all values and returns a sorted output.An example of a Python code of implicitly converting a value to another type:>>> values = [1, False, 0, 'a' == 'b', 0 >= 1] >>> sorted(values) [False, 0, False, False, 1]In the example above, all the elements in the list are converted to boolean type. 0 >= 1 evaluates to a False output. The number 1 and 0 are converted to True and False as bool type respectively.This particular example highlights an important characteristic of sorting– sort stability. Sorting ability means that sorting algorithms are always stable. The original order is retained even if multiple records have the same key argument.An example to illustrate sort stability:>>> values = [False, 0, 0, 3 == 4, 1, False, False] >>> sorted(values) [False, 0, 0, False, 0, False, 1]If you take a look at the original order and the sorted output, you’ll find that the expression 3 == 4 is casted to False and all sorted output is in the actual order. You can also perform complex sorts with the help of the knowledge of sort stability.Case-Sensitive SortingYou can use sorted() to sort a list of strings in ascending order which is alphabetical by default:>>> name_list = ['Markian', 'Alex', 'Suzzane', 'Harleen'] >>> sorted(name_list) ['Alex', 'Harleen', 'Markian', 'Suzzane']However, Python uses Unicode Code Point of the first letter of each string to evaluate the ascending order of the sort. If there are two names Al and al, Python will treat both of them differently.An example to return the Unicode Code Point of the first alphabet of each string:>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen'] >>> sorted(case_sensitive_names) ['Markian', 'Suzzane', 'alex', 'harleen'] >>> # List comprehension for Unicode Code Point of first letter in each word >>> [(ord(name[0]), name[0]) for name in sorted(case_sensitive_names)] [(77, 'M'), (83, 'S'), (97, 'a'), (104, 'h')]In the example above, name[0] returns the first letter of the string and ord(name[0]) returns the Unicode Code Point. You can notice that even a comes before M alphabetically, the output has M before a. This is because the code point of M comes before a.Consider a situation where the first letter is the same for all the strings that need to be sorted. In such cases, the sorted() function will use the second letter to determine the order and if the second letter is also same, it will consider the third letter and so on, till the end of string:>>> similar_strings = ['zzzzzn', 'zzzzzc', 'zzzzza','zzzzze'] >>> sorted(similar_strings) ['zzzzza', 'zzzzzc', 'zzzzze', 'zzzzzn']Here, sorted() will compare the strings based on the sixth character since the first five characters are the same ( z ). The output will also depend on the last character of each string.An example of sorting elements having identical values:>>> different_lengths = ['zzzzz', 'zz', 'zzzz','z'] >>> sorted(different_lengths) ['z', 'zz', 'zzzz', 'zzzzz']In this case, the sorting order will be from the shortest to the longest. The shortest string z is ordered first and the longest string zzzzz is ordered at the last.When should you use .sort() and sorted()?Let us consider a case where you need to collect data from a race of 5k runners, the Python 5k Annual and then sort them. You will have to collect the runner’s bib number and the time it took to finish the race:>>> from collections import namedtuple >>> Runner_data = namedtuple('Runner', 'bibnumber duration')Each of the Runner_data will be added to a list called runners:>>> runners = [] >>> runners.append(Runner_data('2548597', 1200)) >>> runners.append(Runner_data('8577724', 1720)) >>> runners.append(Runner_data('2666234', 1600)) >>> runners.append(Runner_data('2425114', 1450)) >>> runners.append(Runner_data('2235232', 1620))     ...     ... >>> runners.append(Runner_data('2586674', 1886))The bib number and the total time taken by the runner is added to runners each time they cross the finish line.Now, you know the top five runners according to the duration time are the winners and the rest of them will be sorted by the fastest time:>>> runners.sort(key=lambda x: getattr(x, 'duration')) >>> fastest_five_runners = runners[:5]In this example, we didn’t need any multiple types of sorting. The list was a reasonable choice. You just sorted the participants and grabbed the fastest five runners. Storing the list elsewhere was also not needed. The lambda function is used here to get the duration of each runner and then sorting is performed. Finally, the result is stored in fastest_five_runners.However, the managing director of the race comes to you and informs that they have decided that every 20th runner will be awarded a free sports bag. Since the original data has been changed and cannot be recoverable, it is impossible to find every 20th runner.In such cases, where you find a slight possibility that the original data is to be recovered, use sorted() instead of sort().Let us implement the same code above using sorted():>>> runners_by_time = sorted(runners, key=lambda x: getattr(x, 'duration')) >>> fastest_five_runners = runners_by_time[:5]In this situation, sorted() holds the original list of runners and their data and is not overwritten. You can find every 20th person to cross the finish line by interacting with the original values:>>> every_twentieth_runner = runners[::20]List slice on runners is used to create  every_twentieth_runner that holds the actual order in which runners crossed the finish line.So, sorted() should be used in cases where the original data is to be retained and sort() should be used where the original data is a copy or unimportant and losing it won’t stand as an issue.Some Earlier ways of  Python SortingThere were mainly two approaches of sorting when Python 2 was released— decorated-sort-undecorated and using cmp parameter.Decorated-Sort-UndecoratedThis idiom Decorated-Sort-Undecorated is based upon three three steps:First of all, the original list is decorated with new elements which manages the sort order.Secondly, sorting is performed on the decorated list.Finally, a list is created that contains the original elements in the new order and the decorations are removed.Let us see an example of the DSU approach using a class:>>> class Student:       def prop(self,name, grade, age):           self.name = name           self.grade = grade           self.age = age       def stu_repr(self):           return repr((self.name, self.grade, self.age)) >>> student_objects = [       Student('alex', 'B', 13),       Student('bob', 'A', 12),       Student('chrles', 'B', 10),     ] #Regular sorting using sorted() >>> sorted(student_objects, key=lambda student: student.age) [('charles', 'B', 10), ('bob', 'A', 12), ('alex', 'B', 13)] #DSU Approach >>> decorated_values = [(student.grade, i, student) for i, student in enumerate(student_objects)] >>> decorated_values.sort() >>> [student for grade, i, student in decorated_values]   [('bob', 'A', 12), ('alex', 'B', 13),('charles', 'B', 10)]In this code above, a class Student is created with student objects name, grade and age. Firstly, the original values are decorated and then sorted. Finally, the decorations are removed from decorated_values and then the new list is created with original values in new order.The Decorated-Sort-Undecorated technique is also the Schwartzian Transform and is helpful in increasing the efficiency of sorting in Python.Using cmp Parametercmp is a method or  parameter in Python that is used to compare two arguments. It returns either of the three values– a negative value in case of less than (<) comparisons or zero if equal or a positive value for greater than (>) comparisons.An example to illustrate cmp using sorted():>>> def num_compare(a, b):       return a - b >>> sorted([9, 2, 5, 0, 7], cmp=num_compare) [0, 2, 5, 7, 9]Here, a function num_compare is created and then the list is sorted by comparing each value in the list. Finally, the output is displayed in ascending order.Note that cmp parameter will work only in Python 2 . It is completely removed from Python 3 to make the language more simple and to resist conflicts between other comparison techniques and cmp.SummaryLet us sum up what we have learned in this article so far—Sorting and its needs.How to use sorted() to sort values with and without key and reverse.How to use .sort() to order values with and without key and reverse.Limitations and Gotchas with Python Sorting.Appropriate use of .sort() and sorted().Both .sort() and sorted() can be used to sort elements in a similar manner if used properly with key and reverse arguments.However, both have different characteristics when output and in-place modifications are considered, so it is suggested to first have a clear understanding of the program to be worked upon, while using .sort() since it can irrevocably overwrite data.To become a good Python developer, understanding complex sorting algorithms would be a useful skill set in the long run. For more information about sorting in Python, look into the official documentation of sorting of the Python Software Foundation and also grab a glimpse of another Python sorting algorithm called the TimSort. You may also join our Python certification course to gain further skills and knowledge in Python.
Rated 4.5/5 based on 12 customer reviews

How to use sorted() and sort() in Python

8677
How to use sorted() and sort() in Python

Whenever you visit a pharmacy and ask for a particular medicine, have you noticed something? It hardly takes any time for the pharmacist to find it among several medicines. This is because all the items are arranged in a certain fashion which helps them know the exact place to look for. They may be arranged in alphabetical order or according to their category such as ophthalmics or neuro or gastroenterology and so on. A proper arrangement not only saves time but also make operations simple and easy, hence sorting is essential.

At some point or the other, every programmer needs to learn one of the most essential skills,  Sorting. Python sorting functions comprise of a lot of features to perform basic sorting or customize ordering according to the programmer’s needs.

Basically, sorting is a technique that is used to arrange data in an increasing and decreasing fashion according to some linear relationship among the data elements. You can sort numbers, or names or records of any kind in any fashion according to your needs. Sorting techniques can be used to arrange a list of mail recipients in an alphabetical manner.

There are a number of sorting algorithms in Python starting from Bubble Sort, Insertion Sort, Quick Sort, Merge Sort, Selection Sort and so on. In this article we will look into how to use sorted() and sort() in Python. To learn more about other concepts of Python, go through our Python Tutorials.

What is the need for Sorting?

In simple terms, sorting means arranging data systematically. If the data you want to work with  is not sorted you will face problems in finding your desired element.

The main advantages of sorting elements in Python are:

  • When you work with sorting modules, you will get to know about a large number of language components.
  • Sorting Algorithms provide an abstract way of learning about the accuracy of your program without worrying about system developments or dependencies.
  • It will help you in understanding the program complexity and speed and how to increase the efficiency.

How to order values using sorted()?

sorted() is a built-in function that accepts an iterable and returns the sorted values in ascending order by default which contains the iterable items.

Sorting Numbers using sorted()

Let us define a list of integers called num_list and pass it as an argument to sorted():

>>> num_list = [4, 10, 1, 7]
>>> sorted(num_list)
[1, 4, 7, 10]
>>> num_list
[4, 10, 1, 7]

Some of the insights we gain from the code above are:

  • sorted() is a built-in function found in the Python Standard Library. It cannot be defined.
  • sorted() orders the values in num_list in ascending order by default, i.e. smallest to largest.
  • The original values of num_list are not changed.
  • sorted() being called, returns an ordered list of values.

Since sorted() function returns the list in order, we can assign the returned list to another variable:

>>> num_list = [4, 10, 1, 7]
>>> sorted_list = sorted(num_list)
>>> sorted_list
[1, 4, 7, 10]
>>> num_list
[4, 10, 1, 7]

A new variable sorted_list is created which holds the output of sorted().

You can also use sorted() to sort tuples and sets just like numbers:

>>> tuples = (4, 10, 1, 7)
>>> sets = {10, 5, 10, 0, 2}
>>> sorted_tuples = sorted(numbers_tuple)
>>> sorted_sets = sorted(numbers_set)
>>> sorted_tuples
[1, 4, 7, 10]
>>> sorted_sets
[0, 2, 5, 10]

The definition of sorted() states that it will return a new list whatever the input may be. So even if the input variables are tuples and sets, sorted() always returns a list.

You can also perform type casting in cases where you need to match the returned object with the input type:

>>> tuples = (4, 10, 1, 7)
>>> sets = {10, 5, 10, 0, 2}
>>> sorted_tuples = sorted(numbers_tuple)
>>> sorted_sets = sorted(numbers_set)
>>> sorted_tuples
[1, 4, 7, 10]
>>> sorted_sets
[0, 2, 5, 10]
>>> tuples(sorted_tuples)
(1, 4, 7, 10)
>>> sets(sorted_sets)
{0, 2, 5, 10}

In the code above, you can see the sorted_tuples when cast to tuples is retained in an ordered manner whereas sorted_sets when casted does not return an order list since it is unordered by definition.

Sorting Strings using sorted()

Sorting of strings is just like sorting tuples and sets. sorted() iterates across each character of the input and returns a string order.

An example of sorting str type using sorted():

>>> num_string = '98765'
>>> char_string = 'sorting is fun'
>>> sorted_num_string = sorted(num_string)
>>> sorted_char_string = sorted(char_string)
>>> sorted_num_string
['5', '6', '7', '8', '9']
>>> sorted_char_string
['', '','f', 'g', 'i', 'i', 'n', 'n', 'o', 'r', 's', 's', 't','u']

The str is treated as a list and sorted() iterates through each character including spaces.

You can use .split() to change the behavior and clean the output and .join() to rejoin them together:

>>> string = 'sorting is fun'
>>> sorted_string = sorted(string.split())
>>> sorted_string
['fun', 'is', 'sorting']
>>> ' '.join(sorted_string)
'fun is sorting'

The actual string is converted into a list of words using .split() and then it is sorted with sorted() and then again joined together using .join().

How to use sorted() with a reverse Argument?

The syntax of the sorted() function is sorted(iterable, /, *, key=None, reverse=False).

The built-in function sorted() comprises of three parameters:

  • iterable — Required. A sequence such as string, tuple or list and collection such as set or dictionary.
  • key — Optional. A function that serves as a key or to customize the sort order. The argument is set to None by default.
  • reverse — Optional. A boolean flag that reverses the order of sorting. If True, the sorted list is reversed. The default argument is False.

reverse is an optional keyword argument that changes the sorting order according to the Boolean value assigned to it. The default value is False, which performs sorting in ascending order. However, if the value is given as True, descending sort occurs:

>>> name_list = ['Markian', 'Alex', 'Suzzane', 'Harleen']
>>> sorted(name_list)
['Alex', 'Harleen', 'Markian', 'Suzzane']
>>> sorted(name_list, reverse=True)
['Suzzane', 'Markian', 'Harleen', 'Alex']

In the example above, the sorting is done on the basis of the first alphabet. However, when sorted() encounters the reverse keyword with a True argument, the output is reversed.

Another example to understand the behavior of the reverse keyword:

>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen']
>>> sorted(case_sensitive_names, reverse=True)
['harleen', 'alex', 'Suzzane', 'Markian']
>>> values_to_sort = [False, 1, 'A' == 'B', 1 <= 0]
>>> sorted(values_to_sort, reverse=True)
[1, False, False, False]
>>> num_list = [7, 10, 0, 4]
>>> sorted(num_list, reverse=False)
[0, 4, 7, 10]

How to use sorted() with a key Argument?

The keyword argument key accepts a function and this function determines the resulting order by implementing itself in each value of the list.

An example to illustrate sorting of a list using the function len(), which returns the length of the string, and providing the key argument as len:

>>> word = 'pencil'
>>> len(word)
6
>>> word_list = ['cherry', 'donut', 'Michigan', 'transcipt']
>>> sorted(word_list, key=len)
['donut', 'cherry', 'Michigan', 'transcript']

The len() function determines the length of each item in the list and returns the list in ascending order (shortest to longest).

Let us sort the earlier example using key where the first alphabet with different case was considered for the order:

>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen']
>>> sorted(case_sensitive_names, reverse=True)
['Markian', 'Suzzane', 'alex', 'harleen']
>>> sorted(case_sensitive_names, key=str.lower)
['alex', 'harleen', 'Markian', 'Suzzane']

The key cannot make any changes to the original values in the list. So the final output will be the original sorted elements.

Though key is considered as one of the most powerful components of sorted(), it has a number of limitations.

The first limitation is that key accepts only single argument functions.

An example of a function addition that accepts two arguments:

>>> def addition(a, b):
      return a + b
>>> number_to_add = [1, 3, 5]
>>> sorted(number_to_add , key=addition)
Traceback (most recent call last):
  File "stdin", line 5, in <module>
    sorted(number_to_add, key=addition)
TypeError: addition() missing 1 required positional argument: 'b'

The program fails because whenever addition() is called during sorting, it receives only one element from the list at a time. The second argument is always missing.

The second limitation is that the key function that is used must be able to handle all types of iterable values.

An example to illustrate the second limitation:

>>> cast_values = ['4', '5', '6', 'seven']
>>> sorted(cast_values, key=int)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'seven'

The example above contains a list of numbers to be used by sorted() as strings. The key will try to convert the numbers to int. Each of the numbers represented as strings can be converted to int, but four cannot be. So a ValueError gets raised since four is not valid to cast into an int.

Let us see an example to arrange an iterable by the last letter of each string:

>>> def reverse(word):
      return word[::-1]
>>> words = ['cherry', 'cake', 'Michigan', 'transcript']
>>> sorted(words, key=reverse)
['cake', 'Michigan', 'transcript', 'cherry']

The function reverse is defined to reverse the input string and then the function is used as the key argument. The slice syntax word[::-1] reverses the string and then the function reverse() takes all the elements one at a time and sorts the list according to the last alphabet.

You can also use lambda function in the key argument instead of defining a regular function. A lambda is an anonymous function that does not have a name and executes just like normal functions. Lambda functions do not contain any statements.

An example to show the previous code using a lambda function:

>>> words = ['cherry', 'cake', 'Michigan', 'transcript']
>>> sorted(words, key = lambda x: x[::-1])
['cake', 'Michigan', 'transcript', 'cherry']

Here, the key is defined with lambda with no name and x is the argument. The slice syntax word[::-1] reverses each of the element and the reversed output is then used for sorting.

An example to use key along with reverse argument:

>>> words = ['cherry', 'cake', 'Michigan', 'transcript']
>>> sorted(words, key = lambda x: x[::-1], reverse = True)
['cherry', 'transcript', 'Michigan', 'cake']

In this example, the order is reversed into a descending manner.

Lambda functions can also be used to sort class objects according to their properties.

An example to sort a group of students based on their grade in descending order:

>>> from collections import namedtuple
>>> Student = namedtuple('Student', 'name grade')
>>> alex = Student('Alex', 95)
>>> bob = Student('Bob', 87)
>>> charlie = Student('Charlie', 91)
>>> students = [alex, bob, charlie]
>>> sorted(students, key=lambda x: getattr(x, 'grade'), reverse=True)
[Student(name='Alex', grade=95), Student(name='Charlie', grade=91), Student(name='Bob', grade=87)]

The namedtuple is used to produce classes with name and grade attributes. The lambda is used to get the grade property of each student and reverse is used to reverse the output into descending order so that the highest grades are arranged first.

There are a lot of possible techniques to arrange elements using sorted() with key and reverse arguments. Lambda functions can also be helpful during sorting by making your code simple and clean.

You can also use operator module functions like itemgetter() and attrgetter() to make your sorting program simpler and faster. The operator module is used to export a set of accessor functions in correspondence to the operators of Python.

An example to illustrate operator module functions using key:

>>> tuples = [
      ('alex', 'B', 13),
      ('bob', 'A', 12),
      ('charles', 'B', 10),
      ]
>>> from operator import itemgetter
>>> sorted(tuples, key=itemgetter(2))
>>>[('charles', 'B', 10), ('bob', 'B', 12), ('alex', 'A', 13)]

tuples is declared with the name, grade and age of three persons. The function itemgetter is imported from the module operator and then it is sorted by age and the output displayed in ascending order.

How to order values using sort()?

The .sort() which is quite similar to sorted() in naming has few differences than sorted(). The help documentation of Python will clear out the two critical differences between .sort() and sorted():

>>> help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.
    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.
>>> help(list.sort)
Help on method_descriptor:
sort(self, /, *, key=None, reverse=False)
    Stable sort *IN PLACE*.

Firstly, .sort() is not a built-in function unlike sorted(). It is a method of list class and works only with lists. You cannot pass iterables to .sort().

Secondly, .sort()  returns None and changes the values.

Let us see the differences of code for .sort() and what impact it has on the code:

>>> sort_numbers = [10, 2, 7, 3]
>>> sort(sort_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sort' is not defined
>>> sort_tuples = (10, 2, 7, 3)
>>> sort_tuple.sort()>>> sort_tuples = (10, 2, 7, 3)
>>> sort_tuple.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'sort'
>>> sorted_values = sort_numbers.sort()
>>> print(sorted_values)
None
>>> sorted_values = sort_numbers.sort()
>>> print(sorted_values)int(sort_numbers)
[1, 2, 5, 6]

The code above highlights some operational differences between .sort() and sorted():

  • When any assignment is done to a new variable, it returns a None type. This is because .sort() function has no ordered output. 
  • The original order of sort_numbers is not maintained and is changed in place.

.sort() also contains the key and reverse optional keyword arguments just like sorted() which produces the same functionality.

An example of .sort() using lambda to sort a list of phrases by the first letter of the third word:

>>> sort_phrases = ['welcome to python',
      'python is fun',
      'python is easy'
      ]
>>> sort_phrases.sort(key=lambda x: x.split()[2][1], reverse=False)
>>> sort_phrases
['python is easy', 'python is fun', 'welcome to python']

Here, lambda is used to split each phrase into a list of words and then find the second letter of the third element for each phrase.

Disadvantages of  Python Sorting

Python has some limitations when you try to sort values besides integers.

Non-Comparable Data Types

You cannot use sort data types that are different from each other. Python raises an error when sorted() is used on non-comparable data.

An example to illustrate sorting of values of different data types:

>>> mixed_values = [None, 5]
>>> sorted(mixed_values)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'NoneType'

Python raises a TypeError because it cannot sort None and int in the same list because of their incompatibility. It uses the less than operator ( < ) to determine the lower value in the order of the sort.

If you try to compare the same values manually without using sorted(), it will still raise a TypeError because of non-comparable data types:

>> None < 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'NoneType' and 'int'

However, if your list contains a combination of integers and strings that are all numbers, Python will cast them to comparable types using a list comprehension:

>>> num_mix = [10, "5", 200, "11"]
>>> sorted(num_mix)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> # List comprehension to cast all values to integers
>>> [int(z) for z in num_mix]
[10, 5, 200, 11]
>>> sorted([int(z) for z in num_mix])
[5, 10, 11, 200]

int() converts all the string values in num_mix to integers and then sorted() compares all values and returns a sorted output.

An example of a Python code of implicitly converting a value to another type:

>>> values = [1, False, 0, 'a' == 'b', 0 >= 1]
>>> sorted(values)
[False, 0, False, False, 1]

In the example above, all the elements in the list are converted to boolean type. 0 >= 1 evaluates to a False output. The number 1 and 0 are converted to True and False as bool type respectively.

This particular example highlights an important characteristic of sorting– sort stability. Sorting ability means that sorting algorithms are always stable. The original order is retained even if multiple records have the same key argument.

An example to illustrate sort stability:

>>> values = [False, 0, 0, 3 == 4, 1, False, False]
>>> sorted(values)
[False, 0, 0, False, 0, False, 1]

If you take a look at the original order and the sorted output, you’ll find that the expression 3 == 4 is casted to False and all sorted output is in the actual order. You can also perform complex sorts with the help of the knowledge of sort stability.

Case-Sensitive Sorting

You can use sorted() to sort a list of strings in ascending order which is alphabetical by default:

>>> name_list = ['Markian', 'Alex', 'Suzzane', 'Harleen']
>>> sorted(name_list)
['Alex', 'Harleen', 'Markian', 'Suzzane']

However, Python uses Unicode Code Point of the first letter of each string to evaluate the ascending order of the sort. If there are two names Al and al, Python will treat both of them differently.

An example to return the Unicode Code Point of the first alphabet of each string:

>>> case_sensitive_names = ['Markian', 'alex', 'Suzzane', 'harleen']
>>> sorted(case_sensitive_names)
['Markian', 'Suzzane', 'alex', 'harleen']
>>> # List comprehension for Unicode Code Point of first letter in each word
>>> [(ord(name[0]), name[0]) for name in sorted(case_sensitive_names)]
[(77, 'M'), (83, 'S'), (97, 'a'), (104, 'h')]

In the example above, name[0] returns the first letter of the string and ord(name[0]) returns the Unicode Code Point. You can notice that even a comes before M alphabetically, the output has M before a. This is because the code point of M comes before a.

Consider a situation where the first letter is the same for all the strings that need to be sorted. In such cases, the sorted() function will use the second letter to determine the order and if the second letter is also same, it will consider the third letter and so on, till the end of string:

>>> similar_strings = ['zzzzzn', 'zzzzzc', 'zzzzza','zzzzze']
>>> sorted(similar_strings)
['zzzzza', 'zzzzzc', 'zzzzze', 'zzzzzn']

Here, sorted() will compare the strings based on the sixth character since the first five characters are the same ( z ). The output will also depend on the last character of each string.

An example of sorting elements having identical values:

>>> different_lengths = ['zzzzz', 'zz', 'zzzz','z']
>>> sorted(different_lengths)
['z', 'zz', 'zzzz', 'zzzzz']

In this case, the sorting order will be from the shortest to the longest. The shortest string z is ordered first and the longest string zzzzz is ordered at the last.

When should you use .sort() and sorted()?

Let us consider a case where you need to collect data from a race of 5k runners, the Python 5k Annual and then sort them. You will have to collect the runner’s bib number and the time it took to finish the race:

>>> from collections import namedtuple
>>> Runner_data = namedtuple('Runner', 'bibnumber duration')

Each of the Runner_data will be added to a list called runners:

>>> runners = []
>>> runners.append(Runner_data('2548597', 1200))
>>> runners.append(Runner_data('8577724', 1720))
>>> runners.append(Runner_data('2666234', 1600))
>>> runners.append(Runner_data('2425114', 1450))
>>> runners.append(Runner_data('2235232', 1620))
    ...
    ...
>>> runners.append(Runner_data('2586674', 1886))

The bib number and the total time taken by the runner is added to runners each time they cross the finish line.

Now, you know the top five runners according to the duration time are the winners and the rest of them will be sorted by the fastest time:

>>> runners.sort(key=lambda x: getattr(x, 'duration'))
>>> fastest_five_runners = runners[:5]

In this example, we didn’t need any multiple types of sorting. The list was a reasonable choice. You just sorted the participants and grabbed the fastest five runners. Storing the list elsewhere was also not needed. The lambda function is used here to get the duration of each runner and then sorting is performed. Finally, the result is stored in fastest_five_runners.

However, the managing director of the race comes to you and informs that they have decided that every 20th runner will be awarded a free sports bag. Since the original data has been changed and cannot be recoverable, it is impossible to find every 20th runner.

In such cases, where you find a slight possibility that the original data is to be recovered, use sorted() instead of sort().

Let us implement the same code above using sorted():

>>> runners_by_time = sorted(runners, key=lambda x: getattr(x, 'duration'))
>>> fastest_five_runners = runners_by_time[:5]

In this situation, sorted() holds the original list of runners and their data and is not overwritten. You can find every 20th person to cross the finish line by interacting with the original values:

>>> every_twentieth_runner = runners[::20]

List slice on runners is used to create  every_twentieth_runner that holds the actual order in which runners crossed the finish line.

So, sorted() should be used in cases where the original data is to be retained and sort() should be used where the original data is a copy or unimportant and losing it won’t stand as an issue.

Some Earlier ways of  Python Sorting

There were mainly two approaches of sorting when Python 2 was released— decorated-sort-undecorated and using cmp parameter.

Decorated-Sort-Undecorated

This idiom Decorated-Sort-Undecorated is based upon three three steps:

  • First of all, the original list is decorated with new elements which manages the sort order.
  • Secondly, sorting is performed on the decorated list.
  • Finally, a list is created that contains the original elements in the new order and the decorations are removed.

Let us see an example of the DSU approach using a class:

>>> class Student:
      def prop(self,name, grade, age):
          self.name = name
          self.grade = grade
          self.age = age
      def stu_repr(self):
          return repr((self.name, self.grade, self.age))
>>> student_objects = [
      Student('alex', 'B', 13),
      Student('bob', 'A', 12),
      Student('chrles', 'B', 10),
    ]
#Regular sorting using sorted()
>>> sorted(student_objects, key=lambda student: student.age)
[('charles', 'B', 10), ('bob', 'A', 12), ('alex', 'B', 13)]
#DSU Approach
>>> decorated_values = [(student.grade, i, student) for i, student in enumerate(student_objects)]
>>> decorated_values.sort()
>>> [student for grade, i, student in decorated_values]   [('bob', 'A', 12), ('alex', 'B', 13),('charles', 'B', 10)]

In this code above, a class Student is created with student objects name, grade and age. Firstly, the original values are decorated and then sorted. Finally, the decorations are removed from decorated_values and then the new list is created with original values in new order.

The Decorated-Sort-Undecorated technique is also the Schwartzian Transform and is helpful in increasing the efficiency of sorting in Python.

Using cmp Parameter

cmp is a method or  parameter in Python that is used to compare two arguments. It returns either of the three values– a negative value in case of less than (<) comparisons or zero if equal or a positive value for greater than (>) comparisons.

An example to illustrate cmp using sorted():

>>> def num_compare(a, b):
      return a - b
>>> sorted([9, 2, 5, 0, 7], cmp=num_compare)
[0, 2, 5, 7, 9]

Here, a function num_compare is created and then the list is sorted by comparing each value in the list. Finally, the output is displayed in ascending order.

Note that cmp parameter will work only in Python 2 . It is completely removed from Python 3 to make the language more simple and to resist conflicts between other comparison techniques and cmp.

Summary

Let us sum up what we have learned in this article so far—

  • Sorting and its needs.
  • How to use sorted() to sort values with and without key and reverse.
  • How to use .sort() to order values with and without key and reverse.
  • Limitations and Gotchas with Python Sorting.
  • Appropriate use of .sort() and sorted().

Both .sort() and sorted() can be used to sort elements in a similar manner if used properly with key and reverse arguments.

However, both have different characteristics when output and in-place modifications are considered, so it is suggested to first have a clear understanding of the program to be worked upon, while using .sort() since it can irrevocably overwrite data.

To become a good Python developer, understanding complex sorting algorithms would be a useful skill set in the long run. For more information about sorting in Python, look into the official documentation of sorting of the Python Software Foundation and also grab a glimpse of another Python sorting algorithm called the TimSort. You may also join our Python certification course to gain further skills and knowledge in Python.

Priyankur

Priyankur Sarkar

Data Science Enthusiast

Priyankur Sarkar loves to play with data and get insightful results out of it, then turn those data insights and results in business growth. He is an electronics engineer with a versatile experience as an individual contributor and leading teams, and has actively worked towards building Machine Learning capabilities for organizations.

Join the Discussion

Your email address will not be published. Required fields are marked *

Suggested Blogs

Top 10 Python IDEs and Code Editors

Over the years, Python language has evolved enormously with the contribution of developers. Python is one of the most popular programming languages. It was designed primarily for server-side web development, software development, evaluation, scripting and artificial intelligence. For this feature Python encloses certain code editors and IDEs that are used for software development say, Python itself. If you are new to programming, learning Python is highly recommended as it is fast, efficient and easy to learn. Python interpreters are available on various operating systems such as Windows, Linux, Mac OS. This article provides a look into code editors and IDEs along with their features, pros and cons and talks about which are the best suited for writing Python codes. But first let us see what are code editors and IDEs. What is a Code Editor? A code editor is built for editing and modifying source code. A standalone text editor is used for writing and editing computer programs. Excellent ones can execute code as well as control a debugger as well as interact with source control systems. Compared to an IDE, a good dedicated code editor is usually smaller and quicker, but is less functional. Typically they are optimized for programming languages. One major feature of a text editor is that they are designed to modify various files and work with whatever language or framework you choose. What is IDE? IDE (Integrated Development Environment) understands the code significantly better than a text editor. It is a program exclusively built for software development. It is designed with a set of tools that all work together:  Text editor  Compiler Build automation Debugging Libraries, and many more to speed up the work.  These tools integrate: An editor designed to frame codes with text formatting, auto-completionetc., build, execution, debugging tools, file management and source and version control. It reduces manual efforts and combines all the equipment in a typical framework. IDE comes with heavy files. Hence, the downloads and installation is quite tedious. IDE requires expertise along with a lot of patience.  How does an IDE and Code editor differ from each other? An IDE is distinctive from code editors in the following ways: Integrated build process:The user does not have to write his own scripts to build apps in an IDE.  File management: IDE has an integrated file management system and deployment tool. It provides support to other framework as well. On the other hand, a Text editor is a simple editor where source code can be edited and it has no other formatting or compiling options. Development Environment: An IDE is mainly used for development purposes as it provides comparatively better features than a text editor. It allows you to write, compile and debug the entire script.  Syntax Highlighting:The editor displays the text message and puts the source code in different colours to improve its readability. Even error messages are displayed in different colours so that the user understands where he has written the wrong code.  Auto completion:It identifies and inserts a common code for the user instantly. This feature acts as an assistance for the programmer. The code suggestion automatically gets displayed.  Debugger: This tool helps the programmer to test and debug the source code of the main program.  Although IDEs have far better features than a Text editor one major significance of Text editor is that it allows modifying all types of files rather than specifying any definite language or types. Features For a good software development, we need code editors and IDEs which help the developer to automate the process of editing, compiling, testing, debugging and much more. Some of the features of these editors are listed below: Good user interface: They allow users to interact and run programs easily. Incredibly fast: Although these IDEs need to import heavy libraries, compile and debug, they offer fast compilation and run time.  Syntax stylizing: Codes are colorized automatically and syntax is highlighted.    Debugging tool: Itruns the code, set breakpoints, examine the variables. Provides good language syntax: IDEs usually work on a specific language but the others are designed for multi-language support. Code editors are designed with multi-language support.  Good source and version control environment: IDEs come with source control feature to keep a track of changes made in source code and other text files during the development of any software. Intelligent code completion:This feature speeds up the coding process by automatically suggesting for incomplete codes. It reduces typos and other common mistakes. Why do we need a good coding environment? For a good software development one seeks a better coding environment. Although features vary from app to app, a definite set of features is required for one. There are many other things involved such as source code control, extension tools, language support etc. Listed below are the core features which make a good coding environment : Retrieve files: All the codes written in an IDE get saved. Also, the programmer can retrieve his code file at the same state where the work is left off. Run within the environment: It should be able to compile and run within the environment where the codes are written. No external file shall be needed to be downloaded for the execution of the programs.  Good Debugging Tool: An IDE or editor should be able to diagnose and  troubleshoot the programmer’s works and highlight the lines with errors if any. A pop-up window should display the error message. This way the programmer can keep a track of his errands and diagnose them.   Automatic formatting tool: Indentation is done automatically as soon as the programmer moves onto the next line. It keeps the code clean and readable. Quick highlighting: keywords, variables and symbols are highlighted. This feature keeps the code clean and easy to understand. Also, pops up the variables making them easy to spot. This makes it a whole lot easier to pick out portions of code than simply looking at a wall of undifferentiated text. Some of the IDEs and code editors There are various Python IDEs and text editors. Some of the IDEs and text editors along with their features and pros and cons are mentioned below: IDLEKey Features: It is an open source IDE entirely written in Python. It is mainly supported by WINDOWS, LINUX, MAC OS etc.. IDLE is a decent IDE for learning because it is lightweight and quite simple to use. IDLE is installed by default as soon as installation of Python is complete. This makes it easier to get started in Python. IDLE features include the Python shell window(interactive interpreter), auto-completion, syntax highlighting, smart indentation, and a basic integrated debugger. It is however not suitable for the completion of larger projects and best suitable for educational purposes only.  Pros A cross-platform where a developer can search within any window, search through multiple files and replace within the windows editor  Supports syntax highlighting, auto code completion, smart indentation and editable configurations Includes Python shell with highlighter Powerful Integrated Debugger with continuous breakpoints, global view, and local spaces Improves the performance  Call stack visibility Increases the flexibility for developers Cons Used for programming just for beginners Limited to handle normal usage issues. Supports basic design  Large software development cannot be handled  Sublime text Key Features: It is a source code editor, supported on all platforms. It is a very popular cross-platform  and a better text editor. It possesses a built-in support for Python for code editing and packages to extend the syntax and editing features. All Sublime Text packages are written in Python and also a Python API. Installation of the packages often requires you to execute scripts directly in Sublime Text. it is designed to support huge programming and markup languages. Additional functions can be applied by the user with the help of plugins.  Pros More reliable for developers and is cross-platform Supports GOTO anything to access files  Generates wide index of each method, class, and function. AllowsUser interface toolkit Easy navigation to words or symbols Multiple selections to change things at one time Offers command palette to sort, edit and modify the syntax and maintain the indentation.  Offers powerful API and package ecosystem Great performance Highly customizable Allows split editing and instant project switch  Better compatibility with language grammar Custom selection on specific projects Cons Not free Installation of extensions is quite tricky Does not support for direct executing or debugging code from within the editor Less active GIT plugin AtomKey Features: It is an open source code editor developed by Github. It is supported on all platforms. It has features similar to that of Python. It has a framework based on atom shells which help to achieve cross platform functionality. With a sleek interface, file system browser, and marketplace for extensions, it offers a framework for creating desktop applications using JavaScript, HTML, CSS . Extensions can be installed when Atom is running.It enables support for third party packages. Its major feature is that although it is a code editor,it can also be used as an IDE. It is also used for educational purposes. Atom is being improvised day by day, striving to make the user experience rewarding and not remain confined to beginners use only.  Pros Cross-platform  Smooth editing Improves performance of its users Offers built-in package manager and file system browser Faster scripting  Offers smart auto-completion  Smart and flexible Supports multiple pane features Easy navigation across an application Simple to use Allows user interface customization Full support from GitHub Quick access to data and information Cons For beginners only Tedious for sorting configurations and plugins Clumsy tabs reduce performance  Slow loading Runs on JavaScript process  Built on Electron, does not run as a native application VimKey Features: Categorized as a stable open source code editor, VI and VIM are modal editors. As it is supported on almost every platform such as: Windows, LINUX, MAC OS, IOS, Android, UNIX, AmigaOS, MorphOS etc. it is highly configurable. Because of its modal mode of operation, it differs from most other text editors. It possesses three basic modes: insert mode, normal or command mode and command line mode. It is easily customized by the addition of extensions and configuration which makes it easily adaptable for Python development.  Pros Free and easily accessible Customizable and persistent  Has a multi-level undo tree  Extensions are added manually Configuration file is modified Multi-buffers support simultaneous file editing Automated indentation  Good user interface Recognition and conversion of file formats Exclusive libraries including wide range of languages Comes with own scripting language with powerful integration, search and replace functionality Extensive system of plugins Allows debugging and refactoring  Provides two different modes to work: normal and editing mode Strings in VIM can be saved and reused  Cons Used as a text editor only No different color for the pop-up option Not good for beginners PyDev Key Features: It is also categorized as an open source IDE mainly written with JAVA.Since it is an eclipse plugin, the Java IDE is transformed into Python IDE. Its integration with Django gives a Python framework. It also has keyword auto-completion, good debugging tool, syntax highlighting and indentation. Pros Free open source Robust IDE feature set Auto-completion of codes and analysis Smart indentation Interactive console shortcuts Integrated with Django configuration  Platform independent Cons: User interface is not great  Visual studioKey Features: It is categorized as an IDE, is a full-featured IDE developed by Microsoft. It is compatible with Windows and Mac OS only and comes with free as well as paid versions. It has its own marketplace for extensions. PTVS(Python Tools for Visual Studio) offers various features as in coding for Python development, IntelliSense, debugging, refactoring etc. Pros Easy and less tedious installation for development purposes Cons Spacious files  Not supported on Linux Visual studio code Key Features: VS code is a code editor and is way more different from VS. It is a free open source code editor developed by Microsoft can be run on platforms such as Windows, Linux and Mac OS X.  It has a full-featured editor that is highly configurable with Python compatibility for software development. Python tools can be added to enable coding in Python.VS code is integrated with Git which promotes it to perform operations like push, commit directly from the editor itself. It also has electron framework for Node JS applications running on the Blink browser engine. It is enclosed with smart code completion with function definition, imported modules and variable types. Apart from these, VS code also comes with syntax highlighting, a debugging console and proprietary IntelliSense code auto completion. After installing Python, VS code recognizes Python files and libraries immediately.  Pros Free and available on every platform  Small, light-weight but highly extensible Huge compatibility Has a powerful code management system Enables debugging from the editor Multi-language support  Extensive libraries Smart user interface and an acceptable layout Cons Slow search engine Tedious launch time Not a native app just like Atom WingKey Features: Wing is also one of the powerful IDEs today and comes with a lot of good features. It is an open source IDE used commercially. It also is constituted with a strong framework and has a strong debugger and smart editor for Python development making it fast, accurate and fun to perform. It comes with a 30 day trial version. It supports text driven development with unit test, PyTest and Django testing framework.  Pros Open source Find and go-to definition Customizable and extensible Auto-code completion Quick Troubleshoot  Source browser shows all the variables used in the script Powerful debugger  Good refactoring  Cons Not capable of supporting dark themes Wing interface is quite intimidating Commercial version is expensive Python-specific IDEs and Editors Anaconda - Jupyter NotebooksKey Features: It is also an open source IDE with a server-client structure, used to create and edit the codes of a Python. Once it is saved, you can share live code equations, visualizations and text. It has anaconda distribution i.e., libraries are preinstalled so downloading the anaconda itself does the task. It supports Python and R language which are installed by default at installation.  This IDE is again used for data science learning. Quite easy to use, it is not just used as an editor but also as an educational tool or presentation. It supports numerical simulation, machine  learning visualization and statistical modelling. Pros Free Open source  Good user interface Server-client structure Educational tool- Data science, Machine learning  Supports numerical simulation  Enables to create, write, edit and insert images Combines code, text and images Integrated libraries - Matplotlib, NumPy, Pandas Multi-language support Auto code completion Cons Sometimes slow loading is experienced Google Colaboratory Key Features: It is the simplest web IDE used for Python. It gives a free GPU access. Instead of downloading heavy files and tedious launch time, one can directly update the files from Colab to the drive. All you need to do is log in to your google account and open Colab. There is no need for extra setup. Unlike other IDEs no files are required to download. Google provides free computation resources with Colaboratory. It is designed for creating machine learning models. For compilation and execution, all you need to do is to update Python package and get started.   Pros Available to all Code can be run without any interruption Highly user interactive No heavy file downloads Integrated libraries Multi-language support Updated in google drive Update the Python package for execution  Runs on cloud Comments can be added in cells Can import Jupiter or IPython notebooks Cons  All colaboratory files are to be stored in google drive Install all specific libraries No access to unsaved files once the session is over Pycharm Key Features: Developed by Jet Brains and one of the widely used full-featured Python IDE, this is a cross-platform IDE for Python programming and  is well-integrated with Python console and IPython Notebook. It is supported by Windows, Linux, Mac OS and other platforms as well. It has massive productivity and saves ample amount of time. It comes with smart code navigation, code editor, good debugging tool, quick refactoring etc. and supports Python web development frameworks such as Angular JS, JavaScript, CSS, HTML  and live editing functions. The paid version offers advanced features such as full database management and a multitude Framework than the community version such as Django, Flask, Google App, Engine, Pyramid and web2py. Pros Great supportive community Brilliant performance. Amazing editing tools Robust debugging tool Smart code navigation Quick and safe refactoring  Built in developer tools Error detection and fix up suggestions Customizable interface Available in free and paid version Cons Slow loading  Installation is quite difficult and may hang up in between SpyderKey Features: It is an open source IDE supported on all platforms. Ranked as one of the best Python compilers, it supports syntax highlighting, auto completion of codes just like Pycharm. It offers an advanced level of editing, debugging, quick diagnose, troubleshoot and many data exploration features. To get started with Spyder, one needs to install anaconda distribution which is basically used in data science and machine learning. Just like Pycharm it has IntelliSense auto-completion of code. Spyder is built on a structured and powerful framework which makes it one of the best IDE used so far. It is most commonly used for scientific development. Pros Free open source IDE Quick troubleshoot Active framework Smart editing and debugging Syntax is automatically highlighted Auto completion of codes Good for data science and machine learning Structured framework Integrates common Python data science libraries like SciPy, NumPy, and Matplotlib Finds and eliminates bottlenecks Explores and edits variables directly from GUI  Performs well in multi-language editor and auto completion mode Cons Spyder is not capable to configure a specific warning Too many plugins degrades its performance ThonnyKey Features: Thonny is another IDE best suited for beginners for Python development and provides a good virtual environment. It is supported on all platforms. It gives a simple debugger with F5, F6 and F7 keys for debugging. Also, Thonny supports highlighting errors, good representation of function calls, auto code completion and smart indentation. It even allows the developers to configure their code and shell commands. by default,  in Thonny Python is pre-installed as it downloads with its own version of Python.  Pros Simple Graphical user interface.  Free open source IDE Best for beginners Simple debugger with F5, F6, F7 Keys Tackles issues with Python interpreters Highlights syntax error Auto-completion of code Good representation of function calls User can change reference mode easily Step through expression evaluation Reply and resolve to comments Cons Interface is not that good for developers Confined to text editing No template support Slow plugin creation Too basic IDE for software development Which Python IDE is right for you? Requirements vary from programmer to programmer. It is one’s own choice to pick the right tool that is best suited for the task at hand. Beginners need to use a simple tool with few customizations whereas experts require tools with advanced features to bring new updates. Few suggestions are listed below:- Beginners should start with IDLE and Thonny as they do not have complex features and are pretty easy to learn. For data science learners Jupyter Notebooks and Google Colaboratory is preferred. Generally, large scale enterprises prefer the paid versions of IDEs like PyCharm, Atom, Sublime Text etc. in order to get extensive service support from the company. Also, they provide easy finance options and manpower. On the other hand, middle and small scale enterprises tend to look for open source tools which provides them with excellent features. Some of such IDEs are Spyder, Pydev, IDLE and Visual Studio. Conclusion Today, Python stands out as one of the most popular programming languages worldwide. IDE being a program dedicated to software development has made it easier for developers to build, execute, and debug their codes. Code editors can only be used for editing codes whereas an IDE is a feature rich editor which has inbuilt text editor, compiler, debugging tool and libraries. Different IDEs and code editors are detailed in this article along with their merits and demerits. Some are suitable for beginners because of their lightweight nature and simplicity like IDLE, Thonny whereas experts require advance featured ones for building software.  For learning purposes say data science, machine learning Jupyter and Google Colaboratory are strongly recommended. Again there are large scale enterprises who prefer PyCharm, Atom, Sublime Text for software development. On the other hand, small scale enterprises prefer Spyder, Pydev, IDLE and Visual Studio. Hence,the type of IDE or code editor that should be used completely depends upon the requirement of the programmer . To gain more knowledge about Python tips and tricks, check our Python tutorial and get a good hold over coding in Python by joining the Python certification course. 
Rated 4.5/5 based on 19 customer reviews
9880
Top 10 Python IDEs and Code Editors

Over the years, Python language has evolved enormo... Read More

Scala Vs Kotlin

Ever-changing requirements in coding have always been happening, ones that cause programmers to change their minds about using the appropriate programming language and tools to code. Java has been there for a long time, a really long time, 24 years ago. It is relatively easy to use, write, compile, debug, and learn than other programming languages. However, its certain inhibitions like slow performance, unavailability of any support for low-level programming, possessing poor features in GUI 4, and having no control over garbage collection is putting Java developers in a dilemma on choosing an alternative to Java, such as JetBrains’ programming language, Kotlin, presently an officially supported language for Android development or Scala, an all-purpose programming language supporting functional programming and a strong static type system. Today, we will discuss how developers can decide to choose Scala or Kotlin as an alternative to Java. We will briefly talk about Scala and Kotlin separately and talk about their application before moving forward to looking at the differences, advantages, and disadvantages of both and finally have you decide which one of these two suits your requirements. User’s requirement Before we begin, here is a question for the readers, ‘What are you looking for in the next programming language that you will use?’ It is an obvious question because the programming purposes drive the actual basis and need of developing a language. Do you need a language that strives to better Java or use a language that lets you do things that aren’t possible in Java? If it is the first reason, then Scala might be the best one for you, otherwise, it is a simplified programming language like Kotlin. Now let us first briefly discuss Scala and Kotlin individually. ScalaDeveloped by Martin Odersky, the first version of Scala was launched in the year 2003 and is a classic example of a  general-purpose, object-oriented computer language, offering a wide range of functional programming language features and a strong static type system. Inspired from Java itself, Scala, as the name suggests, is highly scalable and this very feature sets Scala apart from other programming languages. When we say that Scala is inspired from Java, that means developers can code Scala in the same way they do for Java. Additionally, Scala makes it possible to use numerous Java and libraries within itself as well. It is designed to be able to use an elegant, concise and type-safe method to express common programming patterns. Scala is a very popular programming language amongst developers and rising up its ranks in the world of technology. Although Scala comes with a number of plus points, there are some which make it a bit ineffective. Here are the strengths and weaknesses of Scala. Strengths: Full Support for Pattern Matching, Macros, and Higher-Kinded Types Has a very flexible code syntax Gets a bigger Community Support Enables overloading operators Weaknesses: Slow in compilation Challenging Binary Compilation Not so proficient in the Management of Null SafetyKotlin Developed by JetBrains, Kotlin was released on February 2012 as an open-source language. Until now, there have been two released versions with the latest one being Kotlin 1.2, the most stable version that was released on November 28, 2017. Since Kotlin is extremely compatible with Java 6 the latest version of Java on Android, it has gained critical acclaim on Android worldwide and additionally, it offers various key features that are prepared only for Java 8 and not even Java 6 developers have access to that. Kotlin provides seamless and flawless interoperability with Java. That means, developers can easily call Java codes from Kotlin and same goes the other way around. The built-in null safety feature avoids showing the NullPointerException (NPE) that makes developing android apps easy and joyful, something every android programmer wants. Below mentioned are the key pointers on the strengths and weaknesses of Kotlin. Strengths Takes a Functional Programming Approach and Object-Oriented Programming style(OOP) Style  Has Higher-Order Functions Short, Neat, and Verbose-Free Expression  Supported by JetBrains and Google. Weaknesses: More limited Pattern Matching Additional Runtime Size Initial Readability of Code Shortage of Official Support Smaller Support Community. Ease of learning: Scala vs Kotlin Scala is a powerful programming language packed with superior features and possesses a flexible syntax. It is not an easy language to learn and is a nightmare for newcomers. Kotlin, on the other hand, has been reported to have been an easy-to-learn language for many Java developers as getting started with Kotlin is relatively easy and so is writing codes. Even though it is a comparatively easier language to learn and code with, Kotlin lacks the solid set of features that is common in Scala. It might take less time to learn a programming language, but the most important thing to look for is a comprehensive array of features. Scala, even though a very difficult language to learn, is cherished by the developers as it lets them do things that cannot be done in Kotlin Here are the major differences between Scala and Kotlin: ScalaKotlinType inferenceEfficientImmutabilityExtension FunctionsSingleton objectMassive InteroperabilityConcurrency controlLessens Crashes at RuntimeString interpolationSmart Cast FunctionHigher-order functionSafe and ReliableCase classes and Pattern matching Lazy computationLow adoption costRich collection setMaking the appropriate choice of languageNow, whether you may like a programming language or not, if that very language helps you get the best out of your job, then you will have to live with it. These are the facts about getting the best results. The outcome is the main factor in you deciding the appropriate language for your job. Kotlin is the only option for Android development as Android doesn’t use JVM, so any old JVM-compatible language will not work in Android. Kotlin has it all what it takes to compile, debug, and run the software on Android because of which it is in-built into Android Studio. However, Kotlin is not so usable outside Android development. If you are one of the developers who like working with Eclipse for your IDE, then Scala IDE is better than the Kotlin Plugin even if you can make Eclipse work with both the languages with limitations. Scala IDE is more advanced than the Kotlin plugin and is easier to set up. Some developers found it quite difficult to make the Kotlin plugin work. This case is quite the same with NetBeans. Kotlin is still getting there but is already popular amongst Java developers as it offers an easier transition than Scala. Kotlin is still maturing, but many Java people find adopting it is an easier transition than Scala is.  Scala, however, is for developers who are focused more on discovering new ideas while Kotlin is for those who want to get results. Kotlin stresses fast compilation but is more restrictive while Scala gives a lot of flexibility. Go for Scala if you breathe functional programming! It has more appropriate features for this type of programming than Kotlin does. Scala supports currying and partial application, the methods of breaking down functions requiring multiple arguments offering more flexibility. Go for the one that is the most appropriate one for your work, style of working and what you are aiming at. Think before you leap. The Outcome At the end of the day, all that matters is what you want to use the language for. While Scala goes well for the projects that require a combination of functional, OOP style programming languages, and where programmers need to handle lots of data or complex modelling, Kotlin becomes the best choice when you want something less frustrating than Java while developing apps because using Kotlin makes app development less cumbersome and a great thing to work on. It is just like a better-looking version of Java with less lengthy codes. 
Rated 4.5/5 based on 19 customer reviews
7592
Scala Vs Kotlin

Ever-changing requirements in coding have always b... Read More

Xcode vs Swift

Xcode and Swift are two different products developed by Apple for macOS, iOS, iPadOS, watchOS, and tvOS. While Xcode is an integrated development environment (IDE) for macOS containing a suite of software development tools to develop software for macOS, iOS, iPadOS, watchOS, and tvOS, Swift is a general-purpose, multi-paradigm, compiled programming language developed iOS, macOS, watchOS, tvOS, Linux, and z/OS. So it is clear that they can not be compared with each other. On the contrary, Swift is compatible with Xcode as Swift v 5.1, the default version of Swift is included in Xcode v 11. In this article, we will go through what Xcode and Swift are in general and cover their features strengths and weaknesses followed by how Swift is compatible with Xcode. XcodeIt was first released in 2003 as version 1 with the latest stable one being version 10.2.1 released on 17 April 2019. It can be downloaded from the Mac App Store and is free to use for macOS Mojave users. Registered developers may download the preview releases and previous versions of the suite using via the Apple Developer website.  Overview of the major featuresSupport: Programming languages such as C, C++, Objective-C, Objective-C++, Java, AppleScript, Python, Ruby, ResEdit (Rez), and Swift are supported by Xcode with source code along with support for a variety of programming models including Cocoa, Carbo, and Java. Not only that, there is additional support via third parties for GNU Pascal, Free Pascal, Ada, C#, Perl, and D Capability: Xcode can build fat binary files that include the code for various architectures in the Mach-O executable format. Known as universal binary files, these allow the application to run on both PowerPC and Intel-based (x86) platforms including both 32-bit and 64-bit codes Compiling and debugging: Xcode uses the iOS SDK to compile and debug applications for iOS that run on ARM architecture processors GUI tool: Xcode comprises of the GUI tool, Instruments that runs dynamic tracing framework on the top of DTrace, a dynamic tracing framework designed by Sun Microsystems and released as a part of OpenSolaris. Advantages and disadvantages of Xcode: Xcode is designed by Apple and will only work with Apple operating systems: macOS, iOS, iPadOS, watchOS, and tvOS. Since its release in 2003, Xcode has made significant improvements and the latest version, Xcode 10.2.1 has all the features that are needed to perform continuous integration. Let us have a look at the pros of using Xcode: Equipped with a well designed and easy to use UI creator Excellent for code completion Using Xcode, a developer can learn profiling and heap analysis in a natural way Xcode’s simulator lets you easily test your app while you build it in an environment that simulates your iPhone The app store has a wide range of audience who are willing to pay for apps. Now, the cons: Clunky and outdated Objective C makes it more frustrating if you are habituated to use a modern language No support for tabbed work environments makes it difficult to work with multiple windows Hardly any information can be found online to solve problems due to a previous Apple NDA on Xcode development It is a complicated process to export your app onto a device Will only work with Apple operating systems The App Store approval process can be annoyingly lengthy.SwiftSwift was launched at Apple's 2014 Worldwide Developers Conference as a general-purpose, multi-paradigm, compiled programming language for iOS, macOS, watchOS, tvOS, Linux, and z/OS Being a new entry these operating systems, Swift accelerates on the best parts of C and Objective C without being held back by its compatibility. It utilises safe patterns for programming, adding more features to it, thus making programming easier and more flexible. By developing their existing debugger, compiler and framework infrastructure, it took quite some time to create the base for Swift. Furthermore, Automatic Reference Counting was used to simplify the memory management part. The framework stack which was once built upon a solid framework of Cocoa and Foundation has undergone significant changes and is now completely regulated and refurbished. Developers who have worked with Objective-C do find Swift quite similar. Objective-C’s dynamic object model and its comprehensively named parameters provide a lot of control to Swift.  Developers can use Swift to have access to the existing Cocoa framework in addition to the mix and match interoperability with an objective C code. Swift uses this common rule to offer multiple new features in combination with object-oriented and procedural portions of the language. The idea is to create the best possible language for a wide range of uses, varying from desktop and mobile apps, systems programming, and scaling up to cloud services. The designing of Swift was done to make sure that developers find it easy to maintain and write correct programs. Coding done in Xcode is safe, fast and expressive. Swift offers a host of features that give developers the control needed to make the code easy to read and write. Furthermore, Apple made Swift to be easily understandable to help developers avoid making mistakes while coding and make the code look organised, along with the modules that give namespaces and eliminate headers. Since Swift uses some features present in other languages, one of them being named parameters written with clean syntax that makes the APIs much easier to maintain and read. Here are some of the additional features of Swift: Multiple return values and Tuples Generics Short and quick iterations over a collection or range Structs that support extensions, methods and protocols Functional programming patterns Advanced control flow Powerful error handling. These features are systematically designed to make them work together resulting in creating a powerful but fun-to-use language. Advantages and disadvantages of Swift: Pros of using the Swift Programming language: Easy to read and maintain: The Swift program codes are based on natural English as it has borrowed syntaxes from other programming languages. This makes the language more expressive Scalable: Users can add more features to Swift, making it a scalable programming language. In the future, Swift is what Apple is relying on and not Objective C Concise: Swift does not include long lines of code and that favours the developers who want a concise syntax, thus increasing the development and testing rate of the program Safety and improved performance: It is almost 40% better than the Objective-C when speed and performance are taken into consideration as it is easy to tackle the bugs which lead to safer programming Cross-device support: This language is capable of handling a wide range of Apple platforms such as iOS, iOS X, macOS, tvOS, and watchOS. Automatic Memory Management: This feature present in Swift prevents memory leaks and helps in optimizing the application’s performance that is done by using Automatic Reference Counting. Cons of Swift: Compatibility issues: The updated versions Swift is found to a bit unstable with the newer versions of Apple leading to a few issues. Switching to a newer version of Swift is the fix but that is costly Speed Issues: This is relevant to the earlier versions of the Swift programming language Less in number: The number of Swift developers is limited as Swift is a new programming language Delay in uploading apps: Developers will be facing delays over their apps written in Swift to be uploaded to the App Store only after iOS 8 and Xcode 6 are released. The estimated time for release is reported to be September-October, 2014. Conclusion So as we discussed both Xcode and Swift, it is clear that they cannot be compared to each other. In fact, they both complement each other to deliver impressive results without any headaches. Apple relies on both quite a lot and it is certain to have Swift and Xcode the perfect combination of a robust application and a user-friendly programming language.
Rated 4.5/5 based on 11 customer reviews
8591
Xcode vs Swift

Xcode and Swift are two different products develop... Read More

20% Discount