tamaño - tipo de letra python
¿Cómo cambiar el estilo de fuente de un widget sin conocer la familia/tamaño de fuente del widget? (8)
¿Hay alguna manera de cambiar el estilo de fuente de un widget Tkinter sin conocer la familia de fuentes y el tamaño de fuente del widget?
Caso de uso: creamos nuestra interfaz de usuario utilizando widgets Tkinter estándar ( etiqueta , entrada , texto , etc.). Mientras se ejecuta nuestra aplicación, es posible que deseemos cambiar dinámicamente el estilo de fuente de estos widgets a negrita y / o cursiva utilizando el método .config() . Lamentablemente, parece que no hay forma de especificar una especificación de fuente sin especificar la familia y el tamaño de la fuente.
Los siguientes son ejemplos de lo que nos gustaría hacer, pero ninguno de estos ejemplos funciona:
widget.config(font=''bold'')
o
widget.config(font=( None, None, ''bold'' ))
A pesar de que ha pasado bastante tiempo desde que se solicitó esta Q, recientemente tuve que implementar una solución para esto, que pensé que valía la pena compartir. La función widget_font_config (...) se ejecuta en Python 2 y 3.
En esencia, el "valor actual" de la fuente del widget se agarra, modifica y luego vuelve a colocar. Las fuentes con nombre son compatibles, y el valor predeterminado inplace_f de True significa que las fuentes con nombre se conservarán y modificarán en su lugar. Pero la bandera también se puede establecer en False , lo que hará que una fuente con nombre sea reemplazada por una fuente con nombre diferente, en caso de que el usuario no desee que los cambios en la fuente del widget se filtren a todos los demás widgets que usan la fuente. fuente con nombre.
def widget_font_config(widget, inplace_f = True, **kwargs):
import sys
if sys.version_info[0] is 2:
import tkFont
else:
import tkinter.font as tkFont
inplace_f = kwargs.pop(''inplace'', inplace_f)
font = None
if widget and ''font'' in widget.config():
font_config = widget.config()[''font'']
current_font = font_config[4] #grabs current value
namedfont_f = False
try:
font = tkFont.nametofont(current_font)
namedfont_f = True
except:
font = current_font
if namedfont_f and inplace_f:
font.config(**kwargs)
else:
font_d = tkFont.Font(font=font).actual()
font_d.update(**kwargs)
font = tkFont.Font(**font_d)
widget.config(font=font)
widget.update_idletasks()
return font
if __name__ == ''__main__'':
import sys
pyVers = sys.version_info.major
if pyVers is 2:
import Tkinter as Tk, tkFont
else:
import tkinter as Tk, tkinter.font as tkFont
def go():
print(widget_font_config(root.label, slant=''roman'', underline=1).actual())
print(widget_font_config(root.button, overstrike=1).actual())
root = Tk.Tk()
font_s = ''Courier 20 italic''
font_d = dict(family=''Courier'', size=10, weight=''normal'', slant=''italic'')
font = tkFont.Font(**font_d)
root.label = Tk.Label(text=''Label {}''.format(font_s), font=font_s)
root.label.pack()
root.button = Tk.Button(text=''Button {}''.format(font), font=font, command=go)
root.button.pack()
root.mainloop()
Hay una forma mucho mejor que utilizar .config() para cambiar la fuente de la aplicación, especialmente si su objetivo es cambiar la fuente de todo un grupo de widgets (o todos los widgets).
Una de las características realmente buenas de Tk es la noción de "fuentes con nombre". La belleza de las fuentes con nombre es que, si actualiza la fuente, todos los widgets que usan esa fuente se actualizarán automáticamente. Por lo tanto, configure sus widgets una vez para usar estas fuentes personalizadas, luego cambiar los atributos es trivial.
Aquí hay un ejemplo rápido:
try:
import Tkinter as tk
import tkFont
# import ttk # not used here
except ImportError: # Python 3
import tkinter as tk
import tkinter.font as tkFont
# import tkinter.ttk as ttk # not used here
class App:
def __init__(self):
root=tk.Tk()
# create a custom font
self.customFont = tkFont.Font(family="Helvetica", size=12)
# create a couple widgets that use that font
buttonframe = tk.Frame()
label = tk.Label(root, text="Hello, world", font=self.customFont)
text = tk.Text(root, width=20, height=2, font=self.customFont)
buttonframe.pack(side="top", fill="x")
label.pack()
text.pack()
text.insert("end","press +/- buttons to change/nfont size")
# create buttons to adjust the font
bigger = tk.Button(root, text="+", command=self.OnBigger)
smaller = tk.Button(root, text="-", command=self.OnSmaller)
bigger.pack(in_=buttonframe, side="left")
smaller.pack(in_=buttonframe, side="left")
root.mainloop()
def OnBigger(self):
''''''Make the font 2 points bigger''''''
size = self.customFont[''size'']
self.customFont.configure(size=size+2)
def OnSmaller(self):
''''''Make the font 2 points smaller''''''
size = self.customFont[''size'']
self.customFont.configure(size=size-2)
app=App()
Si no le gusta ese enfoque, o si desea basar su fuente personalizada en la fuente predeterminada, o si solo está cambiando una o dos fuentes para indicar el estado, puede usar font.actual para obtener el tamaño real de una fuente para un widget dado. Por ejemplo:
import Tkinter as tk
import tkFont
root = tk.Tk()
label = tk.Label(root, text="Hello, world")
font = tkFont.Font(font=label[''font''])
print font.actual()
Cuando ejecuto lo anterior, obtengo el siguiente resultado:
{''family'': ''Lucida Grande'',
''weight'': ''normal'',
''slant'': ''roman'',
''overstrike'': False,
''underline'': False,
''size'': 13}
Incluso más corto para una sola etiqueta:
from Tkinter import *
import Tkinter as tk
root = tk.Tk()
# font="-weight bold" does your thing
example = Label(root, text="This is a bold example.", font="-weight bold")
example.pack()
root.mainloop()
Para hervir gran parte de la información anterior en un único fragmento de código:
lbl = ttk.Label(blah, blah) # Make a label
font = tkFont(lbl[''font'']) # Get its font
font.config(weight=''bold'') # Modify font attributes
lbl[''font''] = font # Tell the label to use the modified font
Esto permite que los atributos de fuente se cambien independientemente de la fuente en uso (siempre que la fuente sea compatible con ese atributo).
También puede hacer esto sobre la marcha, para crear efectos de fuente realmente nauseabundos.
Para obtener la fuente predeterminada sin tocar o tener un widget, puede usar el nombre genérico de la fuente predeterminada.
#!/usr/bin/env python3
import tkinter
import tkinter.font # Python3!
tkinter.Tk()
default_font = tkinter.font.Font(font=''TkDefaultFont'')
print(default_font.actual())
Sé que esta pregunta es muy antigua, pero aún voy a responder por el bien de la gente de Google.
Si solo quieres hacer que el texto sea un poco más grande, puedes hacer font=15 . Tenga en cuenta que esto parece configurar siempre el tamaño de fuente en 15, sin importar el número que se ingrese.
Si quiere un tamaño exacto y no ha cambiado la fuente, puede hacer font=(''TkDefaultFont'', 15) .
( ''TkDefaultFont'' es la fuente predeterminada para tkinter)
Puede usar cualquiera de estos en los parámetros del widget en la creación, o más tarde con .config() .
Funciona en Python 3.6.4
Si usa una fuente con nombre, puede usar un par de declaraciones para obtener lo que desea:
import tkFont
wfont = tkFont.nametofont(widget[''font''])
wfont.config(weight=''bold'')
Editado para incorporar el comentario de B. Oakley.
simplemente use los atributos básicos de un widget en particular, suponga que desea cambiar la fuente de una etiqueta. Puede usar la siguiente sintaxis:
mlabel = Label(text="Your text", font=("Name of your font",size))
este código funciona para python 3.4