Come copio una stringa negli Appunti su Windows usando Python?

Sto cercando di creare un'applicazione Windows di base che crea una stringa dall'input dell'utente e la aggiunge agli Appunti. Come copio una stringa negli appunti usando Python?

In realtà, pywin32e ctypessembra essere eccessivo per questo semplice compito. Tkinterè un framework GUI multipiattaforma, che viene fornito con Python per impostazione predefinita e ha metodi di accesso agli appunti insieme ad altre cose interessanti.

Se tutto ciò che serve è mettere del testo negli appunti di sistema, questo lo farà:

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()

E tutto qui, non c'è bisogno di scherzare con le librerie di terze parti specifiche della piattaforma.

Se si utilizza Python 3, sostituirlo TKintercon tkinter.

Non avevo una soluzione, solo una soluzione alternativa.

Windows Vista in poi ha un comando integrato chiamato clipche prende l'output di un comando dalla riga di comando e lo inserisce negli Appunti. Ad esempio ipconfig | clip,.

Quindi ho creato una funzione con il osmodulo che prende una stringa e la aggiunge agli appunti usando la soluzione integrata di Windows.

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.

Come notato in precedenza nei commenti, un aspetto negativo di questo approccio è che il echocomando aggiunge automaticamente una nuova riga alla fine del testo. Per evitare ciò, è possibile utilizzare una versione modificata del comando:

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

Se stai usando Windows XP funzionerà semplicemente seguendo i passaggi in Copia e incolla dal prompt dei comandi di Windows XP Pro direttamente negli Appunti .

Puoi anche usare ctypes per accedere all'API di Windows ed evitare il massiccio pacchetto pywin32. Questo è quello che uso (scusa lo stile scadente, ma l'idea è lì):

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()

È possibile utilizzare pyperclip - modulo appunti multipiattaforma. O Xerox - modulo simile, tranne per il fatto che il modulo Python win32 funziona su Windows.

Puoi usare gli eccellenti panda, che hanno un supporto integrato negli appunti, ma devi passare attraverso un DataFrame.

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

Il modo più semplice è con pyperclip . Funziona in Python 2 e 3.

Per installare questa libreria, utilizzare:

pip install pyperclip

Esempio di utilizzo:

import pyperclip

pyperclip.copy("your string")

Se vuoi ottenere il contenuto degli appunti:

clipboard_content = pyperclip.paste()

Ho provato varie soluzioni, ma questa è la più semplice che supera il mio test :

#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'))

Testato OK in Python 3.4 su Windows 8.1 e Python 2.7 su Windows 7. Anche durante la lettura di dati Unicode con avanzamenti di riga Unix copiati da Windows. I dati copiati rimangono negli appunti dopo l'uscita di Python:"Testing the “clip—board”: 📋"

Se non desideri dipendenze esterne, utilizza questo codice (ora parte di multipiattaforma 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

Per qualche motivo non sono mai stato in grado di far funzionare la soluzione Tk per me. La soluzione di Kapace è molto più praticabile, ma la formattazione è contraria al mio stile e non funziona con Unicode. Ecco una versione modificata.

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

Quanto sopra è cambiato da quando questa risposta è stata creata per la prima volta, per gestire meglio i caratteri Unicode estesi e Python 3. È stato testato in Python 2.7 e 3.5 e funziona anche con emoji come \U0001f601 (😁).

Sembra che sia necessario aggiungere win32clipboard ai pacchetti del sito. Fa parte del pacchetto pywin32

Ecco il modo più semplice e affidabile che ho trovato se stai bene a seconda dei Panda. Tuttavia, non penso che questo sia ufficialmente parte dell'API Pandas, quindi potrebbe rompersi con futuri aggiornamenti. Funziona a partire da 0.25.3

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

Puoi usare il modulo clipboard. È semplice ed estremamente facile da usare. Funziona con Mac , Windows e Linux .
_{Nota: è un'alternativa dipyperclip}

Dopo l'installazione, importalo:

import clipboard

Quindi è possibile copiare in questo modo:

clipboard.copy("This is copied")

Puoi anche incollare il testo copiato:

clipboard.paste()

I widget hanno anche un metodo denominato .clipboard_get()che restituisce il contenuto degli Appunti (a meno che non si verifichi un tipo di errore basato sul tipo di dati negli Appunti).

Il clipboard_get()metodo è menzionato in questa segnalazione di bug:
http://bugs.python.org/issue14777

Stranamente, questo metodo non è stato menzionato nelle fonti di documentazione TkInter comuni (ma non ufficiali) a cui di solito mi riferisco.

Penso che ci sia una soluzione molto più semplice a questo.

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

Quindi eseguire il programma nella riga di comando

python greeter.py | clip

Questo invierà l'output del tuo file negli Appunti

Oltre alla risposta di Mark Ransom usando i tipi: questo non funziona per (tutti?) Sistemi x64 poiché le maniglie sembrano essere troncate a dimensioni int. Definire esplicitamente args e valori di ritorno aiuta a superare questo problema.

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)

Lo snippet che condivido qui sfrutta la capacità di formattare file di testo: cosa succede se si desidera copiare un output complesso negli Appunti? (Pronuncia una matrice numpy nella colonna o un elenco di qualcosa)

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

funziona solo per Windows, può essere adattato per Linux o Mac credo. Forse un po 'complicato ...

esempio:

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

Ctrl + V in qualsiasi editor di testo:

ET
phone
home

Questa è la risposta migliorata dell'atomizzatore .

Nota 2 chiamate update()e 200 msritardo tra di loro. Proteggono le applicazioni di congelamento a causa di uno stato instabile degli appunti:

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()

Usa la libreria di appunti di Python!

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

Gli appunti ora contengono 'abc'. Buona incolla!

Non tutte le risposte hanno funzionato per le mie varie configurazioni di Python, quindi questa soluzione utilizza solo il modulo di sottoprocesso. Tuttavia, copy_keyworddeve essere pbcopyper Mac o clipWindows:

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

Ecco un codice più ampio che controlla automaticamente qual è l'attuale sistema operativo:

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)

Puoi usare il modulo winclip32! installare:

pip install winclip32

copiare:

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

ottenere:

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

per maggiori informazioni: https://pypi.org/project/winclip32/

Snippet di codice per copiare gli appunti:

Crea un codice Python wrapper in un modulo chiamato ( 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()

Quindi importa il modulo sopra nel tuo codice.

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

Devo dare credito al post sul blog Accesso agli Appunti in IronPython .

puoi provare questo:

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

from Tkinter import Tk
clip = Tk()