相关疑难解决方法(0)

我想在python中从键盘读取数据

我试试这个:

nb = input('Choose a number')
print ('Number%s \n' % (nb))

但它不起作用,既不是日食也不是终端,它总是停止问题.我可以输入一个数字,但没有任何事情发生.

你知道为什么吗？

我正在使用以下bash命令模式运行memcached:

memcached -vv 2>&1 | tee memkeywatch2010098.log 2>&1 | ~/bin/memtracer.py | tee memkeywatchCounts20100908.log

尝试跟踪无与伦比的获取到平台键的集合.

memtracer脚本位于下方并按预期工作,只有一个小问题.看到中间日志文件大小,memtracer.py在memkeywatchYMD.log大小约为15-18K之前不会开始输入.有没有更好的方法来读取stdin或者可能是将缓冲区大小降低到1k以下以获得更快的响应时间？

#!/usr/bin/python

import sys
from collections import defaultdict

if __name__ == "__main__":


    keys = defaultdict(int)
    GET = 1
    SET = 2
    CLIENT = 1
    SERVER = 2

    #if <
    for line in sys.stdin:
        key = None
        components = line.strip().split(" ")
        #newConn = components[0][1:3]
        direction = CLIENT if components[0].startswith("<") else SERVER

        #if lastConn != newConn:        
        #    lastConn = newConn

        if direction == CLIENT:            
            command = SET if …

我正在学习python 3 asyncio库,我遇到了一个小问题.我正在尝试从python文档调整EchoServer示例以提示用户输入,而不是仅回显客户端发送的内容.

我认为它就像添加对input()的调用一样简单,但当然input()将阻塞,直到有用户输入导致问题.

理想情况下,即使服务器没有"说",我也希望继续从客户端接收数据.有点像聊天客户端,每个连接与服务器聊天.我希望能够切换到每个单独的连接,并根据需要从stdin发送输入.几乎像一个P2P聊天客户端.

请考虑以下修改的EchoServer代码:

import asyncio

class EchoServerClientProtocol(asyncio.Protocol):
    def connection_made(self, transport):
        peername = transport.get_extra_info('peername')
        print('Connection from {}'.format(peername))
        self.transport = transport

    def data_received(self, data):
        message = data.decode()
        print('Data received: {!r}'.format(message))

        reply = input()
        print('Send: {!r}'.format(reply))
        self.transport.write(reply.encode())

        #print('Close the client socket')
        #self.transport.close()

loop = asyncio.get_event_loop()
# Each client connection will create a new protocol instance
coro = loop.create_server(EchoServerClientProtocol, '127.0.0.1', 8888)
server = loop.run_until_complete(coro)

# Serve requests until CTRL+c is pressed
print('Serving on {}'.format(server.sockets[0].getsockname()))
try:
    loop.run_forever()
except KeyboardInterrupt:
    pass

# Close …

我正在研究一个竞争机器人,它通过sys.stdin接收'输入,并使用Python的print()输出.我有以下内容:

import sys

def main():
    while True:
        line = sys.stdin.readline()
        parts = line.split()
        if len(parts) > 0:
            # do stuff

问题是输入是通过流进入的,使用上面的方法阻止我打印任何东西直到流关闭.我能做些什么来完成这项工作？

我的问题是:

select表示有数据需要读取,我想读取其中的任何内容,我不想等待max数量存在.如果max<= 0则读取等待直到遇到EOF,如果max> 0读取块直到max可以读取字节.

我不想要这个,我想阅读任何数量的选择把它放在"准备阅读"列表中.read(1)不实用,因为这将涉及大量的读取调用.但它不能阻止.

有没有办法在select返回时找出缓冲区中存在的数量(如果它返回表示可以读取某些内容而不是超时)并读取该数量？有没有办法max像套接字一样使用？它尽可能多地读取,然后返回？

解决方案可能是将文件置于非阻塞模式以进行读取？我不确定,我没想到这个"直到EOF"的行为.

我会继续阅读和尝试,但我只花了30分钟左右而且没有接近,这就是我呼吁你的原因.

注意

有很多问题询问如何使recv等待一定量的输入,并使事情阻塞直到达到最大值,我不是在寻找这个.我的问题是阻塞.

附录

setblocking(False)没有用,我现在正在阅读如何在阅读期间使其无阻塞.我对文件给予了希望:

stdin.read Found at: sys
read([size]) -> read at most size bytes, returned as a string.

If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was 
 requested
may be returned, even if no size parameter was given.

增编二

似乎read(0)实际上读取0,这没什么,这导致无限循环,这很有趣! …

我正在尝试创建一个循环python函数,它执行任务并提示用户进行响应,如果用户在给定时间内没有响应,则序列将重复.

这是基于这个问题:如何设置raw_input的时间限制

任务由...表示some_function().超时是一个变量,以秒为单位.我有以下代码的两个问题:

1. 无论用户是否提示,raw_input提示在指定的4秒时间后都不会超时.

2. 当输入'q'的raw_input时(没有'',因为我知道键入的任何内容会自动输入为字符串),该函数不会退出循环.

`

import thread
import threading
from time import sleep

def raw_input_with_timeout():
    prompt = "Hello is it me you're looking for?"
    timeout = 4
    astring = None
    some_function()
    timer = threading.Timer(timeout, thread.interrupt_main)
    try:
        timer.start()
        astring = raw_input(prompt)
    except KeyboardInterrupt:
        pass
    timer.cancel()
    if astring.lower() != 'q':
        raw_input_with_timeout()
    else:
        print "goodbye"

`

假设我有一个input("> "), 如果您尝试输入小写“Hello, world!” 它看起来像这样：

> HELLO WORLD!

在python 3.4 windows 7上编写和测试的所有代码.

我正在设计一个控制台应用程序,并且需要从命令行(win os)使用stdin来发出命令并更改程序的操作模式.该程序依赖于多处理来处理cpu绑定负载以传播到多个处理器.

我正在使用stdout来监视该状态和一些基本的返回信息和stdin,以根据返回的控制台信息发出命令来加载不同的子进程.

这是我发现问题的地方.我无法让多处理模块接受stdin输入,但是stdout正常工作.我认为在堆栈上找到了以下帮助所以我测试了它并发现使用线程模块这一切都很好用,除了stdout的所有输出都暂停直到每次stdin循环由于GIL锁定与stdin阻塞这一事实.

我会说我已成功完成了使用msvcrt.kbhit()实现的工作.但是,我不禁想知道在多处理功能中是否存在使stdin无法读取任何数据的某种错误.我尝试了很多方法,在使用多处理时没有任何效果.甚至尝试使用队列,但我没有尝试池或多处理的任何其他方法.

我也没有在我的linux机器上尝试这个,因为我专注于尝试让它工作.

这是简化的测试代码,它不能按预期运行(提醒这是用Python 3.4编写的 - win7):

import sys
import time
from multiprocessing import Process

def function1():
    while True:
        print("Function 1")
        time.sleep(1.33)

def function2():
    while True:
        print("Function 2")
        c = sys.stdin.read(1) # Does not appear to be waiting for read before continuing loop.
        sys.stdout.write(c) #nothing  in 'c'
        sys.stdout.write(".") #checking to see if it works at all.
        print(str(c)) #trying something else, still nothing in 'c'
        time.sleep(1.66)

if __name__ == "__main__":
    p1 = …

我正在维护一个基于 cmd 的操作员终端。客户要求报警行为。例如，当某个异步事件发生时，屏幕上会显示一条消息。我创建了一个线程来定期检查警报，当它找到一些时，它只是将它们打印到标准输出。

这似乎工作正常，但它似乎不是很优雅，并且有一个问题：

由于 cmd 不知道发生了警报，因此屏幕上的消息后面跟着空白。不会重新打印命令提示符，并且任何用户输入都处于未决状态。

有没有更好的方法在 Python cmd 期间执行异步警报？使用原样的方法，我可以中断 cmd 并让它重绘其提示吗？

我尝试从我的线程中使用 StringIO 在 stdin 中插入一个换行符，但这并不理想，而且我还没有让它正常工作。

示例代码：

import cmd, sys
import threading, time
import io
import sys

class MyShell(cmd.Cmd):
    intro = '*** Terminal ***\nType help or ? to list commands.\n'
    prompt = '> '
    file = None

    def alert(self):
        time.sleep(5)
        print ('\n\n*** ALERT!\n')
        sys.stdin = io.StringIO("\n")

    def do_bye(self, arg):
        'Stop recording, close the terminal, and exit:  BYE'
        print('Exiting.')
        sys.exit(0)
        return True

    def do_async(self, arg):
        'Set a five second …

我正在使用 Py 3.6 中的用户输入编写脚本。

在脚本中，用户被要求在 shell 中输入一个文本部分——可能包含新行。然后输入的文本将保存到 Python 变量中以供进一步处理。

由于用户输入可能包含换行符，我想我不能使用input()但正在使用sys.stdin.read()（如建议here）。

问题

读入输入工作正常，但要结束用户输入，用户必须按下 Return 键，然后使用组合键CTRL + d（请参阅此处）。（请参阅下面的当前程序）

题

• 我希望用户可以sys.stdin.read通过按回车键来结束他们的输入（参见下面的预期程序）

编辑：对当前过程的任何其他简化CTRL + d也表示赞赏。

• 这是可行的吗？

• 这里有一些技巧，但我想也许有更好的方法

当前代码

    # display text on screen
    print("Review this text\n" + text)
    # user will copy and paste relevant items from text displayed into Terminal
    user_input =  sys.stdin.read() 
    print ("hit ctrl + d to continue")
    # …

玩弄非阻塞控制台输入，将 Pythonselectors与 结合使用sys.stdin，有一些我不明白的地方：

假设我想在用户按下 时退出循环Enter，可能是在先输入一些其他字符之后。

如果我执行阻塞读取，如下所示，该过程总是在\n遇到第一个换行符后完成，如预期的那样，无论前面有任何字符：

import sys

character = ''
while character != '\n':
    character = sys.stdin.read(1)

现在考虑以下非阻塞读取的最小化示例：

import sys
import selectors

selector = selectors.DefaultSelector()
selector.register(fileobj=sys.stdin, events=selectors.EVENT_READ)

character = ''
while character != '\n':
    for key, __ in selector.select(timeout=0):
        character = key.fileobj.read(1)

如果我Enter作为第一个输入点击，则会生成一个换行符，并且该过程按预期完成。

但是，如果我先输入一些其他字符，然后输入Enter，则该过程不会完成：我需要Enter再次点击才能完成。

显然，此实现仅在换行是第一个输入时才有效。

这可能有一个很好的理由，但我目前没有看到，也找不到任何相关问题。

这是否与我的非阻塞实现有关，还是stdin缓冲区的事情，或者可能与控制台或终端实现有关？

（我在 ubuntu 上从 python 3.8 shell 运行它。）

我正在使用此命令来禁用回显并使用以下命令获取用户输入sys.stdin.read(1)

tty.setcbreak(sys.stdin.fileno())

然而，在我的程序过程中，我需要再次启用和禁用控制台回显。我试过

fd = sys.stdin.fileno()
old = termios.tcgetattr(fd)
termios.tcsetattr(fd, termios.TCSADRAIN, old)

但这是行不通的。如何优雅地启用回显？

ps：我使用的是mizipzor 的Python 非阻塞控制台输入的代码

代码如下：

import sys
import select
import tty
import termios
import time

def is_number(s):
    try:
        float(s)
        return True
    except ValueError:
        return False

def calc_time(traw):
    tfactor = {
    's':    1,
    'm':    60,
    'h':    3600,
    }
    if is_number(g[:-1]):
        return float(g[:-1]) * tfactor.get(g[-1])
    else:
        return None   
def isData():
    return select.select([sys.stdin], [], [], 0) == ([sys.stdin], [], [])

old_settings = termios.tcgetattr(sys.stdin)
try:
    tty.setcbreak(sys.stdin.fileno())
    i = 0
    while …