Logo

Programming-Idioms

  • Perl
  • Python

Idiom #28 Sort by a property

Sort the elements of the list (or array-like collection) items in ascending order of x.p, where p is a field of the type Item of the objects in items.

from operator import attrgetter
items = sorted(items, key=attrgetter('p'))

We use attrgetter to avoid having to write a lambda. The Operator module contains lots of useful functions that can be passed to higher-order functions.
items = sorted(items, key=lambda x: x.p)

The lambda expression pulls out the field you want to sort by. If you want to sort in reverse order, add reverse=True to the argument list.
@items = sort { $a->{p} cmp $b->{p} } @items;

sort gives your code block two items to sort: $a and $b. Two operators are commonly used: cmp to sort lexically, and <=> to sort numerically. Swapping the positions of $a and $b reverses the sort direction.
with Ada.Containers.Vectors;
use Ada.Containers;
declare
   function Compare_Function (Left, Right : Item) return Boolean is (Left.P < Right.P);
   
   package Item_Vector_Sorting is new Item_Vectors.Generic_Sorting (Compare_Function);

   use Item_Vector_Sorting;
begin
   Sort (Items);
end;
New implementation...
< > ⌨
programming-idioms.org 
items = sorted(items, key=attrgetter('p'))
items = sorted(items, key=lambda x: x.p)
@items = sort { $a->{p} cmp $b->{p} } @items;
declare
   function Compare_Function (Left, Right : Item) return Boolean is (Left.P < Right.P);
   
   package Item_Vector_Sorting is new Item_Vectors.Generic_Sorting (Compare_Function);

   use Item_Vector_Sorting;
begin
   Sort (Items);
end;
int compareProp (const void *a, const void *b)
{
    return (*(const Item**)a)->p - (*(const Item**)b)->p;
}

qsort(items, N, sizeof(Item*), compareProp);
(sort-by :p items)
std::sort(begin(items), end(items), [](const auto& a, const auto& b) { return a.p < b.p; });
struct {
    bool operator()(const Item &lhs, const Item &rhs) const { return lhs.p < rhs.p; }
} custom_sort;

std::sort(begin(items), end(items), custom_sort);
std::ranges::sort(items, {}, &Item::p);

items.OrderBy(x => x.p)
System.Array.Sort(items, Comparer<Item>.Create((a, b) => a.p - b.p));
sort!("a.p < b.p")(items);
items.sort((a, b) => (a.p).compareTo(b.p));
items.sort((a, b) => Comparable.compare(a.p, b.p));
Enum.sort_by(items, &(&1.p))
sort_by_birth(ListOfMaps) ->
  lists:sort(
    fun(A, B) ->
      maps:get(birth, A, undefined) =< maps:get(birth, B, undefined)
    end, ListOfMaps).

sort_by_birth(ListOfRecords) -> lists:keysort(#item.birth, ListOfRecords).
less := func(i, j int) bool {
	return items[i].p < items[j].p
}
sort.Slice(items, less)
compare := func(a, b Item) int {
	return cmp.Compare(a.p, b.p)
}
slices.SortFunc(items, compare)
type ItemPSorter []Item
func (s ItemPSorter) Len() int{ return len(s) }
func (s ItemPSorter) Less(i,j int) bool{ return s[i].p<s[j].p }
func (s ItemPSorter) Swap(i,j int) { s[i],s[j] = s[j],s[i] }

func sortItems(items []Item){
	sorter := ItemPSorter(items)
	sort.Sort(sorter)
}
items.sort { x -> x.p }
items.sort { x, y -> x.p <=> y.p }
List.sortOn p items
sortBy (comparing p) items
items.sort(function(a,b) {
  return compareFieldP(a.p, b.p);
});
items.sort(comparing(a -> a.p));
items.stream().sorted(Comparator.comparing(x -> x.p))
Arrays.sort(items, new Comparator<Item>(){
	public int compare(Item a, Item b){
		return a.p - b.p;
	}
});
Collections.sort(items, new Comparator<Item>(){
	@Override
	public int compare(Item a, Item b){
		return a.p - b.p;
	}
});
sort(items, comparing(x -> x.p));
items.sortedBy { it.p }

(sort #'< items :key #'p)
table.sort(items, function(a,b)
	if a.p < b.p then return true end
end)
[items sortedArrayUsingDescriptors:@[[NSSortDescriptor sortDescriptorWithKey:@"p" ascending:YES]]]
function cmp($a, $b)
{
    if ($a->p == $b->p) {
        return 0;
    }

    return ($a->p < $b->p) ? -1 : 1;
}

usort($items, 'cmp');
type

  TItem = class p: Integer; end;
  TItems = specialize TFPGObjectList<TItem>;

var items: TItems;

  function compare(const a, b: TItem): Integer;
  begin
    Result := a.p - b.p;
  end;

begin
  items := TItems.Create;
  // Add items here.
  items.Sort(@compare);
end.  
items.sort_by(&:p)
items.sort_by_key(|x| x.p);
items.sort_by(|a,b| a.p.cmp(&b.p));
items.sortBy(_.x)
case class S(x: Int)
val items = List(S(3), S(4), S(2))
items.sortBy( item: S => item.x )
(define-struct item (p x y) #:transparent)
(define items (list (item 1 2 3) (item 0 0 0) (item 5 2 1)))
(sort items < #:key item-p)
items sorted: [:x :y | x p <= y p].
items.OrderBy(Function(x) x.p)
System.Array.Sort(items, Comparer(Of Item).Create(Function(a, b) a.p - b.p))