You can create a folder directly in Finder. Navigate to the desired directory and create a folder. We will create an encrypted disk image from this folder. The files we want to secure will go inside of this folder.

Move any files that you wish to protect inside of the folder you just created.

You can find the Disk Utility app in Applications > Utilities or just hit cmd + space bar and search for “Disk Utility”.

Click on File > New Image > Image From Folder.

A Finder window will appear. Find and select the folder you want to encrypt, then click Choose.

Choose a name and location for the image.

Keep in mind, “.dmg” will be automatically appended to the name you choose.

Then select either either 128 or 256 bit encryption.

By default, this will create a read-only image. If you’ll need to write to this folder again in the future, change the Image Format to read/write.

Enter the password, verify, and click save.

This password will be required when you try to mount the disk image to view the contents so you should write down this password.

Use a strong password, and store it securely. Consider using a password manager like 1Password or Dashlane.

To test the image you’ve created, find the image in Finder and click to open. When prompted, enter the password you set previously. This will mount the image and display the contents of the folder.

When you’re finished, make sure to unmount the image. You’ll see the image in the left column of finder and you can click the eject icon to unmount.

Many online services such as Sculpteo exist that will print your model and ship it to you. You pay a small fee based on the size and complexity of the model, choose your print colors, and receive the model in just a few days.

A hackerspace, or “makerspace”, is a private organization comprised of members who share a shared workspace and, generally, the interest of building things.

Chances are there’s one near you. Members normally pay a monthly fee, but most have “Open Make Nights” where you can pop in and use the equipment without needing a membership. You can find your local hackerspace using this tool, which lists over 2,000 hackerspaces.

In an effort to remain a relevant community resource, many public libraries now have 3D printers available for use! Find your local library and call the information desk to ask if they have any 3D printers available.

If you’re a student, your university can likely provide you with access to one. Call your university library’s information desk and they can direct you to the college/department that will give you access.

Many 3D printing businesses and professionals advertise their printing services on Craigslist. Most charge you when you pick up the model. Be sure to ask for references or photos of their work.

If cost is the primary reason you don’t have a 3D printer, you may not know how low prices have gotten. In the last few years, 3D printers have come way down in price. I picked up my Creality Ender 3 for $179 on GearBest. I also wrote a full Ender 3 review if you want to check it out!

Things used here

See all

Check Price

Creality Ender 3 3D printer

on Amazon

If you’re new to comprehensions, this syntax might be a little confusing. So I’ll break it down:

{key: value for x in iterable}

A conditional can optionally included like this:

new_dict = {key: value for x in iterable if condition}

In many use cases, the elements in the iterable will provide the key and value, but it’s not required. We iterate over iterable assigning each item to the variable x. Then the new dictionary is formed using the variables key and value.

Here’s a simple example:

> {str(x): x for x in range(3)} {'0': 0, '1': 1, '2': 2}

The following shows how our example maps to the syntax instruction from above.

In the remainder of this guide, I’ll provide examples of how dictionary comprehensions can be used to improve your code.

Sometimes we have a list of dictionaries, and we need to lookup a dictionary by a particular key. This can be the case with database query results or data read from a csv.

Goal: Convert a list of dictionaries to a nested dictionary, so we can look up elements by their id.

The initial data is structured like this:

data_list = [ {'id': '1', 'name': ...}, {'id': '2', 'name': ...}, {'id': '3', 'name': ...}, ... ]

If we need to lookup rows by id, we could search the list, but that would be inefficient for multiple lookups. A better way is to convert the list of dictionaries to a dictionary, where the key is the id.

data_dict = { '1': {'id': '1', 'name': ...}, '2': {'id': '2', 'name': ...}, '3': {'id': '3', 'name': ...}, }

Now we can easily and efficiently lookup dictionaries by their id.

some_dict = data_dict[id]

So how do we accomplish this?

Using a for loop

data_dict = {} for item in data_list: data_dict[item['id']] = item

We iterate over the list, grabbing the id from each item. Then we create a new dictionary key and value during each iteration.

This is not too bad, but we can simplify even more using dictionary comprehension.

Using dictionary comprehension

data_dict = {d['id']: d for d in data_list}

Hopefully you can see how both examples accomplish the same thing. They both include the same components, but the second example is cleaner.

Suppose we have a dictionary with many key-value pairs, and we want to copy that dictionary and filter out specific values.

Goal: Create a dictionary of U.S. state data including only states established on or after 1900.

Our initial dictionary contains data for all 50 U.S. states. It looks like this:

state_data = { 'Alabama': { 'Abbreviation': 'AL', 'Capital': 'Montgomery', 'Established': 1819 }, 'Alaska': { 'Abbreviation': 'AK', 'Capital': 'Juneau', 'Established': 1959 }, ... }

So we want to filter our dictionary and include only states that were established on or after 1900.

Using a for loop

states_after_1900 = {} for k, v in state_data.items(): if v['Established'] >= 1900: states_after_1900[k] = v

This gives us the answer we’d like, but with dictionary comprehensions we can accomplish this in a single line of code.

Using dictionary comprehension

states_after_1900 = {k: v for k, v in state_data.items() if v['Established'] >= 1900}

Notice this includes all of the same components, but it’s much more concise.

The results

In order to conserve space, while still proving this worked as expected, I’ll just print the state and the date it was established:

for k, v in states_after_1900.items(): print(k, v['Established']) # => Output Alaska 1959 Arizona 1912 Hawaii 1959 New Mexico 1912 Oklahoma 1907

In some cases, we start with a dictionary that is structured in a specific way, but we need the values to be transformed.

I’m going to use a contrived example to demonstrate how this works. Suppose we have a dictionary, where the key is a user id, and the value is the user’s first name. For some reason, we want to display the users names in reverse, possibly multiple times. We could use the extended slice operator or the reversed function as needed, but that could be wasteful if we’re planning on doing this multiple times for each name. Another option is to create a new dictionary where the names are reversed.

Note: For more details on reversing strings in Python check out our guide.

Here’s the initial names dictionary.

names = { 1: 'Sam', 2: 'Clark', 3: 'Carol', ... }

We’ll create a new dictionary where each value is mapped to it’s reverse.

Using a for loop

names_reversed = {} for k, v in names.items(): names_reversed[k] = v.reversed()

Using dictionary comprehension

names_reversed = {k: v[::-1] for k, v in names.items()}

Results

names_reversed => Output {1: 'maS', 2: 'kralC', 3: 'loraC'}

In Terminal, or your Unix command line, use the following command:

httpd -M 

You should see output similar to this:

core_module (static) mpm_prefork_module (static) http_module (static) so_module (static) auth_basic_module (shared) auth_digest_module (shared) 

This is a list of all loaded Apache modules.

The open command accepts a -a option that allows us to specify which application we want to open.

So if you just want to open Google Chrome from the command line, it’s as simple as this:

open -a "Google Chrome"

This will do nothing more than bring the Google Chrome window into focus.

To open a specific URL in Chrome, simply pass the URL as the first argument of the command, like this:

open -a "Google Chrome" 

This will open your favorite website in your favorite browser.

If you’re like me and use multiple Chrome profiles, you’ll want to be able to specify which profile to use when opening the URL. For this, we’ll have to move away from the convenient open command.

Before we get to the command, we’ll need to figure out the correct profile directory to use. Sadly, this will not be the same value as your profile name. To get your profile directory, open Chrome in the profile you want to use and navigate to chrome://version/. Find the item labeled Profile Path, and copy only the last part of the path. In my case, it’s Profile 5.

/Applications/Google Chrome.app/Contents/MacOS/Google Chrome  --profile-directory=Profile 5

I know its not realistic to type this every time you want to open a URL. You could bake this into a script or see the next step where I’ll cover using aliases and bash functions to make this less painful.

If you’re going to open URLs frequently, there are a few ways to dramatically increase efficiency. The easiest way is to use bash aliases. An alias allows you to basically create a shortcut for longer commands.

Alias for opening URLs in Chrome

Here are a few examples (you can add them to your ~/.bash_profile).

alias gc="open -a Google Chrome"

Or if you’d like to create an alias to the command that let’s you specify a profile, you could do the following:

alias gc="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome --profile-directory=Profile 5"

Anytime you edit your bash_profile, you need to run source ~/.bash_profile or open a new shell to see the changes take effect.

With this, you can run:

gc # Open or focus on the Chrome window gc  # Open the url in Chrome

Similarly, the gc {url} command will open the url in Chrome, but it will use the specified profile every time.

Alias that accepts a URL from STDIN

In some cases, you might want to accept a URL from STDIN. The open command handles stdin the way we’d like, so if you’re using the first alias, you don’t need to do anything.

If you’re using the alias for Google Chrome, one easy way is to create a second alias (using xargs) like this:

alias gcx="xargs /Applications/Google Chrome.app/Contents/MacOS/Google Chrome --profile-directory=Profile 5"

This will allow you to do something like this:

echo "" | gcx

If you’ve got a better way of doing this, let me know in the comments below 🙂