Split (1)

train · 14.5k rows

Text stringlengths 1 9.41k
For example, the decimal fraction ``` 0.125 ``` has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ``` 0.001 ``` has value 0/2 + 0/4 + 1/8.
These two fractions have identical values, the only real difference being that the first is written in base 10 fractional notation, and the second in base 2. Unfortunately, most decimal fractions cannot be represented exactly as binary fractions.
A consequence is that, in general, the decimal floating-point numbers you enter are only approximated by the binary floatingpoint numbers actually stored in the machine. The problem is easier to understand at first in base 10.
Consider the fraction 1/3. You can approximate that as a base 10 fraction: ``` 0.3 ``` or, better, ``` 0.33 ``` or, better, ``` 0.333 ``` and so on.
No matter how many digits you’re willing to write down, the result will never be exactly 1/3, but will be an increasingly better approximation of 1/3. In the same way, no matter how many base 2 digits you’re willing to use, the decimal value 0.1 cannot be represented exactly as a base 2 fraction.
In base 2, 1/10 is the infinitely repeating fraction ``` 0.0001100110011001100110011001100110011001100110011... ``` Stop at any finite number of bits, and you get an approximation.
On most machines today, floats are approximated using a binary fraction with the numerator using the first 53 bits starting with the most significant bit and with the denominator as a power of two.
In the case of 1/10, the binary fraction is ``` 3602879701896397 / 2 ** 55 which is close to but not exactly equal to the true value of 1/10. ``` Many users are not aware of the approximation because of the way values are displayed.
Python only prints a decimal approximation to the true decimal value of the binary approximation stored by the machine.
On most machines, if Python were to print the true decimal value of the binary approximation stored for 0.1, it would have to display ----- That is more digits than most people find useful, so Python keeps the number of digits manageable by displaying a rounded value instead ``` >>> 1 / 10 0.1 ``` Just remember, ev...
For example, the numbers `0.1` and `0.10000000000000001` and `0.1000000000000000055511151231257827021181583404541015625` are all approximated by `3602879701896397` `/` `2` `**` `55.` Since all of these decimal values share the same approximation, any one of them could be displayed while still preserving the invariant e...
Starting with Python 3.1, Python (on most systems) is now able to choose the shortest of these and simply display 0.1. Note that this is in the very nature of binary floating-point: this is not a bug in Python, and it is not a bug in your code either.
You’ll see the same kind of thing in all languages that support your hardware’s floating-point arithmetic (although some languages may not display the difference by default, or in all output modes). For more pleasant output, you may wish to use string formatting to produce a limited number of significant digits: ``` >...
For example, since 0.1 is not exactly 1/10, summing three values of 0.1 may not yield exactly 0.3, either: ``` >>> .1 + .1 + .1 == .3 False ``` Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 cannot get any closer to the exact value of 3/10, then pre-rounding with round() function cannot h...
The problem with “0.1” is explained in [precise detail below, in the “Representation Error” section.
See The Perils of Floating Point for a more](http://www.lahey.com/float.htm) complete account of other common surprises. As that says near the end, “there are no easy answers.” Still, don’t be unduly wary of floating-point!
The errors in Python float operations are inherited from the floating-point hardware, and on most machines are on the order of no more than 1 part in 2**53 per operation.
That’s more than adequate for most tasks, but you do need to keep in mind that it’s not decimal arithmetic and that every float operation can suffer a new rounding error. While pathological cases do exist, for most casual use of floating-point arithmetic you’ll see the result you expect in the end if you simply round ...
str() usually suffices, and for finer control see the str.format() method’s format specifiers in formatstrings. For use cases which require exact decimal representation, try using the decimal module which implements decimal arithmetic suitable for accounting applications and high-precision applications. Another form ...
See [<https://scipy.org>.](https://scipy.org) Python provides tools that may help on those rare occasions when you really do want to know the exact value of a float.
The float.as_integer_ratio() method expresses the value of a float as a fraction: ``` >>> x = 3.14159 >>> x.as_integer_ratio() (3537115888337719, 1125899906842624) ``` Since the ratio is exact, it can be used to losslessly recreate the original value: ``` >>> x == 3537115888337719 / 1125899906842624 True ``` The floa...
That can make a difference in overall accuracy so that the errors do not accumulate to the point where they affect the final total: ----- ### 15.1 Representation Error This section explains the “0.1” example in detail, and shows how you can perform an exact analysis of cases like this yourself.
Basic familiarity with binary floating-point representation is assumed. _Representation error refers to the fact that some (most, actually) decimal fractions cannot be represented_ exactly as binary (base 2) fractions.
This is the chief reason why Python (or Perl, C, C++, Java, Fortran, and many others) often won’t display the exact decimal number you expect. Why is that?
1/10 is not exactly representable as a binary fraction.
Almost all machines today (November 2000) use IEEE-754 floating point arithmetic, and almost all platforms map Python floats to IEEE-754 “double precision”.
754 doubles contain 53 bits of precision, so on input the computer strives to convert 0.1 to the closest fraction it can of the form J/2**N where J is an integer containing exactly 53 bits.
Rewriting ``` 1 / 10 ~= J / (2N) ``` as ``` J ~= 2N / 10 ``` and recalling that J has exactly 53 bits (is >= 252 but < 253), the best value for N is 56: ``` >>> 252 <= 256 // 10 < 2**53 True ``` That is, 56 is the only value for N that leaves J with exactly 53 bits.
The best possible value for J is then that quotient rounded: ``` >>> q, r = divmod(2**56, 10) >>> r 6 ``` Since the remainder is more than half of 10, the best approximation is obtained by rounding up: ``` >>> q+1 7205759403792794 ``` Therefore the best possible approximation to 1/10 in 754 double precision is: ``` 7...
But in no case can it be exactly 1/10! So the computer never “sees” 1/10: what it sees is the exact fraction given above, the best 754 double approximation it can get: ``` >>> 0.1 * 2 55 3602879701896397.0 ``` If we multiply that fraction by 1055, we can see the value out to 55 decimal digits: ----- meaning t...
Instead of displaying the full decimal value, many languages (including older versions of Python), round the result to 17 significant digits: ``` >>> format(0.1, '.17f') '0.10000000000000001' ``` The fractions and decimal modules make these calculations easy: ----- ----- CHAPTER ### SIXTEEN APPENDIX 16.1 ...
In interactive mode, it then returns to the primary prompt; when input came from a file, it exits with a nonzero exit status after printing the stack trace.
(Exceptions handled by an except clause in a try statement are not errors in this context.) Some errors are unconditionally fatal and cause an exit with a nonzero exit; this applies to internal inconsistencies and some cases of running out of memory.
All error messages are written to the standard error stream; normal output from executed commands is written to standard output. Typing the interrupt character (usually Control-C or Delete) to the primary or secondary prompt cancels the input and returns to the primary prompt.[1] Typing an interrupt while a command is...
The #! must be the first two characters of the file. On some platforms, this first line must end with a Unix-style line ending ('\n'), not a Windows ('\r\n') line ending.
Note that the hash, or pound, character, '#', is used to start a comment in Python. The script can be given an executable mode, or permission, using the chmod command. ``` $ chmod +x myscript.py ``` On Windows systems, there is no notion of an “executable mode”.
The Python installer automatically associates .py files with python.exe so that a double-click on a Python file will run it as a script.
The extension can also be .pyw, in that case, the console window that normally appears is suppressed. #### 16.1.3 The Interactive Startup File When you use Python interactively, it is frequently handy to have some standard commands executed every time the interpreter is started.
You can do this by setting an environment variable named PYTHONSTARTUP 1 A problem with the GNU Readline package may prevent this. ----- to the name of a file containing your start-up commands.
This is similar to the .profile feature of the Unix shells. This file is only read in interactive sessions, not when Python reads commands from a script, and not when ``` /dev/tty is given as the explicit source of commands (which otherwise behaves like an interactive session).
It ``` is executed in the same namespace where interactive commands are executed, so that objects that it defines or imports can be used without qualification in the interactive session.
You can also change the prompts ``` sys.ps1 and sys.ps2 in this file. ``` If you want to read an additional start-up file from the current directory, you can program this in the global start-up file using code like if os.path.isfile('.pythonrc.py'): exec(open('.pythonrc.py'). ``` read()).
If you want to use the startup file in a script, you must do this explicitly in the script: import os filename = os.environ.get('PYTHONSTARTUP') if filename and os.path.isfile(filename): with open(filename) as fobj: startup_file = fobj.read() exec(startup_file) #### 16.1.4 The Customization Modules ``` Python...
To see how it works, you need first to find the location of your user site-packages directory.
Start Python and run this code: ``` >>> import site >>> site.getusersitepackages() '/home/user/.local/lib/python3.5/site-packages' ``` Now you can create a file named usercustomize.py in that directory and put anything you want in it.
It will affect every invocation of Python, unless it is started with the -s option to disable the automatic import. ``` sitecustomize works in the same way, but is typically created by an administrator of the computer in the ``` global site-packages directory, and is imported before usercustomize.
See the documentation of the site module for more details. ----- APPENDIX ### A GLOSSARY ``` >>> The default Python prompt of the interactive shell.
Often seen for code examples which can be executed ``` interactively in the interpreter. ``` ...
The default Python prompt of the interactive shell when entering code for an indented code block, when ``` within a pair of matching left and right delimiters (parentheses, square brackets, curly braces or triple quotes), or after specifying a decorator. **2to3 A tool that tries to convert Python 2.x code to Python 3...
See 2to3-reference. ``` abstract base class Abstract base classes complement duck-typing by providing a way to define interfaces when other techniques like hasattr() would be clumsy or subtly wrong (for example with magic methods).
ABCs introduce virtual subclasses, which are classes that don’t inherit from a class but are still recognized by isinstance() and issubclass(); see the abc module documentation.
Python comes with many built-in ABCs for data structures (in the collections.abc module), numbers (in the numbers module), streams (in the io module), import finders and loaders (in the importlib.abc module).
You can create your own ABCs with the abc module. annotation A label associated with a variable, a class attribute or a function parameter or return value, used by convention as a type hint. Annotations of local variables cannot be accessed at runtime, but annotations of global variables, class attributes, and fu...
There are two kinds of argument: - keyword argument: an argument preceded by an identifier (e.g. name=) in a function call or passed as a value in a dictionary preceded by .
For example, 3 and 5 are both keyword arguments in the following calls to complex(): ``` complex(real=3, imag=5) complex(**{'real': 3, 'imag': 5}) ``` - positional argument: an argument that is not a keyword argument.
Positional arguments can appear at the beginning of an argument list and/or be passed as elements of an iterable preceded by *.
For example, 3 and 5 are both positional arguments in the following calls: ----- Arguments are assigned to the named local variables in a function body.
See the calls section for the rules governing this assignment.
Syntactically, any expression can be used to represent an argument; the evaluated value is assigned to the local variable. See also the parameter glossary entry, the FAQ question on the difference between arguments and [parameters, and PEP 362.](https://www.python.org/dev/peps/pep-0362) **asynchronous context manager...
Introduced by PEP 492.](https://www.python.org/dev/peps/pep-0492) **asynchronous generator A function which returns an asynchronous generator iterator.
It looks like a** coroutine function defined with async def except that it contains yield expressions for producing a series of values usable in an async for loop. Usually refers to a asynchronous generator function, but may refer to an asynchronous generator _iterator in some contexts.
In cases where the intended meaning isn’t clear, using the full terms avoids_ ambiguity. An asynchronous generator function may contain await expressions as well as async for, and async ``` with statements. ``` asynchronous generator iterator An object created by a asynchronous generator function. This is an ...
When the asynchronous generator iterator effectively resumes [with another awaitable returned by __anext__(), it picks up where it left off.
See PEP 492 and PEP](https://www.python.org/dev/peps/pep-0492) [525.](https://www.python.org/dev/peps/pep-0525) **asynchronous iterable An object, that can be used in an async for statement.
Must return an asyn-** _[chronous iterator from its __aiter__() method.
Introduced by PEP 492.](https://www.python.org/dev/peps/pep-0492)_ asynchronous iterator An object that implements the __aiter__() and __anext__() methods. ``` __anext__ must return an awaitable object.
async for resolves the awaitables returned by an asyn ``` chronous iterator’s __anext__() method until it raises a StopAsyncIteration exception.
Introduced [by PEP 492.](https://www.python.org/dev/peps/pep-0492) **attribute A value associated with an object which is referenced by name using dotted expressions.
For example, if an object o has an attribute a it would be referenced as o.a. awaitable An object that can be used in an await expression.
Can be a coroutine or an object with an ``` __await__() method. See also PEP 492. ``` [BDFL Benevolent Dictator For Life, a.k.a.
Guido van Rossum, Python’s creator.](https://gvanrossum.github.io/) binary file A file object able to read and write bytes-like objects.
Examples of binary files are files opened in binary mode ('rb', 'wb' or 'rb+'), sys.stdin.buffer, sys.stdout.buffer, and instances of ``` io.BytesIO and gzip.GzipFile. ``` See also text file for a file object able to read and write str objects. bytes-like object An object that supports the bufferobjects and ca...
This** includes all bytes, bytearray, and array.array objects, as well as many common memoryview objects.
Bytes-like objects can be used for various operations that work with binary data; these include compression, saving to a binary file, and sending over a socket. Some operations need the binary data to be mutable.
The documentation often refers to these as “readwrite bytes-like objects”. Example mutable buffer objects include bytearray and a memoryview of a ``` bytearray.
Other operations require the binary data to be stored in immutable objects (“read-only ``` bytes-like objects”); examples of these include bytes and a memoryview of a bytes object. ----- bytecode Python source code is compiled into bytecode, the internal representation of a Python program in the CPython interpr...
The bytecode is also cached in .pyc files so that executing the same file is faster the second time (recompilation from source to bytecode can be avoided).
This “intermediate language” is said to run on a virtual machine that executes the machine code corresponding to each bytecode.
Do note that bytecodes are not expected to work between different Python virtual machines, nor to be stable between Python releases. A list of bytecode instructions can be found in the documentation for the dis module. **class A template for creating user-defined objects.
Class definitions normally contain method definitions which operate on instances of the class. class variable A variable defined in a class and intended to be modified only at class level (i.e., not in an instance of the class). coercion The implicit conversion of an instance of one type to another during an ...
For example, int(3.15) converts the floating point number to the integer 3, but in 3+4.5, each argument is of a different type (one int, one float), and both must be converted to the same type before they can be added or it will raise a TypeError.
Without coercion, all arguments of even compatible types would have to be normalized to the same value by the programmer, e.g., float(3)+4.5 rather than just 3+4.5. complex number An extension of the familiar real number system in which all numbers are expressed as a sum of a real part and an imaginary part.
Imaginary numbers are real multiples of the imaginary unit (the square root of -1), often written i in mathematics or j in engineering.
Python has built-in support for complex numbers, which are written with this latter notation; the imaginary part is written with a j suffix, e.g., 3+1j.
To get access to complex equivalents of the math module, use cmath. Use of complex numbers is a fairly advanced mathematical feature.
If you’re not aware of a need for them, it’s almost certain you can safely ignore them. context manager An object which controls the environment seen in a with statement by defining ``` __enter__() and __exit__() methods.
See PEP 343. ``` contiguous A buffer is considered contiguous exactly if it is either C-contiguous or Fortran contiguous. Zero-dimensional buffers are C and Fortran contiguous.
In one-dimensional arrays, the items must be laid out in memory next to each other, in order of increasing indexes starting from zero.
In multidimensional C-contiguous arrays, the last index varies the fastest when visiting items in order of memory address.
However, in Fortran contiguous arrays, the first index varies the fastest. **coroutine Coroutines is a more generalized form of subroutines.
Subroutines are entered at one point and** exited at another point. Coroutines can be entered, exited, and resumed at many different points. [They can be implemented with the async def statement.
See also PEP 492.](https://www.python.org/dev/peps/pep-0492) **coroutine function A function which returns a coroutine object.
A coroutine function may be defined** with the async def statement, and may contain await, async for, and async with keywords.
These [were introduced by PEP 492.](https://www.python.org/dev/peps/pep-0492) CPython The canonical implementation of the Python programming language, as distributed on [python.org.
The term “CPython” is used when necessary to distinguish this implementation from](https://www.python.org) others such as Jython or IronPython. decorator A function returning another function, usually applied as a function transformation using the ``` @wrapper syntax.
Common examples for decorators are classmethod() and staticmethod(). ``` The decorator syntax is merely syntactic sugar, the following two function definitions are semantically equivalent: ``` def f(...): ... f = staticmethod(f) ``` (continues on next page) ----- (continued from previous page) ``` @s...
See the documentation for function definitions and class definitions for more about decorators. **descriptor Any object which defines the methods __get__(), __set__(), or __delete__().
When a class** attribute is a descriptor, its special binding behavior is triggered upon attribute lookup.
Normally, using a.b to get, set or delete an attribute looks up the object named b in the class dictionary for a, but if b is a descriptor, the respective descriptor method gets called.
Understanding descriptors is a key to a deep understanding of Python because they are the basis for many features including functions, methods, properties, class methods, static methods, and reference to super classes. For more information about descriptors’ methods, see descriptors. **dictionary An associative array...

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.