Python

Python is a...
- popular,
- high-level,
- flexible,
- object-oriented,
- dynamically-typed,
- open-source,
- interpreted
- programming language,
- invented (in 1990) and still overseen by Guido van Rossum
Python's philosophy: make it clear and simple
- A "Hello, world!" program in Java (must be compiled before running)
```
public class HelloWorld
{
    public static void main (String[] args)
    {
        System.out.println("Hello, world!");
    }
}
```
- A "Hello, world!" program in Python (no need to explicitly compile before running)
```
print("Hello, world!")
```

The interpreter, IDLE

Python can be run as an interpreted language.
- You can enter Python expressions on a command line in a shell and see what they evaluate to.
```
>>> print("Hello, world!")
Hello, world!
>>> 31234 * (762 + 181)
29453662
```
  Note that in Python 2 the print statement would be:
```
>>> print "Hello, world!"
```
Python comes with an integrated development called IDLE that includes an interpreter shell and a smart editor

Indentation, lines, and statements

In Python, indentation is used to delimit blocks of code. An increase in indentation follows certain statements.

def check_tense(sentence, tns):
    if not tns:
	    print('Warning: no tense associated with', sentence, '!')
    	return False
    else:
    	print(sentence, 'has tense', tns)
    	return sentence

Lines and statements
- A statement normally takes up a physical line, that is, a string of characters followed by a newline, not a semicolon as in many other languages.
- But if you have a very long expression, you can split it onto multiple physical lines with one ore more backslashes.
```
>>> 'Expecting the world to treat you fairly because you are good ' + \
      'is like expecting the bull not to charge because you are a vegetarian.'
'Expecting the world to treat you fairly because you are good is like expecting the bull not to charge because you are a vegetarian.'
```
- And if you have a series of very short statements, you can combine them on a single line, separated by semicolons.
```
>>> input('A number? '); input('Try again? ')
A number? 11
'11'
Try again? no
'no'
```

Variables

Python is a dynamically typed language.
A type is not specified when a variable is initially assigned a value.
```
>>> x = 3
```
Variables may change their types.
```
>>> x = "three"
```
In function definitions, neither parameters nor return values have their types specified.

Types

Type/class names are functions, which can be used to "cast" objects to a different type.
```
>>> int(5.0)
5
>>> float(5)
5.0
>>> str(5)
'5'
>>> int('5')
5
```

Sequences

There are three basic sequence types: strings (str), tuples (tuple), and lists(list)

Accessing elements in sequences uses indices between square brackets, as in other languages. Negative indices start from the end of the sequence (-1 represents the last element).

>>> goodbye_jp = 'さようなら'
>>> goodbye_jp[1]
'よ'
>>> goodbye_jp[-2]
'な'
>>> goodbye_ls = ['до свидания', 'adiós', 'さようなら']
>>> goodbye_ls[0]
'до свидания'
>>> goodbye_ls[0][3]
'с'
>>> hello_tup = 'أهلاً', '你好', 'नमस्ते'
>>> type(hello_tup[2])
<class 'str'>
>>> hello_tup[0][0]
'أ'
>>> tuple(goodbye_ls[-1])
('さ', 'よ', 'う', 'な', 'ら')

Strings and tuples are immutable; lists are mutable.

Assigning elements in lists uses indices between square brackets

>>> goodbye_ls[1] = 'hasta luego'
>>> goodbye_ls
['до свидания', 'hasta luego', 'さようなら']
>>> goodbye_ls[1][0] = 'H'
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    goodbye_ls[1][0] = 'H'
TypeError: 'str' object does not support item assignment

Strings that contain the same sequence of characters represent the same object.
Two lists or tuples containing the same elements may be different objects. (== tests whether two objects "look" the same; is tests whether they are the same object.)
```
>>> x = []
>>> y = []
>>> x == y
True
>>> x is y
False
```

Working with sequences

Slices allow us to access multiple elements from a sequence.
- In its simplest version, a slice looks like this [index1:index2]; this accesses the elements in the sequence starting with index1 and up to, but not including index2. The number before the colon defaults to 0, and the number after the colon defaults to the length of the sequence, so you can leave either of these out.
```
>>> l = 'linguistics'
>>> l[1:5]
'ingu'
>>> l[5:-1]
'istic'
>>> l[5:]
'istics'
>>> l[:5]
'lingu'
```
- There may also be a second colon and a third number; this specifies how many elements to skip in the sequence that's returned.
```
>>> l[::2]
'lnusis'
>>> l[1::2]
'igitc'
>>> l[-1::-1]
'scitsiugnil'
```
- Each slice of a list creates a new list.
```
>>> l = ['computational', 'linguistics']
>>> l[:]
['computational', 'linguistics']
>>> l is l[:]
False
```

To add an element to the end of a list, use the append method. To concatenate another list onto a list, use the extend method. Both are mutating functions that return nothing.

>>> l.append('is')
>>> l
['computational', 'linguistics', 'is']
>>> l.extend(['a', 'lot', 'of', 'fun'])
>>> l
['computational', 'linguistics', 'is', 'a', 'lot', 'of', 'fun']

There are many built-in methods for strings. Here are some especially useful ones.

>>> l = 'linguistics is a lot of fun'
>>> l.split()
['linguistics', 'is', 'a', 'lot', 'of', 'fun']
>>> l.replace('is', 'was')
'linguwastics was a lot of fun'
>>> ' '.join(['linguistics', 'is', 'a', 'lot', 'of', 'fun'])
'linguistics is a lot of fun'

More collections

Dictionaries

>>> verb_feats = {'tns': 'past', 'asp': 'prog', 'pers': 3, 'num': 'plur'}
>>> verb_feats['asp']
'prog'
>>> verb_feats['gen'] = 'fem'

The in operator tests whether an object is a member of a collection (in the case of dictionaries, one of the keys)
```
>>> 'ó' in 'adiós'
True
>>> 'di' in 'adiós'
True
>>> 'di' in ['adiós']
False
>>> 'asp' in verb_feats
True
```
The built-in function len returns the length of a collection.

Function definitions

Another example

def find_sent(word, sentences):
    """Returns the first sentence in sentences containing word.

    word: str
    sentences: list of lists of strs
    return: list of strs
    """
    for sentence in sentences:
        if word in sentence:
            return sentence
    return []

Docstrings consist of strings within triple quotes.

>>> help(find_sent)
Help on function find_sent in module __main__:

find_sent(word, sentences)
    Returns the first sentence in sentences containing word.
    
    word: str
    sentences: list of lists of strs
    return: list of strs

Optional arguments to functions

Optional parameters are specified in the function definition by putting =default_value after the parameter name.
```
def read_data(filename="data"):
   ...
```
There can be any number of optional parameters, as long as none of them appear before the obligatory parameters in the parameter list.
```
def conjugate(verb, tense="present", person="3", number="singular"):
   ...
```
When you call a function with optional arguments, you can leave out any or all of the optional arguments. If you refer to the arguments in the same order as in the function definition, you don't need to use the parameter names; otherwise they're required.
```
>>> conjugate('pedir')
>>> conjugate('pedir', 'past')
>>> conjugate('pedir', 'past', '1', 'plural')
>>> conjugate('pedir', person='1')
>>> conjugate('pedir', number='singular', person='1', tense='past')
```
Practice with function definitions and dictionaries
- Here's a dictionary of translations of English adjectives to Spanish adjectives. Notice that the Spanish adjectives have multiple forms corresponding to one English adjective, maximally four (masculine singular and plural, feminine singular and plural).
```
EN2ES_ADJ = {'happy': {'s': {'m': 'contento', 'f': 'contenta'}, 'p': {'m': 'contentos', 'f': 'contentas'}},
             'sad': {'s': 'triste', 'p': 'tristes'},
             'poor': {'s': 'pobre', 'p': 'pobres'},
             'rich': {'s': {'m': 'rico', 'f': 'rica'}, 'p': {'m': 'ricos', 'f': 'ricas'}}}
```
- Write a function that takes an English adjective and optional number and gender arguments and provides the Spanish translation. With no gender specified, it uses masculine; with no number, it uses plural.
```
>>> en2es_adj('poor')
'pobre'
>>> en2es_adj('rich')
'rico'
>>> en2es_adj('rich', number='p')
'ricos'
>>> en2es_adj('rich', number='p', gender='f')
'ricas'
>>> en2es_adj('good')
There is no entry for good
```

Loops

while loops
```
while condition:
    statements
```

for loops

seq must be a collection or, more generally, an iterable
```
for var in seq:
    statements
```

With sequences of sequences, multiple variables are possible

>>> nums = [('one', 'uno', 'peteĩ'), ('two', 'dos', 'mokõi'), ('three', 'tres', 'mbohapy')]
>>> for en, es, gn in nums:
	print(en, '=', es, '/', gn)

one = uno / peteĩ
two = dos / mokõi
three = tres / mbohapy

Importing

To import functions, constants, and classes from another module, use an import statement.

Import statements take two forms.

>>> import math
>>> math.exp(5.0)
148.4131591025766
>>> from math import *
>>> exp(5.0)
148.4131591025766

Object-oriented programming

class Sentence:
    """Simple representation of a sentence."""

    def __init__(self, words, verb='', sbj=''):
        """Assign basic attributes.

        words: list of strings
        verb: string
        sbj: string
        """
        self.words = words
        self.verb = verb
        self.sbj = sbj

    def __repr__(self):
        return "<" + ' '.join(self.words) + '>'

    def search_verb(self, lexicon):
        """Look for the verb in a lexicon (a dictionary)."""
        return lexicon.get(self.verb)

    def n_grams(self, n):
        """List of n-grams within the sentence."""
        words = [''] + self.words + ['']
        return [words[i:i+n] for i in range(len(words)-n+1)]
#        result = []
#        for i in range(len(words)-n+1):
#            result.append(words[i:i+n])
#        return result

class TransitiveSentence(Sentence):
    """Sentence with an object."""

    def __init__(self, words, verb='', sbj='', obj=''):
        """Assign object as well as other attributes."""
        Sentence.__init__(self, words, verb=verb, sbj=sbj)
        self.obj = obj

File IO

To open a stream to a file for reading or writing, use the built-in function open, which takes a string representing the path to the file, and an argument representing what to do with the file: 'r' for read (the default), 'w' for write, 'a' for append.
If the file contains, or is to contain, unicode, use the additional argument encoding='utf8'.

A read stream object can be used as an iterable over the lines in the file in a for loop.

>>> file1 = open('am2.txt', encoding='utf8')
>>> for line in file1:
	print(line.strip())

ምአራፍ 6
ነጻነት በዛብህ ወላጆቹን ከድቶ ማንኩሳን አንደለቀቀ ዋሸራ ወደምትባል አገር ሄዶ ቅኔ ቤት ገባ።
በዋሸራም አንድ ዓመት እንደቆየ ቅኔ ተቀኝቶ ዝማሬ መዋሲት ለማካሄድ ወደ ዙር አምባ ሄደ።
ዙር አምባ ሁለት ዓመት ያክል ቆይቶ ዝማሬ መዋሲትና ጽህፈት አወቀ።
በመጨረሻ ደብረወርቅ አምትባል አገር አዲስ የመጽሃፍ መምህር ከጎንደር መምጣታችውን ስለስማ፣
ወደዚያ ሄዶ መጽሓፍ ለመቀጸል ወሰነ።
>>> file.close()

Other useful functions and methods

>>> file2 = open('es1.txt', 'w', encoding='utf8')
>>> print("¿Cómo estás?", file=file2)
>>> file2.write("Muy bien. ¿Y tú?\n")
17
>>> file2.close()
>>> file3 = open('es1.txt', encoding='utf8')
>>> file3.readline()
'¿Cómo estás?\n'
>>> file3.close()
>>> file4 = open('es1.txt', encoding='utf8')
>>> file4.read()
'¿Cómo estás?\nMuy bien. ¿Y tú?\n'

Practice
- Starting with this file, write a function that reads in text from a file in which each line represents a sentence.
- Create a Sentence object for each line, omitting the last character (end-of-sentence punctuation), and return the list of Sentences.

main

If we would like a Python file to be callable as a self-standing program, we usually want to tell the interpreter what function should be called. We do this with an if statement with a condition that checks whether the current name space is __main__:
```
if __name__ == '__main__':
    <stuff to do>
```
In addition, we need to add a line like the following that specifies the path to Python on the computer. (If you have multiple versions of Python on your computer, you may need to specify which one, for example, python3.2.)
```
#! /usr/bin/env python
```
and we need to make the module file executable. In Unix we do this as follows:
```
chmod a+x <module name>
```
Any arguments passed to the program become (string) elements of a list called sys.argv; the program (module) name is the first element of this list. Note that the sys library must be imported.

Here is a simple example.

#! /usr/bin/env python3.2

import sys, math

if __name__ == '__main__':
    angle = int(input('Type in an angle: '))
    if len(sys.argv) > 1 and sys.argv[1] == 'degrees':
        angle = math.radians(angle)
    print('Cosine: ', math.cos(angle))

Here is how you'd run the program from a terminal window, assuming you're in the directory where it resides.
```
% ./cos.py
Type in an angle: 45
Cosine:  0.5253219888177297
```