<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Barlow:ital,wght@0,100;0,200;0,300;0,400;0,500;0,600;0,700;0,800;0,900;1,100;1,200;1,300;1,400;1,500;1,600;1,700;1,800;1,900&family=Noto+Sans:ital,wght@0,100..900;1,100..900&family=Quicksand:wght@300..700&display=swap" rel="stylesheet">
<title>Python documentation</title>
<link href="styles.css" rel="stylesheet">
</head>
<body>
<nav id="navbar">
<header id="zag_nav"><span><img src="https://www.svgrepo.com/show/376344/python.svg" alt="py icon"></span>Python</header>
<ul class="navchik">
<li><a class="nav-link" href="#Introduction">Introduction</a></li>
<li><a class="nav-link" href="#objects_values_and_types">Objects values and types</a></li>
<li><a class="nav-link" href="#Arithmetic_conversions">Arithmetic conversions</a></li>
<li><a class="nav-link" href="#Parenthesized_forms">Parenthesized forms</a></li>
<li><a class="nav-link" href="#Importlib">Importlib</a></li>
<li><a class="nav-link" href="#Searching">Searching</a></li>
<li><a class="nav-link" href="#Structure_of_a_programm">Structure of a programm</li>
<li><a class="nav-link" href="#Class_objects">Class Objects</a></li>
<li><a class="nav-link" href="#The_with_statement">The with statement</a></li>
</ul>
</nav>
<main id="main-doc">
<section class="main-section" id='Introduction'>
<header id="intro">Introduction</header>
<p>Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse. The Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed. </p>
</section>
<section class="main-section" id="objects_values_and_types">
<header id="obj">Objects values and types</header>
<p><em>Objects</em> are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects. (In a sense, and in conformance to Von Neumann’s model of a “stored program computer,” code is also represented by objects.)</p>
<p>
Every object has an identity, a type and a value. An object’s <em>identity</em> never changes once it has been created; you may think of it as the object’s address in memory. The ‘is‘ operator compares the identity of two objects; the <code id="in">id()</code> function returns an integer representing its identity (currently implemented as its address). An object’s type is also unchangeable. An object’s type determines the operations that the object supports (e.g., “does it have a length?”) and also defines the possible values for objects of that type. The <code id="in">type()</code> function returns an object’s type (which is an object itself). The value of some objects can change. Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable. (The value of an immutable container object that contains a reference to a mutable object can change when the latter’s value is changed; however the container is still considered immutable, because the collection of objects it contains cannot be changed. So, immutability is not strictly the same as having an unchangeable value, it is more subtle.) An object’s mutability is determined by its type; for instance, numbers, strings and tuples are immutable, while dictionaries and lists are mutable.</p>
<p>Objects are never explicitly destroyed; however, when they become unreachable they may be garbage-collected. An implementation is allowed to postpone garbage collection or omit it altogether — it is a matter of implementation quality how garbage collection is implemented, as long as no objects are collected that are still reachable. (Implementation note: the current implementation uses a reference-counting scheme with (optional) delayed detection of cyclically linked garbage, which collects most objects as soon as they become unreachable, but is not guaranteed to collect garbage containing circular references. See the documentation of the gc module for information on controlling the collection of cyclic garbage.)</p>
<p>Note that the use of the implementation’s tracing or debugging facilities may keep objects alive that would normally be collectable. Also note that catching an exception with a ‘try...except‘ statement may keep objects alive.</p>
<p>Some objects contain references to “external” resources such as open files or windows. It is understood that these resources are freed when the object is garbage-collected, but since garbage collection is not guaranteed to happen, such objects also provide an explicit way to release the external resource, usually a <code id="in">close()</code> method. Programs are strongly recommended to explicitly close such objects. The‘try...finally‘ statement and the ‘with‘ statement provide convenient ways to do this.</p>
</section>
<section class="main-section" id="Arithmetic_conversions">
<header id="arith">Arithmetic conversions</header>
<p>When a description of an arithmetic operator below uses the phrase “the numeric arguments are converted to a common type,” this means that the operator implementation for built-in types works that way:</p>
<ul>
<li>
If either argument is a complex number, the other is converted to complex;</li>
<li>
otherwise, if either argument is a floating point number, the other is converted to floating point;</li>
<li>otherwise, both must be integers and no conversion is necessary.</li>
</ul>
<p>
Some additional rules apply for certain operators (e.g., a string left argument to the ‘%’ operator). Extensions must define their own conversion behavior.</p>
</section>
<section class="main-section" id="Parenthesized_forms">
<header id="par_form">Parenthesized forms</header>
<p>A parenthesized form is an optional expression list enclosed in parentheses:</p>
<p><code>parenth_form ::= "(" [expression_list] ")"</code></p>
</section>
<section class="main-section" id="Importlib">
<header id="imp">Importlib</header>
<p>The importlib module provides a rich API for interacting with the import system. For example importlib.import_module() provides a recommended, simpler API than built-in __import__() for invoking the import machinery. Refer to the importlib library documentation for additional detail.</p>
</section>
<section class="main-section" id="Searching">
<header id="search">Searching</header>
<p>To begin the search, Python needs the fully qualified name of the module (or package, but for the purposes of this discussion, the difference is immaterial) being imported. This name may come from various arguments to the import statement, or from the parameters to the importlib.import_module() or __import__() functions.</p>
<p>This name will be used in various phases of the import search, and it may be the dotted path to a submodule, e.g. foo.bar.baz. In this case, Python first tries to import foo, then foo.bar, and finally foo.bar.baz. If any of the intermediate imports fail, a ModuleNotFoundError is raised.</p>
</section>
<section class="main-section" id="Structure_of_a_programm">
<header id="structure">Structure of a programm</header>
<p>A Python program is constructed from code blocks. A block is a piece of Python program text that is executed as a unit. The following are blocks: a module, a function body, and a class definition. Each command typed interactively is a block. A script file (a file given as standard input to the interpreter or specified as a
2 command line argument to the interpreter) is a code block. A script command (a command specified on the interpreter command line with the -c option) is a code block. A module run as a top level script (as module __main__) from the command line using a -m argument is also a code block. The string argument passed to the built-in functions eval() and exec() is a code block.</p>
<p>A code block is executed in an execution frame. A frame contains some administrative information (used for debugging) and determines where and how execution continues after the code block’s execution has completed.</p>
</section>
<section class="main-section" id="Class_objects">
<header id="classobj">Class objects</header>
<p>Class objects support two kinds of operations: attribute references and instantiation.</p>
<p><em>Attribute references</em> use the standard syntax used for all attribute references in Python: <code id="in">obj.name </code><br> Valid attribute names are all the names that were in the class’s namespace when the class object was created. So, if the class definition looked like this:</p>
<div><code>class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'</code></div>
</section>
<section class="main-section" id="The_with_statement">
<header id="with_statement">The <a href="https://docs.python.org/release/3.0/reference/compound_stmts.html#with">with</a> statement</header>
<p>The <a href="https://docs.python.org/release/3.0/reference/compound_stmts.html#with">with</a> statement is used to wrap the execution of a block with methods defined by a context manager (see section With Statement Context Managers). This allows common try...except...finally usage patterns to be encapsulated for convenient reuse.</p>
<p><code>with_stmt ::= "with" expression ["as" target] ":" suite</code></p>
<p>The execution of the with statement proceeds as follows:</p>
<ol>
<li>The context expression is evaluated to obtain a context manager.</li>
<li>The context manager’s __enter__() method is invoked.</li>
<li>If a target was included in the with statement, the return value from __enter__() is assigned to it.</li>
<li>The suite is executed.</li>
<li>The context manager’s __exit__() method is invoked. If an exception caused the suite to be exited, its type, value, and traceback are passed as arguments to __exit__(). Otherwise, three None arguments are supplied.</li>
</ol>
</section>
</main>
</body>
</html>Hi there and welcome to our community!
One of your anchor elements is missing a closing tag. Fix that and the test will pass.
1 Like
jesus man, couldn’t find that for hours, thank you very much!
1 Like