The easiest way to sort is with the sorted(list) function, which takes a list and returns a new list with those elements in sorted order. The original list is not changed.
type=codeblock|id=py3_sorting|autocreate=python3a = [5, 1, 4, 3]print(sorted(a)) ## [1, 3, 4, 5]print(a) ## [5, 1, 4, 3]
It's most common to pass a list into the sorted() function, but in fact it can take as input any sort of iterable collection. The older list.sort() method is an alternative detailed below. The sorted() function seems easier to use compared to sort(), so I recommend using sorted().
The sorted() function can be customized through optional arguments. The sorted() optional argument reverse=True, e.g. sorted(list, reverse=True), makes it sort backwards.
type=codeblock|id=py3_sorting_reverse|autocreate=python3strs = ['aa', 'BB', 'zz', 'CC']print(sorted(strs)) ## ['BB', 'CC', 'aa', 'zz'] (case sensitive)print(sorted(strs, reverse=True)) ## ['zz', 'aa', 'CC', 'BB']
For more complex custom sorting, sorted() takes an optional key= specifying a key function that transforms each element before comparison. The key function takes in 1 value and returns 1 value, and the returned "proxy" value is used for the comparisons within the sort.
For example with a list of strings, specifying key=len (the built in len() function) sorts the strings by length, from shortest to longest. The sort calls len() for each string to get the list of proxy length values, and then sorts with those proxy values.
type=codeblock|id=py3_sorting_custom|autocreate=python3strs = ['ccc', 'aaaa', 'd', 'bb']print(sorted(strs, key=len)) ## ['d', 'bb', 'ccc', 'aaaa']
As another example, specifying str.lower as the key function is a way to force the sorting to treat uppercase and lowercase the same:
type=codeblock|id=py3_sorting_custom_2|autocreate=python3## "key" argument specifying str.lower function to use for sortingstrs = ['BB', 'zz', 'CC', 'aa']print(sorted(strs, key=str.lower)) ## ['aa', 'BB', 'CC', 'zz']
You can also pass in your own my_function as the key function, like this:
type=codeblock|id=py3_sorting_custom_3|autocreate=python3## Say we have a list of strings we want to sort by the last letter of the string.strs = ['xc', 'zb', 'yd' ,'wa']## Write a little function that takes a string, and returns its last letter.## This will be the key function (takes in 1 value, returns 1 value).def my_function(s):return s[-1]## Now pass key=my_function to sorted() to sort by the last letter:print(sorted(strs, key=my_function)) ## ['wa', 'zb', 'xc', 'yd']
To use key= custom sorting, remember that you provide a function that takes one value and returns the proxy value to guide the sorting. There is also an optional argument cmp=cmpFn to sorted() that specifies a traditional two-argument comparison function that takes two values from the list and returns negative/0/positive to indicate their ordering. The built in comparison function for strings, ints, ... is cmp(a, b), so often you want to call cmp() in your custom comparator. The newer one argument key= sorting is generally preferable.
As an alternative to sorted(), the sort() method on a list sorts that list into ascending order, e.g. list.sort(). The sort() method changes the underlying list and returns None, so use it like this:
alist.sort() ## correctalist = blist.sort() ## NO incorrect, sort() returns None
The above is a very common misunderstanding with sort() -- it does not return the sorted list. The sort() method must be called on a list; it does not work on any enumerable collection (but the sorted() function above works on anything). The sort() method predates the sorted() function, so you will likely see it in older code. The sort() method does not need to create a new list, so it can be a little faster in the case that the elements to sort are already in a list.
The open() function opens and returns a file handle that can be used to read or write a file in the usual way. The code f = open('name', 'r') opens the file into the variable f, ready for reading operations, and use f.close() when finished. Instead of 'r', use 'w' for writing, and 'a' for append. The special mode 'rU' is the "Universal" option for text files where it's smart about converting different line-endings so they always come through as a simple '\n'.
The standard for-loop works for text files, iterating through the lines of the file (this works only for text files, not binary files). The for-loop technique is a simple and efficient way to look at all the lines in a text file:
# Echo the contents of a filef = open('foo.txt', 'rU')for line in f: ## iterates over the lines of the fileprint(line, end=' ') ## end=' ' so print does not add an end-of-line char## since 'line' already includes the end-of line.f.close()
Reading one line at a time has the nice quality that not all the file needs to fit in memory at one time -- handy if you want to look at every line in a 10 gigabyte file without using 10 gigabytes of memory. The f.readlines() method reads the whole file into memory and returns its contents as a list of its lines. The f.read() method reads the whole file into a single string, which can be a handy way to deal with the text all at once, such as with regular expressions we'll see later.
For writing, you can either do f.write(string), or you can pass the file argument to the print function, like so: print(string, file=f).