Here is the buggy program:

python 1 / 0 print() = None if False ñ = "hello

Each line of code generates a different error message:

• 1 / 0 will generate ZeroDivisionError: division by zero.
• print() = None will generate SyntaxError: cannot assign to function call.
• if False will generate SyntaxError: expected ':'.
• ñ = "hello will generate SyntaxError: EOL while scanning string literal.

The question is… which will be reported first?

Spoilers: the specific version of Python matters (more than I thought it would) so keep that in mind if you see different results.

In this article you started implementing your own version of Python. To do so, you needed to create four main components:

A tokenizer: * accepts strings as input (supposedly, source code); * chunks the input into atomic pieces called tokens; * produces tokens regardless of their sequence making sense or not.

A parser: * accepts tokens as input; * consumes the tokens one at a time, while making sense they come in an order that makes sense; * produces a tree that represents the syntax of the original code.

A compiler: * accepts a tree as input; * traverses the tree to produce bytecode operations.

An interpreter: * accepts bytecode as input; * traverses the bytecode and performs the operation that each one represents; * uses a stack to help with the computations.

``` from .compiler import Bytecode, BytecodeType

...

class Interpreter: def init(self, bytecode: list[Bytecode]) -> None: self.stack = Stack() self.bytecode = bytecode self.ptr: int = 0

def interpret(self) -> None:
    for bc in self.bytecode:
        # Interpret this bytecode operator.
        if bc.type == BytecodeType.PUSH:
            self.stack.push(bc.value)
        elif bc.type == BytecodeType.BINOP:
            right = self.stack.pop()
            left = self.stack.pop()
            if bc.value == "+":
                result = left + right
            elif bc.value == "-":
                result = left - right
            else:
                raise RuntimeError(f"Unknown operator {bc.value}.")
            self.stack.push(result)

    print("Done!")
    print(self.stack)

```

It's an abstract syntax tree because it is a tree representation that doesn't care about the original syntax we used to write the operation. It only cares about the operations we are going to perform.

The tokenizer is the part of your program that accepts the source code and produces a linear sequence of tokens – bits of source code that you identify as being relevant.

• Tokenizer takes source code as input and produces tokens;
• Parser takes tokens as input and produces an AST;
• Compiler takes an AST as input and produces bytecode;
• Interpreter takes bytecode as input and produces program results.

``` import _xxsubinterpreters as interpreters import _xxinterpchannels as channels

interp_id = interpreters.create(site=site) channel_id = channels.create()

interpreters.run_string( interp_id, """ import _xxinterpchannels as channels channels.send('hello!') """, shared={ "channel_id": channel_id } )

print(channels.recv(channel_id)) ```

``` import _xxsubinterpreters as interpreters

interp_id = interpreters.create(site=site)

interpreters.run_string( interp_id, "print(message)", shared={ "message": "hello world!" } )

interpreters.run_string( interp_id, """ for message in messages: print(message) """, shared={ "messages": ("hello world!", "this", "is", "me") } )

interpreters.destroy(interp_id) ```

``` import _xxsubinterpreters as interpreters

interp_id = interpreters.create(site=site)

interpreters.run_string(interp_id, "print('hello world')") interpreters.run_string(interp_id, "print('hello universe')")

interpreters.destroy(interp_id) ```

``` from threading import Thread import _xxsubinterpreters as interpreters

t = Thread(target=interpreters.run, args=("print('hello world')",)) t.start() ```

``` import _xxsubinterpreters as interpreters

interpreters.run(''' print("Hello World") ''') ```

Whether using sub interpreters or multiprocessing you cannot simply send existing Python objects to worker processes.

Multiprocessing uses pickle by default. When you start a process or use a process pool, you can use pipes, queues and shared memory as mechanisms to sending data to/from the workers and the main process. These mechanisms revolve around pickling. Pickling is the builtin serialization library for Python that can convert most Python objects into a byte string and back into a Python object.

Pickle is very flexible. You can serialize a lot of different types of Python objects (but not all) and Python objects can even define a method for how they can be serialized. It also handles nested objects and properties. However, with that flexibility comes a performance hit. Pickle is slow. So if you have a worker model that relies upon continuous inter-worker communication of complex pickled data you’ll likely see a bottleneck.

Sub interpreters can accept pickled data. They also have a second mechanism called shared data. Shared data is a high-speed shared memory space that interpreters can write to and share data with other interpreters. It supports only immutable types, those are:

• Strings
• Byte Strings
• Integers and Floats
• Boolean and None
• Tuples (and tuples of tuples)

To share data with an interpreter, you can either set it as initialization data or you can send it through a channel.

Once you get over the hurdle of starting one, this quickly becomes the most important point. You have two questions to answer:

• How do we communicate between workers?
• How do we manage the state of workers?

For example, you can import something in your module and reference it from inside the thread function:

```python import threading from super.duper.module import cool_function

def worker(info): # This already exists in the interpreter state cool_function()

info = {'a': 1} thread = Thread(target=worker, args=(info, )) ```

The Python standard library has a few options for concurrent programming, depending on some factors:

• Is the task you’re completing IO-bound (e.g. reading from a network, writing to disk)
• Does the task require CPU-heavy work, e.g. computation
• Can the tasks be broken into small chunks or are they large pieces of work?

Here are the models:

• Threads are fast to create, you can share any Python objects between them and have a small overhead. Their drawback is that Python threads are bound to the GIL of the process, so if the workload is CPU-intensive then you won’t see any performance gains. Threading is very useful for background, polling tasks like a function that waits and listens for a message on a queue.
• Coroutines are extremely fast to create, you can share any Python objects between them and have a miniscule overhead. Coroutines are ideal for IO-based activity that has an underlying API that supports async/await.
• Multiprocessing is a Python wrapper that creates Python processes and links them together. These processes are slow to start, so the workload that you give them needs to be large enough to see the benefit of parallelising the workload. However, they are truly parallel since each one has it’s own GIL.
• Sub interpreters have the parallelism of multiprocessing, but with a much faster startup time.

Tested it on my side, and poetry install of one Python project took 44 seconds instead of 2 minutes 53 seconds, so it's nearly a 4x speed increase!

This is WRONG.

numpy.any() checks if there is at least one non-zero element in an array.

In simpler terms, Sutherland's thesis is discussing the basic operations of a data structure known as a ring. A ring is a type of list where the elements are connected in a circular manner. The operations he mentions are:

1. Inserting a new element into the ring at a specified location.
2. Removing an element from the ring.
3. Moving all elements of one ring, in order, into another ring at a specified location.
4. Performing an operation on each member of a ring in either forward or reverse order.

These operations are implemented using macro instructions in the compiler language. A macro instruction is a directive to the compiler which specifies how an input pattern should be mapped to an output pattern.

The thesis also discusses the generation of new elements. Subroutines are used to set up new elements in free spaces in the storage structure. When parts of the drawing are deleted, the registers representing them become free and are placed in a 'FREES' ring. New components are set up at the end of the storage area, while free blocks are allowed to accumulate. A process called 'garbage collection' periodically compacts the storage structure by removing the free blocks and relocating the information above them.

In Python, the ring data structure can be implemented using a doubly linked list. Here's a simple example:

```python class Node: def init(self, data): self.data = data self.next = None self.prev = None

class Ring: def init(self): self.head = None

def append(self, data):
    if not self.head:
        self.head = Node(data)
        self.head.next = self.head
        self.head.prev = self.head
    else:
        new_node = Node(data)
        new_node.prev = self.head.prev
        new_node.next = self.head
        self.head.prev.next = new_node
        self.head.prev = new_node

def display(self):
    temp = self.head
    while True:
        print(temp.data, end = " ")
        temp = temp.next
        if temp == self.head:
            break

```

In this example, the Node class represents an element in the ring, and the Ring class represents the ring itself. The append method is used to add a new element to the ring, and the display method is used to print all elements in the ring.

Ivan writes about a concept called "Ring Structure". This is a way of organizing and linking different elements or components in a system.

In simpler terms, imagine you have a bunch of different objects (like points and lines in a drawing program like Sketchpad). You want to keep track of how these objects are related to each other. For example, you might want to know all the lines that end at a particular point.

To do this, Ivan uses a "ring structure". Each object has a "string of pointers" - basically a list of references to other objects. This list is circular - the last item in the list points back to the first item. This makes it easy to move forwards and backwards through the list.

Each object has two "registers" or slots for keeping track of these relationships. One slot is for the object itself, and the other is for the list of related objects.

Ivan uses the terms "hen" and "chicken" to describe these slots. The "hen" is the object itself, and the "chicken" is the list of related objects.

Here's a simple Python code example to illustrate this concept:

```python class Point: def init(self): self.hen = self self.chickens = []

class Line: def init(self, point1, point2): self.hen = self self.chickens = [point1, point2] point1.chickens.append(self) point2.chickens.append(self) ```

In this example, a Point object has a hen that refers to itself and a list of chickens that will contain any Line objects that end at this point. When a Line is created, it adds itself to the chickens list of its end points.

The "ring structure" is a way to organize and link different elements in a system, making it easier to find and update related elements.

Mnemonics for Registers: Instead of remembering numerical indices, we use human-readable keys.

python point = {'TYPE': 'Point', 'PVAL_X': 5, 'PVAL_Y': 10}

Flexibility: If we want to change the internal structure, we can easily do so by changing the keys.

```python

Changing 'PVAL_X' to 'X_COORD'

point = {'TYPE': 'Point', 'X_COORD': 5, 'PVAL_Y': 10} ```

Conventions:

• The first component ('TYPE') indicates the type of element.
• Numerical information like coordinates is stored at the end.

python line = {'TYPE': 'Line', 'START': 'point1', 'END': 'point2', 'LENGTH': 7.2}

Pointers and Topology: We can use pointers (references) to other elements to establish relationships.

python point1 = {'TYPE': 'Point', 'PVAL_X': 1, 'PVAL_Y': 1} point2 = {'TYPE': 'Point', 'PVAL_X': 4, 'PVAL_Y': 5} line = {'TYPE': 'Line', 'START': point1, 'END': point2}

Relocation: If we move point1 to a new variable, we update the pointer in line.

python new_point1 = point1 # Relocating point1 to new_point1 line['START'] = new_point1 # Updating the pointer

Segregation of Data: Numerical data is at the end, so if we need to move elements, the numerical data remains untouched.

```python

Even if we relocate, the numerical data ('PVAL_X' and 'PVAL_Y') remains the same.

```

This section provides a step-by-step guide on setting up PyCharm for automated testing using the 'Pytest Web Framework'.

Use poetry init to create a sample pyproject.toml, and then trigger this line to export requirements.txt into a pyproject.toml

Slices follow a similar logic than indexing in NumPy array's. array[:2] selects a range of elements along a single axis,, but array[:2, 1:] does it along two axis.

A generator is a function-like iterator object.

Returning multiple values in Python is expressed as a tuple by default and each value is correspondingly assigned. Optionally, you can return a dictionary if specified.

Nested list comprehensions follow the same logic as nested for loops. The difference strives that in list comprehensions the filtered variable is mentioned twice.

So surprised that you can output a calendar view using Python

python -m site <--- see useful information about your Python installation

```python from flask import Flask, request from collections import defaultdict import re import random

GREEN ="🟩" YELLOW ="🟨" WHITE ="⬜"

def get_answers(): with open("allowed_answers.txt") as f: answers = set(l for l in f.read().splitlines() if l) return answers

def get_guesses(): guesses = get_answers() with open("allowed_guesses.txt") as f: for l in f.read().splitlines(): if l: guesses.add(l) return guesses

app = Flask(name, static_folder="static") app.answers = get_answers() app.guesses = get_guesses() word = random.choice(list(app.answers)) print(f"The word is {word}")

def with_header(content): return f"""

<html> <head> <link rel="search" type="application/opensearchdescription+xml" title="searchGame" href="http://searchgame:5000/static/opensearch.xml" /> </head> <body> {content} </body></html>

"""

@app.route("/") def home(): return with_header("

Right click on the address bar to install the search engine.

")

@app.route("/search") def search(): return with_header(f"Content: {request.args.get('q')}")

def to_result(guess, answer): chars = [WHITE] * 5 count = defaultdict(int) for idx, (g, a) in enumerate(zip(guess, answer)): if g == a: chars[idx] = GREEN else: count[a] += 1

for idx, g in enumerate(guess):
    if g in count and count[g] > 0 and chars[idx] == WHITE:
        chars[idx] = YELLOW
        count[g] -= 1

return "".join(chars)

def maybe_error(guess): if len(guess) < 5: return f"less than 5 characters" if len(guess) > 5: return f"greater than 5 characters" if guess not in app.guesses: return f"not in wordlist" return None

@app.route("/game") def game(): query = request.args.get("q") guesses = [x for x in re.split("[. ]", query) if x] response = [] if not guesses: response.append("Enter 5-letter guesses separated by spaces") else: most_recent = guesses[-1] # Don't show "too short" error for most recent guess if len(most_recent) < 5: guesses = guesses[:-1] if not guesses: response.append("Enter a wordle guess") for guess in guesses[::-1]: error = maybe_error(guess) if error is None: result = to_result(guess, word) s = f"{guess} | {result}" if result == GREEN * 5: s = f"{s} | CORRECT!" response.append(s) else: response.append(f"{guess} | ERROR: {error}")

return [query, response]

```

حالا می خواد بره با Axios وصلش کنه

حالا رفت سراغ Vue

در واقع تعیین می کنه که درخواست ها از چه پروتکلی، با چه IP یا Domain Name و رو چه Port می تونی جواب بدی. خیلی خووبه براش تعیین کنی تو فقط باید از این IP و Port که در Front تعیین کردی استفاده کنی

تازه رفت سراغ Flask-origin چقد جاالب.

اول یه Virtual Environment می سازه

Recommendation for when to use Ruff over PyLint or Flake8

```python def split_user(userid): """ Return the user and domain parts from the given user id as a dict.

For example if userid is u'acct:seanh@hypothes.is' then return
{'username': u'seanh', 'domain': u'hypothes.is'}'

:raises InvalidUserId: if the given userid isn't a valid userid

"""
match = re.match(r"^acct:([^@]+)@(.*)$", userid)
if match:
    return {"username": match.groups()[0], "domain": match.groups()[1]}
raise InvalidUserId(userid)

```

```html

<body> <div> {% for chat in chats %} <div>{{ chat.contents }}</div> <button id={{chat.id}} ✅ onClick=getId(id) ✅ > print this chat_id out </button> {% endfor %} </div> ... <script> function getId(id){ console.log(id) } </script> </body>

```

Frontend and backend examples of Python's build backends

setup.py is considered a "legacy" functionality these days

setuptools can now utilize pyproject.toml

PyPDF4 is compared with 6 other python libraries to manipulate, create and annotate pdf files via python

Dataclasses give you a lot more clarity of what the function returns, in comparison to returning tuples or dictionaries

3 ways of running jupyter notebook in a container

python 内置函数next()

we are all beginners

I think the requirements of this were not spelled out well. After reading this over a couple of times, I think the problem should be…

"Add, subtract, and compare binary numbers in Python as strings, without converting them to decimal."

I'll take on that problem sometime when I get free time!

It's as simple as adding "sys.stdout" to the "stream" attribute.

This is a pretty old article, from 2011. Note that it refers to Python 2.6 and 2.7. Today, Python is up to version 3.12.

NICE tables comparing build frameworks, front-ends & backends & others, discovered from this SO.

class starter

Experienced talk on python project configurations

One of the recommendations for Python multi-stage Docker builds. Thanks to pip install --user, the packages won't be spread across 3 different paths.

See the 4 steps below to understand what activating an environment in Python really does

Fast vs full deployments

• Iterator ← one-way communication (can only yield stuff)
• Generator ← bidirectional communication (can also accept information via the send method)

Nim sounds as the most ideal language when comparing to Python, Rust, Julia, C#, Swift, C

Conda can be a sufficient alternative to Docker

(see table below)

Post involved with finding a good jupyter notebook visualization lib for DAGs.

What does the object-oriented means? Objects are models of somethings that can do certain things and have certain things done to them. Formally, an object is a collection of data and associated behaviors.

What is the design and programming mean in OOP?

Cannot make it run due to lib incompatibillities, Feb2023 :-( - related to #199: Is Project Dead? - contributions has fallen after 2021.

This function may be useful if it is necessary to determine if a string is too long or too short for a given task.

Python makes use of lists/arrays

Meaning of Float in Python proramming language

I am getting this error while doing make dev I have installed the required version of python, still update with the required version please.

File "/home/ec2-user/projects/h/h/search/config.py", line 213, in _ensure_icu_plugin

names = [x.strip() for x in conn.cat.plugins(h="component").split("\n")]

AttributeError: 'list' object has no attribute 'split'

The datetime type in pandas can only take values inside a given range, for example, dates less than 1677-09-21 and greater than 2262-04-11 cannot be used in Pandas. Is this due to the bit size the datetime[ns] type uses in Pandas?

Meaning of Dictionary according to Python Language

this is a descripton

Camel Case is a method to avoid spaces in names. For example UpperCamelCase and lowerCamelCase

All PascalCase styles are CamelCase but not all CamelCase are PascalCase

Integers definition

I typically like to use PascalCase to indicate variables in my code. It is common in large development environments to have a coding standard document that defines how each programmer on the team will use various conventions

If you would like to template yaml, then rather do it in Nix or Python

https://www.futurelearn.com/courses/programming-101/16/todo/156613

I would have expected it would remove the string " []", not the occurrences of any of the characters within the string...

Yet another possible solution for M1 users, but you need to use conda and expect less packages than in PyPI

Which options to avoid

Speed is the core problem with emulation

Another possible solution for M1 users (see snippets below)

Third possible solution for M1 users

Second possible solution for M1 users

First possible solution for M1 users

Other possible steps that pip will do when trying to install a Python package without a relevant CPU instruction set

3 steps that pip will do when trying to install a Python package without a relevant CPU instruction set

M1 Python issues

data viz with python and R

Negative opinion on mypy (see below this annotation)

Textual is much easier than tkinter.

Hack for pasting multiline Python scripts in a terminal:

1. python
2. exec('''<paste code>''')
3. [ENTER]

Code to improve Python GC settings to increase the performance by 20%

Trigger for GC runs in Python

https://www.complexityexplorer.org/courses/162-foundations-applications-of-humanities-analytics

Comparison of 4 Python's JSON libraries

Python rules for creating a function or a class