pythonlings 0.3.0__py3-none-any.whl

pythonlings/docs/topics/exceptions.md

@@ -0,0 +1,96 @@
+# Exceptions
+
+Source: https://docs.python.org/3/tutorial/errors.html#handling-exceptions
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`try` and `except` handle errors without crashing the whole program.
+
+## Extracted reference
+
+8.3. Handling Exceptions
+
+It is possible to write programs that handle selected exceptions. Look at the
+following example, which asks the user for input until a valid integer has been
+entered, but allows the user to interrupt the program (using Control-C or
+whatever the operating system supports); note that a user-generated interruption
+is signalled by raising the `KeyboardInterrupt` exception.
+
+```python
+>>> while True:
+... try:
+... x = int(input("Please enter a number: "))
+... break
+... except ValueError:
+... print("Oops! That was no valid number. Try again...")
+...
+
+```
+
+The `try` statement works as follows.
+
+-
+
+First, the try clause (the statement(s) between the `try` and
+`except` keywords) is executed.
+
+-
+
+If no exception occurs, the except clause is skipped and execution of the
+`try` statement is finished.
+
+-
+
+If an exception occurs during execution of the `try` clause, the rest of the
+clause is skipped. Then, if its type matches the exception named after the
+`except` keyword, the except clause is executed, and then execution
+continues after the try/except block.
+
+-
+
+## More reference
+
+Source: https://docs.python.org/3/library/exceptions.html#concrete-exceptions
+
+Concrete built-in exceptions like ValueError, KeyError, and TypeError.
+
+Concrete exceptions
+
+The following exceptions are the exceptions that are usually raised.
+
+exception AssertionError
+
+Raised when an `assert` statement fails.
+
+exception AttributeError
+
+Raised when an attribute reference (see Attribute references) or
+assignment fails. (When an object does not support attribute references or
+attribute assignments at all, `TypeError` is raised.)
+
+The optional name and obj keyword-only arguments
+set the corresponding attributes:
+
+name
+
+The name of the attribute that was attempted to be accessed.
+
+obj
+
+The object that was accessed for the named attribute.
+
+Changed in version 3.10: Added the `name` and `obj` attributes.
+
+exception EOFError
+
+Raised when the `input()` function hits an end-of-file condition (EOF)
+without reading any data. (Note: the `io.TextIOBase.read()` and
+`io.IOBase.readline()` methods return an empty string when they hit EOF.)
+
+exception FloatingPointError
+
+Not currently used.
+
+exception GeneratorExit
+
+Raised when a generator or coroutine is closed;

pythonlings/docs/topics/file_io.md

@@ -0,0 +1,96 @@
+# File I/O
+
+Source: https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`open` and `with` are the usual tools for reading and writing files safely.
+
+## Extracted reference
+
+7.2. Reading and Writing Files
+
+`open()` returns a file object, and is most commonly used with
+two positional arguments and one keyword argument:
+`open(filename, mode, encoding=None)`
+
+```python
+>>> f = open('workfile', 'w', encoding="utf-8")
+
+```
+
+The first argument is a string containing the filename. The second argument is
+another string containing a few characters describing the way in which the file
+will be used. mode can be `'r'` when the file will only be read, `'w'`
+for only writing (an existing file with the same name will be erased), and
+`'a'` opens the file for appending; any data written to the file is
+automatically added to the end. `'r+'` opens the file for both reading and
+writing. The mode argument is optional; `'r'` will be assumed if it’s
+omitted.
+
+Normally, files are opened in text mode, that means, you read and write
+strings from and to the file, which are encoded in a specific encoding.
+If encoding is not specified, the default is platform dependent
+(see `open()`).
+Because UTF-8 is the modern de-facto standard, `encoding="utf-8"` is
+recommended unless you know that you need to use a different encoding.
+Appending a `'b'` to the mode opens the file in binary mode.
+Binary mode data is read and written as `bytes` objects.
+You can not specify encoding when opening file in binary mode.
+
+In text mode, the default when reading is to convert platform-specific line
+endings (`\n` on Unix, `\r\n` on Windows) to just `\n`. When writing in
+text mode, the default is to convert occurrences of `\n` back to
+platform-specific line endings. This behind-the-scenes modification
+to file data is fine for text files, but will corrupt binary data like that in
+`JPEG` or `EXE` files. Be very careful to use binary mode when
+reading and writing such files.
+
+It is good practice to use the `with` keyword when dealing
+with file objects. The advantage is that the file is properly closed
+
+## More reference
+
+Source: https://docs.python.org/3/library/io.html#high-level-module-interface
+
+The high-level `open()` interface and its modes.
+
+High-level Module Interface
+
+io.DEFAULT_BUFFER_SIZE
+
+An int containing the default buffer size used by the module’s buffered I/O
+classes. `open()` uses the file’s blksize (as obtained by
+`os.stat()`) if possible.
+
+io.open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
+
+This is an alias for the builtin `open()` function.
+
+This function raises an auditing event `open` with
+arguments path, mode and flags. The mode and flags
+arguments may have been modified or inferred from the original call.
+
+io.open_code(path)
+
+Opens the provided file with mode `'rb'`. This function should be used
+when the intent is to treat the contents as executable code.
+
+path should be a `str` and an absolute path.
+
+The behavior of this function may be overridden by an earlier call to the
+`PyFile_SetOpenCodeHook()`. However, assuming that path is a
+`str` and an absolute path, `open_code(path)` should always behave
+the same as `open(path, 'rb')`. Overriding the behavior is intended for
+additional validation or preprocessing of the file.
+
+Added in version 3.8.
+
+io.text_encoding(encoding, stacklevel=2, /)
+
+This is a helper function for callables that use `open()` or
+`TextIOWrapper` and have an `encoding=None` parameter.
+
+This function returns encoding if it is not `None`.
+Otherwise, it returns `"locale"` or `"utf-8"` depending on
+UTF-8 Mode.

pythonlings/docs/topics/functional.md

@@ -0,0 +1,96 @@
+# Functional Tools
+
+Source: https://docs.python.org/3/howto/functional.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Functional style uses functions, iterators, and transformations as building blocks.
+
+## Extracted reference
+
+Functional Programming HOWTO — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- Python HOWTOs »
+
+- Functional Programming HOWTO
+
+-
+
+|
+
+-
+
+Theme
+
+Auto
+
+## More reference
+
+Source: https://docs.python.org/3/library/itertools.html#itertool-functions
+
+itertools building blocks with signatures and usage patterns.
+
+Itertool Functions
+
+The following functions all construct and return iterators. Some provide
+streams of infinite length, so they should only be accessed by functions or
+loops that truncate the stream.
+
+itertools.accumulate(iterable[, function, *, initial=None])
+
+Make an iterator that returns accumulated sums or accumulated
+results from other binary functions.
+
+The function defaults to addition. The function should accept
+two arguments, an accumulated total and a value from the iterable.
+
+If an initial value is provided, the accumulation will start with
+that value and the output will have one more element than the input
+iterable.
+
+Roughly equivalent to:
+
+```python
+def accumulate(iterable, function=operator.add, *, initial=None):
+'Return running totals'
+# accumulate([1,2,3,4,5]) → 1 3 6 10 15
+# accumulate([1,2,3,4,5], initial=100) → 100 101 103 106 110 115
+# accumulate([1,2,3,4,5], operator.mul) → 1 2 6 24 120
+
+iterator = iter(iterable)
+total = initial
+if initial is None:
+try:
+total = next(iterator)
+except StopIteration:
+return
+
+yield total
+for element in iterator:
+total = function(total, element)
+yield total

pythonlings/docs/topics/functions.md

@@ -0,0 +1,97 @@
+# Functions
+
+Source: https://docs.python.org/3/tutorial/controlflow.html#defining-functions
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`def` creates reusable behavior with parameters, return values, and optional defaults.
+
+## Extracted reference
+
+4.8. Defining Functions
+
+We can create a function that writes the Fibonacci series to an arbitrary
+boundary:
+
+```python
+>>> def fib(n): # write Fibonacci series less than n
+... """Print a Fibonacci series less than n."""
+... a, b = 0, 1
+... while a < n:
+... print(a, end=' ')
+... a, b = b, a+b
+... print()
+...
+>>> # Now call the function we just defined:
+>>> fib(2000)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
+
+```
+
+The keyword `def` introduces a function definition. It must be
+followed by the function name and the parenthesized list of formal parameters.
+The statements that form the body of the function start at the next line, and
+must be indented.
+
+The first statement of the function body can optionally be a string literal;
+this string literal is the function’s documentation string, or docstring.
+(More about docstrings can be found in the section Documentation Strings.)
+There are tools which use docstrings to automatically produce online or printed
+documentation, or to let the user interactively browse through code; it’s good
+practice to include docstrings in code that you write, so make a habit of it.
+
+The execution of a function introduces a new symbol table used for the local
+variables of the function. More precisely, all variable assignments in a
+function store the value in the local symbol table; whereas variable references
+first look in the local symbol table, then in the local symbol tables of
+enclosing functions, then in the global symbol table, and finally in the table
+of built-in names. Thus, global variables and variables of enclosing functions
+cannot be directly assigned a value within a function (unless, for global
+variables, named in a `global` statement, or, for variables of enclosing
+
+## More reference
+
+Source: https://docs.python.org/3/reference/compound_stmts.html#function-definitions
+
+Function definition syntax including parameters, annotations, and decorators.
+
+8.7. Function definitions
+
+A function definition defines a user-defined function object (see section
+The standard type hierarchy):
+
+```python
+
+funcdef: [decorators] "def" funcname [type_params] "(" [parameter_list] ")"
+["->" expression] ":" suite
+decorators: decorator+
+decorator: "@" assignment_expression NEWLINE
+parameter_list: defparameter ("," defparameter)* "," "/" ["," [parameter_list_no_posonly]]
+| parameter_list_no_posonly
+parameter_list_no_posonly: defparameter ("," defparameter)* ["," [parameter_list_starargs]]
+| parameter_list_starargs
+parameter_list_starargs: "*" [star_parameter] ("," defparameter)* ["," [parameter_star_kwargs]]
+| "*" ("," defparameter)+ ["," [parameter_star_kwargs]]
+| parameter_star_kwargs
+parameter_star_kwargs: "**" parameter [","]
+parameter: identifier [":" expression]
+star_parameter: identifier [":" ["*"] expression]
+defparameter: parameter ["=" expression]
+funcname: identifier
+
+```
+
+A function definition is an executable statement. Its execution binds the
+function name in the current local namespace to a function object (a wrapper
+around the executable code for the function). This function object contains a
+reference to the current global namespace as the global namespace to be used
+when the function is called.
+
+The function definition does not execute the function body; this gets executed
+only when the function is called. [4]
+
+A function definition may be wrapped by one or more decorator expressions.
+Decorator expressions are evaluated when the function is defined, in the scope
+that contains the function definition. The result must be a callable, which is
+invoked with the function object as the only argument. The returned value is
+bound to the function name instead of the function object. Multiple decorators

pythonlings/docs/topics/generators.md

@@ -0,0 +1,97 @@
+# Generators
+
+Source: https://docs.python.org/3/tutorial/classes.html#generators
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Generators produce values lazily with `yield` instead of returning a whole collection.
+
+## Extracted reference
+
+9.9. Generators
+
+Generators are a simple and powerful tool for creating iterators. They
+are written like regular functions but use the `yield` statement
+whenever they want to return data. Each time `next()` is called on it, the
+generator resumes where it left off (it remembers all the data values and which
+statement was last executed). An example shows that generators can be trivially
+easy to create:
+
+```python
+def reverse(data):
+for index in range(len(data)-1, -1, -1):
+yield data[index]
+
+```
+
+```python
+>>> for char in reverse('golf'):
+... print(char)
+...
+f
+l
+o
+g
+
+```
+
+Anything that can be done with generators can also be done with class-based
+iterators as described in the previous section. What makes generators so
+compact is that the `__iter__()` and `__next__()` methods
+are created automatically.
+
+Another key feature is that the local variables and execution state are
+automatically saved between calls. This made the function easier to write and
+much more clear than an approach using instance variables like `self.index`
+and `self.data`.
+
+In addition to automatic method creation and saving program state, when
+generators terminate, they automatically raise `StopIteration`. In
+combination, these features make it easy to create iterators with no more effort
+
+## More reference
+
+Source: https://docs.python.org/3/reference/expressions.html#generator-expressions
+
+Generator expression syntax for compact lazy iterators.
+
+6.2.9. Generator expressions
+
+The syntax for generator expressions is the same as for
+list comprehensions, except that they are enclosed in
+parentheses instead of brackets.
+For example:
+
+```python
+>>> iterator = (x ** 2 for x in range(10))
+>>> iterator
+<generator object <genexpr> at ...>
+
+```
+
+At runtime, a generator expression evaluates to a generator iterator
+which yields the same values as the corresponding list comprehension:
+
+```python
+>>> list(iterator)
+[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+
+```
+
+Thus, the example above is roughly equivalent to defining and calling
+the following generator function:
+
+```python
+def make_generator_of_squares(iterator):
+for x in iterator:
+yield x ** 2
+
+make_generator_of_squares(iter(range(10)))
+
+```
+
+The enclosing parentheses can be omitted in calls when the generator
+expression is the only positional argument and there are no keyword
+arguments.
+See the Calls section for details.
+For example:

pythonlings/docs/topics/itertools.md

@@ -0,0 +1,96 @@
+# Itertools
+
+Source: https://docs.python.org/3/library/itertools.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`itertools` provides fast iterator building blocks for loops and data pipelines.
+
+## Extracted reference
+
+itertools — Functions creating iterators for efficient looping — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Functional Programming Modules »
+
+- `itertools` — Functions creating iterators for efficient looping
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/howto/functional.html#the-itertools-module
+
+The functional HOWTO's tour of itertools with examples.
+
+The itertools module
+
+The `itertools` module contains a number of commonly used iterators as well
+as functions for combining several iterators. This section will introduce the
+module’s contents by showing small examples.
+
+The module’s functions fall into a few broad classes:
+
+-
+
+Functions that create a new iterator based on an existing iterator.
+
+-
+
+Functions for treating an iterator’s elements as function arguments.
+
+-
+
+Functions for selecting portions of an iterator’s output.
+
+-
+
+A function for grouping an iterator’s output.
+
+Creating new iterators
+
+`itertools.count(start, step)` returns an infinite
+stream of evenly spaced values. You can optionally supply the starting number,
+which defaults to 0, and the interval between numbers, which defaults to 1:
+
+```python
+itertools.count() =>
+0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
+itertools.count(10) =>
+10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
+itertools.count(10, 5) =>
+10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...
+
+```

pythonlings/docs/topics/json.md

@@ -0,0 +1,97 @@
+# JSON
+
+Source: https://docs.python.org/3/library/json.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`json` converts between Python values and JSON text.
+
+## Extracted reference
+
+json — JSON encoder and decoder — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Internet Data Handling »
+
+- `json` — JSON encoder and decoder
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/tutorial/inputoutput.html#saving-structured-data-with-json
+
+Tutorial on saving and loading structured data as JSON.
+
+7.2.2. Saving structured data with `json`
+
+Strings can easily be written to and read from a file. Numbers take a bit more
+effort, since the `read()` method only returns strings, which will have to
+be passed to a function like `int()`, which takes a string like `'123'`
+and returns its numeric value 123. When you want to save more complex data
+types like nested lists and dictionaries, parsing and serializing by hand
+becomes complicated.
+
+Rather than having users constantly writing and debugging code to save
+complicated data types to files, Python allows you to use the popular data
+interchange format called JSON (JavaScript Object Notation). The standard module called `json` can take Python
+data hierarchies, and convert them to string representations; this process is
+called serializing. Reconstructing the data from the string representation
+is called deserializing. Between serializing and deserializing, the
+string representing the object may have been stored in a file or data, or
+sent over a network connection to some distant machine.
+
+Note
+
+The JSON format is commonly used by modern applications to allow for data
+exchange. Many programmers are already familiar with it, which makes
+it a good choice for interoperability.
+
+If you have an object `x`, you can view its JSON string representation with a
+simple line of code:
+
+```python
+>>> import json
+>>> x = [1, 'simple', 'list']
+>>> json.dumps(x)
+'[1, "simple", "list"]'
+
+```
+
+Another variant of the `dumps()` function, called `dump()`,
+simply serializes the object to a text file. So if `f` is a
+text file object opened for writing, we can do this:
+
+```python