pythonlings 0.3.0__py3-none-any.whl

pythonlings/docs/topics/lists.md

@@ -0,0 +1,97 @@
+# Lists
+
+Source: https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Lists are mutable ordered collections with methods such as `append`, `pop`, and `sort`.
+
+## Extracted reference
+
+5.1. More on Lists
+
+The list data type has some more methods. Here are all
+of the methods of list objects:
+
+list.append(value, /)
+
+Add an item to the end of the list. Similar to `a[len(a):] = [x]`.
+
+list.extend(iterable, /)
+
+Extend the list by appending all the items from the iterable. Similar to
+`a[len(a):] = iterable`.
+
+list.insert(index, value, /)
+
+Insert an item at a given position. The first argument is the index of the
+element before which to insert, so `a.insert(0, x)` inserts at the front of
+the list, and `a.insert(len(a), x)` is equivalent to `a.append(x)`.
+
+list.remove(value, /)
+
+Remove the first item from the list whose value is equal to value. It raises a
+`ValueError` if there is no such item.
+
+list.pop(index=-1, /)
+
+Remove the item at the given position in the list, and return it. If no index
+is specified, `a.pop()` removes and returns the last item in the list.
+It raises an `IndexError` if the list is empty or the index is
+outside the list range.
+
+list.clear()
+
+Remove all items from the list. Similar to `del a[:]`.
+
+list.index(value[, start[, stop]])
+
+Return zero-based index of the first occurrence of value in the list.
+Raises a `ValueError` if there is no such item.
+
+## More reference
+
+Source: https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range
+
+Sequence types reference with list methods, operations, and type tables.
+
+Sequence Types — `list`, `tuple`, `range`
+
+There are three basic sequence types: lists, tuples, and range objects.
+Additional sequence types tailored for processing of
+binary data and text strings are
+described in dedicated sections.
+
+Common Sequence Operations
+
+The operations in the following table are supported by most sequence types,
+both mutable and immutable. The `collections.abc.Sequence` ABC is
+provided to make it easier to correctly implement these operations on
+custom sequence types.
+
+This table lists the sequence operations sorted in ascending priority. In the
+table, s and t are sequences of the same type, n, i, j and k are
+integers and x is an arbitrary object that meets any type and value
+restrictions imposed by s.
+
+The `in` and `not in` operations have the same priorities as the
+comparison operations. The `+` (concatenation) and `*` (repetition)
+operations have the same priority as the corresponding numeric operations. [3]
+
+Operation
+
+Result
+
+Notes
+
+`x in s`
+
+`True` if an item of s is
+equal to x, else `False`
+
+(1)
+
+`x not in s`
+
+`False` if an item of s is
+equal to x, else `True`

pythonlings/docs/topics/loops.md

@@ -0,0 +1,95 @@
+# Loops
+
+Source: https://docs.python.org/3/tutorial/controlflow.html#for-statements
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`for` loops iterate over items; `while` loops continue while a condition is true.
+
+## Extracted reference
+
+4.2. `for` Statements
+
+The `for` statement in Python differs a bit from what you may be used
+to in C or Pascal. Rather than always iterating over an arithmetic progression
+of numbers (like in Pascal), or giving the user the ability to define both the
+iteration step and halting condition (as C), Python’s `for` statement
+iterates over the items of any sequence (a list or a string), in the order that
+they appear in the sequence. For example (no pun intended):
+
+```python
+>>> # Measure some strings:
+>>> words = ['cat', 'window', 'defenestrate']
+>>> for w in words:
+... print(w, len(w))
+...
+cat 3
+window 6
+defenestrate 12
+
+```
+
+Code that modifies a collection while iterating over that same collection can
+be tricky to get right. Instead, it is usually more straight-forward to loop
+over a copy of the collection or to create a new collection:
+
+```python
+# Create a sample collection
+users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}
+
+# Strategy: Iterate over a copy
+for user, status in users.copy().items():
+if status == 'inactive':
+del users[user]
+
+# Strategy: Create a new collection
+active_users = {}
+for user, status in users.items():
+if status == 'active':
+active_users[user] = status
+
+## More reference
+
+Source: https://docs.python.org/3/reference/compound_stmts.html#the-for-statement
+
+Formal for-statement syntax and iteration semantics.
+
+8.3. The `for` statement
+
+The `for` statement is used to iterate over the elements of a sequence
+(such as a string, tuple or list) or other iterable object:
+
+```python
+
+for_stmt: "for" target_list "in" starred_expression_list ":" suite
+["else" ":" suite]
+
+```
+
+The `starred_expression_list` expression is evaluated
+once; it should yield an iterable object. An iterator is
+created for that iterable. The first item provided by the iterator is then
+assigned to the target list using the standard rules for assignments
+(see Assignment statements), and the suite is executed. This repeats for each
+item provided by the iterator. When the iterator is exhausted,
+the suite in the `else` clause,
+if present, is executed, and the loop terminates.
+
+A `break` statement executed in the first suite terminates the loop
+without executing the `else` clause’s suite. A `continue`
+statement executed in the first suite skips the rest of the suite and continues
+with the next item, or with the `else` clause if there is no next
+item.
+
+The for-loop makes assignments to the variables in the target list.
+This overwrites all previous assignments to those variables including
+those made in the suite of the for-loop:
+
+```python
+for i in range(10):
+print(i)
+i = 5 # this will not affect the for-loop
+# because i will be overwritten with the next
+# index in the range
+
+```

pythonlings/docs/topics/modules.md

@@ -0,0 +1,97 @@
+# Modules
+
+Source: https://docs.python.org/3/tutorial/modules.html#modules
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Modules organize Python code into importable files and packages.
+
+## Extracted reference
+
+6. Modules
+
+If you quit from the Python interpreter and enter it again, the definitions you
+have made (functions and variables) are lost. Therefore, if you want to write a
+somewhat longer program, you are better off using a text editor to prepare the
+input for the interpreter and running it with that file as input instead. This
+is known as creating a script. As your program gets longer, you may want to
+split it into several files for easier maintenance. You may also want to use a
+handy function that you’ve written in several programs without copying its
+definition into each program.
+
+To support this, Python has a way to put definitions in a file and use them in a
+script or in an interactive instance of the interpreter. Such a file is called a
+module; definitions from a module can be imported into other modules or into
+the main module (the collection of variables that you have access to in a
+script executed at the top level and in calculator mode).
+
+A module is a file containing Python definitions and statements. The file name
+is the module name with the suffix `.py` appended. Within a module, the
+module’s name (as a string) is available as the value of the global variable
+`__name__`. For instance, use your favorite text editor to create a file
+called `fibo.py` in the current directory with the following contents:
+
+```python
+# Fibonacci numbers module
+
+def fib(n):
+"""Write Fibonacci series up to n."""
+a, b = 0, 1
+while a < n:
+print(a, end=' ')
+a, b = b, a+b
+print()
+
+def fib2(n):
+"""Return Fibonacci series up to n."""
+result = []
+a, b = 0, 1
+while a < n:
+result.append(a)
+
+## More reference
+
+Source: https://docs.python.org/3/library/importlib.html#importlib.reload
+
+Reloading and dynamically importing modules with importlib.
+
+importlib.reload(module)
+
+Reload a previously imported module. The argument must be a module object,
+so it must have been successfully imported before. This is useful if you
+have edited the module source file using an external editor and want to try
+out the new version without leaving the Python interpreter. The return value
+is the module object (which can be different if re-importing causes a
+different object to be placed in `sys.modules`).
+
+When `reload()` is executed:
+
+-
+
+Python module’s code is recompiled and the module-level code re-executed,
+defining a new set of objects which are bound to names in the module’s
+dictionary by reusing the loader which originally loaded the
+module. The `init` function of extension modules is not called a second
+time.
+
+-
+
+As with all other objects in Python the old objects are only reclaimed
+after their reference counts drop to zero.
+
+-
+
+The names in the module namespace are updated to point to any new or
+changed objects.
+
+-
+
+Other references to the old objects (such as names external to the module) are
+not rebound to refer to the new objects and must be updated in each namespace
+where they occur if that is desired.
+
+There are a number of other caveats:
+
+When a module is reloaded, its dictionary (containing the module’s global
+variables) is retained. Redefinitions of names will override the old
+definitions, so this is generally not a problem. If the new version of a

pythonlings/docs/topics/oop_advanced.md

@@ -0,0 +1,71 @@
+# Advanced OOP
+
+Source: https://docs.python.org/3/tutorial/classes.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+Advanced class patterns build on attributes, methods, inheritance, and special methods.
+
+## Extracted reference
+
+9. Classes — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Tutorial »
+
+- 9. Classes
+
+-
+
+|
+
+-
+
+Theme
+
+Auto
+
+## More reference
+
+Source: https://docs.python.org/3/reference/datamodel.html#object.__repr__
+
+`__repr__` and `__str__` for custom object representations.
+
+object.__repr__(self)
+
+Called by the `repr()` built-in function to compute the “official” string
+representation of an object. If at all possible, this should look like a
+valid Python expression that could be used to recreate an object with the
+same value (given an appropriate environment). If this is not possible, a
+string of the form `<...some useful description...>` should be returned.
+The return value must be a string object. If a class defines `__repr__()`
+but not `__str__()`, then `__repr__()` is also used when an
+“informal” string representation of instances of that class is required.
+
+This is typically used for debugging, so it is important that the representation
+is information-rich and unambiguous. A default implementation is provided by the
+`object` class itself.

pythonlings/docs/topics/pathlib.md

@@ -0,0 +1,79 @@
+# Pathlib
+
+Source: https://docs.python.org/3/library/pathlib.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+`pathlib.Path` represents filesystem paths with object-oriented helpers.
+
+## Extracted reference
+
+pathlib — Object-oriented filesystem paths — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- File and Directory Access »
+
+- `pathlib` — Object-oriented filesystem paths
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/library/pathlib.html#pathlib.Path.mkdir
+
+`Path.mkdir` creates directories with parents/exist_ok options.
+
+Path.mkdir(mode=0o777, parents=False, exist_ok=False)
+
+Create a new directory at this given path. If mode is given, it is
+combined with the process’s `umask` value to determine the file mode
+and access flags. If the path already exists, `FileExistsError`
+is raised.
+
+If parents is true, any missing parents of this path are created
+as needed; they are created with the default permissions without taking
+mode into account (mimicking the POSIX `mkdir -p` command).
+
+If parents is false (the default), a missing parent raises
+`FileNotFoundError`.
+
+If exist_ok is false (the default), `FileExistsError` is
+raised if the target directory already exists.
+
+If exist_ok is true, `FileExistsError` will not be raised unless the given
+path already exists in the file system and is not a directory (same
+behavior as the POSIX `mkdir -p` command).
+
+Changed in version 3.5: The exist_ok parameter was added.

pythonlings/docs/topics/recursion.md

@@ -0,0 +1,73 @@
+# Recursion
+
+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.
+
+Recursive functions solve a problem by calling themselves on smaller inputs.
+
+## 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/library/sys.html#sys.setrecursionlimit
+
+Adjusting the interpreter's recursion limit with `sys.setrecursionlimit`.
+
+sys.setrecursionlimit(limit)
+
+Set the maximum depth of the Python interpreter stack to limit. This limit
+prevents infinite recursion from causing an overflow of the C stack and crashing
+Python.
+
+The highest possible limit is platform-dependent. A user may need to set the
+limit higher when they have a program that requires deep recursion and a platform
+that supports a higher limit. This should be done with care, because a too-high
+limit can lead to a crash.
+
+If the new limit is too low at the current recursion depth, a
+`RecursionError` exception is raised.
+
+Changed in version 3.5.1: A `RecursionError` exception is now raised if the new limit is too
+low at the current recursion depth.

pythonlings/docs/topics/regex.md

@@ -0,0 +1,96 @@
+# Regular Expressions
+
+Source: https://docs.python.org/3/library/re.html
+
+This local reference is generated from the official Python documentation and trimmed for pythonlings.
+
+The `re` module searches, matches, and transforms text using regular expressions.
+
+## Extracted reference
+
+re — Regular expression operations — Python 3.14.6 documentation
+
+Navigation
+
+-
+index
+
+-
+modules |
+
+-
+next |
+
+-
+previous |
+
+-
+
+- Python »
+
+-
+
+-
+
+-
+3.14.6 Documentation »
+
+- The Python Standard Library »
+
+- Text Processing Services »
+
+- `re` — Regular expression operations
+
+-
+
+|
+
+-
+
+Theme
+
+## More reference
+
+Source: https://docs.python.org/3/howto/regex.html#search-and-replace
+
+Practical search-and-replace patterns from the regex HOWTO.
+
+Search and replace
+
+Another common task is to find all the matches for a pattern, and replace them
+with a different string. The `sub()` method takes a replacement value,
+which can be either a string or a function, and the string to be processed.
+
+.sub(replacement, string[, count=0])
+
+Returns the string obtained by replacing the leftmost non-overlapping
+occurrences of the RE in string by the replacement replacement. If the
+pattern isn’t found, string is returned unchanged.
+
+The optional argument count is the maximum number of pattern occurrences to be
+replaced; count must be a non-negative integer. The default value of 0 means
+to replace all occurrences.
+
+Here’s a simple example of using the `sub()` method. It replaces colour
+names with the word `colour`:
+
+```python
+>>> p = re.compile('(blue|white|red)')
+>>> p.sub('colour', 'blue socks and red shoes')
+'colour socks and colour shoes'
+>>> p.sub('colour', 'blue socks and red shoes', count=1)
+'colour socks and red shoes'
+
+```
+
+The `subn()` method does the same work, but returns a 2-tuple containing the
+new string value and the number of replacements that were performed:
+
+```python
+>>> p = re.compile('(blue|white|red)')
+>>> p.subn('colour', 'blue socks and red shoes')
+('colour socks and colour shoes', 2)
+>>> p.subn('colour', 'no colours at all')
+('no colours at all', 0)
+
+```