Wie kopiere ich mit Python eine Zeichenfolge in die Zwischenablage unter Windows?

Ich versuche, eine einfache Windows-Anwendung zu erstellen, die aus Benutzereingaben eine Zeichenfolge erstellt und diese dann zur Zwischenablage hinzufügt. Wie kopiere ich mit Python eine Zeichenfolge in die Zwischenablage?

Eigentlich pywin32und ctypesscheinen ein Overkill für diese einfache Aufgabe zu sein. Tkinterist ein plattformübergreifendes GUI-Framework, das standardmäßig mit Python geliefert wird und über Methoden zum Zugriff auf die Zwischenablage sowie andere coole Dinge verfügt.

Wenn Sie lediglich Text in die Zwischenablage des Systems einfügen müssen, geschieht dies wie folgt:

from Tkinter import Tk
r = Tk()
r.withdraw()
r.clipboard_clear()
r.clipboard_append('i can has clipboardz?')
r.update() # now it stays on the clipboard after the window is closed
r.destroy()

Und das ist alles, Sie müssen nicht mit plattformspezifischen Bibliotheken von Drittanbietern herumspielen.

Wenn Sie Python 3 verwenden, ersetzen Sie TKinterdurch tkinter.

Ich hatte keine Lösung, nur eine Problemumgehung.

Ab Windows Vista gibt es einen integrierten Befehl namens clip, der die Ausgabe eines Befehls über die Befehlszeile in die Zwischenablage legt. Beispielsweise,ipconfig | clip .

Also habe ich mit dem osModul eine Funktion erstellt, die eine Zeichenfolge verwendet und sie mithilfe der integrierten Windows-Lösung zur Zwischenablage hinzufügt.

import os
def addToClipBoard(text):
    command = 'echo ' + text.strip() + '| clip'
    os.system(command)

# Example
addToClipBoard('penny lane')

# Penny Lane is now in your ears, eyes, and clipboard.

Wie bereits in den Kommentaren erwähnt, besteht ein Nachteil dieses Ansatzes darin, dass der echoBefehl am Ende Ihres Textes automatisch eine neue Zeile hinzufügt. Um dies zu vermeiden, können Sie eine geänderte Version des Befehls verwenden:

def addToClipBoard(text):
    command = 'echo | set /p nul=' + text.strip() + '| clip'
    os.system(command)

Wenn Sie Windows XP verwenden, können Sie die Schritte unter Kopieren und Einfügen von der Eingabeaufforderung von Windows XP Pro direkt in die Zwischenablage ausführen .

Sie können auch ctypes verwenden, um auf die Windows-API zuzugreifen und das massive pywin32-Paket zu vermeiden. Dies ist, was ich benutze (entschuldigen Sie den schlechten Stil, aber die Idee ist da):

import ctypes

# Get required functions, strcpy..
strcpy = ctypes.cdll.msvcrt.strcpy
ocb = ctypes.windll.user32.OpenClipboard    # Basic clipboard functions
ecb = ctypes.windll.user32.EmptyClipboard
gcd = ctypes.windll.user32.GetClipboardData
scd = ctypes.windll.user32.SetClipboardData
ccb = ctypes.windll.user32.CloseClipboard
ga = ctypes.windll.kernel32.GlobalAlloc    # Global memory allocation
gl = ctypes.windll.kernel32.GlobalLock     # Global memory Locking
gul = ctypes.windll.kernel32.GlobalUnlock
GMEM_DDESHARE = 0x2000

def Get():
  ocb(None) # Open Clip, Default task

  pcontents = gcd(1) # 1 means CF_TEXT.. too lazy to get the token thingy...

  data = ctypes.c_char_p(pcontents).value

  #gul(pcontents) ?
  ccb()

  return data

def Paste(data):
  ocb(None) # Open Clip, Default task

  ecb()

  hCd = ga(GMEM_DDESHARE, len(bytes(data,"ascii")) + 1)

  pchData = gl(hCd)

  strcpy(ctypes.c_char_p(pchData), bytes(data, "ascii"))

  gul(hCd)

  scd(1, hCd)

  ccb()

Sie können pyperclip - plattformübergreifendes Zwischenablage-Modul verwenden. Oder Xerox - ähnliches Modul, außer dass das win32 Python-Modul unter Windows funktioniert.

Sie können die hervorragenden Pandas verwenden, die über eine integrierte Zwischenablage-Unterstützung verfügen, müssen jedoch einen DataFrame durchlaufen.

import pandas as pd
df=pd.DataFrame(['Text to copy'])
df.to_clipboard(index=False,header=False)

Der einfachste Weg ist mit Pyperclip . Funktioniert in Python 2 und 3.

Verwenden Sie zum Installieren dieser Bibliothek:

pip install pyperclip

Anwendungsbeispiel:

import pyperclip

pyperclip.copy("your string")

Wenn Sie den Inhalt der Zwischenablage erhalten möchten:

clipboard_content = pyperclip.paste()

Ich habe verschiedene Lösungen ausprobiert, aber dies ist die einfachste, die meinen Test besteht :

#coding=utf-8

import win32clipboard  # http://sourceforge.net/projects/pywin32/

def copy(text):
    win32clipboard.OpenClipboard()
    win32clipboard.EmptyClipboard()
    win32clipboard.SetClipboardText(text, win32clipboard.CF_UNICODETEXT)
    win32clipboard.CloseClipboard()
def paste():
    win32clipboard.OpenClipboard()
    data = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
    win32clipboard.CloseClipboard()
    return data

if __name__ == "__main__":  
    text = "Testing\nthe “clip—board”: 📋"
    try: text = text.decode('utf8')  # Python 2 needs decode to make a Unicode string.
    except AttributeError: pass
    print("%r" % text.encode('utf8'))
    copy(text)
    data = paste()
    print("%r" % data.encode('utf8'))
    print("OK" if text == data else "FAIL")

    try: print(data)
    except UnicodeEncodeError as er:
        print(er)
        print(data.encode('utf8'))

OK getestet in Python 3.4 unter Windows 8.1 und Python 2.7 unter Windows 7. Auch beim Lesen von Unicode-Daten mit von Windows kopierten Unix-Zeilenvorschüben. Kopierte Daten bleiben nach dem Beenden von Python in der Zwischenablage:"Testing the “clip—board”: 📋"

Wenn Sie keine externen Abhängigkeiten wünschen, verwenden Sie diesen Code (jetzt Teil von plattformübergreifend pyperclip- C:\Python34\Scripts\pip install --upgrade pyperclip):

def copy(text):
    GMEM_DDESHARE = 0x2000
    CF_UNICODETEXT = 13
    d = ctypes.windll # cdll expects 4 more bytes in user32.OpenClipboard(None)
    try:  # Python 2
        if not isinstance(text, unicode):
            text = text.decode('mbcs')
    except NameError:
        if not isinstance(text, str):
            text = text.decode('mbcs')
    d.user32.OpenClipboard(0)
    d.user32.EmptyClipboard()
    hCd = d.kernel32.GlobalAlloc(GMEM_DDESHARE, len(text.encode('utf-16-le')) + 2)
    pchData = d.kernel32.GlobalLock(hCd)
    ctypes.cdll.msvcrt.wcscpy(ctypes.c_wchar_p(pchData), text)
    d.kernel32.GlobalUnlock(hCd)
    d.user32.SetClipboardData(CF_UNICODETEXT, hCd)
    d.user32.CloseClipboard()

def paste():
    CF_UNICODETEXT = 13
    d = ctypes.windll
    d.user32.OpenClipboard(0)
    handle = d.user32.GetClipboardData(CF_UNICODETEXT)
    text = ctypes.c_wchar_p(handle).value
    d.user32.CloseClipboard()
    return text

Aus irgendeinem Grund konnte ich die Tk-Lösung nie für mich arbeiten lassen. Die Lösung von kapace ist viel praktikabler, aber die Formatierung widerspricht meinem Stil und funktioniert nicht mit Unicode. Hier ist eine modifizierte Version.

import ctypes

OpenClipboard = ctypes.windll.user32.OpenClipboard
EmptyClipboard = ctypes.windll.user32.EmptyClipboard
GetClipboardData = ctypes.windll.user32.GetClipboardData
SetClipboardData = ctypes.windll.user32.SetClipboardData
CloseClipboard = ctypes.windll.user32.CloseClipboard
CF_UNICODETEXT = 13

GlobalAlloc = ctypes.windll.kernel32.GlobalAlloc
GlobalLock = ctypes.windll.kernel32.GlobalLock
GlobalUnlock = ctypes.windll.kernel32.GlobalUnlock
GlobalSize = ctypes.windll.kernel32.GlobalSize
GMEM_MOVEABLE = 0x0002
GMEM_ZEROINIT = 0x0040

unicode_type = type(u'')

def get():
    text = None
    OpenClipboard(None)
    handle = GetClipboardData(CF_UNICODETEXT)
    pcontents = GlobalLock(handle)
    size = GlobalSize(handle)
    if pcontents and size:
        raw_data = ctypes.create_string_buffer(size)
        ctypes.memmove(raw_data, pcontents, size)
        text = raw_data.raw.decode('utf-16le').rstrip(u'\0')
    GlobalUnlock(handle)
    CloseClipboard()
    return text

def put(s):
    if not isinstance(s, unicode_type):
        s = s.decode('mbcs')
    data = s.encode('utf-16le')
    OpenClipboard(None)
    EmptyClipboard()
    handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, len(data) + 2)
    pcontents = GlobalLock(handle)
    ctypes.memmove(pcontents, data, len(data))
    GlobalUnlock(handle)
    SetClipboardData(CF_UNICODETEXT, handle)
    CloseClipboard()

paste = get
copy = put

Das Obige hat sich seit der ersten Erstellung dieser Antwort geändert, um mit erweiterten Unicode-Zeichen und Python 3 besser umgehen zu können. Es wurde sowohl in Python 2.7 als auch in 3.5 getestet und funktioniert sogar mit Emoji wie \U0001f601 (😁).

Sieht so aus, als müssten Sie win32clipboard zu Ihren Site-Paketen hinzufügen. Es ist Teil des pywin32-Pakets

Sie können Modul verwenden clipboard. Es ist einfach und extrem einfach zu bedienen. Funktioniert mit Mac , Windows und Linux .
_{Hinweis: Es ist eine Alternative vonpyperclip}

Importieren Sie es nach der Installation:

import clipboard

Dann können Sie wie folgt kopieren:

clipboard.copy("This is copied")

Sie können den kopierten Text auch einfügen:

clipboard.paste()

Hier ist der einfachste und zuverlässigste Weg, den ich gefunden habe, wenn es Ihnen je nach Pandas gut geht. Ich denke jedoch nicht, dass dies offiziell Teil der Pandas-API ist, so dass es mit zukünftigen Updates brechen kann. Es funktioniert ab 0.25.3

from pandas.io.clipboard import copy 
copy("test")

Widgets haben auch eine Methode namens .clipboard_get() , die den Inhalt der Zwischenablage zurückgibt (es sei denn, aufgrund des Datentyps in der Zwischenablage tritt ein Fehler auf).

Die clipboard_get()Methode wird in diesem Fehlerbericht erwähnt:
http://bugs.python.org/issue14777

Seltsamerweise wurde diese Methode in den allgemeinen (aber inoffiziellen) Online-TkInter-Dokumentationsquellen, auf die ich mich normalerweise beziehe, nicht erwähnt.

Ich denke, es gibt eine viel einfachere Lösung dafür.

name = input('What is your name? ')
print('Hello %s' % (name) )

Führen Sie dann Ihr Programm in der Befehlszeile aus

python greeter.py | Clip

Dadurch wird die Ausgabe Ihrer Datei in die Zwischenablage geleitet

Zusätzlich zu Mark Ransoms Antwort mit ctypes: Dies funktioniert nicht für (alle?) X64-Systeme, da die Handles auf int-size gekürzt zu sein scheinen. Das explizite Definieren von Argumenten und Rückgabewerten hilft, dieses Problem zu überwinden.

import ctypes
import ctypes.wintypes as w

CF_UNICODETEXT = 13

u32 = ctypes.WinDLL('user32')
k32 = ctypes.WinDLL('kernel32')

OpenClipboard = u32.OpenClipboard
OpenClipboard.argtypes = w.HWND,
OpenClipboard.restype = w.BOOL

GetClipboardData = u32.GetClipboardData
GetClipboardData.argtypes = w.UINT,
GetClipboardData.restype = w.HANDLE

EmptyClipboard = u32.EmptyClipboard
EmptyClipboard.restype = w.BOOL

SetClipboardData = u32.SetClipboardData
SetClipboardData.argtypes = w.UINT, w.HANDLE,
SetClipboardData.restype = w.HANDLE

CloseClipboard = u32.CloseClipboard
CloseClipboard.argtypes = None
CloseClipboard.restype = w.BOOL

GHND = 0x0042

GlobalAlloc = k32.GlobalAlloc
GlobalAlloc.argtypes = w.UINT, w.ctypes.c_size_t,
GlobalAlloc.restype = w.HGLOBAL

GlobalLock = k32.GlobalLock
GlobalLock.argtypes = w.HGLOBAL,
GlobalLock.restype = w.LPVOID

GlobalUnlock = k32.GlobalUnlock
GlobalUnlock.argtypes = w.HGLOBAL,
GlobalUnlock.restype = w.BOOL

GlobalSize = k32.GlobalSize
GlobalSize.argtypes = w.HGLOBAL,
GlobalSize.restype = w.ctypes.c_size_t

unicode_type = type(u'')

def get():
    text = None
    OpenClipboard(None)
    handle = GetClipboardData(CF_UNICODETEXT)
    pcontents = GlobalLock(handle)
    size = GlobalSize(handle)
    if pcontents and size:
        raw_data = ctypes.create_string_buffer(size)
        ctypes.memmove(raw_data, pcontents, size)
        text = raw_data.raw.decode('utf-16le').rstrip(u'\0')
    GlobalUnlock(handle)
    CloseClipboard()
    return text

def put(s):
    if not isinstance(s, unicode_type):
        s = s.decode('mbcs')
    data = s.encode('utf-16le')
    OpenClipboard(None)
    EmptyClipboard()
    handle = GlobalAlloc(GHND, len(data) + 2)
    pcontents = GlobalLock(handle)
    ctypes.memmove(pcontents, data, len(data))
    GlobalUnlock(handle)
    SetClipboardData(CF_UNICODETEXT, handle)
    CloseClipboard()

#Test run
paste = get
copy = put
copy("Hello World!")
print(paste())

import wx

def ctc(text):

    if not wx.TheClipboard.IsOpened():
        wx.TheClipboard.Open()
        data = wx.TextDataObject()
        data.SetText(text)
        wx.TheClipboard.SetData(data)
    wx.TheClipboard.Close()

ctc(text)

Das hier freigegebene Snippet nutzt die Möglichkeit, Textdateien zu formatieren: Was ist, wenn Sie eine komplexe Ausgabe in die Zwischenablage kopieren möchten? (Sagen Sie ein numpy Array in Spalte oder eine Liste von etwas)

import subprocess
import os

def cp2clip(clist):

    #create a temporary file
    fi=open("thisTextfileShouldNotExist.txt","w")

    #write in the text file the way you want your data to be
    for m in clist:
        fi.write(m+"\n")

    #close the file
    fi.close()

    #send "clip < file" to the shell
    cmd="clip < thisTextfileShouldNotExist.txt"
    w = subprocess.check_call(cmd,shell=True)

    #delete the temporary text file
    os.remove("thisTextfileShouldNotExist.txt")

    return w

funktioniert nur für Windows, kann für Linux oder Mac angepasst werden, denke ich. Vielleicht etwas kompliziert ...

Beispiel:

>>>cp2clip(["ET","phone","home"])
>>>0

Strg + V in einem beliebigen Texteditor:

ET
phone
home

Dies ist die verbesserte Antwort des Zerstäubers .

Beachten Sie 2 Anrufe von update()und 200 msVerzögerung zwischen ihnen. Sie schützen Einfrieranwendungen aufgrund eines instabilen Zustands der Zwischenablage:

from Tkinter import Tk
import time     

r = Tk()
r.withdraw()
r.clipboard_clear()
r.clipboard_append('some string')

r.update()
time.sleep(.2)
r.update()

r.destroy()

Verwenden Sie die Python-Zwischenablagebibliothek!

import clipboard as cp
cp.copy("abc")

Die Zwischenablage enthält jetzt 'abc'. Viel Spaß beim Einfügen!

Nicht alle Antworten funktionierten für meine verschiedenen Python-Konfigurationen, daher verwendet diese Lösung nur das Unterprozessmodul. Muss copy_keywordjedoch pbcopyfür Mac oder clipWindows sein:

import subprocess
subprocess.run('copy_keyword', universal_newlines=True, input='New Clipboard Value 😀')

Hier ist ein ausführlicherer Code, der automatisch überprüft, welches Betriebssystem aktuell ist:

import platform
import subprocess

copy_string = 'New Clipboard Value 😀'

# Check which operating system is running to get the correct copying keyword.
if platform.system() == 'Darwin':
    copy_keyword = 'pbcopy'
elif platform.system() == 'Windows':
    copy_keyword = 'clip'

subprocess.run(copy_keyword, universal_newlines=True, input=copy_string)

Sie können das winclip32-Modul verwenden! Installieren:

pip install winclip32

Kopieren:

import winclip32
winclip32.set_clipboard_data(winclip32.UNICODE_STD_TEXT, "some text")

bekommen:

import winclip32
print(winclip32.get_clipboard_data(winclip32.UNICODE_STD_TEXT))

Für weitere Informationen: https://pypi.org/project/winclip32/

Code-Snippet zum Kopieren der Zwischenablage:

Erstellen Sie einen Wrapper-Python-Code in einem Modul mit dem Namen ( clipboard.py ):

import clr
clr.AddReference('System.Windows.Forms')
from System.Windows.Forms import Clipboard
def setText(text):
    Clipboard.SetText(text)

def getText():
    return Clipboard.GetText()

Importieren Sie dann das obige Modul in Ihren Code.

import io
import clipboard
code = clipboard.getText()
print code
code = "abcd"
clipboard.setText(code)

Ich muss dem Blog-Beitrag Zwischenablage-Zugriff in IronPython Ehre machen .

Sie können dies versuchen:

command = 'echo content |clip'
subprocess.check_call(command, shell=True)

from Tkinter import Tk
clip = Tk()