The answer of Mark Byers is the optimal in this situation. Though in more complex situations you can take the select query that returns rowids and calculated values and attach it to the update query like this:

with t as (
  -- Any generic query which returns rowid and corresponding calculated values
  select t1.id as rowid, f(t2, t2) as calculatedvalue
  from table1 as t1
  join table2 as t2 on t2.referenceid = t1.id
)
update table1
set value = t.calculatedvalue
from t
where id = t.rowid

This approach lets you develop and test your select query and in two steps convert it to the update query.

So in your case the result query will be:

with t as (
    select v.id as rowid, s.price_per_vehicle as calculatedvalue
    from vehicles_vehicle v 
    join shipments_shipment s on v.shipment_id = s.id 
)
update vehicles_vehicle
set price = t.calculatedvalue
from t
where id = t.rowid

Note that column aliases are mandatory otherwise PostgreSQL will complain about the ambiguity of the column names.

I want to address part of the question from a SQL Server perspective.

In T-SQL I would do an update using a join using something like this:

UPDATE foo
SET bar = t2.bar
FROM foo t1
JOIN foo2 t2
ON t1.id = t2.id;

Maybe something like that, but probably not exactly that. It is too easy to end up with an accidental cross join. The SQL Server documentation doesn't really talk about that, but it should because this trips people up all the time.

Algebrization of UPDATE...FROM can be quirky (often for backward-compatibility), so it is important to be explicit and follow best practice. This means:

1. Assigning an alias
2. Updating that alias; and
3. Ensuring the update is deterministic i.e. each target row is updated from at most one source row.

Extracts from the same documentation page:

If the object being updated is the same as the object in the FROM clause and there is only one reference to the object in the FROM clause, an object alias may or may not be specified. If the object being updated appears more than one time in the FROM clause, one, and only one, reference to the object must not specify a table alias. All other references to the object in the FROM clause must include an object alias.

Use caution when specifying the FROM clause to provide the criteria for the update operation. The results of an UPDATE statement are undefined if the statement includes a FROM clause that is not specified in such a way that only one value is available for each column occurrence that is updated, that is if the UPDATE statement is not deterministic.

and, revealing some of the algebrization issues:

When a common table expression (CTE) is the target of an UPDATE statement, all references to the CTE in the statement must match. For example, if the CTE is assigned an alias in the FROM clause, the alias must be used for all other references to the CTE. Unambiguous CTE references are required because a CTE does not have an object ID, which SQL Server uses to recognize the implicit relationship between an object and its alias. Without this relationship, the query plan may produce unexpected join behavior and unintended query results.

So the T-SQL example would be:

CREATE TABLE dbo.foo (
  id INTEGER NOT NULL PRIMARY KEY,
  bar INTEGER NULL
);

CREATE TABLE dbo.foo2 (
  id INTEGER NOT NULL PRIMARY KEY,
  bar INTEGER NULL
);

-- Update the alias
UPDATE F1
SET F1.bar = F2.bar
FROM dbo.foo AS F1
JOIN dbo.foo2 AS F2
    ON F2.id = F1.id -- deterministic;

One way to check an update is deterministic in SQL Server is to first write it as a MERGE, which does check for non-deterministic updates at runtime. You would not routinely write a simple update as a merge for performance reasons (and maybe because merge has a few issues of its own).