{"id":906,"date":"2021-06-27T14:43:50","date_gmt":"2021-06-27T18:43:50","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=906"},"modified":"2022-06-16T15:23:54","modified_gmt":"2022-06-16T19:23:54","slug":"python-ascii-builtin-function","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-ascii-builtin-function-504314\/","title":{"rendered":"Python ascii(): Built-in Function to Enforce ASCII-Printable Object Representation"},"content":{"rendered":"

The Python ascii() function returns a printable ASCII-escaped string representation of an object. This function is part of the Python built-ins and works in close concert with the repr() function, an Object’s __repr__() and __str__() methods, and offers developers greater control over how Object models are represented in string form.<\/p>\n

The ascii()<\/code> function in Python is not used to obtain the ASCII value for a character. Rather, it is used to represent an Object as an ASCII-formatted string to the greatest extent possible. It escapes non-ASCII characters to their hexadecimal Unicode values. These values are then inserted into the original string alongside valid ASCII characters<\/a>.<\/p>\n

TL;DR<\/strong> – The ascii()<\/code> function ensures an object can be represented as a printable ASCII-formatted string by substituting for any non-ASCII characters representing that object.<\/p>\n

# Call the ascii() function on a string with\r\n# a mix of ASCII and non-ASCII characters\r\n>>> ascii(\"\"\"\u00f0v\u00ear\u00a2o\u00d0e\u00d0\"\"\")\r\n\r\n# Valide ASCII characters returned\r\n# along with \/x escaped hex values\r\n# for non-ASCII valid characters\r\n'\\xf0v\\xear\\xa2o\\xd0e\\xd0'<\/pre>\n
Basic Use Cases<\/h2>\n
The ascii()<\/code> function ensures that an object’s string representation contains only printable ASCII characters. For any non-ASCII characters, the ascii()<\/code> function will substitute an escaped sequence of hexadecimal characters. This function can be used with any object including strings, collections, and custom object models. Let’s take a look at some of the ascii()<\/code> function’s basic uses.<\/p>\n
# Create a list with some random values\r\n# containing all ASCII characters\r\na = ['string', 1, 5.773, 'overcoded']\r\nprint(a)\r\n\r\n['string', 1, 5.773, 'overcoded']\r\n\r\n# Create a list with some values\r\n# containing some non-ASCII characters\r\no = ['stri\u00f1g', \"\u00d8\", '\u00d8verc\u00d8ded']\r\nprint(ascii(o))\r\n\r\n['stri\\xf1g', '\\xd8', '\\xd8verc\\xd8ded']\r\n\r\n# Create a custom object with an\r\n# ASCII format name\r\nprint(ascii(type('CustomObject', (object,), {'name': 'custom object'})()))\r\n\r\n<__main__.CustomObject object at 0x000001E5691AF6D0>\r\n\r\n# Create a custom object with an\r\n# nont-ASCII format name\r\nprint(ascii(type('C\u00fcstom\u00d8bject', (object,), {'name': 'custom object'})()))\r\n\r\n<__main__.C\\xfcstom\\xd8bject object at 0x000001E5691AF6D0>\r\n<\/pre>\n
Note that for any non-ASCII character the ascii()<\/code> function is substituting a sequence of characters starting with \\x<\/code>. This is the standard Python escape character for a leading hexadecimal-escaped value. The formal format is \\xhh<\/code> where the two h’s are hexadecimal-valid characters (a-f; 0-9)<\/code> or any combination.<\/p>\n
Some of this may look like nonsense still. Most notably, it’s not exactly<\/em> clear how the ascii()<\/code> function is using the non-ASCII characters used in defining our custom object’s name. That’s how why \u00d8verc\u00d8ded<\/code> is printed out as \\xd8verc\\xd8ded<\/code>. The two \u00d8<\/code> characters are\u00a0escaped<\/em> to their Unicode-mapped values using the hexadecimal value \\x + d8<\/code>.<\/p>\n
This is still a little confusing in my opinion. For starters, it’s not immediately clear where ascii()<\/code> is getting the value that it is choosing to evaluate for ASCII compliance. To tease apart that question we’ll have to take a quick detour to consider Python’s approach to data modeling<\/a>.<\/p>\n
Crash Course: Python’s Data Model<\/h2>\n
Python’s\u00a0 ascii()<\/code> function is related closely to Python’s data model and how it controls textual representations of data\/objects. This article focuses on the ascii()<\/code> function but we will need to touch on some basics of how Python’s data model works to fully understand how to use the ascii()<\/code> function. I promise it’ll be as brief as possible.<\/p>\n
Python’s data model uses a __repr__()<\/code> method that is tied into the built-in repr()<\/code> function. Together, these work in concert to control how objects are visually represented during processes like printing to console, logging, or other string-based contexts. The official __repr__() documentation<\/a> describes the method as such:<\/p>\n
Called by the repr() built-in function to compute the \u201cofficial\u201d string representation of an object. The return value must be a string object. If a class defines __repr__() but not __str__(), then __repr__() is also used when an \u201cinformal\u201d string representation of instances of that class is required.<\/em><\/p>\n
Let’s pick that apart, just a bit. This description hints that the __repr__()<\/code> and __str__()<\/code> methods of Python’s data model are very related. Here’s what you need to know:<\/p>\n
    \n
  1. __str__()<\/code> uses the value of __repr__()<\/code> unless explicitly defined.<\/li>\n
  2. __repr__()<\/code> is used for debugging and contains pertinent info including object type and memory address.<\/li>\n
  3. __str__()<\/code> is a casual<\/em> representation of an object.<\/li>\n
  4. __repr__()<\/code> is a formal representation of an object.<\/li>\n
  5. The ascii()<\/code> function uses the repr() function, which uses the __repr__() of an object, as its data source.<\/li>\n<\/ol>\n
    Class-Based Usage<\/h2>\n
    We can now consider use cases of Python’s ascii()<\/code> function given our quick crash course on Python’s data modeling. I’m going to create a very basic class to demonstrate how the ascii()<\/code> function uses an object’s __repr__()<\/code> method to provide a valid ASCII format string representation of that object.<\/p>\n
    class Dude:\r\n    \"\"\"A custom class for Dude's\"\"\"\r\n    def __init__(self, name: str = 'John Doe'):\r\n        self.name = name\r\n\r\n\r\n# Create a new Dude named Bob\r\nbob = Dude(name='Bob')\r\n\r\n# View the type and default repr of bob\r\nprint(type(bob))\r\nprint(bob)\r\n\r\n<__main__.Dude object at 0x00000158D03A6940>\r\n<class '__main__.Dude'>\r\n\r\n# View the default __str__ value of bob\r\nprint(bob.__str__())\r\nprint(type(bob.__str__()))\r\n\r\n<__main__.Dude object at 0x0000020114426940>\r\n<class 'str'>\r\n\r\n# View the default __repr__ value for bob\r\nprint(bob.__repr__())\r\nprint(type(bob.__repr__()))\r\n\r\n<__main__.Dude object at 0x0000020114426940>\r\n<class 'str'>\r\n\r\n# View the type and value of bob as ascii\r\nprint(type(ascii(bob)))\r\nprint(ascii(bob))\r\n\r\n<__main__.Dude\u00a0object\u00a0at\u00a00x0000020114426940>\r\n<class 'str'><\/pre>\n
    We’re getting str values all-around it would seem. This behavior isn’t relevant to the ascii()<\/code> function yet because we’re still using only valid ASCII characters in our representations of Bob. Let’s make another Dude that’s a little more worldly:<\/p>\n
    # Create another dude using non-ASCII characters\r\nrob = Dude(name=\"R\u00f2b\")\r\n\r\n# View the default repr of R\u00f2b\r\nprint(type(rob))\r\nprint(rob)\r\n\r\n<class '__main__.Dude'>\r\n<__main__.Dude object at 0x0000013423F2F2E0><\/pre>\n
    We’ve added a non-ASCII character into our new Dude object but it hasn’t changed anything. Now, let’s see what tweaking our object’s __str__() method will change:<\/p>\n
    class Dude:\r\n    \"\"\"A custom class for Dude's\"\"\"\r\n    def __init__(self, name: str = 'John Doe'):\r\n        self.name = name\r\n\r\n    def __str(self):\r\n        \"\"\"\r\n        A custom method to explicitly define\r\n        the string representation of a Dude\r\n        \"\"\"\r\n        return self.name\r\n\r\n# Create another dude using non-ASCII characters\r\nrob = Dude(name=\"R\u00f2b\")\r\n\r\n# View the default repr of R\u00f2b\r\nprint(type(rob))\r\nprint(rob)\r\nprint(ascii(rob))\r\n\r\n<class '__main__.Dude'>\r\nR\u00f2b\r\n<__main__.Dude object at 0x000001EB52914AC0><\/pre>\n
    Aha! We can now see that when an object explicitly defines a __str__()<\/code> method that value will override the object’s default __repr__()<\/code> value. However, when using the ascii()<\/code> function to get an ASCII-printable version of our Rob object things are still bland. That’s because the ascii() methods uses the value of __repr__() even if __str__() is explicitly defined.\u00a0<\/strong>That’s important to keep in mind for later.<\/p>\n
    We’ve altered our Dude object model in such a way that printing to console will afford us a friendlier representation. We can still fall back to the object’s __repr__()<\/code> method for debugging should we need information like memory address or object type. Being this responsable doesn’t really<\/em> let us stretch the legs of Python’s built-in ascii()<\/code> function. Let’s alter the __repr__()<\/code> method and see what happens!<\/p>\n
    class Dude:\r\n    \"\"\"A custom class for Dudes\"\"\"\r\n    def __init__(self, name: str = 'John Doe'):\r\n        self.name = name\r\n\r\n    def __str__(self):\r\n        \"\"\"\r\n        A custom method to explicitly define\r\n        the informal string representation of a Dude\r\n        \"\"\"\r\n        return self.name\r\n    \r\n    def __repr__(self):\r\n        \"\"\"\r\n        A custom method to explicitly define\r\n        the formal string representation of a Dude\r\n        \"\"\"\r\n        return self.__str__()\r\n\r\n# Create another dude using non-ASCII characters\r\nrob = Dude(name=\"R\u00f2b\")\r\n\r\n# View the default repr of R\u00f2b\r\nprint(type(rob))\r\nprint(rob)\r\nprint(ascii(rob))\r\n\r\n<class '__main__.Dude'>\r\nR\u00f2b\r\nR\\xf2b<\/pre>\n
    The ascii()<\/code> function now uses the __str__()<\/code> value of Rob because we’ve told our Dude object model’s __repr__()<\/code> method to return the __str__<\/code> value. This now feeds our object’s non-ASCII name into the ascii()<\/code> function via the object’s __repr__<\/code> value and results in an ASCII-escaped, the printable value of R\\xf2b<\/code>. The \\xf2b<\/code> value is an escaped hexadecimal value<\/strong> assigned to the Unicode character \u00f2<\/code>. Now we’re juggling several layers of Objects, instances, built-ins, and defaults. Let’s take a moment to visualize this to make sure we’re keeping things straight.<\/p>\n
    Visualizing Python’s ascii() Function<\/h2>\n
    \"ascii
    Python’s ascii() function uses the __repr__ value of an object for the source data<\/figcaption><\/figure>\n
    Python’s ascii()<\/code> function can be incredibly useful when one is aware of the flow of data of the object model. Without knowing where the ascii()<\/code> function is getting its data the function can be quite frustrating. Using the above illustration and the following attribute’s list, I hope to help make the source of the ascii()<\/code> function’s data a bit clearer<\/p>\n
      \n
    1. __str__<\/code> uses __repr__<\/code> by default<\/li>\n
    2. __str__<\/code> can be overridden, without affecting __repr__<\/code><\/li>\n
    3. ascii()<\/code> uses the value of __repr__<\/code>\u00a0regardless<\/em> of what’s going on with __str__<\/code><\/li>\n
    4. ascii()<\/code> can use the\u00a0value\u00a0<\/em>of __str__<\/code> if __repr__<\/code> explicitly returns that value.\n
        \n
      1. ascii()<\/code> is still using the value of __repr__<\/code>, it’s just that __repr__<\/code> is then using the value of __str__<\/code><\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
        Now that we have a solid grasp on how data is flowing between these functions, attributes, and our object let’s really\u00a0<\/em>have some fun with the ascii()<\/code> function. Those wary of violating PEP-approved naming conventions<\/a> may want to stop reading here!<\/p>\n
        Non-ASCII Character Representations<\/h2>\n
        We’ve seen that overriding the __repr__ method can affect the return value of Python’s ascii()<\/code> function when used on our Dude objects. We’ve also seen that returning the value from our Dude object’s __str__() method via its __repr__() method can result in the ascii()<\/code> function providing its designed escaping functionality<\/strong>. Let’s now consider how the ascii() function might behave if we used non-ASCII characters in\u00a0defining our class<\/em>.<\/p>\n
        class D\u00fcde:\r\n    \"\"\"A c\u00fcstom class for D\u00fcdes\"\"\"\r\n    def __init__(self, name: str = 'John Doe'):\r\n        self.name = name\r\n\r\n\r\n# Create a new D\u00fcde named B\u00fcd\r\nb\u00fcd = D\u00fcde(name='B\u00fcd')\r\n\r\n# Print the str and repr\r\n<__main__.D\u00fcde object at 0x000002A911931FD0>\r\n<__main__.D\u00fcde object at 0x000002A911931FD0>\r\n<__main__.D\u00fcde object at 0x000002A911931FD0>\r\n<__main__.D\\xfcde object at 0x000002A911931FD0><\/pre>\n
        In this class, I’ve substituted our boring domesticated u<\/code> for a more exciting umlaut-ornamented \u00fc<\/code>. This non-ASCII character will display fine in most consoles but certainly isn’t within the range of printable ASCII characters.\u00a0<\/em>Note how the \u00fc<\/code> displays in its encoded form in our Object’s class name (sorry PEP) via the __repr__<\/code> value. Now note that the __repr__<\/code> value, using the default Object model value taken from the class name D\u00fcde, has the \u00fc<\/code> escaped via the ascii()<\/code> function: D\\xfcde<\/code>.<\/p>\n
        Review<\/h2>\n
        Did you ever think there could be so much to know about such a simple built-in function? Python’s ascii()<\/code> function is a great gatekeeper function for cases where one wants to ensure avoidance of errors when logging to files that are to be printed or on systems where fuller ranges of encoding may not be available.<\/p>\n
        The ascii()<\/code> function, along with the other built-ins, are one of the many reasons that Python continues to be one of the most widely-used programming languages<\/a> in the world. In my experience, it’s not a function designed for everyday use among us casual developers. I find it to be a useful tool in better understanding the dynamics of Python’s data modeling nonetheless!<\/p>\n","protected":false},"excerpt":{"rendered":"
        The Python ascii() function returns a printable ASCII-escaped string representation of an object. This function is part of the Python built-ins and works in close concert with the repr() function, an Object’s __repr__() and __str__() methods, and offers developers greater control over how Object models are represented in string form. The ascii() function in Python […]<\/p>\n","protected":false},"author":2,"featured_media":908,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[655,10],"tags":[123,165,69,250,303,230,334,143,363],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/906"}],"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=906"}],"version-history":[{"count":4,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/906\/revisions"}],"predecessor-version":[{"id":912,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/906\/revisions\/912"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/908"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=906"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=906"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=906"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}