Python allows developers to use common arithmetic operators on strings. This high-level manipulation of textual data is one of the many reasons Python has surged in popularity. One example of this is the ability to use arithmetic operators to manipulate strings in Python.<\/p>\n
While convenient, there are some limitations to using arithmetic operators such as the plus, minus, plus-equal, and even multiplication operators on strings. For example, multiplying a string by a float will result in TypeError: can’t multiply sequence by non-int of type ‘float’<\/strong> exception.<\/p>\n In this article, we look at some use cases for applying arithmetic operators to Python strings. The discussion will include some common cases, advanced cases, and also common issues. By the end, we will cover the following:<\/p>\n Before we dive in, let us first consider the nature of Python strings. Namely, we will briefly discuss how Python strings are immutable, what that means, and the implications this has on performing string-based arithmetic operations.<\/p>\n Python strings are different from strings in many other languages. Without diving deeply into the details, it is important to note the following points about Python strings:<\/p>\n This is not an example of multiplying, adding, or subtracting strings. However, this point is so essential to understanding how strings are stored and accessed in Python that it must be discussed. Consider the following example:<\/p>\n This shows a variable Here we see additional text added to the Here we get our first glimpse at the immutable nature of Python strings. A Here we see the output reflect our changes without any exception being raised. This\u00a0kind of<\/em> illustrates how Python strings are “special” arrays in that their contained data cannot be manipulated. For a deeper dive, read this article<\/a>.\u00a0Simple recognition of the immutability of Python strings is enough for our discussion here.<\/p>\n Python allows the use of arithmetic operators to be used for string manipulation. This allows the addition, subtraction, and even multiplication of strings to take place via common operators such as Here we see the output to be identical whether we explicitly add a new string via assignment to a new variable Here we see the same Multiplication is an edge case whereby Python provides some extended features. Similar to subtraction and division, the multiplication operator doesn’t work in the direct manipulation of a string:<\/p>\n Python does allow the multiplication operator to be used to create multiple copies of a string.<\/strong> Consider the following example:<\/p>\n The same output would be produced using the Here we see a TypeError: can’t multiply sequence by non-int of type ‘float’<\/strong> exception being raised. Python could 100% have elected to interpret fractional values such as floats to return a percentage of total characters with creating copies of strings. In this case the It should be clear at this point that the addition and multiplication operators are useful for manipulating strings. We have seen the application of each in isolate but have not yet considered how one might use them in conjunction with one another. Consider the following code:<\/p>\n Rather than the expected 5 copies of This example highlights that operator precedence is valid even when dealing with strings. To add the space between 5 copies as intended, we would need to add parenthesis to specify a different order of operations as such:<\/p>\n Here we see the output returned as expected. By adding the When accepting user input in Python, any input provided by the user is converted into a string. For example, the following code prompts the user for a number that will be multiplied by the value Here we entered a value of This problem can be solved by converting user input that is expected to be numerical to numerical data before performing arithmetic operations. For example, the following code would result in the expected output:<\/p>\n Python creates new copies of any strings in which changing manipulations are made. As a broadly implying description — Python allocates new memory when strings are being mutated. As such, performing large numbers of string manipulations can become a burden on memory. To get around this issue, byte-arrays can be created as such:<\/p>\n We have an entire article dedicated to the topic of using Python bytearry objects<\/a>. Check it out to learn more about this built-in function of Python and how it relates to manipulating strings!<\/p>\n Python strings are just one of the many data types<\/a> offered to developers. The decisions made during Python’s development prioritize syntactic ease vs. conceptual precedence such that somewhat odd syntaxes such as using the Here we’ve seen how arithmetic operators can be used to manipulate Python strings. The most common error is when attempting to multiply via floating-point values or in creating copies rather than numerical values from user input. Keeping these in mind can help leverage the power of Python string manipulation syntax without generating a Python allows developers to use common arithmetic operators on strings. This high-level manipulation of textual data is one of the many reasons Python has surged in popularity. One example of this is the ability to use arithmetic operators to manipulate strings in Python. While convenient, there are some limitations to using arithmetic operators such as […]<\/p>\n","protected":false},"author":2,"featured_media":3036,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[10],"tags":[696,143,363],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3035"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=3035"}],"version-history":[{"count":1,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3035\/revisions"}],"predecessor-version":[{"id":3037,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3035\/revisions\/3037"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/3036"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=3035"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=3035"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=3035"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Highlights<\/h2>\n
\n
bytearray<\/code> objects can mutate strings.<\/li>\n<\/ol>\nQuick Intro: Understanding Python Strings<\/h2>\n
\n
[i]<\/code> where i<\/code> is a numerical index into the array (list.)<\/li>\nExample 0: Strings are Immutable<\/h2>\n
# example of number mutability\r\na = 5\r\nprint(a)\r\n\r\na += 1\r\nprint(a)\r\n\r\n# output\r\n5\r\n6<\/pre>\n
a<\/code> being assigned an integer value of 5<\/code> then, via the +=<\/code> operator (equivalent to a = a + 1<\/code>) the value is “incremented” by 1 resulting in a final value of 6. This is confirmed via the output from the 2 print<\/code> statements. In most other programming languages it would be insane to consider doing such an operation to a string. Let’s see how Python handles it:<\/p>\n# Create an example string\r\ns1 = \"alpharithms\"\r\nprint(s1)\r\n\r\n# concatenate some text\r\ns1 += \" is cool.\"\r\nprint(s1)\r\n\r\n# output\r\nalpharithms\r\nalpharithms is cool.<\/pre>\n
s1<\/code> variable. It\u00a0seems<\/em> like we are mutating a string but really we are not. Rather, we are simply reassigning a new value to the variables s1<\/code>. Let’s see what happens if we try to mutate a string directly in Python:<\/p>\n# create a string\r\ns1 = \"alpharithms\"\r\n\r\n# attempt to remove the s from the end\r\ns1[-1] = \"\"\r\n\r\nTypeError: 'str' object does not support item assignment\r\n<\/pre>\n
TypeError<\/code> exception is raised when trying to directly manipulate a value contained in a Python string array. This is in stark contrast to how one can manipulate arrays of numerical values — or even arrays of characters. Consider the following code:<\/p>\n# change single character\r\na1 = ['a', 'l', 'p', 'h', 'a', 'r', 'i', 't', 'h', 'm', 's']\r\na1[-1] = \"\\0\"\r\nprint(a1)\r\n\r\n# change integer item\r\na2 = [1, 2, 3, 4, 5]\r\na2[0] = 6\r\nprint(a2)\r\n\r\n# Output\r\n['a', 'l', 'p', 'h', 'a', 'r', 'i', 't', 'h', 'm', '\\x00']\r\n[6, 2, 3, 4, 5]<\/pre>\n
Example 1: Arithmetic Operator-Based Concatenation<\/h2>\n
+<\/code> and\u00a0 *<\/code>, as well as the assignment operator, but not -=<\/code> or *=<\/code>. We’ll take a look at those last cases in a moment. For now, let’s consider the others:<\/p>\n# creates a string\r\na1 = \"alpharithms\"\r\n\r\n# create a new string with extra text\r\na2 = a1 + \" is cool\"\r\nprint(a2)\r\n\r\n# use assignment operator to do the same\r\na1 += \" is cool\"\r\nprint(a1)\r\n\r\n# output\r\nalpharithms is cool\r\nalpharithms is cool<\/pre>\n
a2<\/code> or implicitly via the +=<\/code> operator (assigning a new value to the initial variables a1<\/code>.) Let’s see how some other arithmetic operators hold up in this approach:<\/p>\nsubtraction<\/h3>\n
# Subtraction and multiplication don't always work\r\nb1 = \"alpharithms\"\r\nb2 = b1 - \"s\"\r\nprint(b2)\r\n\r\n# Output\r\nTypeError: unsupported operand type(s) for -: 'str' and 'str'\r\n\r\nb1 = \"alpharithms\"\r\nb1 -= \"s\"\r\nprint(b1)\r\n\r\n# Output\r\nTypeError: unsupported operand type(s) for -=: 'str' and 'str'<\/pre>\n
TypeError<\/code> exception being raised. Clearly, the subtraction operator doesn’t work well with strings. Division and multiplication operations generate similar exceptions. However, multiplication-based string manipulation is possible in another way.<\/p>\nExample 2: Multiplication-Based String Manipulation<\/h2>\n
# create the sample string\r\ns1 = \"alpharithms\"\r\n\r\n# attempt a direct multiplication operation\r\ns2 = s1 * \" is cool\"\r\n\r\n# output\r\nTypeError: can't multiply sequence by non-int of type 'str'\r\n\r\n# attempt an assignment operation\r\ns1 *= \" is cool\"\r\n\r\n# output\r\nTypeError: can't multiply sequence by non-int of type 'str'\r\n<\/pre>\n
# Create an example string\r\ns1 = \"alpharithms\"\r\n\r\n# Use multiplication modifier with an integer value\r\n# to create a new string made of duplicates of the\r\n# initial string\r\ns2 = s1 * 5\r\n\r\nprint(s2)\r\n# output\r\nalpharithmsalpharithmsalpharithmsalpharithmsalpharithms\r\n\r\n<\/pre>\n
s1 *= 5<\/code> syntax. On a conceptual level this makes sense — equivalent to issuing the instruction “create 5 copies of s1<\/code>“. What would happen if we used a fractional value though? Let’s see what happens when we try to create 5 and a half copies of the string:<\/p>\n# Create an example string\r\ns1 = \"alpharithms\"\r\n\r\n# Create 5 and a half copies\r\ns2 = s1 * 5.5\r\n\r\nTypeError: can't multiply sequence by non-int of type 'float'\r\n\r\n<\/pre>\n
0.5<\/code> would be 11\/2 would be 5.5, rounded down to the nearest whole-number 5 characters: alpha<\/code>. This is not the case however and float multiplication cannot be used with strings.<\/p>\nExample 3: Mixing Operators<\/h2>\n
# create a sample string\r\ns1 = \"alpharithms\"\r\n\r\n# Create 5 copies separated by a space\r\ns2 = s1 + \" \" * 5\r\n\r\n# print result\r\nprint(s2)\r\n\r\n# result\r\nalpharithms<\/pre>\n
alpharithms<\/code> we instead see what looks to be a single copy! In fact, this is a single copy with 5 additional space characters appended to the end. If the \" \"<\/code> portion was replaced with \"-\"<\/code> the output would be alpharithms-----<\/code>.<\/p>\n# create a sample string \r\ns1 = \"alpharithms\"\r\n\r\n# Create 5 copies separated by a space \r\ns2 = s1 + \" \" * 5 \r\n\r\n# print result \r\nprint(s2) \r\n\r\n# result\r\nalpharithms alpharithms alpharithms alpharithms alpharithms \r\n<\/pre>\n
(<\/code> and )<\/code> characters around the s1 + \" \"<\/code> operation we add the space character before creating 5 copies of the string!<\/p>\nExample 4: User Input Converts to Strings<\/h2>\n
3<\/code>:<\/p>\n# prompt user\r\nvalue = input(\"Enter a number to multiply by 3: \")\r\n\r\n# < enter the number 3 here >\r\n\r\n# Multiply input by 3\r\nresult = value * 3\r\n\r\n# Display result to user\r\nprint(\"The result is:\", result)\r\n\r\n# View result\r\nThe Result is: 333<\/pre>\n
3<\/code> at the prompt and noticed a return value of 333<\/code> — clearly not an accurate calculation of 3 * 3 = 9<\/code>. The issue is that python interprets the user inputted value of 3<\/code> as a string, which results in an operation equivalent to \"3\" * 3<\/code> which, as shown above, creates 3 copies of the string input.<\/p>\n# prompt user\r\nvalue = input(\"Enter a number to multiply by 3: \")\r\n\r\n# Multiply input by 3\r\nresult = int(value) * 3\r\n\r\n# Display result to user\r\nprint(\"The result is:\", result)\r\n\r\n# Result\r\nEnter a number to multiply by 3: 3\r\nThe result is: 9\r\n<\/pre>\n
Example x: Using Bytearry Objects to Manipulate Strings<\/h2>\n
# create a byte array from a string, encoded as ascii\r\ns1 = bytearray(\"alpharithms\", encoding='ascii')\r\n\r\n# Change the last character to a newline\r\ns1[-1:] = bytearray(\"\\n\", encoding='ascii')\r\n\r\n# print decoded result\r\nprint(s1.decode('ascii'))\r\n\r\n# Output\r\nalpharithm\r\n<\/pre>\nFinal Thoughts<\/h2>\n
*<\/code> operator to create copies of strings can be used. However alien compared to other popular programming languages<\/a> this approach is without a doubt convenient.<\/p>\nTypeError<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"