The Python str class has many helpful options that may enable you out while you’re processing textual content or strings in your code. Nonetheless, in some conditions, all these nice options might not be sufficient for you. It’s possible you’ll must create customized string-like lessons. To do that in Python, you possibly can inherit from the built-in str class instantly or subclass UserString, which lives within the collections module.
On this tutorial, you’ll learn to:
- Create customized string-like lessons by inheriting from the built-in
strclass - Construct customized string-like lessons by subclassing
UserStringfrom thecollectionsmodule - Resolve when to make use of
strorUserStringto create customized string-like lessons
In the meantime, you’ll write a number of examples that’ll enable you resolve whether or not to make use of str or UserString while you’re creating your customized string lessons. Your alternative will largely rely in your particular use case.
To comply with together with this tutorial, it’ll assist for those who’re aware of Python’s built-in str class and its normal options. You’ll additionally must know the fundamentals of object-oriented programming and inheritance in Python.
Creating String-Like Lessons in Python
The built-in str class permits you to create strings in Python. Strings are sequences of characters that you just’ll use in lots of conditions, particularly when working with textual information. Occasionally, the usual functionalities of Python’s str could also be inadequate to satisfy your wants. So, you could need to create customized string-like lessons that resolve your particular downside.
You’ll usually discover no less than two causes for creating customized string-like lessons:
- Extending the common string by including new performance
- Modifying the usual string’s performance
It’s also possible to face conditions by which you should each prolong and modify the usual performance of strings on the identical time.
In Python, you’ll generally use one of many following methods to create your string-like lessons. You’ll be able to inherit from the Python built-in str class instantly or subclass UserString from collections.
One related characteristic of Python strings is immutability, which implies which you could’t modify them in place. So, when choosing the suitable method to create your individual customized string-like lessons, you should contemplate whether or not your required options will have an effect on immutability or not.
For instance, if you should modify the present habits of present string strategies, then you definitely’ll in all probability be okay subclassing str. In distinction, if you should change how strings are created, then inheriting from str will demand superior data. You’ll need to override the .__new__() technique. On this latter case, inheriting from UserString could make your life simpler since you received’t have to the touch .__new__().
Within the upcoming sections, you’ll be taught the professionals and cons of every method so as to resolve which is the perfect technique to make use of in your particular downside.
Inheriting From Python’s Constructed-in str Class
For a very long time, it was not possible to inherit instantly from Python varieties applied in C. Python 2.2 fastened this challenge. Now you possibly can subclass built-in types, together with str. This new characteristic is kind of handy when you should create customized string-like lessons.
By inheriting from str instantly, you possibly can prolong and modify the usual habits of this built-in class. It’s also possible to tweak the instantiation process of your customized string-like lessons to carry out transformations earlier than new cases are prepared.
Extending the String’s Normal Conduct
An instance of requiring a customized string-like class is when you should prolong the usual Python strings with new habits. For instance, say that you just want a string-like class that implements a brand new technique to rely the variety of phrases within the underlying string.
On this instance, your customized string will use the whitespace character as its default phrase separator. Nonetheless, it must also help you present a particular separator character. To code a category that fulfills these wants, you are able to do one thing like this:
>>> class WordCountString(str):
... def phrases(self, separator=None):
... return len(self.cut up(separator))
...
This class inherits from str instantly. Which means that it gives the identical interface as its mum or dad class.
On high of this inherited interface, you add a brand new technique referred to as .phrases(). This technique takes a separator character as an argument that’s handed on to .cut up(). Its default worth is None which is able to split on runs of consecutive whitespace. You then name .cut up() with the goal separator to separate the underlying string into phrases. Lastly, you utilize the len() perform to find out the phrase rely.
Right here’s how you should utilize this class in your code:
>>> sample_text = WordCountString(
... """Lorem ipsum dolor sit amet consectetur adipisicing elit. Maxime
... mollitia, molestiae quas vel sint commodi repudiandae consequuntur
... voluptatum laborum numquam blanditiis harum quisquam eius sed odit
... fugiat iusto fuga praesentium optio, eaque rerum! Provident similique
... accusantium nemo autem. Veritatis obcaecati tenetur iure eius earum
... ut molestias architecto voluptate aliquam nihil, eveniet aliquid
... culpa officia aut! Impedit sit sunt quaerat, odit, tenetur error,
... harum nesciunt ipsum debitis quas aliquid."""
... )
>>> sample_text.phrases()
68
Cool! Your .phrases() strategies works effective. It splits the enter textual content into phrases after which returns the phrase rely. You’ll be able to modify how this technique delimits and processes phrases, however the present implementation works okay for this demonstrative instance.
On this instance, you haven’t modified the usual habits of Python’s str. You’ve simply added new habits to your customized class. Nonetheless, it’s additionally attainable to alter the default habits of str by overriding any of its default strategies, as you’ll discover subsequent.
Modifying the String’s Normal Conduct
To learn to modify the usual habits of str in a customized string-like class, say that you just want a string class that at all times prints its letters in uppercase. You are able to do this by overriding the .__str__() special method, which takes care of how string objects are printed.
Right here’s an UpperPrintString class that behaves as you want:
>>> class UpperPrintString(str):
... def __str__(self):
... return self.higher()
...
Once more, this class inherits from str. The .__str__() technique returns a replica to the underlying string, self, with all of its letters in uppercase. To rework the letters, you utilize the .upper() technique.
To check out your customized string-like class, go forward and run the next code:
>>> sample_string = UpperPrintString("Whats up, Pythonista!")
>>> print(sample_string)
HELLO, PYTHONISTA!
>>> sample_string
'Whats up, Pythonista!'
If you print an occasion of UpperPrintString, you get the string in uppercase letters in your display screen. Notice that the unique string wasn’t modified or affected. You solely modified the usual printing characteristic of str.
Tweaking the Instantiation Strategy of str
On this part, you’ll do one thing completely different. You’ll create a string-like class that transforms the unique enter string earlier than making the ultimate string object. For instance, say that you just want a string-like class that shops all of its letters in lowercase. To do that, you’ll attempt to override the category initializer, .__init__(), and do one thing like this:
>>> class LowerString(str):
... def __init__(self, string):
... tremendous().__init__(string.decrease())
...
On this code snippet, you present an .__init__() technique that overrides the default str initializer. Inside this .__init__() implementation, you utilize super() to entry the mum or dad class’s .__init__() technique. You then name .decrease() on the enter string to transform all of its letters into lowercase letters earlier than initializing the present string.
Nonetheless, the above code doesn’t work, as you’ll verify within the following instance:
>>> sample_string = LowerString("Whats up, Pythonista!")
Traceback (most up-to-date name final):
...
TypeError: object.__init__() takes precisely one argument...
Since str objects are immutable, you possibly can’t change their worth in .__init__(). It is because the worth is about throughout object creation and never throughout object initialization. The one approach to rework the worth of a given string through the instantiation course of is to override the .__new__() technique.
Right here’s how to do that:
>>> class LowerString(str):
... def __new__(cls, string):
... occasion = tremendous().__new__(cls, string.decrease())
... return occasion
...
>>> sample_string = LowerString("Whats up, Pythonista!")
>>> sample_string
'hey, pythonista!'
On this instance, your LowerString class overrides the tremendous class’s .__new__() technique to customise how cases are created. On this case, you rework the enter string earlier than creating the brand new LowerString object. Now your class works as you want it to. It takes a string as enter and shops it as a lowercase string.
In the event you ever want to remodel the enter string at instantiation time, then you definitely’ll need to override .__new__(). This system would require superior data of Python’s data model and particular strategies.
Subclassing UserString From collections
The second instrument that permits you to create customized string-like lessons is the UserString class from the collections module. This class is a wrapper across the built-in str sort. It was designed to develop string-like lessons when it wasn’t attainable to inherit from the built-in str class instantly.
The opportunity of instantly subclassing str means you might need much less want for UserString. Nonetheless, this class remains to be obtainable within the standard library, each for comfort and backward compatibility. In follow, this class additionally has some hidden options that may be useful, as you’ll be taught quickly.
Essentially the most related characteristic of UserString is its .information attribute, which provides you entry to the wrapped string object. This attribute can facilitate the creation of customized strings, particularly in instances the place your required customization impacts the string mutability.
Within the following two sections, you’ll revisit the examples from earlier sections, however this time you’ll be subclassing UserString as a substitute of str. To kick issues off, you’ll begin by extending and modifying the usual habits of Python strings.
Extending and Modifying the String’s Normal Conduct
As an alternative of subclassing the built-in str class, you may implement WordCountString and UpperPrintString by inheriting from the UserString class. This new implementation will solely require you to alter the superclass. You received’t have to alter the unique inner implementation of your lessons.
Listed here are new variations of WordCountString and UpperPrintString:
>>> from collections import UserString
>>> class WordCountString(UserString):
... def phrases(self, separator=None):
... return len(self.cut up(separator))
...
>>> class UpperPrintString(UserString):
... def __str__(self):
... return self.higher()
...
The one distinction between these new implementations and the unique ones is that now you’re inheriting from UserString. Notice that inheriting from UserString requires you to import the category from the collections module.
In the event you check out these lessons with the identical examples as earlier than, then you definitely’ll verify that they work the identical as their equal lessons based mostly on str:
>>> sample_text = WordCountString(
... """Lorem ipsum dolor sit amet consectetur adipisicing elit. Maxime
... mollitia, molestiae quas vel sint commodi repudiandae consequuntur
... voluptatum laborum numquam blanditiis harum quisquam eius sed odit
... fugiat iusto fuga praesentium optio, eaque rerum! Provident similique
... accusantium nemo autem. Veritatis obcaecati tenetur iure eius earum
... ut molestias architecto voluptate aliquam nihil, eveniet aliquid
... culpa officia aut! Impedit sit sunt quaerat, odit, tenetur error,
... harum nesciunt ipsum debitis quas aliquid."""
... )
>>> sample_text.phrases()
68
>>> sample_string = UpperPrintString("Whats up, Pythonista!")
>>> print(sample_string)
HELLO, PYTHONISTA!
>>> sample_string
'Whats up, Pythonista!'
In these examples, your new implementations of WordCountString and UpperPrintString work the identical because the previous ones. So, why do you have to use UserString relatively than str? Up so far, there’s no obvious motive for doing this. Nonetheless, UserString turns out to be useful when you should modify how your strings are created.
Tweaking the Instantiation Strategy of UserString
You’ll be able to code the LowerString class by inheriting from UserString. By altering the mum or dad class, you’ll be capable of customise the initialization course of within the occasion initializer, .__init__(), with out overriding the occasion creator, .__new__().
Right here’s your new model of LowerString and the way it works in follow:
>>> from collections import UserString
>>> class LowerString(UserString):
... def __init__(self, string):
... tremendous().__init__(string.decrease())
...
>>> sample_string = LowerString("Whats up, Pythonista!")
>>> sample_string
'hey, pythonista!'
Within the instance above, you’ve made operating transformations on the enter string attainable by utilizing UserString as a substitute of str as your superclass. The transformations are attainable as a result of UserString is a wrapper class that shops the ultimate string in its .information attribute, which is the actual immutable object.
As a result of UserString is a wrapper across the str class, it gives a versatile and simple approach to create customized strings with mutable behaviors. Offering mutable behaviors by inheriting from str is difficult due to the category’s pure immutability situation.
Within the following part, you’ll use UserString to create a string-like class that simulates a mutable string information sort.
Simulating Mutations in Your String-Like Lessons
As a closing instance of why it is best to have UserString in your Python instrument package, say that you just want a mutable string-like class. In different phrases, you want a string-like class which you could modify in place.
Not like lists and dictionaries, strings don’t present the .__setitem__() particular technique, as a result of they’re immutable. Your customized string will want this technique to help you replace characters and slices by their indices utilizing an assignment assertion.
Your string-like class can even want to alter the usual habits of frequent string strategies. To maintain this instance brief, you’ll solely modify the .upper() and .lower() strategies. Lastly, you’ll present a .sort() technique to type your string in place.
Normal string strategies don’t mutate the underlying string. They return a brand new string object with the required transformation. In your customized string, you want the strategies to carry out their modifications in place.
To realize all these objectives, hearth up your favourite code editor, create a file named mutable_string.py, and write the next code:
1# mutable_string.py
2
3from collections import UserString
4
5class MutableString(UserString):
6 def __setitem__(self, index, worth):
7 data_as_list = listing(self.information)
8 data_as_list[index] = worth
9 self.information = "".be a part of(data_as_list)
10
11 def __delitem__(self, index):
12 data_as_list = listing(self.information)
13 del data_as_list[index]
14 self.information = "".be a part of(data_as_list)
15
16 def higher(self):
17 self.information = self.information.higher()
18
19 def decrease(self):
20 self.information = self.information.decrease()
21
22 def type(self, key=None, reverse=False):
23 self.information = "".be a part of(sorted(self.information, key=key, reverse=reverse))
Right here’s how this code works line by line:
-
Line 3 imports
UserStringfromcollections. -
Line 5 creates
MutableStringas a subclass ofUserString. -
Line 6 defines
.__setitem__(). Python calls this particular technique everytime you run an task operation on a sequence utilizing an index, like insequence[0] = worth. This implementation of.__setitem__()turns.informationinto an inventory, replaces the merchandise atindexwithworth, builds the ultimate string utilizing.be a part of(), and assigns its worth again to.information. The entire course of simulates an in-place transformation or mutation. -
Line 11 defines
.__delitem__(), the particular technique that permits you to use thedelassertion for eradicating characters by index out of your mutable string. It’s applied just like.__setitem__(). On line 13, you utilizedelto delete gadgets from the momentary listing. -
Line 16 overrides
UserString.higher()and callsstr.higher()on.information. Then it shops the end result again in.information. Once more, this final operation simulates an in-place mutation. -
Line 19 overrides
UserString.decrease()utilizing the identical method as in.higher(). -
Line 22 defines
.type(), which mixes the built-insorted()perform with thestr.join()technique to create a sorted model of the unique string. Notice that this technique has the identical signature aslisting.type()and the built-insorted()perform.
That’s it! Your mutable string is prepared! To attempt it out, get again to your Python shell and run the next code:
>>> from mutable_string import MutableString
>>> sample_string = MutableString("ABC def")
>>> sample_string
'ABC def'
>>> sample_string[4] = "x"
>>> sample_string[5] = "y"
>>> sample_string[6] = "z"
>>> sample_string
'ABC xyz'
>>> del sample_string[3]
>>> sample_string
'ABCxyz'
>>> sample_string.higher()
>>> sample_string
'ABCXYZ'
>>> sample_string.decrease()
>>> sample_string
'abcxyz'
>>> sample_string.type(reverse=True)
>>> sample_string
'zyxcba'
Nice! Your new mutable string-like class works as anticipated. It permits you to modify the underlying string in place, as you’d do with a mutable sequence. Notice that this instance covers a number of string strategies solely. You’ll be able to play with different strategies and proceed offering your class with new mutability options.
Conclusion
You’ve realized to create customized string-like lessons with new or modified behaviors. You’ve completed this by subclassing the built-in str class instantly and by inheriting from UserString, which is a handy class obtainable within the collections module.
Inheriting from str and subclassing UserString are each appropriate choices in the case of creating your individual string-like lessons in Python.
On this tutorial, you’ve realized tips on how to:
- Create string-like lessons by inheriting from the built-in
strclass - Construct string-like lessons by subclassing
UserStringfrom thecollectionsmodule - Resolve when to subclass
strorUserStringto create your customized string-like lessons
Now you’re prepared to jot down customized string-like lessons, which is able to help you leverage the complete energy of this worthwhile and commonplace information sort in Python.
