Das deutsche Python-Forum

Code: Alles auswählen

from time import monotonic



def get_prime():
    prim_counter = 0
    prim_pruefzahl = 0
    zahl = 1
    prime = []

    while prim_counter < 10001:
        for teiler in range(1, zahl):
            if zahl % teiler == 0:
                prim_pruefzahl += 1
        if prim_pruefzahl == 1:
            prime.append(zahl)
            prim_counter += 1
        else:
            prim_pruefzahl = 0
        zahl += 1
    return prime


def main():
    start = monotonic()
    print(get_prime()[-1])
    print(f"Dauer {monotonic() - start:.2f} s")


if __name__ == '__main__':
    main()

Code: Alles auswählen

[dennis@dennis ~]$ ~/PycharmProjects/Forum/.venv/bin/python ~/PycharmProjects/Forum/cpython.py 
104759
Dauer 511.75 s

Code: Alles auswählen

from time import monotonic
from numba import njit

@njit
def get_prime():
    prim_counter = 0
    prim_pruefzahl = 0
    zahl = 1
    prime = []

    while prim_counter < 10001:
        for teiler in range(1, zahl):
            if zahl % teiler == 0:
                prim_pruefzahl += 1
        if prim_pruefzahl == 1:
            prime.append(zahl)
            prim_counter += 1
        else:
            prim_pruefzahl = 0
        zahl += 1
    return prime


def main():
    start = monotonic()
    print(get_prime()[-1])
    print(f"Dauer {monotonic() - start:.2f} s")


if __name__ == '__main__':
    main()

Code: Alles auswählen

[dennis@dennis ~]$ ~/PycharmProjects/Forum/.venv/bin/python ~/PycharmProjects/Forum/njit_test.py 
104759
Dauer 17.73 s

Code: Alles auswählen

use std::time::Instant;


fn get_prime() -> Vec<i32> {
    let mut prim_counter: i32 = 0;
    let mut prim_pruefzahl: i32 = 0;
    let mut zahl: i32 = 1;
    let mut prime: Vec<i32> = Vec::with_capacity(1000);

    while prim_counter < 10001 {
        for teiler in 1..zahl {
            if zahl % teiler == 0 {
                prim_pruefzahl += 1;
            };
	};
	if prim_pruefzahl == 1 {
            prime.push(zahl);
            prim_counter += 1;
        } else {
            prim_pruefzahl = 0;
        };
	zahl += 1;
    }
    prime

}


fn main() {
    let start = Instant::now();
    let prime = get_prime();
    println!("{:?}", prime.last());
    println!("Dauer: {:.2?}", start.elapsed());
}

Code: Alles auswählen

[dennis@dennis ~]$ ./rust_test/main 
Some(104759)
Dauer: 61.26s

Code: Alles auswählen

Rust: 
Some(104759)
Dauer: 6.40s

Python + numba:
104759
Dauer 7.64 s

Python:
104759
Dauer 267.56 s

Code: Alles auswählen

if random.random() > 0.5:
    answer = 42

Code: Alles auswählen

def f():
    print(this_name_does_not_exist)

Code: Alles auswählen

> python -VV
Python 3.7.5 Stackless 3.7 (default, Mar 20 2023, 17:34:24) 
[GCC 12.2.1 20230201]

> python dennis-1.py
104759
Dauer 177.83 s

> ./pypy3.10-v7.3.16-linux64/bin/pypy3 -VV
Python 3.10.14 (75b3de9d9035, Apr 21 2024, 10:54:48)
[PyPy 7.3.16 with GCC 10.2.1 20210130 (Red Hat 10.2.1-11)]


> ./pypy3.10-v7.3.16-linux64/bin/pypy3 dennis-1.py
104759
Dauer 10.81 s

Code: Alles auswählen

f:
        mov     eax, edi          ; eax = n
        lea     ecx, [rax + rax]  ; ecx = eax + eax
        shl     eax, 4            ; eax = eax << 4
        sub     eax, ecx          ; eax = eax - exc
        ret

Code: Alles auswählen

#!/usr/bin/env python3
from math import factorial
from operator import add, mul, neg, sub, truediv

from attrs import field, frozen

BINARY_OPERATOR_SYMBOL_TO_FUNCTION = {
    "*": mul,
    "+": add,
    "-": sub,
    "/": truediv,
}
UNARY_OPERATOR_SYMBOL_TO_FUNCTION = {"-": neg, "!": factorial}


@frozen
class Literal:
    value = field()


@frozen
class UnaryExpression:
    operator = field()
    operand = field()


@frozen
class BinaryExpression:
    left_operand = field()
    operator = field()
    right_operand = field()


@frozen
class Grouping:
    expression = field()


class Visitor:
    def visit(self, node):
        method = getattr(self, "visit_" + node.__class__.__name__)
        if method:
            return method(node)
        return None


class AstPrinter(Visitor):
    def _parenthesize(self, name, expressions):
        expressions_text = " ".join(map(self.visit, expressions))
        return f"({name} {expressions_text})"

    def visit_Literal(self, node):
        return "nil" if node.value is None else repr(node.value)

    def visit_UnaryExpression(self, node):
        return self._parenthesize(node.operator, [node.operand])

    def visit_BinaryExpression(self, node):
        return self._parenthesize(
            node.operator, [node.left_operand, node.right_operand]
        )

    def visit_Grouping(self, node):
        return self._parenthesize("group", [node.expression])


def _parenthesize(name, expressions):
    expressions_text = " ".join(map(ast_as_string, expressions))
    return f"({name} {expressions_text})"


def ast_as_string(node):
    match node:
        case Literal(value):
            return "nil" if value is None else repr(value)

        case UnaryExpression(operator, operand):
            return _parenthesize(operator, [operand])

        case BinaryExpression(left_operand, operator, right_operand):
            return _parenthesize(operator, [left_operand, right_operand])

        case Grouping(expression):
            return _parenthesize("group", [expression])

        case _:
            return None


class AstEvaluator(Visitor):
    def visit_Literal(self, node):
        return node.value

    def visit_UnaryExpression(self, node):
        return UNARY_OPERATOR_SYMBOL_TO_FUNCTION[node.operator](
            self.visit(node.operand)
        )

    def visit_BinaryExpression(self, node):
        return BINARY_OPERATOR_SYMBOL_TO_FUNCTION[node.operator](
            self.visit(node.left_operand), self.visit(node.right_operand)
        )

    def visit_Grouping(self, node):
        return self.visit(node.expression)


def evaluate(node):
    match node:
        case Literal(value):
            return value

        case UnaryExpression(operator, expression):
            return UNARY_OPERATOR_SYMBOL_TO_FUNCTION[operator](
                evaluate(expression)
            )

        case BinaryExpression(left_operand, operator, right_operand):
            return BINARY_OPERATOR_SYMBOL_TO_FUNCTION[operator](
                evaluate(left_operand), evaluate(right_operand)
            )

        case Grouping(expression):
            return evaluate(expression)

        case _:
            raise ValueError(f"cannot evaluate {node!r}")


def as_rpn(node):
    match node:
        case Literal(value):
            return "nil" if value is None else repr(value)

        case UnaryExpression("-", operand):
            return f"0 {as_rpn(operand)} -"

        case UnaryExpression(operator, operand):
            return f"{as_rpn(operand)} {operator}"

        case BinaryExpression(left_operand, operator, right_operand):
            return f"{as_rpn(left_operand)} {as_rpn(right_operand)} {operator}"

        case Grouping(expression):
            return as_rpn(expression)

        case _:
            raise ValueError(f"cannot represent {node!r} as RPN")


def main():
    ast = BinaryExpression(
        UnaryExpression("-", Literal(123)),
        "*",
        Grouping(Literal(45.67)),
    )
    print(AstPrinter().visit(ast))
    print(ast_as_string(ast))

    print(AstEvaluator().visit(ast))
    print(evaluate(ast))

    print(as_rpn(ast))


if __name__ == "__main__":
    main()