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?
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?
Risposte:
In realtà, pywin32
e ctypes
sembra 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 TKinter
con tkinter
.
r.destroy()
. Una volta che lo chiamo, gli Appunti diventano vuoti e premendo Ctrl-V si può bloccare l'app di destinazione. (
Non avevo una soluzione, solo una soluzione alternativa.
Windows Vista in poi ha un comando integrato chiamato clip
che 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 os
modulo 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 echo
comando 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 .
text
contiene | calc.exe
?
text with " quotes and | pipe
diventa "text with "" quotes and | pipe"
Sebbene ciò possa avere problemi su sistemi con finestre più vecchie di 95.
type
. Scrivo il mio testo su file e utilizzo il comando type myfile.txt | clip
.
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()
bytes(data,"ascii")
in bytes(data)
. Grazie per aver risposto alla domanda, non posso usare pywin32 o tk o un numero di altre cose e questo funziona.
bytes(data, "mbcs")
funzionerà con la codifica predefinita di Windows. Mi ha permesso di caricare questo negli appunti "másreas ç saod é í ó u* ü ö ï/"
e rileggerlo correttamente.
È possibile utilizzare pyperclip - modulo appunti multipiattaforma. O Xerox - modulo simile, tranne per il fatto che il modulo Python win32 funziona su Windows.
pyperclip
non fa Unicode su Windows. win32clipboard
lo fa.
pyperclip
patch è stata accettata; c:\python34\Scripts\pip install --upgrade pyperclip
per gestire il testo Unicode.
pyperclip
non è così paperclip
. Inoltre, come nel 2016, pyperclip funziona anche con i caratteri Unicode. Ho testato i caratteri ± ° © αβγθΔΨΦåäö per lavorare su Win10 64-bit, con Python 3.5 e pyperclip 1.5.27.
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)
pyperclip
comunque, quindi un uso migliorepyperpclip
pandas
è prontamente disponibile ma import pyperclip
non funziona. Quindi non sono d'accordo con "usare meglio pyperclip".
import pandas.io.clipboard as pyperclip
o nominarlo come preferisci. È lì che si trova all'interno pandas
, almeno
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()
pyperclip
modulo viene fornito con Python? Quali versioni? Non lo vedo in Python 2.7 ...
pyperclip.paste()
non funziona con le immagini restituisce solo NoneType
errori. ma funziona con il tasto destro del mouse e copia quindi utilizzando Python per incollare i risultati copiati.
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
win32clipboard
? Non fa parte del mio Python 2.7. E perché paste
usa CF_TEXT
invece di CF_UNICODETEXT
?
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 (😁)
.
put()
funzione ha anche bisogno di lavoro; emoji "📋" (\ U0001f400) viene copiato come "🐀" (\ U0001f4cb) o "📋." diventa "📋".
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()
pip install clipboard
.
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 ms
ritardo 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_keyword
deve essere pbcopy
per Mac o clip
Windows:
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 .
from Tkinter import Tk
clip = Tk()