Tag: Programming

To create and manage multiline strings in Python, you can use triple quotes and backslashes, while more advanced options involve string literals, parentheses, the + operator, f-strings, the textwrap module, and join() method to handle long strings within collections like dictionaries and lists.

Let’s get started with the simple techniques first:

Basic Multiline Strings

In Python, there are multiple ways to create multiline strings. This section will cover two primary methods of writing multiline strings: using triple quotes and backslashes.

Triple Quotes

Triple quotes are one of the most common ways to create multiline strings in Python. This method allows you to include line breaks and special characters like newline characters directly in the string without using escape sequences. You can use triple single quotes (''') or triple double quotes (""") to define a multiline string.

Here is an example:

multiline_string = '''This is an example
of a multiline string
in Python using triple quotes.''' print(multiline_string)

This will print:

This is an example
of a multiline string
in Python using triple quotes.

Backslash

Another way to create a multiline string is by using backslashes (\). The backslash at the end of a line helps in splitting a long string without inserting a newline character. When the backslash is used, the line break is ignored, allowing the string to continue across multiple lines.

Here is an example:

multiline_string = "This is an example " \ "of a multiline string " \ "in Python using backslashes." print(multiline_string)

This will print:

This is an example of a multiline string in Python using backslashes.

In this example, even though the string is split into three separate lines in the code, it will be treated as a single line when printed, as the backslashes effectively join the lines together.

Advanced Multiline Strings

In this section, we will explore advanced techniques for creating multiline strings in Python. These techniques not only improve code readability but also make it easier to manipulate long strings with different variables and formatting options.

String Literals

String literals are one way to create multiline strings in Python. You can use triple quotes (''' or """) to define a multiline string:

multiline_string = """This is a multiline string
that spans multiple lines."""

This method is convenient for preserving text formatting, as it retains the original line breaks and indentation.

Recommended: Proper Indentation for Python Multiline Strings

Parentheses

Another approach to create multiline strings is using parentheses. By enclosing multiple strings within parentheses, Python will automatically concatenate them into a single string, even across different lines:

multiline_string = ("This is a long string that spans " "multiple lines and is combined using " "the parentheses technique.")

This technique improves readability while adhering to Python’s PEP 8 guidelines for line length.

+ Operator

You can also create multiline strings using the + operator to concatenate strings across different lines:

multiline_string = "This is a long string that is " + \ "concatenated using the + operator."

While this method is straightforward, it can become cluttered when dealing with very long strings or multiple variables.

F-Strings

F-Strings, introduced in Python 3.6, provide a concise and flexible way to embed expressions and variables within strings. They can be combined with the aforementioned techniques to create multiline strings. To create an F-String, simply add an f or F prefix to the string and enclose expressions or variables within curly braces ({}):

name = "Alice"
age = 30
multiline_string = (f"This is an example of a multiline string " f"with variables, like {name} who is {age} years old.")

F-Strings offer a powerful and readable solution for handling multiline strings with complex formatting and variable interpolation.

Recommended: Python f-Strings — The Ultimate Guide

Handling Multiline Strings

In Python, there are several ways to create multiline strings, but sometimes it is necessary to split a long string over multiple lines without including newline characters. Two useful methods to achieve this are the join() method and the textwrap module.

Join() Method

The join() method is a built-in method in Python used to concatenate list elements into a single string. To create a multiline string using the join() method, you can split the long string into a list of shorter strings and use the method to concatenate the list elements without newline characters.

Here is an example:

multiline_string = ''.join([ "This is an example of a long string ", "that is split into multiple lines ", "using the join() method."
])
print(multiline_string)

This code would print the following concatenated string:

This is an example of a long string that is split into multiple lines using the join() method.

Notice that the list elements were concatenated without any newline characters added.

Textwrap Module

The textwrap module in Python provides tools to format text strings for displaying in a limited-width environment. It’s particularly useful when you want to wrap a long string into multiple lines at specific column widths.

To use the textwrap module, you’ll need to import it first:

import textwrap

To wrap a long string into multiple lines without adding newline characters, you can use the textwrap.fill() function. This function takes a string and an optional width parameter, and returns a single string formatted to have line breaks at the specified width.

Here is an example:

long_string = ( "This is an example of a long string that is " "split into multiple lines using the textwrap module."
)
formatted_string = textwrap.fill(long_string, width=30)
print(formatted_string)

This code would print the following wrapped string:

This is an example of a long
string that is split into
multiple lines using the
textwrap module.

The textwrap module provides additional functions and options to handle text formatting and wrapping, allowing you to create more complex multiline strings when needed.

Code Style and PEP8

Line Continuation

In Python, readability is important, and PEP8 is the widely-accepted code style guide. When working with long strings, it is essential to maintain readability by using multiline strings. One common approach to achieve line continuation is using parentheses:

long_string = ("This is a very long string that " "needs to be split across multiple lines " "to follow PEP8 guidelines.")

Another option is using the line continuation character, the backslash \:

long_string = "This is a very long string that " \ "needs to be split across multiple lines " \ "to follow PEP8 guidelines."

Flake8

Flake8 is a popular code checker that ensures your code adheres to PEP8 guidelines. It checks for syntax errors, coding style issues, and other potential problems. By using Flake8, you can maintain a consistent code format across your project, improving readability and reducing errors.

To install and run Flake8, use the following commands:

pip install flake8
flake8 your_script.py

E501

When using PEP8 code checkers like Flake8, an E501 error is raised when a line exceeds 80 characters. This is to ensure that your code remains readable and easy to maintain. By splitting long strings across multiple lines using line continuation techniques, as shown above, you can avoid E501 errors and maintain a clean and readable codebase.

Working with Collections

In Python, working with collections like dictionaries and lists is an important aspect of dealing with long strings spanning multiple lines. Breaking down these collections into shorter, more manageable strings is often necessary for readability and organization.

Dictionaries

A dictionary is a key-value pair collection, and in Python, you can define and manage long strings within dictionaries by using multiple lines. The syntax for creating a dictionary is with {} brackets:

my_dict = { "key1": "This is a very long string in Python that " "spans multiple lines in a dictionary value.", "key2": "Another lengthy string can be written " "here using the same technique."
}

In the example above, the strings are spread across multiple lines without including newline characters. This helps keep the code clean and readable.

Brackets

For lists, you can use [] brackets to create a collection of long strings or other variables:

my_list = [ "This is a long string split over", "multiple lines in a Python list."
] another_list = [ "Sometimes, it is important to use", "newline characters to separate lines.",
]

In this example, the first list stores the chunks of a long string as separate elements. The second list showcases the usage of a newline character (\n) embedded within the string to further organize the text.

Frequently Asked Questions

How can I create a multiline string in Python?

There are multiple ways to create a multiline string in Python. One common approach is using triple quotes, either with single quotes (''') or double quotes ("""). For example:

multiline_string = ''' This is a multiline string '''

How to break a long string into multiple lines without adding newlines?

One way to break a long string into multiple lines without including newlines is by enclosing the string portions within parentheses. For example:

long_string = ('This is a very long string ' 'that spans multiple lines in the code ' 'but remains a single line when printed.')

What is the best way to include variables in a multiline string?

The best way to include variables in a multiline string is by using f-strings (formatted string literals) introduced in Python 3.6. For example:

name = 'John'
age = 30 multiline_string = f''' My name is {name} and I am {age} years old. ''' print(multiline_string)

How to manage long string length in Python?

To manage long string length in Python and adhere to the PEP8 recommendation of keeping lines under 80 characters, you can split the string over multiple lines. This can be done using parentheses as shown in a previous example or through string concatenation:

long_string = 'This is a very long string ' + \ 'that will be split over multiple lines ' + \ 'in the code but remain a single line when printed.'

What are the ways to write a multi-line statement in Python?

To create multiline statements in Python, you can use line continuation characters \, parentheses (), or triple quotes ''' or """ for strings. For example:

result = (1 + 2 + 3 + 4 + 5) multiline_string = """ This is a multiline string """

How to use f-string for multiline formatting?

To use f-strings for multiline formatting, you can create a multiline string using triple quotes and include expressions inside curly braces {}. For example:

item = 'apple'
price = 1.99 multiline_string = f""" Item: {item} Price: ${price} """ print(multiline_string)

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments.

You’ll also learn how to:

• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators
• Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

Problem Formulation

Sorting a list of string numbers numerically in Python can lead to unexpected issues.

For example, using the naive approach to sort the list lst = ["1", "10", "3", "22", "23", "4", "2", "200"] using lst.sort() will result in the incorrect order as it sorts the list of strings lexicographically, not numerically.

In this short article, my goal is to present the five best methods to correctly sort this list numerically. My recommended approach is the fifth one, see below.

Method 1: Convert Strings to Integers and Sort

This method involves converting each string in the list to an integer and then sorting them. It’s a direct and simple approach to ensure numerical ordering.

lst = [int(x) for x in lst]
lst.sort()

Output: ['1', '2', '3', '4', '10', '22', '23', '200']

Recommended: Python List Comprehension

Method 2: Using the key Parameter with sort()

This method uses the key parameter with the int function to sort the strings as integers. It allows for numerical comparison without altering the original strings.

lst.sort(key=int)

Output: ['1', '2', '3', '4', '10', '22', '23', '200']

Recommended: Python list.sort() with key parameter

Method 3: Using the natsort Module

The natsort module provides a natural sorting algorithm, useful for sorting strings that represent numbers. This method can handle more complex string sorting scenarios.

from natsort import natsorted
lst = natsorted(lst)

Output: ['1', '2', '3', '4', '10', '22', '23', '200']

Method 4: Using Regular Expressions

Using regular expressions, this method can sort strings containing both letters and numbers. It converts the numeric parts into floats for comparison, handling mixed content.

import re def sort_human(l): convert = lambda text: float(text) if text.isdigit() else text alphanum = lambda key: [convert(c) for c in re.split('([-+]?[0-9]*\.?[0-9]*)', key)] l.sort(key=alphanum) return l lst = sort_human(lst)

Output: ['1', '2', '3', '4', '10', '22', '23', '200']

Recommended: Python Regular Expression Superpower

Method 5: Using sorted() with key Parameter (Recommended)

This method combines the simplicity of using the key parameter with the benefit of creating a new sorted list, leaving the original untouched. It’s concise and effective.

lst = sorted(lst, key=int)

Output: ['1', '2', '3', '4', '10', '22', '23', '200']

Recommended: Python sorted() function

Summary – When to Use Which

• Method 1: Converts strings to integers, then sorts. Simple but alters the original list.
• Method 2: Uses the key parameter with int for sorting. Preserves the original strings.
• Method 3: Utilizes the natsort module. Handles complex scenarios.
• Method 4: Employs regular expressions for sorting alphanumeric strings.
• Method 5 (Recommended): Combines the simplicity of using key with sorted(). Preserves the original list and offers concise code.

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments.

You’ll also learn how to:

• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators
• Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

Basics of Sorting in Python

In Python, sorting data structures like lists, strings, and tuples can be achieved using built-in functions like sort() and sorted(). These functions enable you to arrange the data in ascending or descending order. This section will provide an overview of how to use these functions.

The sorted() function is primarily used when you want to create a new sorted list from an iterable, without modifying the original data. This function can be used with a variety of data types, such as lists, strings, and tuples.

Here’s an example of sorting a list of integers:

numbers = [5, 8, 2, 3, 1]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # Output: [1, 2, 3, 5, 8]

To sort a string or tuple, you can simply pass it to the sorted() function as well:

text = "python"
sorted_text = sorted(text)
print(sorted_text) # Output: ['h', 'n', 'o', 'p', 't', 'y']

For descending order sorting, use the reverse=True argument with the sorted() function:

numbers = [5, 8, 2, 3, 1]
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc) # Output: [8, 5, 3, 2, 1]

On the other hand, the sort() method is used when you want to modify the original list in-place. One key point to note is that the sort() method can only be called on lists and not on strings or tuples.

To sort a list using the sort() method, simply call this method on the list object:

numbers = [5, 8, 2, 3, 1]
numbers.sort()
print(numbers) # Output: [1, 2, 3, 5, 8]

For descending order sorting using the sort() method, pass the reverse=True argument:

numbers = [5, 8, 2, 3, 1]
numbers.sort(reverse=True)
print(numbers) # Output: [8, 5, 3, 2, 1]

Using the sorted() function and the sort() method, you can easily sort various data structures in Python, such as lists, strings, and tuples, in ascending or descending order.

Recommended: Python List sort() – The Ultimate Guide

Sorting Lists

In Python, sorting a list is a common operation that can be performed using either the sort() method or the sorted() function. Both these approaches can sort a list in ascending or descending order.

Using .sort() Method

The sort() method is a built-in method of the list object in Python. It sorts the elements of the list in-place, meaning it modifies the original list without creating a new one. By default, the sort() method sorts the list in ascending order.

Here’s an example of how to use the sort() method to sort a list of numbers:

numbers = [5, 2, 8, 1, 4]
numbers.sort()
print(numbers) # Output: [1, 2, 4, 5, 8]

To sort the list in descending order, you can pass the reverse=True argument to the sort() method:

numbers = [5, 2, 8, 1, 4]
numbers.sort(reverse=True)
print(numbers) # Output: [8, 5, 4, 2, 1]

Sorting Lists with sorted() Function

The sorted() function is another way of sorting a list in Python. Unlike the sort() method, the sorted() function returns a new sorted list without modifying the original one.

Here’s an example showing how to use the sorted() function:

numbers = [5, 2, 8, 1, 4]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # Output: [1, 2, 4, 5, 8]

Similar to the sort() method, you can sort a list in descending order using the reverse=True argument:

numbers = [5, 2, 8, 1, 4]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers) # Output: [8, 5, 4, 2, 1]

Both the sort() method and sorted() function allow for sorting lists as per specified sorting criteria. Use them as appropriate depending on whether you want to modify the original list or get a new sorted list.

Check out my video on the sorted() function:

Recommended: Python sorted() Function

Sorting Tuples

Tuples are immutable data structures in Python, similar to lists, but they are enclosed within parentheses and cannot be modified once created. Sorting tuples can be achieved using the built-in sorted() function.

Ascending and Descending Order

To sort a tuple or a list of tuples in ascending order, simply pass the tuple to the sorted() function.

Here’s an example:

my_tuple = (3, 1, 4, 5, 2)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple) # Output: [1, 2, 3, 4, 5]

For descending order, use the optional reverse argument in the sorted() function. Setting it to True will sort the elements in descending order:

my_tuple = (3, 1, 4, 5, 2)
sorted_tuple = sorted(my_tuple, reverse=True)
print(sorted_tuple) # Output: [5, 4, 3, 2, 1]

Sorting Nested Tuples

When sorting a list of tuples, Python sorts them by the first elements in the tuples, then the second elements, and so on. To effectively sort nested tuples, you can provide a custom sorting key using the key argument in the sorted() function.

Here’s an example of sorting a list of tuples in ascending order by the second element in each tuple:

my_list = [(1, 4), (3, 1), (2, 5)]
sorted_list = sorted(my_list, key=lambda x: x[1])
print(sorted_list) # Output: [(3, 1), (1, 4), (2, 5)]

Alternatively, to sort in descending order, simply set the reverse argument to True:

my_list = [(1, 4), (3, 1), (2, 5)]
sorted_list = sorted(my_list, key=lambda x: x[1], reverse=True)
print(sorted_list) # Output: [(2, 5), (1, 4), (3, 1)]

As shown, you can manipulate the sorted() function through its arguments to sort tuples and lists of tuples with ease. Remember, tuples are immutable, and the sorted() function returns a new sorted list rather than modifying the original tuple.

Sorting Strings

In Python, sorting strings can be done using the sorted() function. This function is versatile and can be used to sort strings (str) in ascending (alphabetical) or descending (reverse alphabetical) order.

In this section, we’ll explore sorting individual characters in a string and sorting a list of words alphabetically.

Sorting Characters

To sort the characters of a string, you can pass the string to the sorted() function, which will return a list of characters in alphabetical order. Here’s an example:

text = "python"
sorted_chars = sorted(text)
print(sorted_chars)

Output:

['h', 'n', 'o', 'p', 't', 'y']

If you want to obtain the sorted string instead of the list of characters, you can use the join() function to concatenate them:

sorted_string = ''.join(sorted_chars)
print(sorted_string)

Output:

hnopty

For sorting the characters in descending order, set the optional reverse parameter to True:

sorted_chars_desc = sorted(text, reverse=True)
print(sorted_chars_desc)

Output:

['y', 't', 'p', 'o', 'n', 'h']

Sorting Words Alphabetically

When you have a list of words and want to sort them alphabetically, the sorted() function can be applied directly to the list:

words = ['apple', 'banana', 'kiwi', 'orange']
sorted_words = sorted(words)
print(sorted_words)

Output:

['apple', 'banana', 'kiwi', 'orange']

To sort the words in reverse alphabetical order, use the reverse parameter again:

sorted_words_desc = sorted(words, reverse=True)
print(sorted_words_desc)

Output:

['orange', 'kiwi', 'banana', 'apple']

Using Key Parameter

The key parameter in Python’s sort() and sorted() functions allows you to customize the sorting process by specifying a callable to be applied to each element of the list or iterable.

Sorting with Lambda

Using lambda functions as the key argument is a concise way to sort complex data structures. For example, if you have a list of tuples representing names and ages, you can sort by age using a lambda function:

names_ages = [('Alice', 30), ('Bob', 25), ('Charlie', 35)]
sorted_names_ages = sorted(names_ages, key=lambda x: x[1])
print(sorted_names_ages)

Output:

[('Bob', 25), ('Alice', 30), ('Charlie', 35)]

Using itemgetter from operator Module

An alternative to using lambda functions is the itemgetter() function from the operator module. The itemgetter() function can be used as the key parameter to sort by a specific index in complex data structures:

from operator import itemgetter names_ages = [('Alice', 30), ('Bob', 25), ('Charlie', 35)]
sorted_names_ages = sorted(names_ages, key=itemgetter(1))
print(sorted_names_ages)

Output:

[('Bob', 25), ('Alice', 30), ('Charlie', 35)]

Sorting with Custom Functions

You can also create custom functions to be used as the key parameter. For example, to sort strings based on the number of vowels:

def count_vowels(s): return sum(s.count(vowel) for vowel in 'aeiouAEIOU') words = ['apple', 'banana', 'cherry']
sorted_words = sorted(words, key=count_vowels)
print(sorted_words)

Output:

['apple', 'cherry', 'banana']

Sorting Based on Absolute Value

To sort a list of integers based on their absolute values, you can use the built-in abs() function as the key parameter:

numbers = [5, -3, 1, -8, -7]
sorted_numbers = sorted(numbers, key=abs)
print(sorted_numbers)

Output:

[1, -3, 5, -7, -8]

Sorting with cmp_to_key from functools

In some cases, you might need to sort based on a custom comparison function. The cmp_to_key() function from the functools module can be used to achieve this. For instance, you could create a custom comparison function to sort strings based on their lengths:

from functools import cmp_to_key def custom_cmp(a, b): return len(a) - len(b) words = ['cat', 'bird', 'fish', 'ant']
sorted_words = sorted(words, key=cmp_to_key(custom_cmp))
print(sorted_words)

Output:

['cat', 'ant', 'bird', 'fish']

Sorting with Reverse Parameter

In Python, you can easily sort lists, strings, and tuples using the built-in functions sort() and sorted(). One notable feature of these functions is the reverse parameter, which allows you to control the sorting order – either in ascending or descending order.

By default, the sort() and sorted() functions will sort the elements in ascending order. To sort them in descending order, you simply need to set the reverse parameter to True. Let’s explore this with some examples.

Suppose you have a list of numbers and you want to sort it in descending order. You can use the sort() method for lists:

numbers = [4, 1, 7, 3, 9]
numbers.sort(reverse=True) # sorts the list in place in descending order
print(numbers) # Output: [9, 7, 4, 3, 1]

If you have a string or a tuple and want to sort in descending order, use the sorted() function:

text = "abracadabra"
sorted_text = sorted(text, reverse=True)
print(sorted_text) # Output: ['r', 'r', 'd', 'c', 'b', 'b', 'a', 'a', 'a', 'a', 'a'] values = (4, 1, 7, 3, 9)
sorted_values = sorted(values, reverse=True)
print(sorted_values) # Output: [9, 7, 4, 3, 1]

Keep in mind that the sort() method works only on lists, while the sorted() function works on any iterable, returning a new sorted list without modifying the original iterable.

When it comes to sorting with custom rules, such as sorting a list of tuples based on a specific element, you can use the key parameter in combination with the reverse parameter. For example, to sort a list of tuples by the second element in descending order:

data = [("apple", 5), ("banana", 3), ("orange", 7), ("grape", 2)]
sorted_data = sorted(data, key=lambda tup: tup[1], reverse=True)
print(sorted_data) # Output: [('orange', 7), ('apple', 5), ('banana', 3), ('grape', 2)]

So the reverse parameter in Python’s sorting functions provides you with the flexibility to sort data in either ascending or descending order. By combining it with other parameters such as key, you can achieve powerful and customized sorting for a variety of data structures.

Sorting in Locale-Specific Order

Sorting lists, strings, and tuples in Python is a common task, and it often requires locale-awareness to account for language-specific rules. You can sort a list, string or tuple using the built-in sorted() function or the sort() method of a list. But to sort it in a locale-specific order, you must take into account the locale’s sorting rules and character encoding.

We can achieve locale-specific sorting using the locale module in Python. First, you need to import the locale library and set the locale using the setlocale() function, which takes two arguments, the category and the locale name.

import locale
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8') # Set the locale to English (US)

Next, use the locale.strxfrm() function as the key for the sorted() function or the sort() method. The strxfrm() function transforms a string into a form suitable for locale-aware comparisons, allowing the sorting function to order the strings according to the locale’s rules.

strings_list = ['apple', 'banana', 'Zebra', 'éclair']
sorted_strings = sorted(strings_list, key=locale.strxfrm)

The sorted_strings list will now be sorted according to the English (US) locale, with case-insensitive and accent-aware ordering.

Keep in mind that it’s essential to set the correct locale before sorting, as different locales may have different sorting rules. For example, the German locale would handle umlauts differently from English, so setting the locale to de_DE.UTF-8 would produce a different sorting order.

Sorting Sets

In Python, sets are unordered collections of unique elements. To sort a set, we must first convert it to a list or tuple, since the sorted() function does not work directly on sets. The sorted() function returns a new sorted list from the specified iterable, which can be a list, tuple, or set.

import locale
strings_list = ['apple', 'banana', 'Zebra', 'éclair']
sorted_strings = sorted(strings_list, key=locale.strxfrm)
print(sorted_strings)
# ['Zebra', 'apple', 'banana', 'éclair']

In this example, we begin with a set named sample_set containing four integers. We then use the sorted() function to obtain a sorted list named sorted_list_from_set. The output will be:

[1, 2, 4, 9]

The sorted() function can also accept a reverse parameter, which determines whether to sort the output in ascending or descending order. By default, reverse is set to False, meaning that the output will be sorted in ascending order. To sort the set in descending order, we can set reverse=True.

sorted_list_descending = sorted(sample_set, reverse=True)
print(sorted_list_descending)

This code snippet will output the following:

[9, 4, 2, 1]

It’s essential to note that sorting a set using the sorted() function does not modify the original set. Instead, it returns a new sorted list, leaving the original set unaltered.

Sorting by Group and Nested Data Structures

Sorting nested data structures in Python can be achieved using the built-in sorted() function or the .sort() method. You can sort a list of lists or tuples based on the value of a particular element in the inner item, making it useful for organizing data in groups.

To sort nested data, you can use a key argument along with a lambda function or the itemgetter() method from the operator module. This allows you to specify the criteria based on which the list will be sorted.

For instance, suppose you have a list of tuples representing student records, where each tuple contains the student’s name and score:

students = [("Alice", 85), ("Bob", 78), ("Charlie", 91), ("Diana", 92)]

To sort the list by the students’ scores, you can use the sorted() function with a lambda function as the key:

sorted_students = sorted(students, key=lambda student: student[1])

This will produce the following sorted list:

[("Bob", 78), ("Alice", 85), ("Charlie", 91), ("Diana", 92)]

Alternatively, you can use the itemgetter() method:

from operator import itemgetter sorted_students = sorted(students, key=itemgetter(1))

This will produce the same result as using the lambda function.

When sorting lists containing nested data structures, consider the following tips:

• Use the lambda function or itemgetter() for specifying the sorting criteria.
• Remember that sorted() creates a new sorted list, while the .sort() method modifies the original list in-place.
• You can add the reverse=True argument if you want to sort the list in descending order.

Handling Sorting Errors

When working with sorting functions in Python, you might encounter some common errors such as TypeError. In this section, we’ll discuss how to handle such errors and provide solutions to avoid them while sorting lists, strings, and tuples using the sort() and sorted() functions.

TypeError can occur when you’re trying to sort a list that contains elements of different data types. For example, when sorting an unordered list that contains both integers and strings, Python would raise a TypeError: '<' not supported between instances of 'str' and 'int' as it cannot compare the two different data types.

Consider this example:

mixed_list = [3, 'apple', 1, 'banana']
mixed_list.sort()
# Raises: TypeError: '<' not supported between instances of 'str' and 'int'

To handle the TypeError in this case, you can use error handling techniques such as a try-except block. Alternatively, you could also preprocess the list to ensure all elements have a compatible data type before sorting. Here’s an example using a try-except block:

mixed_list = [3, 'apple', 1, 'banana']
try: mixed_list.sort()
except TypeError: print("Sorting error occurred due to incompatible data types")

Another approach is to sort the list using a custom sorting key in the sorted() function that can handle mixed data types. For instance, you can convert all the elements to strings before comparison:

mixed_list = [3, 'apple', 1, 'banana']
sorted_list = sorted(mixed_list, key=str)
print(sorted_list) # Output: [1, 3, 'apple', 'banana']

With these techniques, you can efficiently handle sorting errors that arise due to different data types within a list, string, or tuple when using the sort() and sorted() functions in Python.

Sorting Algorithm Stability

Stability in sorting algorithms refers to the preservation of the relative order of items with equal keys. In other words, when two elements have the same key, their original order in the list should be maintained after sorting. Python offers several sorting techniques, with the most common being sort() for lists and sorted() for strings, lists, and tuples.

Python’s sorting algorithms are stable, which means that equal keys will have their initial order preserved in the sorted output. For example, consider a list of tuples containing student scores and their names:

students = [(90, "Alice"), (80, "Bob"), (90, "Carla"), (85, "Diana")]

Sorted by scores, the list should maintain the order of students with equal scores as in the original list:

sorted_students = sorted(students)
# Output: [(80, 'Bob'), (85, 'Diana'), (90, 'Alice'), (90, 'Carla')]

Notice that Alice and Carla both have a score of 90 but since Alice appeared earlier in the original list, she comes before Carla in the sorted list as well.

To take full advantage of stability in sorting, the key parameter can be used with both sort() and sorted(). The key parameter allows you to specify a custom function or callable to be applied to each element for comparison. For instance, when sorting a list of strings, you can provide a custom function to perform a case-insensitive sort:

words = ["This", "is", "a", "test", "string", "from", "Andrew"]
sorted_words = sorted(words, key=str.lower)
# Output: ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

Frequently Asked Questions

How to sort a list of tuples in descending order in Python?

To sort a list of tuples in descending order, you can use the sorted() function with the reverse=True parameter. For example, for a list of tuples tuples_list, you can sort them in descending order like this:

sorted_tuples = sorted(tuples_list, reverse=True)

What is the best way to sort a string alphabetically in Python?

The best way to sort a string alphabetically in Python is to use the sorted() function, which returns a sorted list of characters. You can then join them using the join() method like this:

string = "hello"
sorted_string = "".join(sorted(string))

What are the differences between sort() and sorted() in Python?

sort() is a method available for lists, and it sorts the list in-place, meaning it modifies the original list. sorted() is a built-in function that works with any iterable, returns a new sorted list of elements, and doesn’t modify the original iterable.

# Using sort()
numbers = [3, 1, 4, 2]
numbers.sort()
print(numbers) # [1, 2, 3, 4] # Using sorted()
numbers = (3, 1, 4, 2)
sorted_numbers = sorted(numbers)
print(sorted_numbers) # [1, 2, 3, 4]

How can you sort a tuple in descending order in Python?

To sort a tuple in descending order, you can use the sorted() function with the reverse=True parameter, like this:

tuple_numbers = (3, 1, 4, 2)
sorted_tuple = sorted(tuple_numbers, reverse=True)

Keep in mind that this will create a new list. If you want to create a new tuple instead, you can convert the sorted list back to a tuple like this:

sorted_tuple = tuple(sorted_tuple)

How do you sort a string in Python without using the sort function?

You can sort a string without using the sort() function by converting the string to a list of characters, using a list comprehension to sort the characters, and then using the join() method to create the sorted string:

string = "hello"
sorted_list = [char for char in sorted(string)]
sorted_string = "".join(sorted_list)

What is the method to sort a list of strings with numbers in Python?

If you have a list of strings containing numbers and want to sort them based on the numeric value, you can use the sorted() function with a custom key parameter. For example, to sort a list of strings like ["5", "2", "10", "1"], you can do:

strings_with_numbers = ["5", "2", "10", "1"]
sorted_strings = sorted(strings_with_numbers, key=int)

This will sort the list based on the integer values of the strings: ["1", "2", "5", "10"].

Python One-Liners Book: Master the Single Line First!

Python programmers will improve their computer science skills with these useful one-liners.

Python One-Liners will teach you how to read and write “one-liners”: concise statements of useful functionality packed into a single line of code. You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce key computer science concepts and boost your coding and analytical skills. You’ll learn about advanced Python features such as list comprehension, slicing, lambda functions, regular expressions, map and reduce functions, and slice assignments.

You’ll also learn how to:

• Leverage data structures to solve real-world problems, like using Boolean indexing to find cities with above-average pollution
• Use NumPy basics such as array, shape, axis, type, broadcasting, advanced indexing, slicing, sorting, searching, aggregating, and statistics
• Calculate basic statistics of multidimensional data arrays and the K-Means algorithms for unsupervised learning
• Create more advanced regular expressions using grouping and named groups, negative lookaheads, escaped characters, whitespaces, character sets (and negative characters sets), and greedy/nongreedy operators
• Understand a wide range of computer science topics, including anagrams, palindromes, supersets, permutations, factorials, prime numbers, Fibonacci numbers, obfuscation, searching, and algorithmic sorting

By the end of the book, you’ll know how to write Python at its most refined, and create concise, beautiful pieces of “Python art” in merely a single line.

Get your Python One-Liners on Amazon!!

The post Sort a List, String, Tuple in Python (sort, sorted) appeared first on Be on the Right Side of Change.

Installing Auto-GPT is not simple, especially if you’re not a coder, because you need to set up Docker and do all the tech stuff. And even if you’re a coder you may not want to go through the hassle. In this article, I’ll show you some easy Auto-GPT web interfaces that’ll make the job easier!

Tool #1 – Auto-GPT on Hugging Face

Hugging Face user aliabid94 created an Auto-GPT web interface (100% browser-based) where you can put in your OpenAI API key and try out Auto-GPT in seconds.

To get an OpenAI API key, check out this tutorial on the Finxter blog or visit your paid OpenAI account directly here.

The example shows the Auto-GPT run of an Entrepreneur-GPT that is designed to grow your Twitter account.

Tool #2 – AutoGPTJS.com

I haven’t tried autogptjs.com but the user interface looks really compelling and easy to use. Again, you need to enter your OpenAI API key and you should create a new one and revoke it after use. Who knows where the keys are really stored?

Well, this project looks trustworthy as it’s also available on GitHub.

Tool #3 – AgentGPT

AgentGPT is an easy-to-use browser based autonomous agent based on GPT-3.5 and GPT-4. It is similar to Auto-GPT but uses its own repository and code base.

I have written a detailed comparison between Auto-GPT and AgentGPT on the Finxter blog but the TLDR is that it’s easier to setup and use at the cost of being much more expensive and less suitable for long-running tasks.

Tool #4 – AutoGPT UI with Nuxt.js

AutoGPT UI, built with Nuxt.js, is a user-friendly web tool for managing AutoGPT workspaces. Users can easily upload AI settings and supporting files, adjust AutoGPT settings, and initiate the process via our intuitive GUI. It supports both individual and multi-user workspaces. Its workspace management interface enables easy file handling, allowing drag-and-drop features and seamless interaction with source or generated content.

Some More Comments…

Before you go, here are a few additional notes.

Token Usage and Revoking Keys

To access Auto-GPT, you need to use the OpenAI API key, which is essential for authenticating your requests. The token usage depends on the API calls you make for various tasks.

You should set a spending limit and revoke your API keys after putting them in any browser-based Auto-GPT tool. After all, you don’t know where your API keys will end up so I use a strict one-key-for-one-use policy and revoke all keys directly after use.

3 More Tools

The possibilities with Auto-GPT innovation are vast and ever-expanding.

For instance, researchers and developers are creating new AI tools such as Godmode (I think it’s based on BabyAGI) to easily deploy AI agents directly in the web browser.

With its potential to grow and adapt, Auto-GPT is poised to make an impact on numerous industries, driving further innovation and advancements in AI applications.

AutoGPT Chrome extension is another notable add-on, providing an easily accessible interface for users.

Yesterday I found a new tool called JARVIS (HuggingGPT), named after the J.A.R.V.I.S. artificial intelligence from Ironman, that is an Auto-GPT alternative created by Microsoft research that uses not only GPT-3.5 and GPT-4 but other LLMs as well and is able to generate multimedia output such as audio and images (DALL-E). Truly mindblowing times we’re living in.

Recommended: Auto-GPT vs Jarvis HuggingGPT: One Bot to Rule Them All

Greatness is not about overnight success but multiple periods of repeatable habits. It is not about being better than someone else but about being dependable, disciplined and earned.

Many people want to be great but do not want to put in the effort over a sustained period of time to get there.

Success comes from hard work, consistency and intentional inputs that lead to expected outputs. The best way to achieve this is to focus on small wins consistently rather than trying to achieve perfection. By doing small things a great number of times, one can achieve greatness.

Continuous improvement and developing a habit of progression are essential to achieving greatness. Stop speculating and start taking action, focusing on tangible progress and developing repeatable habits to transform into greatness.

Recommended Reading: How to Be Great? Just Be Good, Repeatably

Achieving Greatness

Throughout our lives, we encounter various levels of success and failure. As we accumulate more experiences, it’s natural to wonder which ones were genuinely great and why.

Surprisingly, it’s often not the sudden, dramatic achievements that stand out, but the incremental, sustained efforts that lead to significant achievements over time.

In other words, greatness is not about overnight successes but about periods of repeatable habits.

This article seeks to explore the true nature of greatness, the importance of consistency, and the process of building a habit of progression to rise above mediocrity and achieve lasting success.

The Foundations of Greatness

Before delving into the heart of the article, let’s establish two fundamental principles:

1. Greatness is not instantaneous.
2. Greatness is earned.

The following story tries to establish those.

Story Warren Buffett

One of the most clear examples of a person achieving greatness through compounding effort and habits over a long time is Warren Buffett. Warren Buffett is one of the most successful investors in the world, known for his disciplined approach to investment and his philosophy of buying and holding.

Buffett started investing when he was just 11 years old and learned about the power of compounding at a very young age. He was not an overnight success. His wealth and success have grown slowly and steadily over the decades, thanks to his consistent investment habits and the magic of compound interest.

Buffett’s investing principles involve patience, long-term thinking, and a focus on fundamentals, including the quality of the business, its management, and its potential for long-term profitability. This strategy allowed him to make consistent, measured investment decisions, often going against popular trends.

He is known for reading extensively, up to 500 pages per day, to increase his knowledge and understanding of different businesses and industries. This is a habit he developed early in life and has maintained throughout his career.

Additionally, he has been a strong advocate of living frugally and prioritizing saving and investing over excessive consumption. He still lives in the same house in Omaha, Nebraska, that he bought in 1958 for $31,500.

Buffett’s consistent investment strategies and frugal lifestyle habits, sustained over several decades, have allowed his wealth to compound and grow exponentially. As of my last knowledge cut-off in September 2021, Warren Buffett’s net worth was approximately $100 billion, making him one of the wealthiest people in the world. This success story is a testament to the power of compounding effort, disciplined habits, and long-term thinking.

---

Becoming great starts with acknowledging that you’re not already great and recognizing that greatness is not achieved in a single moment or through a stroke of luck. Instead, greatness is a reflection of consistent effort put in over time.

Additionally, greatness is not about being better than others. It’s about being reliable, disciplined, and continuous progress towards mastery.

In short, greatness is earned through hard work persisted over a long period.

The Role of Consistency in Achieving Greatness

One common misconception is that success or notoriety is achieved through flashy and unconventional methods.

This idea arises from the media’s focus on outliers – events or personalities that deviate from the norm. This portrayal can mislead people into aspiring for notoriety solely for the sake of it, or believing that the success of these outliers is solely due to their unorthodox approaches.

In reality, the most reliable and effective path to success is through consistency. Consistency may not be the easiest way to achieve success, but it provides a higher level of certainty and a more predictable outcome rather than relying on a lucky break or being “discovered.”

Check out the following example that beautifully illustrates these considerations.

The Art Class – Quantity vs Quality

James Clear, the author of “Atomic Habits,” provides an insightful example highlighting the importance of consistency.

A study in a photography class divided students into two groups – “quantity” and “quality.”

The quantity group would be graded based on the number of photographs they submitted, while the quality group would be graded on the excellence of a single image.

Surprisingly, the best photographs were produced by the quantity group. Rather than merely theorizing about perfection, they consistently tested and refined their skills through practice.

Developing a Habit of Progression

The journey to greatness requires the development of a habit of progression. In other words, you need to become accustomed to consistently improving even when faced with obstacles or setbacks. The key here is to ensure that your habits and efforts are focused on the right inputs, as consistency in the wrong direction will still lead you astray.

Nothing goes up into the right forever. Greatness is achieved when pushing forward with action when you doubt your future success the most.

If you’re struggling to identify the right path forward, try creating more opportunities for optimization. Instead of making significant life changes annually, be open to trying new things monthly or even weekly. Test various options and, when you’ve found a path that seems to work, double down.

Simple algorithm: Do more of what works.

Remember, the objective is not perfection but rather continuous and incremental improvements. Learn to be satisfied with being “good” at something and then working towards making those “good” habits second nature.

In time, these small, sustained efforts will be what sets you apart from those who merely aspire to greatness without putting in the necessary work.

Maintaining Patience and Perspective

Another key ingredient in achieving greatness is patience.

Recognize that progress may be slow, and that’s okay. In most cases, significant changes happen incrementally and often without fanfare. The key is to stay dedicated to your practice and improvement, even during periods where it feels like you’re not making any headway.

Additionally, avoid the temptation of getting bogged down in the search for an optimal plan or strategy.

While it’s essential to learn from your experiences and make informed decisions, it’s also crucial not to become paralyzed by the desire for a perfect approach. Focus instead on taking action, learning from the results and iterating your tactics accordingly.

The Power of Repeated Small Wins

One powerful strategy for achieving greatness is to accumulate small, consistent wins.

Rather than aiming for grandiose accomplishments, aim for reliable successes that you can build upon over time. These small and often unremarkable successes might not make headlines, but they add up and compound to significant achievements in the long run.

The Story of British Athlete Sir Chris Hoy

Sir Chris Hoy, one of Britain’s most successful Olympians, is an excellent example of how small, consistent wins can lead to greatness. Hoy didn’t burst onto the scene as an unstoppable force. Instead, his success was built slowly and steadily over time through disciplined training and continuous improvement.

Born in Edinburgh, Scotland, in 1976, Hoy was always athletic but did not start competitive cycling until his late teens. His early career was marked by consistent performances and modest successes, but he was not an immediate superstar.

Hoy’s approach to training emphasized incremental improvements. He followed a principle called the “aggregation of marginal gains,” which was popularized by Dave Brailsford, the British Cycling performance director. The idea was simple: find a 1% margin for improvement in everything you do. Instead of looking for one area to improve by 100%, Brailsford and Hoy sought hundreds of areas to improve by 1%, accumulating small, consistent wins.

From adjusting his training routines and optimizing his sleep patterns to tweaking the ergonomics of his bike, Hoy focused on these marginal gains. These small changes might not have made headlines, but they added up and compounded over time into significant improvements in performance.

The result? Hoy became one of the most decorated cyclists in history. He has six Olympic gold medals and eleven World Championship titles to his name. He was knighted by Queen Elizabeth II for his services to cycling.

Sir Chris Hoy’s story encapsulates the power of small, consistent wins.

His approach underscores the idea that the best things in life and the most successful endeavors are not usually the result of miraculous events, but rather of carefully planned and executed strategies born from dedication, consistency, and gradual improvement.

His story highlights that focusing on the process and developing the right habits can help achieve and sustain greatness.

Remember, the best things in life and the most successful endeavors are typically not miraculous events but carefully planned and executed strategies born from dedication, consistency, and gradual improvement.

By focusing on the process and developing the right habits, you’ll forge yourself into the person who can not only reach but also sustain greatness.

The Pursuit of Greatness …

… is not about achieving sudden, monumental successes but rather about embracing the power of consistency and adopting habits that foster continuous improvement and progression.

By staying focused on the process, learning from your experiences, and remaining patient, you’ll set yourself apart from those who only dream of greatness without ever putting in the work.

Remember: greatness is simply good, repeated consistently over time. By cultivating this mindset and dedicating yourself to the process, you’ll discover the true essence of greatness and see it reflected in your own accomplishments.

In the realm of AI agents and artificial general intelligence, Auto-GPT and Agent GPT are making waves as innovative tools built on OpenAI’s API. These language models have become popular choices for AI enthusiasts seeking to leverage the power of artificial intelligence in various tasks.

Auto-GPT is an experimental, open-source autonomous AI agent based on the GPT-4 language model. It’s designed to chain together tasks autonomously, streamlining the multi-step prompting process commonly found in chatbots like ChatGPT.

Agent GPT boasts a user-friendly interface that makes AI interaction seamless even for individuals without coding experience.

AgentGPT is more expensive as you need to subscribe to a professional plan whereas with Auto-GPT you only need to provide an OpenAI API key without paying a third party.

While Auto-GPT pushes the boundaries of AI autonomy, Agent GPT focuses on a more intuitive user experience.

I created a table that subjectively summarizes the key similarities and differences:

Feature	Auto-GPT	Agent GPT	Similarities	Differences
Autonomy	Can operate and make decisions on its own	Same. From time to time needs human intervention to operate	Both are powered by GPT technology	Auto-GPT can be fully autonomous. Agent GPT not fully.
User-Friendliness	Less user-friendly compared to Agent GPT	More user-friendly due to its intuitive UI	Both are designed to make AI accessible	Auto-GPT more technical. Agent GPT easier and non-technical.
Functionality	Designed to function autonomously	Can create and deploy autonomous AI agents	Both can generate human-like text	Both worked the same in my case. Auto-GPT more customizable.
Intended use cases	Best suited for individuals with programming or AI expertise	More accessible to individuals without programming or AI expertise	Both can be used for a range of applications, including chatbots and content creation	Auto-GPT for technical users who want more control. Agent GPT ideal for non-technical users
Pricing	OpenAI API pricing ($0.03 per 1000 tokens)	$40 per month for a few agents	Both are relatively cheap for what they provide	AgentGPT free for trial but more expensive than Auto-GPT for non-trivial tasks

Auto-GPT and Agent GPT Overview

In the realm of AI-powered language models, Auto-GPT and Agent GPT are two prominent technologies built on OpenAI’s API for automating tasks and language processing. This section provides a brief overview of both Auto-GPT and Agent GPT, focusing on their fundamentals and applications in various fields.

Auto-GPT Fundamentals

Auto-GPT is an open-source interface to large language models such as GPT-3.5 and GPT-4. It empowers users by self-guiding to complete tasks using a predefined task list. Requiring coding experience to be effectively used, Auto-GPT operates autonomously, making decisions and generating its own prompts .

With core capabilities in natural language processing, Auto-GPT applies to areas like data mining, content creation, and recommendation systems. Its autonomous nature makes it an ideal choice for developers seeking a more hands-off approach to task automation.

Recommended: 30 Creative AutoGPT Use Cases to Make Money Online

Agent GPT Fundamentals

In contrast, Agent GPT is a user-friendly application with a direct browser interface for task input. Eliminating the need for coding expertise, Agent GPT provides an intuitive user experience suited for a broader audience. While it depends on user inputs for prompt generation, it still boasts a powerful language model foundation.

Agent GPT finds applications in various fields, including virtual assistants, chatbots, and educational tools. Its user-friendliness and customizability make it an appealing choice for non-technical users seeking artificial general intelligence (AGI) support in their projects.

Technology Comparison

In this section, we will compare Auto-GPT and AgentGPT, focusing on their Language Models and Processing, Autonomy and Workflow, and User Interface and Accessibility. These AI agents have distinct advantages and offer a range of features for different user needs.

Language Models and Processing

Auto-GPT and AgentGPT both utilize OpenAI’s GPT-3 or GPT-4 API, which handles natural language processing and deep learning tasks. As a result, they can handle complex text-based tasks effectively. The primary difference lies in their implementation and target audience.

Autonomy and Workflow

Auto-GPT is designed to function autonomously by providing a task list and working towards task completion without much user interaction. This is ideal for developers with coding experience looking to automate more technical tasks in their workflow.

In contrast, AgentGPT is more user-friendly, requiring input through a direct browser interface. This makes AgentGPT a better choice for those without programming or AI expertise, as it simplifies the adoption and integration of the AI-powered tool in everyday tasks.

Autonomy of both is similar although you can keep Auto-GPT running much longer in your shell or terminal. Having the browser tab open in Agent GPT will only get you so far…

User Interface and Accessibility

Auto-GPT’s open-source nature means that it requires coding experience to be used effectively. While this may be perfect for developers, it can be a barrier for non-technical users.

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

On the other hand, AgentGPT offers a straightforward browser interface, enabling users to input tasks without prior coding knowledge. This increased accessibility makes it a popular choice for individuals seeking AI assistance in a variety of professional settings.

Key Features

Generative AI and Content Creation

Auto-GPT and AgentGPT are both AI agents used for generating text and content creation, but they have some differences.

Auto-GPT is an open-source project on GitHub made by Toran Bruce Richards. AgentGPT, on the other hand, is designed for user-friendliness and accessibility for those without AI expertise, thus making it perfect for non-programmers.

Recommended: AutoGPT vs BabyAGI: Comparing OpenAI-Based Autonomous Agents

These AI agents employ advanced natural language processing algorithms to generate and structure content efficiently. They are optimized for various tasks, such as writing articles, creating summaries, and generating chatbot responses.

Machine Learning and Data Analysis

Both Auto-GPT and AgentGPT rely on cutting-edge machine learning algorithms to analyze and process data. Auto-GPT utilizes GPT-4 API for its core functionalities, while AgentGPT doesn’t rely on a specific GPT model.

Through their machine learning capabilities, these AI agents can not only create content but also analyze and process it effectively. This makes them perfect for applications like sentiment analysis, recommender systems, and classifications in a wide range of industries, from marketing to healthcare.

To sum up, Auto-GPT and AgentGPT are powerful and similar AI tools with a minor number of distinct features that cater to different needs. They both excel in generative AI and content creation, as well as machine learning and data analysis.

Personally, I found that AgentGPT is more fun!

Pricing and Costs

AI agents like Auto-GPT and AgentGPT have become increasingly popular for automating tasks, but the security concerns surrounding them and their API access need to be taken into account. In this section, we will discuss securing AI integration and obtaining an OpenAI API key for these AI agents.

AgentGPT is more expensive as you need to subscribe to a professional plan whereas with Auto-GPT you only need to provide an OpenAI API key without paying a third party.

Here’s a screenshot of the product pricing of AgentGPT:

The pricing of OpenAI API is very inexpensive, so Auto-GPT will be much cheaper for larger projects:

Use Cases and Industries

This section explores the distinct applications of Auto-GPT and AgentGPT in various industries, focusing on automation, marketing strategy, and customer service. We will examine how these AI agents can streamline tasks and enhance decision-making, contribute to marketing initiatives, and improve customer service through chatbots.

Automate Tasks and Decision-Making

Auto-GPT excels at autonomous operation, making it a powerful choice for automating tasks and decision-making.

Industries like finance, manufacturing, and logistics can benefit from Auto-GPT’s ability to process vast amounts of data, identify patterns, and execute decisions based on predefined goals.

On the other hand, AgentGPT requires a higher amount of human intervention but excels in more user-friendly applications, providing an intuitive interface that non-experts can easily navigate. I have yet to see somebody running Agent GPT for days whereas it’s easy to do with Auto-GPT.

Marketing Strategy

In the realm of marketing, AgentGPT’s intuitive user interface makes it the more suitable choice for strategizing and creating content.

Digital marketers can leverage the language model to develop relevant and engaging materials for various platforms, including social media, email campaigns, and blog posts.

While Auto-GPT can also generate content, its autonomous nature might not be as ideal for crafting customized and targeted marketing messages.

Development and Future Prospects

In the rapidly evolving field of AI, Auto-GPT and Agent GPT are two key players making significant strides. This section explores their open-source interfaces, repositories, and future research involving GPT-4 and beyond, delving into how these developments might shape the future of large language models.

By the way, if you’re interested in open-source developments in the large language models (LLM) space, check out this article on the Finxter blog!

6 New AI Projects Based on LLMs and OpenAI

Open-Source Interfaces and Repositories

In the world of artificial intelligence, open-source interfaces facilitate broader access to cutting-edge technology. Auto-GPT is one such agent, available as an open-source project on GitHub.

Developed by Toran Bruce Richards aka “Significant Gravitas”, its accessibility to those with coding experience helps to foster innovation in AI applications.

On the other hand, Agent GPT is a more expensive and user-friendly platform geared toward a wider audience, requiring less technical know-how for utilization.

GPT-4 and Future Research

As AI research continues, the focus has shifted to larger language models—like GPT-4—that are expected to outperform their predecessors.

Auto-GPT, as a self-guiding agent capable of task completion via a provided task list, is primed for incorporation with future GPT iterations. Meanwhile, BabyAGI is another emerging language model, developed simultaneously with agents like Auto-GPT and Agent GPT, in response to the growing generative AI domain.

TLDR; Auto-GPT and Agent GPT contribute to a brighter future in AI research, with the former offering a more technical approach that’s inexpensive and highly customizable and the latter catering to a less code-oriented user base that is willing to pay more for the convenience.

The introduction of GPT-4 represents a step toward more advanced and efficient AI applications, ensuring that the race for better language models continues.

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

References

• openaimaster.com
• docs.kanaries.net
• teccgadgets.com
• mashable.com
• openaimaster.com

Artificial intelligence has brought us powerful tools to simplify our lives, and among these tools are Auto-GPT and ChatGPT. While they both revolve around the concept of generating text, there are some key differences that set them apart.

Auto-GPT, an open-source AI project, is built on ChatGPT’s Generative Pre-trained Transformers, giving it the ability to act autonomously without requiring continuous human input. It shines in handling multi-step projects and demands technical expertise for its utilization.

On the other hand, ChatGPT functions as an AI chatbot that provides responses based on human prompts. Although it excels at generating shorter, conversational replies, it lacks the autonomy found in Auto-GPT.

In this article, we’ll dive deeper into the distinctions and possible applications of these two groundbreaking technologies.

Overview of Auto-GPT and ChatGPT

This section provides a brief overview of Auto-GPT and ChatGPT, two AI technologies based on OpenAI’s generative pre-trained transformer (GPT) models. We will discuss the differences between these AI tools and their functionalities.

Auto-GPT

Auto-GPT, an open-source AI project, harnesses the power of GPT-4 to operate autonomously, without requiring human intervention for every action.

Developed by Significant Gravitas and posted on GitHub on March 30, 2023, this Python application is perfect for completing tasks with minimal human oversight. Its primary goal is to create an AI assistant capable of tackling projects independently.

See an example run here (source):

Recommended: 10 High-IQ Things GPT-4 Can Do That GPT-3.5 Can’t

This sets it apart from its predecessor, ChatGPT, in terms of autonomy.

ChatGPT

ChatGPT, built on the GPT-3.5 and GPT-4 models, is a web app designed specifically for chatbot applications and optimized for dialogue. It’s developed by OpenAI, and its primary focus lies in generating human-like text conversationally.

By leveraging GPT’s potential in language understanding, it can perform tasks such as explaining code or composing poetry. ChatGPT mainly relies on AI agents to produce text based on input prompts given by users, unlike Auto-GPT, which operates autonomously.

TLDR; While both Auto-GPT and ChatGPT use OpenAI’s large language models, their goals and functionalities differ. Auto-GPT aims for independent task completion, while ChatGPT excels in conversational applications.

Main Features

Auto-GPT and ChatGPT, both AI-driven tools, have distinct features that cater to various applications. Let’s dive into the main features of these two innovative technologies.

Auto-GPT: Autonomy and Decision-Making

Auto-GPT is an open-source AI project designed for task-oriented conversations.

Its core feature is its ability to act autonomously without requiring constant prompts or input from human agents. This enables Auto-GPT to make decisions on its own and efficiently complete tasks.

It leverages powerful language models like GPT-3.5 and GPT-4 to generate detailed responses, making it ideal for applications where automation and decision-making are crucial.

For more information about Auto-GPT, check out this Finxter article:

Recommended: What is AutoGPT and How to Get Started?

ChatGPT: General-Purpose and Conversational

ChatGPT, on the other hand, is an AI tool optimized for generating general-purpose responses in chatbot applications and APIs.

Although it shares some similarities with Auto-GPT, it requires more detailed prompts from human agents to engage in meaningful conversations. ChatGPT uses large language models (LLMs) like GPT-4 to produce accurate and relevant responses in various dialogue contexts.

Its flexibility and vast knowledge base make it an excellent choice for chatbot applications that need a more human-like touch. You can learn more about ChatGPT here.

While both Auto-GPT and ChatGPT offer unique advantages, their applications differ based on users’ needs. Auto-GPT suits those looking for more automation and autonomy, while ChatGPT caters to developers seeking a more interactive and human-like AI tool.

Technical Details

API and API Keys

Auto-GPT and ChatGPT both utilize OpenAI APIs to interact with their respective systems. To access these APIs, users need an OpenAI API key .

These keys ensure proper usage, security, and authentication for the applications making the requests to the systems. Make sure to obtain the necessary API keys from the service providers to use Auto-GPT or ChatGPT.

Python and Open-Source

Both Auto-GPT and ChatGPT are built on open-source frameworks, making it easier for developers to access and modify the code.

Python is the primary programming language for these projects, as it’s user-friendly and widely adopted in the AI and machine learning community. Using Python enables seamless integration and implementation in various applications.

GitHub and Experimental Projects

For those interested in the cutting-edge developments and experimental projects involving Auto-GPT and ChatGPT, GitHub is the place to go.

Many experimental projects reside on GitHub repositories, allowing users to explore and contribute to the ongoing advancements in these technologies.

Stay curious and engaged to stay ahead in the AI landscape . You can do so by following me regular email tech updates focused on exponential technologies such as ChatGPT and LLMs. Simply download our cheat sheets:

Architecture and Decision-Making

Auto-GPT and ChatGPT are both built on Generative Pre-trained Transformers (GPT), but there are differences in their decision-making abilities and autonomy levels. This section explores these aspects, showing how these AI models differ in terms of software and potential applications.

Auto-GPT is an open-source AI project focused on task-oriented conversations, with more decision-making powers than ChatGPT . It’s designed to break a goal into smaller tasks and use its decision-making abilities to accomplish the objective. Auto-GPT benefits from using GPT-3.5 and GPT-4 text-generating models, providing it with a higher level of autonomy compared to ChatGPT (source).

ChatGPT, on the other hand, is tailored for generating general-purpose responses in a conversational context . It is trained on extensive text data, including human-to-human conversations, and excels at producing human-like dialogue. ChatGPT relies on GPT architecture, but its focus is more on interaction than decision-making (source).

Auto-GPT’s enhanced decision-making capabilities position it as a possible contender in pursuing artificial general intelligence (AGI) . Its better memory and ability to construct and remember longer chains of information make it a formidable tool in more complex tasks (source).

Both Auto-GPT and ChatGPT have their unique strengths and areas of focus. Auto-GPT’s edge lies in its decision-making processes and task-oriented nature, while ChatGPT thrives in generating natural-sounding text for general conversation. The right choice depends on the specific application or requirement in hand.

User Interface and Experience

The user interface and experience allow users to interact with Auto-GPT and ChatGPT more efficiently and effectively. This section covers the various ways users can access and engage with these AI tools to ensure smooth interaction.

Browser Access

Both Auto-GPT and ChatGPT offer convenient browser-based access, enabling users to use these tools without the need for technical knowledge or any additional software installation.

Yeah, you shouldn’t try to install Auto-GPT on your own machine, frankly. You should access it via a browser-based website – just google “Auto-GPT browser” and take the latest one.

A simple visit to their respective websites allows users to start benefiting from the power of these AI models. Experience smooth and efficient conversation with these AI chatbots right on your browser.

Docker and Mobile Accessibility

For those seeking greater flexibility and customization, Docker containerization is an option.

Docker enables users to deploy and manage both Auto-GPT and ChatGPT more efficiently, meeting individual needs and configuration preferences. IN fact, Docker is the recommended way to install Auto-GPT as shown in my article here:

Recommended: Setting Up Auto-GPT Any Other Way is Dangerous!

Additionally, mobile accessibility helps users on the go, with platforms like Google’s Android, ensuring personal assistant services are just a tap away.

User-Friendly Platforms

Understanding the importance of user-friendly interfaces, both Auto-GPT and ChatGPT developers emphasize creating straightforward and easily navigable platforms.

This focus on accessibility helps users, including those with limited technical expertise, to interact with the AI models successfully. Clear instructions, well-organized layouts, and intuitive design elements contribute to the overall positive experience.

Applications and Use Cases

Natural Language Processing and Content Creation

Auto-GPT and ChatGPT both excel in natural language processing tasks, making them powerful tools for content creation .

Auto-GPT is designed for multi-step projects and requires programming knowledge, while ChatGPT is more suitable for shorter, conversational prompts, making it a great chatbot solution.

With the help of the Pinecone API, both AI tools can efficiently generate high-quality content for creative and professional needs.

Social Media Management and Multi-Step Projects

In the realm of social media management, AI tools like Auto-GPT can streamline tasks, such as posting updates and engaging with followers .

Its ability to handle multi-step projects makes it an ideal choice for group projects needing assistance with task completion and workflow management.

ChatGPT, on the other hand, works best for fast and natural responses, engaging users and enhancing their experience.

Personal Assistants and Companion Robots

Both Auto-GPT and ChatGPT have the potential to bring personal assistant apps and companion robots to life .

Their language models can be used for password management, credit card information handling, and even Pinecone API key management. While

ChatGPT is driven by human prompts, Auto-GPT’s independence allows it to make decisions and simplify everyday tasks. As AI technology continues to improve, these tools can revolutionize the way we interact with the digital world.

Recommended: AutoGPT vs BabyAGI: Comparing OpenAI-Based Autonomous Agents

Pros and Cons of Auto-GPT and ChatGPT

Auto-GPT offers increased autonomy compared to ChatGPT as it doesn’t always require human input. This means it can be more useful for certain tasks where constant human guidance isn’t needed or feasible. However, this autonomy can also lead to an increased likelihood of inaccuracies and mistakes, since there is less human oversight to correct errors (source). Also, it quickly evolves as ChatGPT builds out the plugins functionality.

When it comes to complex projects, Auto-GPT has a slight edge as it is designed to handle more complex and multi-stage projects, unlike ChatGPT which is more suited for short projects and mid-length writing assignments (source).

In terms of ease of use, both Auto-GPT and ChatGPT can be user-friendly, but the level of required technical expertise may vary depending on the specific use case or implementation. Users may find one to be more accessible than the other depending on their technical background and familiarity with AI models. Auto-GPT is also way harder to install.

As for the technological limitations, both Auto-GPT and ChatGPT share similar constraints as they are both built on GPT-based models. These limitations include potential biases, inaccuracies, hallucinations, and issues that stem from the training data used in their development. The complexity of the autonomous Auto-GPT model also leads to specific technical limitations such as getting stuck in infinite loops.

Customer satisfaction may vary depending on the implementation and end-user needs. Users may find value in both models, but ultimately, the satisfaction level will depend on the specific requirements and desired outcomes of their AI-powered projects.

TLDR;

Auto-GPT and ChatGPT each have their pros and cons related to autonomy, scalability, ease of use, technological limitations, and customer satisfaction.

Auto-GPT builds on GPT and designs prompts, then tries to access information from the internet.

The additional complexity leads to possible issues such as infinite action-feedback loops or high costs but it cannot really be held against them—after all, the additional complexity brings a massive advantage: being able to act autonomously and for a long period of time unlike ChatGPT which needs a human prompt.

Recommended: 30 Creative AutoGPT Use Cases to Make Money Online

OpenAI’s Error Reference Number 1020 is a common issue faced by some users when trying to access services like ChatGPT. This error message indicates that access has been denied, which can be quite frustrating for those looking to utilize the capabilities of OpenAI products.

There are several possible reasons behind this error, including site restrictions, security measures, or issues with cookies and extensions.

To address Error Reference Number 1020 and regain access to OpenAI services, I consider possible causes such as site data and permissions, and disabling problematic extensions or clearing cookies.

Quick fix: Do you use a VPN service? Turn it off, and try without it because the VPN may be the reason for you not being able to access the OpenAI site.

Understanding OpenAI Error Reference Number 1020

Error Reference Number 1020 can affect users while interacting with OpenAI services like ChatGPT, causing access issues and hindering smooth usage. This section will provide insights into Error Code 1020 and ChatGPT Error Code 1020, helping users identify and troubleshoot them effectively. Let’s dive into these two sub-sections.

Error Code 1020

Error Code 1020 occurs when a user’s request cannot reach OpenAI’s servers or establish a secure connection.

This can be due to various reasons, such as network problems, proxy configurations, SSL certificate issues, or firewall rules . It can be caused by Cloudfare as reported in the forum:

Quick Fix Cloudfare Reason: The 1020 error messages are produced by Cloudflare, possibly due to reasons such as using TOR, accessing OpenAI from a blocked domain or country, or using a proxy server or VPN. OpenAI’s current exponential growth may have led to more restrictive Cloudflare settings, potentially causing false flags. Resolving the issue may require further research or even contacting https://help.openai.com/.

To resolve this error, users should check their network settings and ensure they align with OpenAI’s requirements.

ChatGPT Error Code 1020

ChatGPT Error Code 1020, specifically, is an “Access Denied” error that prevents the user from using the ChatGPT service. This error can be caused by using proxies like TOR, misconfigured browser settings, or installed Chrome extensions that conflict with the service .

To combat this issue, users can clear their browser site data and permissions, ensure they’re not using proxies or TOR, and remove conflicting extensions on Chrome.

Causes of Error 1020

In this section, we will discuss the common causes of Error 1020 with OpenAI ChatGPT.

IP Address Restrictions

One of the primary reasons for encountering Error 1020 is being restricted by the IP address. OpenAI might have blocked certain IP addresses due to security concerns or misuse of their services. Furthermore, Cloudflare might be flagging and blocking access from suspicious IPs, causing the error message .

VPN and Proxy Usage

If you’re using a VPN or a proxy server, it might cause Error 1020. Many websites, including OpenAI, sometimes restrict access for VPN users to ensure security and combat potential service abuse . Disabling the VPN or proxy might resolve the issue.

DNS Server Configuration

Another potential cause of Error 1020 could be an improperly configured DNS server. Incorrect DNS settings might lead to connectivity issues and trigger the error. Ensuring that your DNS configurations are accurate and up-to-date is essential for seamless access to ChatGPT .

Recommended: Best 35 Helpful ChatGPT Prompts for Coders (2023)

Cookie and Browsing Data Issues

Error 1020 might also be caused by issues with cookies and browsing data stored by your web browser . Clearing ChatGPT-related cookies and browsing data can often resolve the error. To do this, access your browser settings, search for “OpenAI,” and delete any stored cookies or data associated with it.

TLDR; Error 1020 with OpenAI ChatGPT can be due to IP address restrictions, VPN and proxy usage, DNS server configurations, or cookie and browsing data issues. Identifying and resolving the specific problem can help you regain access to ChatGPT services .

Browser Compatibility

When encountering OpenAI error reference number 1020, checking browser compatibility is a crucial step. The following subsections briefly discuss compatibility adjustments for Google Chrome, Mozilla Firefox, Microsoft Edge, and Apple Safari.

Google Chrome

For optimized access to OpenAI services, make sure your Chrome browser is up-to-date and clear any stored ChatGPT cookies. Disable or remove unwanted extensions which may cause compatibility issues with ChatGPT.

Mozilla Firefox

Firefox users should update their browser to the latest version to reduce compatibility issues. Remove any suspicious or unnecessary add-ons, and clear cache and cookies related to OpenAI.

Microsoft Edge

Ensure that the latest version of Microsoft Edge is installed, and clear browsing data, such as cookies, for OpenAI. Remove potentially problematic extensions to avoid compatibility conflicts.

Apple Safari

For Safari users, it’s essential to keep the browser up-to-date. Clear any stored cookies related to OpenAI services, and disable or remove any extensions that may create compatibility problems.

Troubleshooting Steps

In this section, we will explore various troubleshooting methods to resolve the OpenAI Error Reference Number 1020. Follow the steps mentioned below for each sub-section.

Managing Browsing Data

Clear your browsing data, including cookies and cache, as they might be causing the issue. In most browsers, press Ctrl+Shift+Del to access the clearing options. Be sure to select the appropriate time range and click on the “Clear data” button. After completing this process, refresh the page and check if the error has been resolved.

Adjusting Browser Extensions and Permissions

Browser extensions and add-ons might interfere with your access to the ChatGPT service. To eliminate this possibility, disable your browser extensions one by one and try reloading the page. If the error persists, check your browser’s site data and permissions for OpenAI, and update them as necessary by navigating to the settings menu. Learn more from this resource on how to fix ChatGPT Error Code 1020.

Configuring DNS Settings

Sometimes, DNS settings can cause connectivity issues. To resolve this, change your DNS server settings to a reliable alternative, such as Google’s public DNS addresses (8.8.8.8 and 8.8.4.4), by accessing the “Properties” of your internet connection in the Control Panel. Input the new DNS addresses and save the changes. Reboot your device and check if the error is still present.

Resetting Network Connections

Lastly, consider resetting your router and Wi-Fi network. Unplug your router from power for at least 30 seconds before plugging it back in. Afterward, reconnect your devices to the Wi-Fi network and try accessing the site again. If the issue persists, you may need to look into other network-related settings or reach out to OpenAI support for further assistance.

Access Denied Scenarios

Daily Limit Usage

If you encounter the Error 1020 with OpenAI’s ChatGPT, it might be due to the daily limit usage. Each user has a certain quota to stay within, preventing system overloads and maintaining smooth functionality. When the daily limit is exceeded, access to the service is temporarily halted until the next day.

To avoid this issue, monitor your usage and stay within the allocated limits. Upgrading to a higher tier plan could also provide more resources and increase your daily limit, allowing you to avoid the Error 1020 caused by usage restrictions.

Recommended: 9 Easy Ways to Fix “Rate Limit Error” in OpenAI Codex

Restricted Permissions

Another factor contributing to Error 1020 could be restricted permissions. These occur when a user doesn’t have the necessary access rights or their location is blocked for security purposes. Various factors, such as using a VPN or being flagged by Cloudflare, can lead to restricted access. To resolve this problem, you can try:

1. Disabling any active VPN or proxy services.
2. Removing suspicious Chrome extensions that might cause conflicts with ChatGPT.
3. Clearing ChatGPT cookies stored in the browser.

Remember, keeping your system and browser settings up-to-date and avoiding actions that may trigger security measures can help prevent Error 1020 and maintain seamless access to OpenAI’s ChatGPT.

Connection Considerations

Internet Connection Stability

A stable and fast internet connection is crucial for smooth interaction with ChatGPT. If you are experiencing error code 1020, it might be due to an unstable connection . Make sure to check and test your connection, and if needed, switch to a wired connection to improve stability.

Checking Wi-Fi Network

If you are connected to a Wi-Fi network , poor signal or a congested network could be causing issues with ChatGPT. Verify if you have a strong Wi-Fi signal and if possible, move closer to the router, or consider reducing the number of devices connected to your network to improve performance. Additionally, check your proxy configuration to ensure compatibility with OpenAI services.

Remember, a well-functioning internet connection is essential for seamless access to ChatGPT. Always be mindful of your connectivity when using the service.

Recommended: ChatGPT at the Heart – Building a Movie Recommendation Python Web App in 2023

OpenAI Glossary Cheat Sheet (100% Free PDF Download)

Finally, check out our free cheat sheet on OpenAI terminology, many Finxters have told me they love it!

Recommended: OpenAI Terminology Cheat Sheet (Free Download PDF)

Pandas, an open-source data analysis and manipulation library for Python, is a tool of choice for many professionals in data science. Its advanced features and capabilities enable users to manipulate, analyze, and visualize data efficiently.

Recommended: 10 Minutes to Pandas (in 5 Minutes)

In the above video “Making $65 per Hour on Upwork with Pandas” , the highlighted strategy is centered on mastering this versatile tool and effectively communicating its benefits to potential clients. A key fact to remember is that Pandas is highly valued in various industries, including finance, retail, healthcare, and technology, where data is abundant and insights are critical.

For a freelancer, proficiency in Pandas can command an hourly rate of $65 or more, even if it’s just a side business to add an additional and independent income stream.

But it’s not just about the tool; it’s about showcasing your ability to drive business value.

Recommended: Python Freelancer Course – How to Create a Thriving Coding Business Online

Highlighting case studies where you’ve used Pandas to extract meaningful insights or solve complex business problems can significantly boost your profile’s appeal.

As for project bidding, understanding the client‘s requirements and tailoring your proposal to highlight how your Pandas expertise can meet those needs is vital. Negotiation, too, plays a critical role in securing a lucrative rate.

Mastering Pandas and marketing this skill effectively can unlock high-paying opportunities on platforms like Upwork, as demonstrated by the impressive $65 per hour rate (for a freelancer with very little practical experience). This reinforces the importance of specialized skills in enhancing your freelancing career.

Recommended: What’s the Average Python Developer Salary in the US? Six Figures!