Tkinter 텍스트 위젯에서 입력을 가져오는 방법은 무엇입니까?

Tkinter 텍스트 위젯에서 입력을 가져오는 방법은 무엇입니까?

은 다음과 같습니다.Text위젯?

편집

저는 같은 문제를 가진 다른 사람들을 돕기 위해 이 질문을 했습니다. 이것이 예제 코드가 없는 이유입니다.이 문제는 몇 시간 동안 저를 괴롭혔고 저는 다른 사람들을 가르치기 위해 이 질문을 사용했습니다.그것이 진짜 질문인 것처럼 평가하지 마십시오. 중요한 것은 답입니다.

인 Tkinter에 몇 ..get()기능.텍스트 상자가 있는 경우myText_Box그러면 이것이 입력을 검색하는 방법은 다음과 같습니다.

def retrieve_input():
    input = self.myText_Box.get("1.0",END)

번째 파트, 번부분은째첫."1.0"입력을 라인 1, 문자 0(즉, 첫 번째 문자)에서 읽어야 함을 의미합니다. END " 열설로된가상져수니다입온정문자다▁string니▁the▁which"로 상수입니다."end".END합니다.part는 텍스트 상자의 끝에 도달할 때까지 읽습니다.이것의 유일한 문제는 이것이 실제로 우리의 입력에 새로운 선을 추가한다는 것입니다.그래서, 그것을 고치기 위해서 우리는 바뀌어야 합니다.ENDend-1c(Bryan Oakley에게 감사합니다)그-1c하나의 문자를 삭제하는 동안-2c두 개의 문자를 삭제하는 등의 작업을 수행합니다.

def retrieve_input():
    input = self.myText_Box.get("1.0",'end-1c')

다음은 Python 3.5.2를 사용한 방법입니다.

from tkinter import *
root=Tk()
def retrieve_input():
    inputValue=textBox.get("1.0","end-1c")
    print(inputValue)

textBox=Text(root, height=2, width=10)
textBox.pack()
buttonCommit=Button(root, height=1, width=10, text="Commit", 
                    command=lambda: retrieve_input())
#command=lambda: retrieve_input() >>> just means do this when i press the button
buttonCommit.pack()

mainloop()

그것으로, 제가 텍스트 위젯에 "blah blah"를 입력하고 버튼을 눌렀을 때, 제가 입력한 것이 무엇이든 인쇄되었습니다.그래서 저는 그것이 텍스트 위젯에서 변수로 사용자 입력을 저장하는 답이라고 생각합니다.

파이썬 3의 텍스트 상자에서 Tkinter 입력을 가져오려면 제가 사용하는 전체 학생 수준 프로그램은 다음과 같습니다.

#Imports all (*) classes,
#atributes, and methods of tkinter into the
#current workspace

from tkinter import *

#***********************************
#Creates an instance of the class tkinter.Tk.
#This creates what is called the "root" window. By conventon,
#the root window in Tkinter is usually called "root",
#but you are free to call it by any other name.

root = Tk()
root.title('how to get text from textbox')


#**********************************
mystring = StringVar()

####define the function that the signup button will do
def getvalue():
##    print(mystring.get())
#*************************************

Label(root, text="Text to get").grid(row=0, sticky=W)  #label
Entry(root, textvariable = mystring).grid(row=0, column=1, sticky=E) #entry textbox

WSignUp = Button(root, text="print text", command=getvalue).grid(row=3, column=0, sticky=W) #button


############################################
# executes the mainloop (that is, the event loop) method of the root
# object. The mainloop method is what keeps the root window visible.
# If you remove the line, the window created will disappear
# immediately as the script stops running. This will happen so fast
# that you will not even see the window appearing on your screen.
# Keeping the mainloop running also lets you keep the
# program running until you press the close buton
root.mainloop()

의문을 얻면려으의 을 얻기 Text정의된 방법을 간단히 사용할 수 있는 위젯Text를 1~2개의 인수로 .start그리고.end 캐터의위치릭,,text_widget_object.get(start, end=None)에.다면start되고 통습니다했과다▁is.end 통되지않다니에 만 반환합니다. 위치에 있는 단일 문자만 반환합니다.start,한다면end 또한 전달되며, 위치 사이에 있는 모든 문자를 반환합니다.start그리고.end끈으로

기반이 되는 TK에 변수가 되는 특수 문자열도 있습니다.그 중 하나는"end"또는tk.END이것은 가장 마지막 문자의 가변 위치를 나타냅니다.Text를 들어위젯의 를 반환하는 경우가 .text_widget_object.get('1.0', 'end')또는text_widget_object.get('1.0', 'end-1c')마지막 줄 문자를 원하지 않는 경우.

데모

슬라이더를 사용하여 지정된 위치 사이의 문자를 선택하는 아래 시연을 참조하십시오.

try:
    import tkinter as tk
except:
    import Tkinter as tk


class Demo(tk.LabelFrame):
    """
    A LabeFrame that in order to demonstrate the string returned by the
    get method of Text widget, selects the characters in between the
    given arguments that are set with Scales.
    """

    def __init__(self, master, *args, **kwargs):
        tk.LabelFrame.__init__(self, master, *args, **kwargs)
        self.start_arg = ''
        self.end_arg = None
        self.position_frames = dict()
        self._create_widgets()
        self._layout()
        self.update()


    def _create_widgets(self):
        self._is_two_args = tk.Checkbutton(self,
                                    text="Use 2 positional arguments...")
        self.position_frames['start'] = PositionFrame(self,
                                    text="start='{}.{}'.format(line, column)")
        self.position_frames['end'] = PositionFrame(   self,
                                    text="end='{}.{}'.format(line, column)")
        self.text = TextWithStats(self, wrap='none')
        self._widget_configs()


    def _widget_configs(self):
        self.text.update_callback = self.update
        self._is_two_args.var = tk.BooleanVar(self, value=False)
        self._is_two_args.config(variable=self._is_two_args.var,
                                    onvalue=True, offvalue=False)
        self._is_two_args['command'] = self._is_two_args_handle
        for _key in self.position_frames:
            self.position_frames[_key].line.slider['command'] = self.update
            self.position_frames[_key].column.slider['command'] = self.update


    def _layout(self):
        self._is_two_args.grid(sticky='nsw', row=0, column=1)
        self.position_frames['start'].grid(sticky='nsew', row=1, column=0)
        #self.position_frames['end'].grid(sticky='nsew', row=1, column=1)
        self.text.grid(sticky='nsew', row=2, column=0,
                                                    rowspan=2, columnspan=2)
        _grid_size = self.grid_size()
        for _col in range(_grid_size[0]):
            self.grid_columnconfigure(_col, weight=1)
        for _row in range(_grid_size[1] - 1):
            self.grid_rowconfigure(_row + 1, weight=1)


    def _is_two_args_handle(self):
        self.update_arguments()
        if self._is_two_args.var.get():
            self.position_frames['end'].grid(sticky='nsew', row=1, column=1)
        else:
            self.position_frames['end'].grid_remove()


    def update(self, event=None):
        """
        Updates slider limits, argument values, labels representing the
        get method call.
        """

        self.update_sliders()
        self.update_arguments()


    def update_sliders(self):
        """
        Updates slider limits based on what's written in the text and
        which line is selected.
        """

        self._update_line_sliders()
        self._update_column_sliders()


    def _update_line_sliders(self):
        if self.text.lines_length:
            for _key in self.position_frames:
                self.position_frames[_key].line.slider['state'] = 'normal'
                self.position_frames[_key].line.slider['from_'] = 1
                _no_of_lines = self.text.line_count
                self.position_frames[_key].line.slider['to'] = _no_of_lines
        else:
            for _key in self.position_frames:
                self.position_frames[_key].line.slider['state'] = 'disabled'


    def _update_column_sliders(self):
        if self.text.lines_length:
            for _key in self.position_frames:
                self.position_frames[_key].column.slider['state'] = 'normal'
                self.position_frames[_key].column.slider['from_'] = 0
                _line_no = int(self.position_frames[_key].line.slider.get())-1
                _max_line_len = self.text.lines_length[_line_no]
                self.position_frames[_key].column.slider['to'] = _max_line_len
        else:
            for _key in self.position_frames:
                self.position_frames[_key].column.slider['state'] = 'disabled'


    def update_arguments(self):
        """
        Updates the values representing the arguments passed to the get
        method, based on whether or not the 2nd positional argument is
        active and the slider positions.
        """

        _start_line_no = self.position_frames['start'].line.slider.get()
        _start_col_no = self.position_frames['start'].column.slider.get()
        self.start_arg = "{}.{}".format(_start_line_no, _start_col_no)
        if self._is_two_args.var.get():
            _end_line_no = self.position_frames['end'].line.slider.get()
            _end_col_no = self.position_frames['end'].column.slider.get()
            self.end_arg = "{}.{}".format(_end_line_no, _end_col_no)
        else:
            self.end_arg = None
        self._update_method_labels()
        self._select()


    def _update_method_labels(self):
        if self.end_arg:
            for _key in self.position_frames:
                _string = "text.get('{}', '{}')".format(
                                                self.start_arg, self.end_arg)
                self.position_frames[_key].label['text'] = _string
        else:
            _string = "text.get('{}')".format(self.start_arg)
            self.position_frames['start'].label['text'] = _string


    def _select(self):
        self.text.focus_set()
        self.text.tag_remove('sel', '1.0', 'end')
        self.text.tag_add('sel', self.start_arg, self.end_arg)
        if self.end_arg:
            self.text.mark_set('insert', self.end_arg)
        else:
            self.text.mark_set('insert', self.start_arg)


class TextWithStats(tk.Text):
    """
    Text widget that stores stats of its content:
    self.line_count:        the total number of lines
    self.lines_length:      the total number of characters per line
    self.update_callback:   can be set as the reference to the callback
                            to be called with each update
    """

    def __init__(self, master, update_callback=None, *args, **kwargs):
        tk.Text.__init__(self, master, *args, **kwargs)
        self._events = ('<KeyPress>',
                        '<KeyRelease>',
                        '<ButtonRelease-1>',
                        '<ButtonRelease-2>',
                        '<ButtonRelease-3>',
                        '<Delete>',
                        '<<Cut>>',
                        '<<Paste>>',
                        '<<Undo>>',
                        '<<Redo>>')
        self.line_count = None
        self.lines_length = list()
        self.update_callback = update_callback
        self.update_stats()
        self.bind_events_on_widget_to_callback( self._events,
                                                self,
                                                self.update_stats)


    @staticmethod
    def bind_events_on_widget_to_callback(events, widget, callback):
        """
        Bind events on widget to callback.
        """

        for _event in events:
            widget.bind(_event, callback)


    def update_stats(self, event=None):
        """
        Update self.line_count, self.lines_length stats and call
        self.update_callback.
        """

        _string = self.get('1.0', 'end-1c')
        _string_lines = _string.splitlines()
        self.line_count = len(_string_lines)
        del self.lines_length[:]
        for _line in _string_lines:
            self.lines_length.append(len(_line))
        if self.update_callback:
            self.update_callback()


class PositionFrame(tk.LabelFrame):
    """
    A LabelFrame that has two LabelFrames which has Scales.
    """

    def __init__(self, master, *args, **kwargs):
        tk.LabelFrame.__init__(self, master, *args, **kwargs)
        self._create_widgets()
        self._layout()


    def _create_widgets(self):
        self.line = SliderFrame(self, orient='vertical', text="line=")
        self.column = SliderFrame(self, orient='horizontal', text="column=")
        self.label = tk.Label(self, text="Label")


    def _layout(self):
        self.line.grid(sticky='ns', row=0, column=0, rowspan=2)
        self.column.grid(sticky='ew', row=0, column=1, columnspan=2)
        self.label.grid(sticky='nsew', row=1, column=1)
        self.grid_rowconfigure(1, weight=1)
        self.grid_columnconfigure(1, weight=1)


class SliderFrame(tk.LabelFrame):
    """
    A LabelFrame that encapsulates a Scale.
    """

    def __init__(self, master, orient, *args, **kwargs):
        tk.LabelFrame.__init__(self, master, *args, **kwargs)

        self.slider = tk.Scale(self, orient=orient)
        self.slider.pack(fill='both', expand=True)


if __name__ == '__main__':
    root = tk.Tk()
    demo = Demo(root, text="text.get(start, end=None)")

    with open(__file__) as f:
        demo.text.insert('1.0', f.read())
    demo.text.update_stats()
    demo.pack(fill='both', expand=True)
    root.mainloop()

텍스트 위젯에서 전체 텍스트를 가져오는 문제에 직면하여 다음과 같은 해결책이 효과가 있었습니다.

txt.get(1.0,END)

여기서 1.0은 첫 번째 줄을 의미하며, 0번째 문자(즉, 첫 번째 줄 앞에 있음)는 시작 위치이고 END는 끝 위치입니다.

이 링크에서 앨런 골드에게 감사합니다.

이게 더 좋은 방법인 것 같아요

variable1=StringVar() # Value saved here

def search():
  print(variable1.get())
  return ''

ttk.Entry(mainframe, width=7, textvariable=variable1).grid(column=2, row=1)

ttk.Label(mainframe, text="label").grid(column=1, row=1)

ttk.Button(mainframe, text="Search", command=search).grid(column=2, row=13)

버튼을 누르면 텍스트 필드의 값이 인쇄됩니다.하지만 ttk는 따로 가져오셔야 합니다.

기본 응용 프로그램의 전체 코드는 -입니다.

from tkinter import *
from tkinter import ttk

root=Tk()
mainframe = ttk.Frame(root, padding="10 10 12 12")
mainframe.grid(column=0, row=0, sticky=(N, W, E, S))
mainframe.columnconfigure(0, weight=1)
mainframe.rowconfigure(0, weight=1)


variable1=StringVar() # Value saved here

def search():
  print(variable1.get())
  return ''

ttk.Entry(mainframe, width=7, textvariable=variable1).grid(column=2, row=1)

ttk.Label(mainframe, text="label").grid(column=1, row=1)

ttk.Button(mainframe, text="Search", command=search).grid(column=2, row=13)

root.mainloop()

텍스트 위젯에서 입력 데이터를 가져오는 방법도 찾아 왔습니다.문자열 끝에 있는 새 줄의 문제와 관련하여..strip()은 항상 문자열인 텍스트 위젯이기 때문에 그냥 사용할 수 있습니다.

또한 다중 텍스트 위젯을 생성하여 사전에 양식 데이터로 저장하는 방법을 확인할 수 있는 코드를 공유하고 있습니다. 제출 단추를 클릭하면 양식 데이터를 가져와 원하는 작업을 수행할 수 있습니다.다른 사람들에게 도움이 되길 바랍니다.모든 3.x 파이썬에서 작동해야 하며 아마도 2.7에서도 작동할 것입니다.

from tkinter import *
from functools import partial

class SimpleTkForm(object):
    def __init__(self):
        self.root = Tk()

    def myform(self):
        self.root.title('My form')
        frame = Frame(self.root, pady=10)
        form_data = dict()
        form_fields = ['username', 'password', 'server name', 'database name']
        cnt = 0
        for form_field in form_fields:
            Label(frame, text=form_field, anchor=NW).grid(row=cnt,column=1, pady=5, padx=(10, 1), sticky="W")
            textbox = Text(frame, height=1, width=15)
            form_data.update({form_field: textbox})
            textbox.grid(row=cnt,column=2, pady=5, padx=(3,20))
            cnt += 1

        conn_test = partial(self.test_db_conn, form_data=form_data)
        Button(frame, text='Submit', width=15, command=conn_test).grid(row=cnt,column=2, pady=5, padx=(3,20))
        frame.pack()
        self.root.mainloop()

    def test_db_conn(self, form_data):
        data = {k:v.get('1.0', END).strip() for k,v in form_data.items()}
        # validate data or do anything you want with it
        print(data)


if __name__ == '__main__':
    api = SimpleTkForm()
    api.myform()

나는 텍스트의 단순한 확장을 만들고 회전하는 것이text부동산에 들어가는 것이 가장 깨끗한 방법입니다.그런 다음 항상 가져온 파일에 해당 확장명을 붙여 원본 대신 사용할 수 있습니다.Text위젯이렇게 하면, 기억하고, 쓰고, 반복하는 등의 모든 후프를 사용하여 가장 간단한 작업을 수행하는 대신, 어떤 프로젝트에서도 재사용할 수 있는 간단한 인터페이스를 사용할 수 있습니다.다음에 대해 수행할 수 있습니다.Entry마찬가지로, 하지만 구문이 약간 다릅니다.

import tkinter as tk

root = tk.Tk()    
    
class Text(tk.Text):
    @property
    def text(self) -> str:
        return self.get('1.0', 'end-1c')
        
    @text.setter
    def text(self, value) -> None:
        self.replace('1.0', 'end-1c', value)
        
    def __init__(self, master, **kwargs):
        tk.Text.__init__(self, master, **kwargs)

#Entry version of the same concept as above      
class Entry(tk.Entry):
    @property
    def text(self) -> str:
        return self.get()
        
    @text.setter
    def text(self, value) -> None:
        self.delete(0, 'end')
        self.insert(0, value)
        
    def __init__(self, master, **kwargs):
        tk.Entry.__init__(self, master, **kwargs)      
      
textbox = Text(root)
textbox.grid()

textbox.text = "this is text" #set
print(textbox.text)           #get  

entry = Entry(root)
entry.grid()

entry.text = 'this is text'   #set
print(entry.text)             #get

root.mainloop()

예를 들어, 당신은Text호출된 위젯my_text_widget.

에서 입력을 받으려면my_text_widget사용할 수 있습니다.get기능.

다음을 가져왔다고 가정합니다.tkinter정의합니다.my_text_widget먼저, 단순한 텍스트 위젯으로 만들어 보겠습니다.

my_text_widget = Text(self)

에서 입력을 받으려면text사용하는 데 필요한 위젯get둘 다, 수함, 둘다,text그리고.entry위젯에 이 기능이 있습니다.

input = my_text_widget.get()

변수에 저장하는 이유는 추가 프로세스에서 변수를 사용하기 위한 것입니다. 예를 들어 입력 내용을 테스트하는 것입니다.

언급URL : https://stackoverflow.com/questions/14824163/how-to-get-the-input-from-the-tkinter-text-widget