1. 1 Python Data Structures LING 5200 Computational Corpus Linguistics Martha Palmer

2. 2 An Overview of Python

3. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 3 Basic Datatypes Integers (default for numbers) z = 5 / 2 # Answer is 2, integer division. Floats x = 3.456 Strings Can use “” or ‘’ to specify. “abc” ‘abc’ (Same thing.) Unmatched ones can occur within the string. “matt’s” Use triple double-quotes for multi-line strings or strings than contain both ‘ and “ inside of them: “““a‘b“c”””

4. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 4 Whitespace Whitespace is meaningful in Python: especially indentation and placement of newlines.  Use a newline to end a line of code. (Not a semicolon like in C++ or Java.) (Use \ when must go to next line prematurely.)  No braces { } to mark blocks of code in Python… Use consistent indentation instead. The first line with a new indentation is considered outside of the block.  Often a colon appears at the start of a new block. (We’ll see this later for function and class definitions.)

5. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 5 Comments Start comments with # – the rest of line is ignored. Can include a “documentation string” as the first line of any new function or class that you define. The development environment, debugger, and other tools use it: it’s good style to include one. def my_function(x, y): “““This is the docstring. This function does blah blah blah.””” # The code would go here...

6. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 6 Defining Functions No header file or declaration of types of function or arguments. def get_final_answer(filename): “Documentation String” line1 line2 return total_counter The indentation matters… First line with different indentation is considered to be outside of the function definition. Function definition begins with “def.” Function name and its arguments. The keyword ‘return’ indicates the value to be sent back to the caller. Colon.

7. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 7 Python and Types Python determines the data types in a program automatically.“Dynamic Typing” But Python’s not casual about types, it enforces them after it figures them out. “Strong Typing” So, for example, you can’t just append an integer to a string. You must first convert the integer to a string itself. x = “the answer is ” # Decides x is string. y = 23 # Decides y is integer. print x + y # Python will complain about this.

8. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 8 Calling a Function The syntax for a function call is: >>> def myfun(x, y): return x * y >>> myfun(3, 4) 12 Parameters in Python are “Call by Assignment.”  Sometimes acts like “call by reference” and sometimes like “call by value” in C++. Depends on the data type.  We’ll discuss mutability of data types later: this will specify more precisely how function calls behave.

9. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 9 Functions without returns All functions in Python have a return value, even ones without a specific “return” line inside the code. Functions without a “return” will give the special value None as their return value.  None is a special constant in the language.  None is used like NULL, void, or nil in other languages.  None is also logically equivalent to False.

10. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 10 Names and References 1 Python has no pointers like C or C++. Instead, it has “names” and “references”. (Works a lot like Lisp or Java.) You create a name the first time it appears on the left side of an assignment expression: x = 3 Names store “references” which are like pointers to locations in memory that store a constant or some object.  Python determines the type of the reference automatically based on what data is assigned to it.  It also decides when to delete it via garbage collection after any names for the reference have passed out of scope.

11. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 11 Names and References 2 There is a lot going on when we type: x = 3 First, an integer 3 is created and stored in memory. A name x is created. An reference to the memory location storing the 3 is then assigned to the name x. Type: Integer Data: 3 Name: x Ref: name listmemory

12. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 12 Names and References 3 The data 3 we created is of type integer. In Python, the basic datatypes integer, float, and string are “immutable.” This doesn’t mean we can’t change the value of x… For example, we could increment x. >>> x = 3 >>> x = x + 1 >>> print x 4

13. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 13 Names and References 4 If we increment x, then what’s really happening is:  The reference of name x is looked up.  The value at that reference is retrieved.  The 3+1 calculation occurs, producing a new data element 4 which is assigned to a fresh memory location with a new reference.  The name x is changed to point to this new reference.  The old data 3 is garbage collected if no name still refers to it. Type: Integer Data: 3 Name: x Ref:

14. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 14 Names and References 4 If we increment x, then what’s really happening is:  The reference of name x is looked up.  The value at that reference is retrieved.  The 3+1 calculation occurs, producing a new data element 4 which is assigned to a fresh memory location with a new reference.  The name x is changed to point to this new reference.  The old data 3 is garbage collected if no name still refers to it. Type: Integer Data: 3 Name: x Ref: Type: Integer Data: 4

15. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 15 Names and References 4 If we increment x, then what’s really happening is:  The reference of name x is looked up.  The value at that reference is retrieved.  The 3+1 calculation occurs, producing a new data element 4 which is assigned to a fresh memory location with a new reference.  The name x is changed to point to this new reference.  The old data 3 is garbage collected if no name still refers to it. Type: Integer Data: 3 Name: x Ref: Type: Integer Data: 4

16. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 16 Names and References 4 If we increment x, then what’s really happening is:  The reference of name x is looked up.  The value at that reference is retrieved.  The 3+1 calculation occurs, producing a new data element 4 which is assigned to a fresh memory location with a new reference.  The name x is changed to point to this new reference.  The old data 3 is garbage collected if no name still refers to it. Name: x Ref: Type: Integer Data: 4

17. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 17 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3

18. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 18 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3 Type: Integer Data: 3 Name: x Ref:

19. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 19 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3 Type: Integer Data: 3 Name: x Ref: Name: y Ref:

20. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 20 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3 Type: Integer Data: 3 Name: x Ref: Type: Integer Data: 4 Name: y Ref:

21. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 21 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3 Type: Integer Data: 3 Name: x Ref: Type: Integer Data: 4 Name: y Ref:

22. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 22 Assignment 1 So, for simple built-in datatypes (integers, floats, strings), assignment behaves as you would expect: >>> x = 3 # Creates 3, name x refers to 3 >>> y = x # Creates name y, refers to 3. >>> y = 4 # Creates ref for 4. Changes y. >>> print x # No effect on x, still ref 3. 3 Type: Integer Data: 3 Name: x Ref: Type: Integer Data: 4 Name: y Ref:

23. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 23 Assignment 2 But we’ll see that for other more complex data types assignment seems to work differently.  We’re talking about: lists, dictionaries, user-defined classes. We will learn details about all of these type later.  The important thing is that they are “mutable.”  This means we can make changes to their data without having to copy it into a new memory reference address each time. >>> x = 3 x = some mutable object >>> y = x y = x >>> y = 4 make a change to y >>> print x look at x 3 x will be changed as well immutablemutable

24. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 24 Assignment 3 Assume we have a name x that refers to a mutable object of some user-defined class. This class has a “set” and a “get” function for some value. >>> x.getSomeValue() 4 We now create a new name y and set y=x. >>> y = x This creates a new name y which points to the same memory reference as the name x. Now, if we make some change to y, then x will be affected as well. >>> y.setSomeValue(3) >>> y.getSomeValue() 3 >>> x.getSomeValue() 3

25. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 25 Assignment 4 Because mutable data types can be changed in place without producing a new reference every time there is a modification, then changes to one name for a reference will seem to affect all those names for that same reference. This leads to the behavior on the previous slide. Passing Parameters to Functions:  When passing parameters, immutable data types appear to be “call by value” while mutable data types are “call by reference.”  (Mutable data can be changed inside a function to which they are passed as a parameter. Immutable data seems unaffected when passed to functions.)

26. 26 Naming and Assignment Details

27. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 27 Naming Rules Names are case sensitive and cannot start with a number. They can contain letters, numbers, and underscores. bob Bob _bob _2_bob_ bob_2 BoB There are some reserved words: and, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, not, or, pass, print, raise, return, try, while

28. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 28 Accessing Non-existent Name If you try to access a name before it’s been properly created (by placing it on the left side of an assignment), you’ll get an error. >>> y Traceback (most recent call last): File " ", line 1, in -toplevel- y NameError: name ‘y' is not defined >>> y = 3 >>> y 3

29. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 29 Multiple Assignment You can also assign to multiple names at the same time. >>> x, y = 2, 3 >>> x 2 >>> y 3

30. 30 String Operations

31. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 31 String Operations We can use some methods built-in to the string data type to perform some formatting operations on strings: >>> “hello”.upper() ‘HELLO’ There are many other handy string operations available. Check the Python documentation for more.

32. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 32 String Formatting Operator: % The operator % allows us to build a string out of many data items in a “fill in the blanks” fashion.  Also allows us to control how the final string output will appear.  For example, we could force a number to display with a specific number of digits after the decimal point. It is very similar to the sprintf command of C.

33. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 33 Formatting Strings with % >>> x = “abc” >>> y = 34 >>> “%s xyz %d” % (x, y) ‘abc xyz 34’ The tuple following the % operator is used to fill in the blanks in the original string marked with %s or %d.  Check Python documentation for whether to use %s, %d, or some other formatting code inside the string.

34. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 34 Printing with Python You can print a string to the screen using “print.” Using the % string operator in combination with the print command, we can format our output text. >>> print “%s xyz %d” % (“abc”, 34) abc xyz 34 “Print” automatically adds a newline to the end of the string. If you include a list of strings, it will concatenate them with a space between them. >>> print “abc”>>> print “abc”, “def” abcabc def

35. 35 Container Types in Python

36. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 36 Container Types Last time, we saw the basic data types in Python: integers, floats, and strings. Containers are other built-in data types in Python.  Can hold objects of any type (including their own type).  There are three kinds of containers: Tuples A simple immutable ordered sequence of items. Lists Sequence with more powerful manipulations possible. Dictionaries A look-up table of key-value pairs.

37. 37 Tuples, Lists, and Strings: Similarities

38. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 38 Similar Syntax Tuples and lists are sequential containers that share much of the same syntax and functionality.  For conciseness, they will be introduced together.  The operations shown in this section can be applied to both tuples and lists, but most examples will just show the operation performed on one or the other. While strings aren’t exactly a container data type, they also happen to share a lot of their syntax with lists and tuples; so, the operations you see in this section can apply to them as well.

39. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 39 Tuples, Lists, and Strings 1 Tuples are defined using parentheses (and commas). >>> tu = (23, ‘abc’, 4.56, (2,3), ‘def’) Lists are defined using square brackets (and commas). >>> li = [“abc”, 34, 4.34, 23] Strings are defined using quotes (“, ‘, or “““). >>> st = “Hello World” >>> st = ‘Hello World’ >>> st = “““This is a multi-line string that uses triple quotes.”””

40. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 40 Tuples, Lists, and Strings 2 We can access individual members of a tuple, list, or string using square bracket “array” notation. >>> tu[1] # Second item in the tuple. ‘abc’ >>> li[1] # Second item in the list. 34 >>> st[1] # Second character in string. ‘e’

41. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 41 Looking up an Item >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’) Positive index: count from the left, starting with 0. >>> t[1] ‘abc’ Negative lookup: count from right, starting with – 1. >>> t[-3] 4.56

42. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 42 Slicing: Return Copy of a Subset 1 >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’) Return a copy of the container with a subset of the original members. Start copying at the first index, and stop copying before the second index. >>> t[1:4] (‘abc’, 4.56, (2,3)) You can also use negative indices when slicing. >>> t[1:-1] (‘abc’, 4.56, (2,3))

43. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 43 Slicing: Return Copy of a Subset 2 >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’) Omit the first index to make a copy starting from the beginning of the container. >>> t[:2] (23, ‘abc’) Omit the second index to make a copy starting at the first index and going to the end of the container. >>> t[2:] (4.56, (2,3), ‘def’)

44. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 44 Copying the Whole Container You can make a copy of the whole tuple using [:]. >>> t[:] (23, ‘abc’, 4.56, (2,3), ‘def’) So, there’s a difference between these two lines: >>> list2 = list1 # 2 names refer to 1 ref # Changing one affects both >>> list2 = list1[:] # Two copies, two refs # They’re independent

45. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 45 The ‘in’ Operator Boolean test whether a value is inside a container: >>> t = [1, 2, 4, 5] >>> 3 in t False >>> 4 in t True >>> 4 not in t False Be careful: the ‘in’ keyword is also used in the syntax of other unrelated Python constructions: “for loops” and “list comprehensions.”

46. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 46 The + Operator The + operator produces a new tuple, list, or string whose value is the concatenation of its arguments. >>> (1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) >>> [1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] >>> “Hello” + “ ” + “World” ‘Hello World’

47. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 47 The * Operator The * operator produces a new tuple, list, or string that “repeats” the original content. >>> (1, 2, 3) * 3 (1, 2, 3, 1, 2, 3, 1, 2, 3) >>> [1, 2, 3] * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] >>> “Hello” * 3 ‘HelloHelloHello’

48. 48 Mutability: Tuples vs. Lists

49. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 49 Tuples: Immutable >>> t = (23, ‘abc’, 4.56, (2,3), ‘def’) >>> t[2] = 3.14 Traceback (most recent call last): File " ", line 1, in -toplevel- tu[2] = 3.14 TypeError: object doesn't support item assignment You’re not allowed to change a tuple in place in memory; so, you can’t just change one element of it. But it’s always OK to make a fresh tuple and assign its reference to a previously used name. >>> t = (1, 2, 3, 4, 5)

50. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 50 Lists: Mutable >>> li = [‘abc’, 23, 4.34, 23] >>> li[1] = 45 >>> li [‘abc’, 45, 4.34, 23] We can change lists in place. So, it’s ok to change just one element of a list. Name li still points to the same memory reference when we’re done.

51. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 51 Slicing: with mutable lists >>> L = [‘spam’, ’Spam’, ’SPAM’] >>> L[1] = ‘eggs’ >>> L [‘spam’, ‘eggs’, ‘SPAM’] >>> L[0:2] = [‘eat’,’more’] >>> L [‘eat’, ‘more’, ‘SPAM’]

52. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 52 Operations on Lists Only 1 Since lists are mutable (they can be changed in place in memory), there are many more operations we can perform on lists than on tuples. The mutability of lists also makes managing them in memory more complicated… So, they aren’t as fast as tuples. It’s a tradeoff.

53. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 53 Operations on Lists Only 2 >>> li = [1, 2, 3, 4, 5] >>> li.append(‘a’) >>> li [1, 2, 3, 4, 5, ‘a’] >>> li.insert(2, ‘i’) >>>li [1, 2, ‘i’, 3, 4, 5, ‘a’] NOTE: li = li.insert(2,’I’) loses the list!

54. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 54 Operations on Lists Only 3 The ‘extend’ operation is similar to concatenation with the + operator. But while the + creates a fresh list (with a new memory reference) containing copies of the members from the two inputs, the extend operates on list li in place. >>> li.extend([9, 8, 7]) >>>li [1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7] Extend takes a list as an argument. Append takes a singleton. >>> li.append([9, 8, 7]) >>> li [1, 2, ‘i’, 3, 4, 5, ‘a’, 9, 8, 7, [9, 8, 7]]

55. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 55 Operations on Lists Only 4 >>> li = [‘a’, ‘b’, ‘c’, ‘b’] >>> li.index(‘b’) # index of first occurrence 1 >>> li.count(‘b’) # number of occurrences 2 >>> li.remove(‘b’) # remove first occurrence >>> li [‘a’, ‘c’, ‘b’]

56. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 56 Operations on Lists Only 5 >>> li = [5, 2, 6, 8] >>> li.reverse() # reverse the list *in place* >>> li [8, 6, 2, 5] >>> li.sort() # sort the list *in place* >>> li [2, 5, 6, 8] >>> li.sort(some_function) # sort in place using user-defined comparison

57. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 57 Tuples vs. Lists Lists slower but more powerful than tuples.  Lists can be modified, and they have lots of handy operations we can perform on them.  Tuples are immutable and have fewer features. We can always convert between tuples and lists using the list() and tuple() functions. li = list(tu) tu = tuple(li)

58. 58 String Conversions

59. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 59 String to List to String Join turns a list of strings into one string..join( ) >>> “;”.join( [“abc”, “def”, “ghi”] ) “abc;def;ghi” Split turns one string into a list of strings..split( ) >>> “abc;def;ghi”.split( “;” ) [“abc”, “def”, “ghi”] >>> “I love New York”.split() [“I”, “love”, “New”, “York”]

60. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 60 Convert Anything to a String The built-in str() function can convert an instance of any data type into a string.  You can define how this function behaves for user-created data types. You can also redefine the behavior of this function for many types. >>> “Hello ” + str(2) “Hello 2”

61. 61 Dictionaries

62. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 62 Basic Syntax for Dictionaries 1 Dictionaries store a mapping between a set of keys and a set of values.  Keys can be any immutable type.  Values can be any type, and you can have different types of values in the same dictionary. You can define, modify, view, lookup, and delete the key-value pairs in the dictionary.

63. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 63 Basic Syntax for Dictionaries 2 >>> d = {‘user’:‘bozo’, ‘pswd’:1234} >>> d[‘user’] ‘bozo’ >>> d[‘pswd’] 1234 >>> d[‘bozo’] Traceback (innermost last): File ‘ ’ line 1, in ? KeyError: bozo

64. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 64 Basic Syntax for Dictionaries 3 >>> d = {‘user’:‘bozo’, ‘pswd’:1234} >>> d[‘user’] = ‘clown’ >>> d {‘user’:‘clown’, ‘pswd’:1234} Note: Keys are unique. Assigning to an existing key just replaces its value. >>> d[‘id’] = 45 >>> d {‘user’:‘clown’, ‘id’:45, ‘pswd’:1234} Note: Dictionaries are unordered. New entry might appear anywhere in the output.

65. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 65 Basic Syntax for Dictionaries 4 >>> d = {‘user’:‘bozo’, ‘p’:1234, ‘i’:34} >>> del d[‘user’] # Remove one. >>> d {‘p’:1234, ‘i’:34} >>> d.clear() # Remove all. >>> d {}

66. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 66 Basic Syntax for Dictionaries 5 >>> d = {‘user’:‘bozo’, ‘p’:1234, ‘i’:34} >>> d.keys() # List of keys. [‘user’, ‘p’, ‘i’] >>> d.values() # List of values. [‘bozo’, 1234, 34] >>> d.items() # List of item tuples. [(‘user’,‘bozo’), (‘p’,1234), (‘i’,34)]

67. 67 Assignment and Containers

68. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 68 Multiple Assignment with Container Classes We’ve seen multiple assignment before: >>> x, y = 2, 3 But you can also do it with containers.  The type and “shape” just has to match. >>> (x, y, (w, z)) = (2, 3, (4, 5)) >>> [x, y] = [4, 5]

69. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 69 Empty Containers 1 We know that assignment is how to create a name. x = 3 Creates name x of type integer. Assignment is also what creates named references to containers. >>> d = {‘a’:3, ‘b’:4} We can also create empty containers: >>> li = [] >>> tu = () >>> di = {} Note: an empty container is logically equivalent to False. (Just like None.)

70. LING 5200, 2006 BASED on Matt Huenerfauth’s Python Slides 70 Empty Containers 2 Why create a named reference to empty container? You might want to use append or some other list operation before you really have any data in your list. This could cause an unknown name error if you don’t properly create your named reference first. >>> g.append(3) Python complains here about the unknown name ‘g’! >>> g = [] >>> g.append(3) >>> g [3]