Shulou(Shulou.com)06/02 Report--

Python 3.1 core language changes, I believe that many inexperienced people do not know what to do, so this article summarizes the causes of the problem and solutions, through this article I hope you can solve this problem.

Here we will analyze the changes in the core language of Python 3.1, including string formatting, specifiers, and other aspects.

Seven months after the release of Python 3.0, Python core developers released the new Python 3.1 version on June 27, 2009. Although this version 3.1 is only a minor upgrade to Python 3.0, it not only brings many interesting features to developers, but also improves performance. This article will give readers a detailed introduction to Python 3.1's changes in core languages, standard libraries, and performance improvements.

I. formatting the string

The * version of Python brings us the ability to automatically fill in fields in a delightful format. We know that formatting strings are often needed in many programs. Version 2.x of Python uses a percent operator similar to the [s] printf function, as follows:

>'s,% s'% ('Hello',' World')

'Worldwide, Hello' Python 3.0 adds more advanced string formatting capabilities, as follows:

>'{0}, {1}! '.format (' Hello', 'World')

'Worldwide, Hello' Today, Python 3.1 has new improvements in string formatting. For Python 3.0, whenever you want to reference a location parameter in a format string, you must give an index of each location parameter. But in Python 3.1, you can forget about these indexes, because Python populates these parameters for you in turn:

>'{}, {}! '.format (' Hello', 'World')' Hello, Worldwide'

2. PEP-378: format specifier for thousand-bit delimiters

In financial applications, thousands of delimiters are usually used in numbers. People who work in finance or accounting do not write "you owe me $12345678", but "you owe me $12345678". They are used to using commas as delimiters. So how do you use Python to achieve this effect:

> format (12345678,',')

'12345678 'you can use other distinguishers to group numbers. The width specifier here (8 in this case) includes commas and decimal points:

> format (1234,','). Replace (',','_')

The '12345.7' comma is usually used as the default delimiter. If you want to use other characters as delimiters, simply replace the comma with your favorite character through the replace function, as shown below:

> format (1234,','). Replace (',','_')

Of course, you can also use the format function as a string method:

>'{0pur8jue .1f} '.format (123.456)

3. Maketrans function

With the maketrans () and translate () functions, we can replace one set of characters with another. Using this replacement feature is somewhat cumbersome because it requires the use of the maketrans () function, which maps input characters to output characters, to establish a conversion table, which is then passed to the translate () function. Of course, the string module still has its own maketrans () function, but Python 3.1 deprecates it, preferring the use of separate maketrans () functions to manipulate bytes, byte arrays, and strings.

The following example shows how to use the maketrans () and translate () functions to handle byte objects. It is important to note that the conversion table for bytes has 256 items (each item corresponds to a possible byte), and this example maps most of the bytes to themselves, with the exception of 1line 2 and 3, because they map to 4, 5 and 6, respectively. As follows:

> tt = bytes.maketrans (bouncy 123, baux456') > > len (tt) 256 > tt b'\ X00\ X01\ X03\ X04\ x05\ X06\ X07\ X08\ t\ n\ X0b\ X0c\ r\ X0e\ x0f\ x11\ x12\ x14\ x15\ x17\ X19\ X1a\ X1b\ X1c\ x1d\ X1e\ x1f! "# $% &\'() * +, -. / 0456456789: ? @ ABCDEFGHIJKLMNOPQSTUVWXYZ [\\] ^ _ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ _ `ABCDEFGHIJKLMNOPQSTUVWXYZZ [\] ^ _ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ `ABCDEFGHIJKLMNOPQSTUVWXYZ] ^ _ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ `ABCDEFGHHIJKLMNOPQSTUVWXYZ] ^ _ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ `ABCDEFGHIJKLMNOPQSTUVWXYZ [\] ^ _ `ABCDEFGHIJKLMNOPQSTU Xb0\ xb1\ xb2\ xb3\ xb4\ xb5\ xb6\ xb7\ xb8\ xb9\ xbb\ xbc\ xbd\ xbe\ xbf\ xc0\ xc1\ xc2\ xc3\ xc4\ xc5\ xc6\ xc7\ xc8\ xc9\ xca\ xcb xcc\ xcd\ xce\ xcf\ xd0\ xd1\ xd2\ xd3\ xd4\ xd5\ xd4\ xd5\ xd4 Xe9\ xea\ xeb\ xec\ xed\ xee\ xef\ xf0\ xf1\ xf2\ xf3\ xf4\ xf5\ xf6\ xf7\ xf8\ xf9\ xfa\ xfb\ xfc\ xfd\ xfe\ xff'

After building the conversion table, we just pass it to the translate () function, as shown below:

> b'123456'.translate (tt)

We can also pass other parameters as characters to be deleted:

> b'123456'.translate (tt, baked 5')

We can see that the original 5 has been deleted from 123456, but the converted 5 (remember, our mapping table converts 2 to 5) has not been deleted. This shows that the system deletes the corresponding characters from the original string before the conversion operation.

String conversion is slightly different, and the string version of the maketrans function returns a dictionary:

> tt = str.maketrans ('123,' 456') {49: 52,50: 53,51: 54} > '123456'.translate (tt)' 456456'

IV. Changes related to mathematics

> int.bit_length (19) 5 > bin (19)

Version 3.1 has also changed in terms of mathematics.

Int added a bit_length method

In the new version, the int variable has a bit_length method that returns the number of digits when the int variable is represented as a binary number. For example, if the binary representation of the number 19 is 10011, then its number of digits is 5:

Rounding of '0b10011' floating point numbers

The round () function in Python 3.0 and earlier is a bit capricious: if you don't specify precision, it returns an integer; if you specify precision, it returns the type of data you entered:

> round (1000) 1000 > round (1000.0) 1000 > round (1000, 2) 1000 > round (1000.0, 2)

1000.0 in Python 1000.0, as long as the number entered is an integer (even if it is represented as a floating-point number, for example, 1000.0), it always returns an integer:

> round (1000) 1000 > round (1000.0) 1000 > round (1000, 2) 1000 > round (1000.0, 2)

1000 representation of floating point numbers

At present, real numbers are represented by 32-bit (single-precision) or 64-bit (double-precision) in most hardware and operating systems. However, this can lead to some real numbers that cannot be accurately represented. Because of the binary nature of computer memory, some numbers are very concise in decimal representation, but it is more complicated if they are expressed in a floating-point scheme. For example, if you use a 32-bit single-precision floating point number to represent the number 0.6, it will be 0.599999999999998:

> 0.6

0.599999999999998 for this representation, the above number is to be as accurate as possible, but it is very unfriendly to the user. Python 3.1 uses a new algorithm to make the representation of the original value as concise as possible. So in Python 3.1, people type in the numbers above for a more concise expression:

> 0.6

0.6 this is already accurate, except when it comes to arithmetic. For example, the value of the expression 0.7-0.1 is 0.79999999999999993 in 32-bit floating-point notation, while the value of the number 0.8 is 0.800000000000004 in 32-bit floating-point representation. This means that 0.7 to 0.1 is not equal to 0.8, which can lead to some problems. For example, the following loop will never end:

> x = 0.0 > while x! = 1.0:... Print (repr (x))... X + = 0.1 output result: 0 0.10000000000000001 0.200000000000001 0.300000000000004 0.400000000000002 0.5 0.599999999999998 0.6999999999999999993 0.8999999999991 0.999999999999989 1.09999999999999 1.2 1.3 1.40000000000001 1.50000000000002 1.6000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.9999999999999999999999999999999999990000000000000000000000000000000000000000000000000000000000003

... In Python 3.0, the repr () function returns the actual representation; in Python 3.1, it returns a concise representation. Whether in Python 3.0 or Python 3.1, the print () function shows a concise representation:

> print (0.1) > print (0.100000000000001)

The 0.1Python language also has a module called decimal, which can be used for accurate representation of real numbers. It uses a different representation scheme to represent floating-point numbers, and when memory is running, use as many digits as possible to represent a real number-- and there is no rounding error when doing arithmetic. In Python 3.0, the Decimal type uses a new method to initialize the value it represents from a string; in Python 3.1, another new method, from_float (), has been added to receive floating-point numbers. Note that even when using from_float (), the Decimal module is more accurate than 32-bit.

> from decimal import Decimal > Decimal.from_float (0.1000000000000000055511151231257827021181583404541015625') Decimal

5. Improved WITH statement

In Python 2.5, the WITH statement was introduced as a _ _ future__ feature, and the formal introduction of this statement actually began with Python 3.0. By Python 3.1, this statement has been able to support more resources. In the most common case, it can open input and output files and close them after processing is complete. In Python 3.0, we either use nested with statements or explicitly close them in a file. The following is an example of Python 3.0, which opens an input file, reads its contents as a string, processes the contents with the string's title () method, and writes the results to an output file.

This example contains two nested with statements. Notice the * line in the nested with statements. When the code tries to read the out.txt, the result is empty because the file is buffered and has not been written yet. When the with statement is complete, Python closes the file, so a single line of code determines that the content of the out.txt is indeed uppercase.

Open ('in.txt',' w'). Write ('abc def') with open (' in.txt') as in_file: with open ('out.txt',' w') as out_file: text = in_file.read () assert text = 'abc def' text = text.title () assert text =' Abc Def' out_file.write (text) assert open ('out.txt'). Read () = =''

Assert open ('out.txt'). Read () =' Abc Def' does not feel a little headache when seeing the nested with statement, hehe. Next, we open two two files and close them after processing is complete (if you need to open three files, you need three nested with statements). Python 3.1 runs you open all files with a single WITH statement:

Open ('in.txt', 'w'). Write (' abc def') with open ('in.txt') as in_file: with open (' out.txt','w') as out_file: text = in_file.read () assert text = = 'abc def' text = text.title () assert text =' Abc Def' out_file.write (text) assert open ('out.txt'). Read () =' assert open ('out.txt'). Read () = =' Abc Def'

Another improvement of Python 3.1is that gzip.GzipFile and bz2.BZ2File can now also be used for WITH statements. We know that these are compressed file formats. The following sample code uses a gzip file and a bz2 file to store 5000 bytes of content and display its size. Some additional Python 3 features are also useful here, such as statistical results with named attributes and advanced string formatting.

From bz2 import BZ2File from gzip import GzipFile import os with GzipFile ('1.gz,' wb') as g, BZ2File ('1.bz2,' wb') as b: g.write (baked X' * 5000) b.write (baked X' * 5000) for ext in ('.gz', '.bz2'): filename ='1' + ext print ('The size of the {0} file is {1.st_size} bytes'.format (ext) Os.stat (filename)) output result: The size of the .gz file is 43 bytes The size of the .bz2 file is 45 bytes

VI. Summary

Seven months after the release of Python 3.0, Python core developers released the new Python 3.1 version on June 27, 2009. Although this version 3.1 is only a minor upgrade to Python 3.0, it not only brings many interesting features to developers, but also improves performance. This article gives readers a detailed introduction to the core language changes in Python 3.1. in the following articles, we will continue to introduce readers to the changes in standard libraries and performance improvements in the new version.

After reading the above, have you mastered how the core language of Python 3.1 has changed? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.