LG

client.py

import asyncio

async def tcp_echo_client(message, loop):
    reader, writer = await asyncio.open_connection('localhost', 6719, loop=loop)
    for i in range(10000):
        print('Send: %r' % message)
        writer.write(message.encode())
        await writer.drain()
    writer.close()




message = 'Hello World'
loop = asyncio.get_event_loop()
loop.run_until_complete(tcp_echo_client(message, loop))
loop.close()

server.py

import asyncio
async def handle_client(reader, writer):
    while True:
        request = (await reader.read(1000))
        print(request)
        if request == b'':
            break


loop = asyncio.get_event_loop()
server = asyncio.start_server(handle_client, 'localhost', 6719, loop=loop)
loop.create_task(server)
loop.run_forever()

Output für den Server:

b'Hello World'
b'Hello World'
b'Hello WorldHello World'
b'Hello World'
b'Hello WorldHello World'
...

Warum "überlappen" sich manchmal die Daten, obwohl ich nur b'Hello World' sende?

Warum ist das so und wie kann ich es beheben?

LG

Programmcode:

program1.py: https://www.codepile.net/pile/OqlZ5Kvr

program2.py: https://www.codepile.net/pile/M0yQqP0z

Output:

für program1.py: https://www.codepile.net/pile/JMej20EP

für program2.py: https://www.codepile.net/pile/9LKlmdnm

Sorry muss ich so machen, weil es sonst die max. Zeichengrenze überschreitet.

Wenn ihr euch alles durchgelesen habt: den Fehler für program2.py (Output) verstehe ich ja, weil ja der Server geschlossen wird, aber bei program1.py (Output) verstehe ich den Fehler nicht...

(bei Programmcode von program1.py, bei send() sendet über den Port 4761 Daten zu einem Server, der Server macht gar nichts, sondern empfängt einfach nur das b'hello')

Könntet ihr mir vielleicht helfen, den Fehler im Programm "program1.py" zu verbessern?

LG

https://www.hardwaredealz.com/bester-gaming-pc-fuer-unter-1500-euro-gamer-pc-bis-1500-euro

Bin eher nicht auf gamen ausgerichtet, sondern für 4k Videoediting. Kann man in bauen und ist er gut?

LG

Der PC sollte zwischen 1000-1700 Euro sein.

Ich möchte einen PC worauf ich vielleicht Gamen kann, ob ich Hig-End Games spielen werde, weiß ich noch nicht... tendiere aber eher nicht ganz zum Gamen.

ABER der PC soll top im Videoediting sein und auch im Programmieren sollte er gut sein. Er sollte ungefähr so 6-8 Jahre halten, also schon etwas länger.

Was soll ich nehmen, vielleicht doch einen Laptop? Was sagt ihr?

LG

server.py

import asyncio, socket

async def handle_client(reader, writer):
    request = None
    while True:
        request = (await reader.read(255)).decode('utf8')
        #do other things...
        writer.write(xyz.encode())
        await writer.drain()

async def run_server():
    server = await asyncio.start_server(handle_client, 'localhost', 15555)
    async with server:
        await server.serve_forever()

asyncio.run(run_server())

sender.py

async def tcp_echo_client(message):
    reader, writer = await asyncio.open_connection(
        '127.0.0.1', 8888)

    print(f'Send: {message!r}')
    writer.write(message.encode())
    await writer.drain()

asyncio.run(tcp_echo_client('Hello World!'))

Diese 2 unabhängig laufenden Programme will ich "gleichzeitig" laufen lassen und in ein Programm schreiben, wie mache ich das? Habe es mit asyncio.gather probiert, aber damit gibt es irgendwann im Programm Probleme... Wie mache ich das?

LG

Ich möchte innerhalb und später vielleicht auch außerhalb meines Heimnetzwerkes mit dem Raspberry Pi kommunizieren. Diese Kommunikation soll in einem Python3 Skript ablaufen, sodass ich mit den Übertragenen Daten selbst hantieren kann. (und wenn das Python Skript nicht läuft soll keine Kommunikation stattfinden) Welche Art von Kommunikation soll ich benutzen und wie soll ich das anstellen?

LG

LG

import asyncio, socket

async def handle_client(reader, writer):
    request = None
    while request != 'quit':
        request = (await reader.read(255)).decode('utf8')
        response = str(eval(request)) + '\n'
        writer.write(response.encode('utf8'))
        await writer.drain()
    writer.close()

async def run_server():
    server = await asyncio.start_server(handle_client, 'localhost', 15555)
    async with server:
        await server.serve_forever()

asyncio.run(run_server())

Kann dieses Programm viele Clients gleichzeitig bearbeiten?

LG

import asyncio, socket


async def handle_client(reader, writer):
    request = None
    while request != 'quit':
        request = (await reader.read(255)).decode('utf8')
        response = str(eval(request)) + '\n'
        writer.write(response.encode('utf8'))
        await writer.drain()
    writer.close()


async def run_server():
    server = await asyncio.start_server(handle_client, 'localhost', 15555)
    async with server:
        await server.serve_forever()


asyncio.run(run_server())

Meine Frage: Was macht der writer und warum while request != 'quit' ?

LG

Ich habe ein eigenen Socket Server geschrieben, was der macht ist egal, aber... ich habe eine Frage: Kann ich einen Socket Server Programm (Python3) als Server benutzen (also keinen NAS Server oder so was) und selbst wenn ich einen Gaming PC als Server benutze, könnte der Socket Server dann rein theoretisch um die 5000 Threads schaffen und ist es sinnvoll?

LG

Client:

import sock
import time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.send(xyz)
#hier geht der server offline und direkt wieder online
time.sleep(2)
s.send(xyz) #hier das Problem, hier kommt dann ein error, er reconnected sich nicht mit dem Server

Der Server macht nichts großes er existiert einfach und wartet auf Clients...

Mein Problem: ich möchte, dass wenn der Server mehrmals oder einmal offline und direkt wieder online geht und der client noch läuft, sich automatisch reconnected (also der client) und ich somit Nachrichten nach dem offline und online gehen des Servers senden kann. Wie mache ich das?

LG

Ich benutze Python 3.7. Seit 1 Tag öffnet sich nicht mehr die IDLE mit dem Code drin, wenn ich mit rechtsklick auf eine .py Datei gehe und auf Edit with IDLE klicke. Ich kann aber noch nach der IDLE suchen und dann öffnet sich sie auch, es ist aber sehr umständlich.

Hast jemand eine Idee was ich machen soll?

LG

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((IP, PORT))
sock.listen(2)
client, addr = sock.accept()

Ich möchte währenddessen er nach clients sucht und sie akzeptiert noch etwas anderes machen. Ich kann ja keine while == True Schleife um die letzte Zeile packen und da meinen anderen COde reinschreiben, wie mache ich das?

LG

Möchte das in Numpy haben:

v = [0,0,0]
v[0] = [1,2,3,4]
print(v)

Output: [[1,2,3,4],0,0]

Wie kann ich das hier in Numpy programmieren?

Ich nutze numpy.dot(inputs, weights) um Neuronen in einem Neuronalen Netz zu simulieren. So ich habe einmal mir die weights ausgeben lassen um mal selber per Hand nachzurechnen und da hab ich ein Problem gefunden:

Outputwerte des NN (nicht mit Hand nachgerechnet): [0.72869682 0.66322603]

Outputwerte des NN (mit Hand nachgerechnet): 0.7286968208123374 und 0.6632260356519584

Warum rundet numpy.dot ab und kann ich festlegen, dass er die Zahlen ausschreibt?

Also ich möchte, wie oben genannt, einen ARGB Wert in einen einmaligen Wert zwischen 0-1 übersetzten. Also es soll für jeden Farbton und jeder Farbkonsistenz ein einmaliger Wert zwischen 0 und 1 geben. Habt ihr einen Idee wie ich das in Python3 anstelle?