micropython/tests/basics/list_sort.py

l = [1, 3, 2, 5]

print(l)
print(sorted(l))
l.sort()
print(l)
print(l == sorted(l))

print(sorted(l, key=lambda x: -x))
l.sort(key=lambda x: -x)
print(l)
print(l == sorted(l, key=lambda x: -x))

print(sorted(l, key=lambda x: -x, reverse=True))
l.sort(key=lambda x: -x, reverse=True)
print(l)
print(l == sorted(l, key=lambda x: -x, reverse=True))

print(sorted(l, reverse=True))
l.sort(reverse=True)
print(l)
print(l == sorted(l, reverse=True))

print(sorted(l, reverse=False))
l.sort(reverse=False)
print(l)
print(l == sorted(l, reverse=False))
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l = [1, 3, 2, 5]`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(sorted(l))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l.sort()`
			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(l == sorted(l))`

			`print(sorted(l, key=lambda x: -x))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l.sort(key=lambda x: -x)`
			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(l == sorted(l, key=lambda x: -x))`

			`print(sorted(l, key=lambda x: -x, reverse=True))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l.sort(key=lambda x: -x, reverse=True)`
			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(l == sorted(l, key=lambda x: -x, reverse=True))`

			`print(sorted(l, reverse=True))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l.sort(reverse=True)`
			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(l == sorted(l, reverse=True))`

			`print(sorted(l, reverse=False))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00			`l.sort(reverse=False)`
			`print(l)`
Add tests for sorted() function and check that sorted(list) produces same output as list.sort() 2014-04-07 03:41:54 +00:00			`print(l == sorted(l, reverse=False))`
This implements a better (more python-conformant) list.sort. It's not really about that, though; it's about me figuring out a sane way forward for keyword-argument functions (and function metadata). But it's useful as is, and shouldn't break any existing code, so here you have it; I'm going to park it in my mind for a bit while sorting out the rest of the dict branch. 2014-01-07 17:29:16 +00:00