Feeds

The horror Some years ago, my husband and I were looking for houses to rent. We both were in different cities and were having a telephone conversation. We had three or four phone calls to discuss this. After that, I opened my laptop and turned on my then browser, Google. Advertisements started popping up. Showing the adds of houses for rent at the very same location, the same budget I was looking for. A chill went down my bone. How did this particular website knows that we are looking for a house? The internet The internet was designed to give a home to the mind. It is the place for genuine independence and liberty. To create a new global social space exclusive of any authority, Government, sovereignty, and the “weary giants of flesh and steel,” the industrial area. Anonymity was there in the very ethos of the internet. It offered the opportunity to the users not to be discriminated against on religious, economic, and/or social background. It provided the platform to people to be themselves. And the Right to Privacy lies in the very core to the self-being of people. It was our chance to leave the world's nastiness, selfishness, and be an open and equal world. It was our chance to be better. The last decade has seen a surge in the usage of the internet. The growth can most prominently be observed in the area of social media. The smartphones, smartwatch, every other smart device aided to that. There is a substantive number of people for whom using the internet is similar to using Facebook. There is a parallel universe built around Facebook and What's app. And every day, each second it is growing. According to the survey made by brandwatch.com Facebook adds 500,000 new users every day, six new profiles every second. This Mammuthus growth of social media and our dependency on/over the internet has blurred the line of individual privacy. What considered to be private once is now in the public domain. Be it our first date, our breakups, dinner plans, childbirth list goes on. This does not end here. Our behavior is also under watch. Different types of Online activities We give reactions to different situations, people, promote, support, reject issues on social media. We have conversations about what food we like to eat, where do we want to go shopping, or when we are getting married. It is the information-sharing aspect of the internet. The other principal usage of the internet is gaining knowledge. We browse to ask random things. Like - What is the total area of earth? What is global warming? What is the best brand of lingerie suitable for thin women? Where in the first set of information (the activity on social media), we are sharing with our full consent and knowledge. For the second of information which we presume it to be private, between us, the browser and the website we are getting information from. But in reality, it is not. Tracking and it’s kind First party tracking There are certain rights we waive, the information we give to avail a service over the internet. Like the name, contact details for Facebook, Instagram. Signing up for Instagram means voluntarily agreeing to their “Terms, Data Policy, and Cookies Policy.” It is precisely like an agreement in the real world — the primary distinction between the two lies in our approach. In case of an actual world agreement, we make sure we read it. But do rarely care about understanding what we are signing for a while signing something in the digital world. Here what we only care about is the service and nothing else. Signing up for the service then means letting the service provider (in this case, Instagram) insert cookies in our browser, get data from us. Also, these services, Facebook knows who our friends are? And what we “like” and how much? Similarly, Amazon, Flipkart know - What we want to buy? When are we buying? This is called First Party Tracking, of which we are fully aware of and have agreed to. Third-party tracking There is another kind of Tracking. It happens behind our back, without our knowledge and consent, Third Party Tracking. These third-party trackers are there in almost all mobile apps, web pages, everywhere we go in online. Any regular mobile app collects and shares our private data, as sensitive as call records and location data with at least dozens third party companies. By third party company, we mean some other company than the service provider (in this case, the company making the mobile application). An average web page does the same thing to the user. The Physical world is also not spared by these trackers. Whenever we connect into the WiFi network into some coffee shop, hotel, restaurant, the service provider ( the coffee shop) can monitor our activity online. Also, they (coffee shop, hotel) use Bluetooth and WiFi beacons for passive monitoring of people in that locality. Who performs these third party tracking? The data brokers, advertisers, and tech companies are the ones who are tracking us behind our backs. A research paper published by EFF describes the situation aptly “ Corporations have built a hall of one-way mirrors: from the inside, you can see only apps, web pages, ads, and yourself reflected by social media. But in the shadows behind the glass, trackers quietly take notes on nearly everything you do. These trackers are not omniscient, but they are widespread and indiscriminate.” To know about the deep]down technical part of t)hird party tracking, go through the paper published by EFF. The data the trackers collect may be benign, but together with the public information, they tend to reveal a lot. Like if someone is political or not, ambitious or not, if you like to safe or prone to take risks. We, our lives, are being sold, and we are nothing but an accumulation of data for them. Therefore with us feeding information and the third party tracking together subjects us to constant surveillance. Our profiles are being created based on these data. This profile makes There is an invisible but unavoidable panopticon around us — a nearly unbreakable chain. Why would someone want to track me? I have nothing to hide. This is the general response we get when we initiate the discussion of and about privacy. To which Glen Greenworld has a great reply, ‘if you do not have to hide anything, please write down all your email ids, not just the work ones, the respectable ones but all, along with the passwords to me.’ Though people have nothing to hide no one has ever got back to him :) Everyone needs privacy. We flourish our being and can be true to ourselves when we do not have the fear and knowledge of being watched by someone. Everyone cares about privacy. If they did not have, there would be no password on their accounts, no locker, no keys. The evolution of physical self to digital self and protecting that Now with us entering into the digital world, we are being measured by bits of data. Our data is an extension of our Physical being. The information forms a core part of a person. We are familiar with the norms of the Physical world. But the digital world is still a maze, where we are trying to find a way to safety, success, and survival. From this very blog post, I am starting a new series on saving ourselves in the digital world. This series is meant for beginners and newbies. In the coming posts, I will be dealing with the threats of the digital world, how to be safe in here? What does the law say about it? and other relevant topics Till we meet the next time, stay safe.

The following things are relatively easy to do, but also easy not to do. Do them consistently and they can change your career and life. 1. Follow up How many interactions die after the first meeting? Not if you follow up. It shows you're interested (to be interesting, be interested - Carnegie), it keeps the momentum going, and it creates ongoing opportunities. Keep nurturing your network, you never know where the next opportunity will come from. 2. Audit your time How often you feel exhausted at the end of the day asking "where did my time go?". Like money and calories, what gets measured gets managed (Drucker). Be in control of your time, or somebody else inevitably will! 3. Control your mood Willpower and positive energy are finite. Start your day early using an empowering ritual. For me that is steps and listening to an inspiring podcast or audiobook. It sets the tone and confidence of the day. Improving our morning routine has been a game changer for us this year. 4. Use the right tool Mobiles are great but highly interruptive. Avoid email (social) first thing in the morning. Flight mode is not only for airplanes, it can be your new best friend in the early morning, especially when you have to eat that ugly frog :) Talking about the right tool for the job: calls can be great. Sometimes email is just not the right tool. It starts clean but people get cc'd and some people go off on a tangent resulting in long, unfocused email chains. Break the pattern: host a 15 min call with a clear agenda and come out with follow up actions. Win/win: not only will you save a lot of time, people will see you as a leader. 5. Just ask There are no dumb questions! (Unless you did not do your homework of course.) There is nothing more frustrating than being stuck on a problem for hours while somebody else can guide you in the right direction in minutes. Don't let self imposed ceilings hold you back from asking for help. You are not bothering the other person, you actually give him/her an opportunity to feel great by helping you! Another reason to be assertive is to stay focused on your longer term goal. Without speaking up, your manager/team/audience does not know where you can be(come) more valuable and therefore risk getting stuck in a rut. I hope this gives you some healthy inspiration to start off your week. Now go crush it this week and comment below which of these tips boosted your productivity/ motivation/ moved you closer to your goal. See you next week. -- Bob With so many avenues to pursue in Python it can be tough to know what to do. If you're looking for some direction or want to take your Python code and career to the next level, schedule a call with us now. We can help you!

Usually, when I want to learn how to use a tool, the thing that works best for me is to try to build something using it. Watching someone build something instead is the second best thing. So, join me while I build a little thing using "serverless" Google Cloud Platform, Python and some other bits and pieces. Caveat: this was originally a twitter thread, so there will be typos and things. Sorry! Also it's possible that it will look better here in threaderapp Read more… (7 min remaining to read)

I am excited to announce that my newest book, Python 101, 2nd Edition is launching on Kickstarter today! Click the Photo to Jump to Kickstarter Python 101 holds a special place in my heart as it was the very first book I ever wrote. Frankly, I don’t think I would have even written a book if it weren’t for the readers of this blog who encouraged me to do so. The new edition of Python 101 will be an entirely new, rewritten from scratch, book. While I will be covering most of the same things as in the original, I have reorganized the book a lot and I am adding all new content. I have also removed old content that is no longer relevant. I hope you will join me by backing the book and giving me feedback as I write it so that I can put together a really great learning resource for you! The post Python 101 2nd Edition Kickstarter is Live! appeared first on The Mouse Vs. The Python.

In the previous tutorial in this introductory series, you learned how to format string data using the string modulo operator. The string modulo operator is useful, and it’s good for you to be familiar with it because you’re likely to encounter it in older Python code. However, there are two newer ways that you can use Python to format strings that are arguably more preferable. In this tutorial, you’ll learn about: The string .format() method The formatted string literal, or f-string You’ll learn about these formatting techniques in detail and add them to your Python string formatting toolkit. Note that there’s a standard module called string containing a class called Template, which provides some string formatting through interpolation. The string modulo operator provides more or less the same functionality, so you won’t cover string.Template here. Free Bonus: Click here to get access to a chapter from Python Tricks: The Book that shows you Python's best practices with simple examples you can apply instantly to write more beautiful + Pythonic code. The Python String .format() Method The Python string .format() method was introduced in version 2.6. It’s similar in many ways to the string modulo operator, but .format() goes well beyond in versatility. The general form of a Python .format() call is shown below: <template>.format(<positional_argument(s)>, <keyword_argument(s)>) Note that this is a method, not an operator. You call the method on <template>, which is a string containing replacement fields. The <positional_arguments> and <keyword_arguments> to the method specify values that are inserted into <template> in place of the replacement fields. The resulting formatted string is the method’s return value. In the <template> string, replacement fields are enclosed in curly braces ({}). Anything not contained in curly braces is literal text that’s copied directly from the template to the output. If you need to include a literal curly bracket character, like { or }, in the template string, then you can escape this character by doubling it: >>>>>> '{{ {0} }}'.format('foo') '{ foo }' Now the curly braces are included in your output. The String .format() Method: Arguments Let’s start with a quick example to get you acquainted before you dive into more detail on how to use this method in Python to format strings. For review, here’s the first example from the previous tutorial on the string modulo operator: >>>>>> print('%d %s cost $%.2f' % (6, 'bananas', 1.74)) 6 bananas cost $1.74 Here, you used the string modulo operator in Python to format the string. Now, you can use Python’s string .format() method to obtain the same result, like this: >>>>>> print('{0} {1} cost ${2}'.format(6, 'bananas', 1.74)) 6 bananas cost $1.74 In this example, <template> is the string '{0} {1} cost ${2}'. The replacement fields are {0}, {1}, and {2}, which contain numbers that correspond to the zero-based positional arguments 6, 'bananas', and 1.74. Each positional argument is inserted into the template in place of its corresponding replacement field: Using The String .format() Method in Python to Format a String With Positional Arguments The next example uses keyword arguments instead of positional parameters to produce the same result: >>>>>> print('{quantity} {item} cost ${price}'.format( ... quantity=6, ... item='bananas', ... price=1.74)) 6 bananas cost $1.74 In this case, the replacement fields are {quantity}, {item}, and {price}. These fields specify keywords that correspond to the keyword arguments quantity=6, item='bananas', and price=1.74. Each keyword value is inserted into the template in place of its corresponding replacement field: Using The String .format() Method in Python to Format a String With Keyword Arguments You’ll learn more about positional and keywords arguments there in the next tutorial in this introductory series, which explores functions and argument passing. For now, the two sections that follow will show you how these are used with the Python .format() method. Positional Arguments Positional arguments are inserted into the template in place of numbered replacement fields. Like list indexing, the numbering of replacement fields is zero-based. The first positional argument is numbered 0, the second is numbered 1, and so on: >>>>>> '{0}/{1}/{2}'.format('foo', 'bar', 'baz') 'foo/bar/baz' Note that replacement fields don’t have to appear in the template in numerical order. They can be specified in any order, and they can appear more than once: >>>>>> '{2}.{1}.{0}/{0}{0}.{1}{1}.{2}{2}'.format('foo', 'bar', 'baz') 'baz.bar.foo/foofoo.barbar.bazbaz' When you specify a replacement field number that’s out of range, you’ll get an error. In the following example, the positional arguments are numbered 0, 1, and 2, but you specify {3} in the template: >>>>>> '{3}'.format('foo', 'bar', 'baz') Traceback (most recent call last): File "<pyshell#26>", line 1, in <module> '{3}'.format('foo', 'bar', 'baz') IndexError: tuple index out of range This raises an IndexError exception. Starting with Python 3.1, you can omit the numbers in the replacement fields, in which case the interpreter assumes sequential order. This is referred to as automatic field numbering: >>>>>> '{}/{}/{}'.format('foo', 'bar', 'baz') 'foo/bar/baz' When you specify automatic field numbering, you must provide at least as many arguments as there are replacement fields: >>>>>> '{}{}{}{}'.format('foo','bar','baz') Traceback (most recent call last): File "<pyshell#27>", line 1, in <module> '{}{}{}{}'.format('foo','bar','baz') IndexError: tuple index out of range In this case, there are four replacement fields in the template but only three arguments, so an IndexError exception occurs. On the other hand, it’s fine if the arguments outnumber the replacement fields. The excess arguments simply aren’t used: >>>>>> '{}{}'.format('foo', 'bar', 'baz') 'foobar' Here, the argument 'baz' is ignored. Note that you can’t intermingle these two techniques: >>>>>> '{1}{}{0}'.format('foo','bar','baz') Traceback (most recent call last): File "<pyshell#28>", line 1, in <module> '{1}{}{0}'.format('foo','bar','baz') ValueError: cannot switch from manual field specification to automatic field numbering When you use Python to format strings with positional arguments, you must choose between either automatic or explicit replacement field numbering. Keyword Arguments Keyword arguments are inserted into the template string in place of keyword replacement fields with the same name: >>>>>> '{x}/{y}/{z}'.format(x='foo', y='bar', z='baz') 'foo/bar/baz' In this example, the values of the keyword arguments x, y, and z take the place of the replacement fields {x}, {y}, and {z}, respectively. If you refer to a keyword argument that’s missing, then you’ll see an error: >>>>>> '{x}/{y}/{w}'.format(x='foo', y='bar', z='baz') Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'w' Here, you specify replacement field {w}, but there’s no corresponding keyword argument named w. Python raises a KeyError exception. While you have to specify positional arguments in sequential order, but you can specify keyword arguments in any arbitrary order: >>>>>> '{0}/{1}/{2}'.format('foo', 'bar', 'baz') 'foo/bar/baz' >>> '{0}/{1}/{2}'.format('bar', 'baz', 'foo') 'bar/baz/foo' >>> '{x}/{y}/{z}'.format(x='foo', y='bar', z='baz') 'foo/bar/baz' >>> '{x}/{y}/{z}'.format(y='bar', z='baz', x='foo') 'foo/bar/baz' You can specify both positional and keyword arguments in one Python .format() call. Just note that, if you do so, then all the positional arguments must appear before any of the keyword arguments: >>>>>> '{0}{x}{1}'.format('foo', 'bar', x='baz') 'foobazbar' >>> '{0}{x}{1}'.format('foo', x='baz', 'bar') File "<stdin>", line 1 SyntaxError: positional argument follows keyword argument In fact, the requirement that all positional arguments appear before any keyword arguments doesn’t apply only to Python format methods. This is generally true of any function or method call. You’ll learn more about this in the next tutorial in this series, which explores functions and function calls. In all the examples shown so far, the values you passed to the Python .format() method have been literal values, but you may specify variables as well: >>>>>> x = 'foo' >>> y = 'bar' >>> z = 'baz' >>> '{0}/{1}/{s}'.format(x, y, s=z) 'foo/bar/baz' In this case, you pass the variables x and y as positional parameter values and z as a keyword parameter value. The String .format() Method: Simple Replacement Fields As you’ve seen, when you call Python’s .format() method, the <template> string contains replacement fields. These indicate where in the template to insert the arguments to the method. A replacement field consists of three components: {[<name>][!<conversion>][:<format_spec>]} These components are interpreted as follows: Component Meaning <name> Specifies the source of the value to be formatted <conversion> Indicates which standard Python function to use to perform the conversion <format_spec> Specifies more detail about how the value should be converted Each component is optional and may be omitted. Let’s take a look at each component in more depth. The <name> Component The <name> component is the first portion of a replacement field: {[<name>][!<conversion>][:<format_spec>]} <name> indicates which argument from the argument list is inserted into the Python format string in the given location. It’s either a number for a positional argument or a keyword for a keyword argument. In the following example, the <name> components of the replacement fields are 0, 1, and baz, respectively: >>>>>> x, y, z = 1, 2, 3 >>> '{0}, {1}, {baz}'.format(x, y, baz=z) '1, 2, 3' If an argument is a list, then you can use indices with <name> to access the list’s elements: >>>>>> a = ['foo', 'bar', 'baz'] >>> '{0[0]}, {0[2]}'.format(a) 'foo, baz' >>> '{my_list[0]}, {my_list[2]}'.format(my_list=a) 'foo, baz' Similarly, you can use a key reference with <name> if the corresponding argument is a dictionary: >>>>>> d = {'key1': 'foo', 'key2': 'bar'} >>> d['key1'] 'foo' >>> '{0[key1]}'.format(d) 'foo' >>> d['key2'] 'bar' >>> '{my_dict[key2]}'.format(my_dict=d) 'bar' You can also reference object attributes from within a replacement field. In the previous tutorial in this series, you learned that virtually every item of data in Python is an object. Objects may have attributes assigned to them that are accessed using dot notation: obj.attr Here, obj is an object with an attribute named attr. You use dot notation to access the object’s attribute. Let’s see an example. Complex numbers in Python have attributes named .real and .imag that represent the real and imaginary portions of the number. You can access these using dot notation as well: >>>>>> z = 3+5j >>> type(z) <class 'complex'> >>> z.real 3.0 >>> z.imag 5.0 There are several upcoming tutorials in this series on object-oriented programming, in which you’ll learn a great deal more about object attributes like these. The relevance of object attributes in this context is that you can specify them in a Python .format() replacement field: >>>>>> z (3+5j) >>> 'real = {0.real}, imag = {0.imag}'.format(z) 'real = 3.0, imag = 5.0' As you can see, it’s relatively straightforward in Python to format components of complex objects using the .format() method. The <conversion> Component The <conversion> component is the middle portion of a replacement field: {[<name>][!<conversion>][:<format_spec>]} Python can format an object as a string using three different built-in functions: str() repr() ascii() By default, the Python .format() method uses str(), but in some instances, you may want to force .format() to use one of the other two. You can do this with the <conversion> component of a replacement field. The possible values for <conversion> are shown in the table below: Value Meaning !s Convert with str() !r Convert with repr() !a Convert with ascii() The following examples force Python to perform string conversion using str(), repr(), and ascii(), respectively: >>>>>> '{0!s}'.format(42) '42' >>> '{0!r}'.format(42) '42' >>> '{0!a}'.format(42) '42' In many cases, the result is the same regardless of which conversion function you use, as you can see in the example above. That being said, you won’t often need the <conversion> component, so you won’t spend a lot of time on it here. However, there are situations where it makes a difference, so it’s good to be aware that you have the capability to force a specific conversion function if you need to. The <format_spec> Component The <format_spec> component is the last portion of a replacement field: {[<name>][!<conversion>][:<format_spec>]} <format_spec> represents the guts of the Python .format() method’s functionality. It contains information that exerts fine control over how values are formatted prior to being inserted into the template string. The general form is this: :[[<fill>]<align>][<sign>][#][0][<width>][<group>][.<prec>][<type>] The ten subcomponents of <format_spec> are specified in the order shown. They control formatting as described in the table below: Subcomponent Effect : Separates the <format_spec> from the rest of the replacement field <fill> Specifies how to pad values that don’t occupy the entire field width <align> Specifies how to justify values that don’t occupy the entire field width <sign> Controls whether a leading sign is included for numeric values # Selects an alternate output form for certain presentation types 0 Causes values to be padded on the left with zeros instead of ASCII space characters <width> Specifies the minimum width of the output <group> Specifies a grouping character for numeric output .<prec> Specifies the number of digits after the decimal point for floating-point presentation types, and the maximum output width for string presentations types <type> Specifies the presentation type, which is the type of conversion performed on the corresponding argument These functions are analogous to the components you’ll find in the string modulo operator’s conversion specifier, but with somewhat greater capability. You’ll see their capabilities explained more fully in the following sections. The <type> Subcomponent Let’s start with <type>, which is the final portion of <format_spec>. The <type> subcomponent specifies the presentation type, which is the type of conversion that’s performed on the corresponding value to produce the output. The possible values are shown below: Value Presentation Type b Binary integer c Single character d Decimal integer e or E Exponential f or F Floating point g or G Floating point or Exponential o Octal integer s String x or X Hexadecimal integer % Percentage These are like the conversion types used with the string modulo operator, and in many cases, they function the same. The following examples demonstrate the similarity: >>>>>> '%d' % 42 '42' >>> '{:d}'.format(42) '42' >>> '%f' % 2.1 '2.100000' >>> '{:f}'.format(2.1) '2.100000' >>> '%s' % 'foobar' 'foobar' >>> '{:s}'.format('foobar') 'foobar' >>> '%x' % 31 '1f' >>> '{:x}'.format(31) '1f' However, there are some minor differences between some of the Python .format() presentation types and the string modulo operator conversion types: Type .format() Method String Modulo Operator b Designates binary integer conversion Not supported i, u Not supported Designates integer conversion c Designates character conversion, and the corresponding value must be an integer Designates character conversion, but the corresponding value may be either an integer or a single-character string g, G Chooses between floating point or exponential output, but the rules governing the choice are slightly more complicated Chooses between floating point or exponential output, depending on the magnitude of the exponent and the value specified for <prec> r, a Not supported (though the functionality is provided by the !r and !a conversion components in the replacement field) Designates conversion with repr() or ascii(), respectively % Converts a numeric argument to a percentage Inserts a literal '%' character into the output Next, you’ll see several examples illustrating these differences, as well as some of the added features of the Python .format() method presentation types. The first presentation type you’ll see is b, which designates binary integer conversion: >>>>>> '{:b}'.format(257) '100000001' The modulo operator doesn’t support binary conversion type at all: >>>>>> '%b' % 257 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: unsupported format character 'b' (0x62) at index 1 However, the modulo operator does allow decimal integer conversion with any of the d, i, and u types. Only the d presentation type indicates decimal integer conversion with the Python .format() method. The i and u presentation types aren’t supported and aren’t really necessary. Next up is single character conversion. The modulo operator allows either an integer or single character value with the c conversion type: >>>>>> '%c' % 35 '#' >>> '%c' % '#' '#' On the other hand, Python’s .format() method requires that the value corresponding to the c presentation type be an integer: >>>>>> '{:c}'.format(35) '#' >>> '{:c}'.format('#') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: Unknown format code 'c' for object of type 'str' When you try to pass a value of a different type, you’ll get a ValueError. For both the string modulo operator and Python’s .format() method, the g conversion type chooses either floating-point or exponential output, depending on the magnitude of the exponent and the value specified for <prec>: >>>>>> '{:g}'.format(3.14159) '3.14159' >>> '{:g}'.format(-123456789.8765) '-1.23457e+08' The exact rules governing the choice are slightly more complicated with .format() than they are with the modulo operator. Generally, you can trust that the choice will make sense. G is identical to g except for when the output is exponential, in which case the 'E' will be in uppercase: >>>>>> '{:G}'.format(-123456789.8765) '-1.23457E+08' The result is the same as in the previous example, but this time with an uppercase 'E'. Note: There are a couple of other situations where you’ll see a difference between the g and G presentations types. Under some circumstances, a floating-point operation can result in a value that’s essentially infinite. The string representation of such a number in Python is 'inf'. It may also happen that a floating-point operation produces a value that can’t be represented as a number. Python represents this with the string 'NaN', which stands for Not a Number. When you pass these values to Python’s .format() method, the g presentation type produces lowercase output, and G produces uppercase output: >>>>>> x = 1e300 * 1e300 >>> x inf >>> '{:g}'.format(x) 'inf' >>> '{:g}'.format(x * 0) 'nan' >>> '{:G}'.format(x) 'INF' >>> '{:G}'.format(x * 0) 'NAN' You’ll see similar behavior with the f and F presentations types as well: >>>>>> '{:f}'.format(x) 'inf' >>> '{:F}'.format(x) 'INF' >>> '{:f}'.format(x * 0) 'nan' >>> '{:F}'.format(x * 0) 'NAN' For more information on floating-point representation, inf, and NaN, check out the Wikipedia page on IEEE 754-1985. The modulo operator supports r and a conversion types to force conversion by repr() and ascii(), respectively. Python’s .format() method doesn’t support r and a presentation types, but you can accomplish the same thing with the !r and !a conversion components in the replacement field. Finally, you can use the % conversion type with the modulo operator to insert a literal '%' character into the output: >>>>>> '%f%%' % 65.0 '65.000000%' You don’t need anything special to insert a literal '%' character into the Python .format() method’s output, so the % presentation type serves a different handy purpose for percent output. It multiplies the specified value by 100 and appends a percent sign: >>>>>> '{:%}'.format(0.65) '65.000000%' The remaining parts of <format_spec> indicate how the chosen presentation type is formatted, in much the same way as the string modulo operator’s width and precision specifiers and conversion flags. These are described more fully in the following sections. The <fill> and <align> Subcomponents <fill> and <align> control how formatted output is padded and positioned within the specified field width. These subcomponents only have meaning when the formatted field value doesn’t occupy the entire field width, which can only happen if a minimum field width is specified with <width>. If <width> isn’t specified, then <fill> and <align> are effectively ignored. You’ll cover <width> later on in this tutorial. Here are the possible values for the <align> subcomponent: < > ^ = A value using the less than sign (<) indicates that the output is left-justified: >>>>>> '{0:<8s}'.format('foo') 'foo ' >>> '{0:<8d}'.format(123) '123 ' This behavior is the default for string values. A value using the greater than sign (>) indicates that the output should be right-justified: >>>>>> '{0:>8s}'.format('foo') ' foo' >>> '{0:>8d}'.format(123) ' 123' This behavior is the default for numeric values. A value using a caret (^) indicates that the output should be centered in the output field: >>>>>> '{0:^8s}'.format('foo') ' foo ' >>> '{0:^8d}'.format(123) ' 123 ' Finally, you can also specify a value using the equals sign (=) for the <align> subcomponent. This only has meaning for numeric values, and only when a sign is included in the output. When numeric output includes a sign, it’s normally placed directly to the left of the first digit in the number, as shown above. If <align> is set to the equals sign (=), then the sign appears at the left edge of the output field, and padding is placed in between the sign and the number: >>>>>> '{0:+8d}'.format(123) ' +123' >>> '{0:=+8d}'.format(123) '+ 123' >>> '{0:+8d}'.format(-123) ' -123' >>> '{0:=+8d}'.format(-123) '- 123' You’ll cover the <sign> component in detail in the next section. <fill> specifies how to fill in extra space when the formatted value doesn’t completely fill the output width. It can be any character except for curly braces ({}). (If you really feel compelled to pad a field with curly braces, then you’ll just have to find another way!) Some examples of the use of <fill> are shown below: >>>>>> '{0:->8s}'.format('foo') '-----foo' >>> '{0:#<8d}'.format(123) '123#####' >>> '{0:*^8s}'.format('foo') '**foo***' If you specify a value for <fill>, then you should also include a value for <align> as well. The <sign> Subcomponent You can control whether a sign appears in numeric output with the <sign> component. For example, in the following, the plus sign (+) specified in the <format_spec> indicates that the value should always be displayed with a leading sign: >>>>>> '{0:+6d}'.format(123) ' +123' >>> '{0:+6d}'.format(-123) ' -123' Here, you use the plus sign (+), so a sign will always be included for both positive and negative values. If you use the minus sign (-), then only negative numeric values will include a leading sign, and positive values won’t: >>>>>> '{0:-6d}'.format(123) ' 123' >>> '{0:-6d}'.format(-123) ' -123' When you use a single space (' '), it means a sign is included for negative values, and an ASCII space character for positive values: >>>>>> '{0:*> 6d}'.format(123) '** 123' >>> '{0:*>6d}'.format(123) '***123' >>> '{0:*> 6d}'.format(-123) '**-123' Since the space character is the default fill character, you’d only notice the effect of this if an alternate <fill> character is specified. Lastly, recall from above that when you specify the equals sign (=) for <align> and you include a <sign> specifier, the padding goes between the sign and the value, rather than to the left of the sign. The # Subcomponent When you specify a hash character (#) in <format_spec>, Python will select an alternate output form for certain presentation types. This is analogous to the # conversion flag for the string modulo operator. For binary, octal, and hexadecimal presentation types, the hash character (#) causes inclusion of an explicit base indicator to the left of the value: >>>>>> '{0:b}, {0:#b}'.format(16) '10000, 0b10000' >>> '{0:o}, {0:#o}'.format(16) '20, 0o20' >>> '{0:x}, {0:#x}'.format(16) '10, 0x10' As you can see, the base indicator can be 0b, 0o, or 0x. For floating-point or exponential presentation types, the hash character forces the output to contain a decimal point, even if the output consists of a whole number: >>>>>> '{0:.0f}, {0:#.0f}'.format(123) '123, 123.' >>> '{0:.0e}, {0:#.0e}'.format(123) '1e+02, 1.e+02' For any presentation type other than those shown above, the hash character (#) has no effect. The 0 Subcomponent If output is smaller than the indicated field width and you specify the digit zero (0) in <format_spec>, then values will be padded on the left with zeros instead of ASCII space characters: >>>>>> '{0:05d}'.format(123) '00123' >>> '{0:08.1f}'.format(12.3) '000012.3' You’ll typically use this for numeric values, as shown above. However, it works for string values as well: >>>>>> '{0:>06s}'.format('foo') '000foo' If you specify both <fill> and <align>, then <fill> overrides 0: >>>>>> '{0:*>05d}'.format(123) '**123' <fill> and 0 essentially control the same thing, so there really isn’t any need to specify both. In fact, 0 is really superfluous, and was probably included as a convenience for developers who are familiar with the string modulo operator’s similar 0 conversion flag. The <width> Subcomponent <width> specifies the minimum width of the output field: >>>>>> '{0:8s}'.format('foo') 'foo ' >>> '{0:8d}'.format(123) ' 123' Note that this is a minimum field width. Suppose you specify a value that’s longer than the minimum: >>>>>> '{0:2s}'.format('foobar') 'foobar' In this case, <width> is effectively ignored. The <group> Subcomponent <group> allows you to include a grouping separator character in numeric output. For decimal and floating-point presentation types, <group> may be specified as either a comma character (,) or an underscore character (_). That character then separates each group of three digits in the output: >>>>>> '{0:,d}'.format(1234567) '1,234,567' >>> '{0:_d}'.format(1234567) '1_234_567' >>> '{0:,.2f}'.format(1234567.89) '1,234,567.89' >>> '{0:_.2f}'.format(1234567.89) '1_234_567.89' A <group> value using an underscore (_) may also be specified with the binary, octal, and hexadecimal presentation types. In that case, each group of four digits is separated by an underscore character in the output: >>>>>> '{0:_b}'.format(0b111010100001) '1110_1010_0001' >>> '{0:#_b}'.format(0b111010100001) '0b1110_1010_0001' >>> '{0:_x}'.format(0xae123fcc8ab2) 'ae12_3fcc_8ab2' >>> '{0:#_x}'.format(0xae123fcc8ab2) '0xae12_3fcc_8ab2' If you try to specify <group> with any presentation type other than those listed above, then your code will raise an exception. The .<prec> Subcomponent .<prec> specifies the number of digits after the decimal point for floating point presentation types: >>>>>> '{0:8.2f}'.format(1234.5678) ' 1234.57' >>> '{0:8.4f}'.format(1.23) ' 1.2300' >>> '{0:8.2e}'.format(1234.5678) '1.23e+03' >>> '{0:8.4e}'.format(1.23) '1.2300e+00' For string types, .<prec> specifies the maximum width of the converted output: >>>>>> '{:.4s}'.format('foobar') 'foob' If the output would be longer than the value specified, then it will be truncated. The String .format() Method: Nested Replacement Fields Recall that you can specify either <width> or <prec> by an asterisk with the string modulo operator: >>>>>> w = 10 >>> p = 2 >>> '%*.*f' % (w, p, 123.456) # Width is 10, precision is 2 ' 123.46' The associated values are then taken from the argument list. This allows <width> and <prec> to be evaluated dynamically at run-time, as shown in the example above. Python’s .format() method provides similar capability using nested replacement fields. Inside a replacement field, you can specify a nested set of curly braces ({}) that contains a name or number referring to one of the method’s positional or keyword arguments. That portion of the replacement field will then be evaluated at run-time and replaced using the corresponding argument. You can accomplish the same effect as the above string modulo operator example with nested replacement fields: >>>>>> w = 10 >>> p = 2 >>> '{2:{0}.{1}f}'.format(w, p, 123.456) ' 123.46' Here, the <name> component of the replacement field is 2, which indicates the third positional parameter whose value is 123.456. This is the value to be formatte

Recently, I had a great interaction with one of my coworkers that I think is worth sharing, with the hope you may learn a bit about refactoring and python.My colleague came to me to help him think through a problem that surfaced with a change to a project. The code in question sends a file to a remote storage service. It looked like this:Read more...

This week we welcome Martin Fitzpatrick (@mfitzp) as our PyDev of the Week! Martin is the author of “Create Simple GUI Applications with Python and Qt 5” and the creator of the LearnPyQt website. You can also check out his personal site or see what he’s up to by visiting his Github profile. Let’s spend some time getting to know Martin better! Can you tell us a little about yourself (hobbies, education, etc): I’m a developer from the United Kingdom, who’s been working with Python for the past 12 years, and living in the Netherlands (Amersfoort) for the past 5. I started coding on 8 bit machines back in the early 90s, creating platform games of dubious quality ” in my defence we didn’t have StackOverflow back then. Later I moved onto the PC, first writing DOS games and then, after someone invented the internet, doing a stint of web dev. I’ve been programming on and off ever since. Rather than pursue software development as a career, I instead took a long detour into healthcare/biology. I worked first in the ambulance service, then as a physiotherapy assistant and finally completed a degree and PhD in Bioinformatics and Immunology. This last step was where I discovered Python, ultimately leading me to where I am now. In my spare time I tinker in my workshop, creating daft electronic games and robots. I like robots. Why did you start using Python? I first used Python back in 2007 when I was looking for at alternatives to building websites with Drupal/PHP. That led me to Django and Python. It felt so much simpler and more logical than what I’d used before, after knocking something together in an afternoon I was basically hooked. For the next few years I was using Python almost exclusively for web development, and it probably would have stayed that way was it not for my PhD. My thesis project was looking at the effects of metabolism on rheumatoid arthritis, and required me to analyse some big chunks of data. Having worked with Python for the previous 4 years it only seemed natural to try and use it here, rather than stop and learn R or MATLAB. The Python data analysis landscape was still a bit rough back then, but improving quickly ” pandas and Jupyter notebooks first appeared during this time. The final couple of years of my PhD I was looking to make the tools I’d written more accessible to non-technical users and started building GUI applications with PyQt5. In the past couple of years I discovered microcontrollers (ESP8266 and Raspberry Pi) and have built some silly things with MicroPython. What other programming languages do you know and which is your favorite? Python is my favourite, hands down. There is something about the language that lines up very well with my brain, might be all the empty space. I have learnt and forgotten quite a few languages including PHP, Pascal, Perl, Prolog and Z80 assembler. I can still bash something together in C and does MicroPython count as another language? What projects are you working on now? For the past month I’ve been working on updates to my PyQt5 book, Create Simple GUI Applications with Python & Qt and the accompanying PyQt5/PySide2 tutorials. There are plenty of good beginner resources available but once you get into developing real applications you’re a bit out of luck. I’ve now got a small team of writers together now which is really kicking things up a notch, it’s a lot of fun. The site itself is custom built on top of Wagtail/Django, and I would like to make that available to other Python developers who want to host their own courses and tutorials. Over on my workbench I have a few electronic game projects in progress using Python but can’t share anything yet. My biggest success to date was Etch-A-Snap a Raspberry Pi powered Etch-A-Sketch camera. Basically, you take a photo and it draws it automatically on a mini Etch-A-Sketch. That was bought by a Japanese collector which was kind of mind-blowing. If anyone is interested in working with me I’m always open to collaborate! Which Python libraries are your favorite (core or 3rd party)? Python numeric libraries (numpy, scipy, pandas) and Jupyter notebooks are the big standouts for me. Collectively they have saved me hours upon hours of work, and having these kinds of tools available has been a major boost to Python’s popularity. I think I have to say PyQt5/PySide2 here as well. How did you become a self-published author? When I started writing GUI applications in PyQt5 it was a bit of an uphill struggle. There were very few examples or tutorials available at the time, so I was stuck converting examples from C++. Once I had it figured out I just sat and wrote down everything I’d needed to learn on the way ” hopefully to save other people from the same fate. That was the first edition of the book, and I’ve been updating it regularly ever since. Self publishing was just the simplest option to begin with, allowing me to concentrate on writing the book I wanted to read. Offers I have had from publishers all come with changes or restrictions on distribution I don’t agree with (the book is currently Creative Commons licensed). Why did you choose PyQt over the other Python GUI toolkits? During my PhD I was developing a tool for visualizing chemical pathways in cells and needed a good way to visualize overlaid pathways. The only solution I could find for this involved rendering using HTML/Javascript in an embedded window. I built prototypes of the app with Tkinter, wxWidgets and Qt, and actually quite liked wxWidgets for its native widgets. But Qt was the only toolkit which shipped with its own built-in browser and so worked reliably across different platforms (I was on MacOS, my supervisor on Windows). The rest, as they say, is history. The big benefit of Qt for me now is the QGraphicsScene vector graphics canvas which is great for interactive visualizations. Do you have any advice for other potential authors? Firstly, everybody knows something, or some combination of things or some things from a certain angle that is unique enough to form the basis of a book. Even if a book already exists in your niche, your own voice or experience is valuable. Secondly, pick a topic that you’re interested in but that you also enjoy doing. Writing a programming book means writing a lot of example code, and if you don’t enjoy creating these things it’s going to be a unpleasant experience. One of my first steps writing my book was to start a collection of example PyQt5 applications including clones of classics like Paint and Solitaire. This helped me figure out what was *required* knowledge, but ” more importantly ” it was a lot of fun. Is there anything else you’d like to say? I often get questions from Python developers who’ve come to programming a little later, asking “am I too old to start doing this professionally?” The answer is no! I’ve had a career spanning admin (finance, human resources), healthcare (ambulance service, physiotherapy assistant, disability support worker), research scientist (PhD and post-doc) and landed my first actual “programming job” at 37. One great advantage of learning to code in Python is that it can be applied to so many different problem domains. Whether you build your experience automating some office reports, doing data analysis or building websites, those skills will transfer and and your Python will improve. Thanks for doing the interview, Martin! The post PyDev of the Week: Martin Fitzpatrick appeared first on The Mouse Vs. The Python.