DEV Community: Adam Lombard

MacOS: Make Paste and Match Style the default Paste hotkey behavior

Adam Lombard — Tue, 18 Nov 2025 18:08:59 +0000

When copying and pasting in most applications, the default behavior is to paste not only the content from one document into another, but also the styling. Font, color, text size, etc. will not match the target document.

This is almost never the outcome I want.

Many applications have an option called 'Paste and Match Style', which does properly adopt the styling of the target document. But I find this option frustrating because I prefer keyboard shortcuts to menu clicks, and I can never remember the hotkey. It's long, and turns my hand into a pretzel.

On Mac, the 'Paste' hotkey is simply Command-V (⌘-V).
The 'Paste and Match Style' hotkey (the one I want) is Option-Shift-Command-V (⌥-⇧-⌘-V). 😣

You can see these settings in the edit menu of many applications:

How to swap the default paste behaviors

Here's how to swap the two hotkeys, so Command-V will paste and match style, while also leaving normal 'Paste' in your menu (or available for finger contortions), if you ever need it:

Open System Settings and search for Keyboard
In the Keyboard settings click Keyboard Shortcuts
Select App Shortcuts
Click the + button
Leave All Applications selected
For the Menu Title enter Paste and Match Style. Spelling, spacing, and capitalization are important, because the name must match the default application menu item name.
For Keyboard Shortcut press Command-V (⌘-V) on your keyboard.
Click Done
Repeat the process for Paste with the shortcut Option-Shift-Command-V (⌥-⇧-⌘-V).

Done!

Now, in most Mac applications, Command-V will paste and match the style of your target document.

Here's a typical Edit menu, after the changes we made:

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Python: class vs. instance vs. static methods

Adam Lombard — Fri, 20 Nov 2020 22:03:47 +0000

In Python, a method provides functionality to a Class.

There are, broadly, three types of methods:

Class Methods : Provide functionality to a class itself
Instance Methods : Provide functionality to one instance of a class
Static Methods : Provide functionality that can be accessed from a class or from one instance of a class

Consider the following Python class, which defines a Person object and the methods which allow that object to say "hello":

class Person():
  # (Discussing __init__ is beyond the scope of this
  # tutorial)
  def __init__(self, first_name):
    self.first_name = first_name

  # Instance methods are the default method type in a
  # class definition. They receive the class instance
  # itself as their first argument. By convention, 
  # the parameter for this argument is labeled 'self'.
  def say_hi_from_an_instance(self):
    print(f"Hello! My name is {self.first_name}.")

  # Class methods are defined using a special
  # decorator, and receive the class as the first
  # argument. By convention, the parameter for this
  # argument is labeled 'cls'.
  @classmethod
  def say_hi_from_the_class(cls):
    print(f"Hello! I am a {cls.__name__}.")

  # Static methods are defined using a special
  # decorator. They are available on the class and on
  # instances of the class.
  @staticmethod
  def say_hi_from_anywhere():
    print("Why, hello!!!")

Now, from the class:

# We can call the class method greeting
> Person.say_hi_from_the_class()
Hello! I am a Person.

# But we cannot call the instance method greeting
> Person.say_hi_from_an_instance()
Traceback ...
TypeError: say_hi_from_an_instance() missing 1 required positional argument: 'self'

While, from an instance of the class:

> a_person = Person('Louise')

# We can call the instance method greeting
> a_person.say_hi_from_an_instance()
Hello! My name is Louise.

# And we can still call the class method greeting
> a_person.say_hi_from_the_class()
Hello! I am a Person.

Static methods are available on both classes and class instances. They are intended to provide functionality that does not rely on the class or instance itself:

> Person.say_hi_from_anywhere()
Why, hello!!!
> a_person.say_hi_from_anywhere()
Why, hello!!!

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Python: Assignment Operators

Adam Lombard — Sat, 25 Jul 2020 19:26:26 +0000

In a programming language, assignment operators are typically used to assign values to variables.

In Python, the basic assignment operator works like this:

Operator	Description	Example
`=`	Assign a value to a variable	`x = 2`

Python also has seven arithmetic assignment operators, which are a sort of shorthand for performing two operations in sequence -- 1) arithmetic between a variable operand on the left of the expression and some other value on the right, and then 2) the assigning of the result back to the original variable:

Operator	Description	Example	Equivalent To
`+=`	Add a value to a variable	`x += 2`	`x = x + 2`
`-=`	Subtract a value from a variable	`x -= 2`	`x = x - 2`
`*=`	Multiply a variable by a value	`x *= 2`	`x = x * 2`
`**=`	Raise a variable to the power of a value (exponentiation)	`x **= 2`	`x = x ** 2`
`/=`	Divide a variable by a value	`x /= 2`	`x = x / 2`
`//=`	Divide a variable by a value, and round down (floor division)	`x //= 2`	`x = x // 2`
`%=`	The remainder of dividing a variable by a value (modulo)	`x %= 2`	`x = x % 2`

Similarly, Python also has five bitwise assignment operators. These perform bitwise operations (the subject of a future article... ) between the left operand variable and a value on the right, assigning the result back to the variable:

Operator	Description	Example	Equivalent To
`&=`	Bitwise AND	`x &= 2`	`x = x & 2`
`\|=`	Bitwise OR	`x \|= 2`	`x = x \| 2`
`^=`	Bitwise XOR	`x ^= 2`	`x = x ^ 2`
`>>=`	Bitwise right shift	`x >>= 2`	`x = x >> 2`
`<<=`	Bitwise left shift	`x <<= 2`	`x = x << 2`

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Python: Formatting dates and times

Adam Lombard — Tue, 07 Jul 2020 21:37:44 +0000

Formatting dates and times into human-readable strings is a common programming task, and Python has a comprehensive method for doing so.

Let's begin by importing the datetime and tz (timezone) libraries:

>>> import datetime
>>> from dateutil import tz

The datetime library has many useful (and advanced) classes and methods, but exploring them is beyond the scope of this article. To explore formatting dates and times in Python, we will begin by generating a specific datetime, far out in the future. This will provide us with uniquely recognizable string components in our examples below.

Python datetime objects contain the following information, in order: Year, Month, Day, Hour, Minute, Second, Millisecond, and Timezone. Let's generate the datetime for May 4, 9876, at exactly 1.001 seconds after 3:02AM, in Los Angeles. :

>>> location = tz.gettz('America/Los_Angeles')
>>> dt = datetime.datetime(9876, 5, 4, 3, 2, 1, 1, tzinfo=location)

To format our datetime, we use its strftime() method. Let's try a few examples.

Dates

Let's format our date per the ISO 8601 standard, which is my personal favorite and takes the form "YYYY-MM-DD":

>>> dt.strftime("%Y-%m-%d")
'9876-05-04'

You may notice that the formatting is controlled by characters preceded with a %. These are called "directives", and allow us to declare formatting for specific parts of the date and time, while mixing in other plaintext characters, like -. There is a reference chart of most strftime() directives at the end of this article.

Let's try another. In many parts of the world, it's common to format dates as "DD.MM.YY":

>>> dt.strftime("%d.%m.%y")
'04.05.76'

(You may notice that the lowercase y directive yields a two-character year, instead of the four-character year yielded by the uppercase Y directive.)

Finally, let's try a format like "Weekday Name, Month Name (Abbreviated) Date, Year":

>>> dt.strftime("%A, %b %d, %Y")
'Thursday, May 04, 9876'

Times

Now we'll format the time.

First, let's try 24-hour time, like "HH:MM:SS":

>>> dt.strftime("%H:%M:%S")
'03:02:01'

And let's also do 12-hour time, without seconds, showing whether it's AM or PM:

>>> dt.strftime("%-I:%M%p")
'3:02AM'

Directives

By mixing and matching the directives below, we can now freely format dates and times in Python:

(NOTE: Python implements strftime() by calling strftime() in the platform's C library. Not all directives are available on all platforms, and some platforms may have directives not shown here. These directives were tested in Python 3.8 on macOS 10.15.4.)

Dates

Directive	Meaning	Example
`%C`	Century as a 2-digit decimal number (00-99).	98
`%Y`	Year (with century) as a decimal number (0001-9999).	9876
`%G`	ISO 8601 week-based year (with century) as a decimal number (0001-9999). Represents the year that contains the greater part of the ISO week. See `%V`.	9876
`%y`	Year (without century) as a zero-padded decimal number (00-99).	76
`%g`	ISO 8601 week-based year (without century) as a decimal number (00-99).	76
`%m`	Month as a zero-padded decimal number (01-12).	05
`%-m`	Month as a decimal number (1-12).	5
`%B`	Locale's full month name.	May
`%b`	Locale's abbreviated month name.	May
`%h`	Equivalent to `%b`.	May
`%d`	Day of the month as a zero-padded decimal number (01-31).	04
`%e`	Day of the month as a space-padded decimal number ( 1-31).	' 4'
`%-d`	Day of the month as a decimal number (1-31).	4
`%j`	Day of the year as a zero-padded decimal number (001-366).	125
`%-j`	Day of the year as a decimal number (1-366).	125
`%w`	Weekday as a decimal number, where Sunday is `0` and the first day of the week (0-6).	4
`%u`	Weekday as a decimal number, where Monday is `1` and the first day of the week (1-7).	4
`%A`	Locale's full weekday name.	Thursday
`%a`	Locale's abbreviated weekday name.	Thu
`%U`	Week of the year as a zero-padded decimal number. Treats Sunday as the first day of the week. All days in a new year preceding the first Sunday are considered to be in week 0. (00-53)	18
`%W`	Week of the year as a zero-padded decimal number. Treats Monday as the first day of the week. All days in a new year preceding the first Monday are considered to be in week 0. (00-53)	18
`%V`	ISO 8601 week of the year as a zero-padded decimal number. Treats Monday as the first day of the week. Week `01` is the week containing Jan 4. (01-53)	18

Times

Directive	Meaning	Example
`%H`	Hour (24-hour clock) as a zero-padded decimal number (00-23).	03
`%k`	Hour (24-hour clock) as a space-padded decimal number ( 0-23).	' 3'
`%-H`	Hour (24-hour clock) as a decimal number (0-23).	3
`%I`	Hour (12-hour clock) as a zero-padded decimal number (01-12).	03
`%l`	Hour (12-hour clock) as a space-padded decimal number ( 1-12).	' 3'
`%-I`	Hour (12-hour clock) as a decimal number (1-12).	3
`%M`	Minute as a zero-padded decimal number (00-59).	02
`%-M`	Minute as a decimal number (0-59).	2
`%S`	Second as a zero-padded decimal number (00-59).	01
`%-S`	Second as a decimal number (0-59).	1
`%f`	Millisecond as a six-digit, zero-padded decimal number (000000-999999).	000001
`%p`	Locale's equivalent of either AM or PM.	AM
`%z`	Locale's UTC offset in the form `±HHMM[SS[.ffffff]]`. Empty string if the object is naive.	-0800
`%Z`	Locale's time zone name.	PST

Short Codes

Directive	Meaning	Example
`%c`	Locale's preferred date and time representation.	Thu May 4 03:02:01 9876
`%D`	Equivalent to `%m/%d/%y`.	5/04/76
`%F`	Equivalent to `%Y-%m-%d` (the ISO 8601 format).	9876-05-04
`%r`	Time in locale's preferred AM or PM notation.	03:02:01 AM
`%R`	Time in 24-hour notation (without seconds). Equivalent to `%H:%M`.	03:02
`%T`	Time in 24-hour notation (with seconds). Equivalent to `%H:%M:%S`.	03:02:01
`%x`	Locale's preferred date representation (without time).	05/04/76
`%X`	Locale's preferred time representation (without date).	03:02:01

Misc

Directive	Meaning	Example
`%%`	A literal `%` character.	%
`%n`	A newline character.
`%t`	A tab character.
`%s`	The number of seconds since the Unix Epoch: `1970-01-01 00:00:00 +0000 (UTC)`	249499998121

Documentation for strftime().

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Python: What is an f-string?

Adam Lombard — Tue, 16 Jun 2020 16:14:46 +0000

In Python, f-strings are a string formatting mechanism that allow us to embed Python expressions in string literals. 'F-string' is short for 'formatted string'.

They are formatted like so:

f"string literal {expression}"

Say, for instance, we want to print a user greeting where the username is variable:

username = 'Ellen'
print(f"Hello, {username}!")

Hello, Ellen!

Any valid Python expression can be used in the f-string brackets:

year = 2020
print(f"The year is {year}. A decade from now, the year will be {year + 10}.")

The year is 2020. A decade from now, the year will be 2030.

F-strings were added in Python 3.6.

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Python: What is a Lambda Function?

Adam Lombard — Sat, 13 Jun 2020 20:41:59 +0000

In Python, the lambda keyword is used to define an anonymous (i.e., nameless) function, using the following syntax:

lambda parameters: expression

Assume we have the following list of fruits:

fruits = ['apple', 'orange', 'grape', 'lemon', 'mango', 'banana']

Now imagine we need to filter our list to print only fruit names which are 5 characters long. We could do so by defining a named function to test word lengths, and then passing it (and our list of fruits) to filter():

def five_letter_words(word):
  if len(word) == 5:
    return True

five_letter_fruits = filter(five_letter_words, fruits)

for fruit in five_letter_fruits:
  print(fruit)

apple
grape
lemon
mango
>>>

Or, the same task can be accomplished directly in filter() using a lambda expression, without needing to define a separate named function:

five_letter_fruits = filter(lambda word: len(word) == 5, fruits)

for fruit in five_letter_fruits:
  print(fruit)

apple
grape
lemon
mango
>>>

Because lambda functions are Python expressions, they can be assigned to variables.

So, this:

add_two = lambda x, y: x+y
add_two(3, 5)

Is equivalent to this:

def add_two(x, y):
  return x + y

add_two(3, 5)

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Django: What version do I have?

Adam Lombard — Wed, 06 May 2020 20:10:00 +0000

Here's how to see what version of Django you're using:

Make sure you're in the virtual environment for your project.
At the terminal prompt, open the Python shell:

$ python

In the Python shell, import the Django module and check the version:

>>> import django
>>> django.__version__
'2.2.9'

Edit: User @biplov pointed out that there's an even easier way to see your Django version right from your terminal prompt:

$ django-admin --version

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

VSCode: Setting line lengths in the Black Python code formatter

Adam Lombard — Fri, 01 May 2020 22:28:14 +0000

The docs for the Black Python code formatter say that the formatter "is not configurable". This is largely true, but if you have Black set up to work in VSCode, you can configure the line length.

In VSCode, go 'Code -> Preferences -> Settings' and search for "python formatting black args".

Add two separate arguments, in this order: --line-length and n, where "n" is your desired number of allowed characters per line:

A few notes about line lengths in Python:

PEP8 recommends a line length of 79 characters (72 for docstrings)
Black sets line lengths to 88 characters by default
The Django docs recommend a maximum line length of 119 characters (79 for docstrings)

If you are working on a shared project with a team, consider bypassing the VSCode settings entirely, and setting line lengths via the project's pyproject.toml:



[tool.black]
line-length = 119

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

VSCode: Using Black to automatically format Python

Adam Lombard — Thu, 30 Apr 2020 21:40:45 +0000

Black is "the uncompromising Python code formatter." It can be configured to automatically format your code whenever you save a file in VSCode.

Install Black in your virtual environment:



$ pip install black

Install Microsoft's Python extension in VSCode:

Open your VSCode settings, by going 'Code -> Preferences -> Settings'.

Search for "python formatting provider" and select "black" from the dropdown menu:

In the settings, search for "format on save" and enable the "Editor: Format on Save" option:

Black will now format your code whenever you save a *.py file.

Before saving:

After saving:

Was this helpful? Did I save you some time? For $1 you can...

🫖 Buy Me A Tea! ☕️

More: How to set Black line lengths in VSCode

Images from VSCode using Hyper Term Theme.

CSS: Automatically number subheadings in nested lists

Adam Lombard — Sat, 11 Apr 2020 17:35:49 +0000

In documents like technical specifications, academic outlines, contracts, etc., it's not uncommon to find nested lists with numbered headings and subheadings:

1. Heading
  1.1 Subheading
    1.1.1 Sub-subheading

How do we use CSS to automatically number nested lists?

Let's start with a nested mix of ordered (<ol>) and unordered (<ul>) list elements:

We want to number the ordered items, and not the unordered ones. Let's remove the default number prefixes from our ordered list elements, leaving the bullets for our unordered list elements:

We'll make a CSS counter using a property called counter-reset, which works like this:

element {
  counter-reset: <identifier> <integer>?;
}

The identifier is the name that will hold our counter. The integer is an optional number to which we would like to initialize (or reset) our counter. By default, integer is 0.

We'll pair counter-reset with counter-increment, which works like this:

element {
  counter-increment: <identifier> <integer>?;
}

The identifier in counter-increment is the name of the counter to increment; in our case this will match the identifier we initialize with counter-reset. The integer is optional, and determines by how much the counter will be incremented; it defaults to 1.

In our code we want separate counters for each <ol> element, incremented on each <li>, but we want to ignore <ul> elements completely, and not have them affect the heading counter. We'll target <li> children of <ol> elements like so:

Lastly, we want to prefix our counters to each ordered list item. To do so, we'll target a ::before pseudo-element on our ordered list items, and pass the counters() function to their content property. It works like this:

  counters(<identifier>, <separator-string>, <counter-style>?)

The identifier here must match an identifier initialized in counter-reset and used in counter-increment. It is technically a list of all the separate instances of identifier for the current context (there is a counter() function for single counters). So, if we are nested three levels deep, there will be three separate identifiers, and the counters() function will concatenate them together. separator-string will be placed between each concatenated identifier instance. The optional counter-style can be used to change the counter to, say, Roman numerals. It defaults to integers.

In our code, we will also pass a ' - ' string to the content property, to separate our numbered prefixes from the rest of the element. Our final CSS will look something like this:

Let me know what you make! 🙂

Was this helpful? Did I save you some time? For just $1 you can:

🫖 Buy Me A Tea! ☕️

Learn more about using CSS counters.

macOS: Run a script from any app via custom hotkey

Adam Lombard — Tue, 07 Apr 2020 03:34:56 +0000

In MacOS, it's possible to run a script -- from any application -- via custom hotkeys we set ourselves.

I use modified ISO 8601 datetime strings (in a YYYYMMDD_HHMMSS format) several times a day, for all sorts of things, because they are relatively unique (you get a new one every second), they keep items sorted by creation time, and they're fairly easy to read and/or remember if you have to. Let's set up our Mac to generate these strings on the fly!

1 - In our Applications, let's open a program called Automator.

2 - Select "Quick Action" and click "Choose". (We may need to go "File -> New" in order to see the "Quick Action" option.)

3 - In the setup group box for our Quick Action, set "Workflow receives current" to "no input" in "any application".

4 - In the menu tree on the left-hand side, select "Library -> Utilities".

5 - In the "Utilities" sub-tree, double-click "Run Shell Script". This will place a shell script interface in the work area on the right of the application.

6 - In the script interface, enter this shell script:



date '+%Y%m%d_%H%M%S'

7 - At the bottom of the script interface, click "Results" to expand the results panel.

8 - In the upper right corner of Automator, click "Run (►)". We should see the formatted datetime string appear in the "Results" panel of the script interface.

At this point, our finished service should look like this in Automator:

9 - Save our new service! Name it something nice, like... like... FancyDateStamper or... Louise!

10 - Go to "System Preferences -> Keyboard -> Shortcuts".

11 - Select "Services" from the left-hand menu.

12 - In the right-hand menu, find our new service, make sure it has a checkmark in front of it, and click "Add Shortcut".

13 - Now things get hard, because it's really tough to find a shortcut that isn't already used by an app. I went with ctrl+alt+command+D, but I'm almost certain to regret that someday. 😐

And that's it! At this point, we should now be able to open almost any app, and, anywhere we can enter text via the keyboard, we should be able to instead run our hotkey combo and get our datetime stamp. If not, we may have some permissions issues...

14 - Go "System Preferences -> Security & Privacy -> Privacy"

15 - Select "Accessibility" from the left-hand menu.

16 - Unlock to make changes, if necessary, then click the "+" sign at the bottom of the right-hand menu.

17 - Add "Automator" as a trusted app.

While in Automator, you may have noticed the option to create a service in JavaScript as well! Let me know what you automate! 😊

Credit to this StackExchange article, where I first learned the general steps involved.

Was this helpful? Did I save you some time?

🫖 Buy Me A Tea! ☕️

Git: How to configure repo-specific user settings

Adam Lombard — Wed, 25 Mar 2020 00:52:34 +0000

Many Git tutorials instruct us to do something like the following when first setting up Git:

$ git config --global user.name "Susanna Bauer"
$ git config --global user.email susanna@example.com

This configures user.name and user.email settings globally, for every repo on our machine.

But, say we use the same computer to work in multiple Git repositories across two or more accounts. Perhaps we have separate professional and hobby GitLab accounts, for instance. How do we override the global settings, and configure user.name and user.eamil on a per-repo basis?

We can cd into our repo, and re-run the same commands without the --global flags:

$ git config user.name "sueB"
$ git config user.email sb@example.com

The global settings remain unchanged, but this repository will use the new, local settings. You can see the local configuration at <repo>/.git/config.

Learn more about the artwork of Susanna Bauer.

Was this helpful? Did I save you some time?