Learn Python in One Hour

Programming by Example

Victor R. Volkman

• Publisher: Modern History Press
• Year: 2017
• Print ISBN: 9781615992393
• eBook ISBN: 9781615992409
• Topic: Computer Science
• Subtopic: Programming in Python
• Index: Computer Science

You're already a smart person, you don't need a 1000+ page book to get you started on the web's fastest growing programming platform. Instead, Learn Python in One Hour delivers on the promise of code literacy while saving your most precious commodity - time itself. Volkman's innovative programming-by-example approach means you focus on usage, not mindless detail. Based on the author's sold-out live seminars, you'll see Python's flexible coding technique in action as we refactor from script to procedural to object-oriented during actual problem solving.
In a twelve-lesson progression, you'll be exposed to this and more:

• Basic file input and output operations, incuding exceptions
• Using functions to compute and return  multiple values
• Basic elements of a class definition and how to call methods
• Lists, dictionaries, sets, and other collections
• Iteration through collections, files, sorted sets
• Searching strings with regular expressions (regex)
• Client and server programs for REST methods
• Using threads in Python for multiple tasks
• CGI-BIN programming for simple HTML Forms processing
• Six most common Python pitfalls

Take the One Hour challenge and see if you too can pick up 90% of syntax and semantics in less time than you probably spend commuting each day.

About the Author Victor R. Volkman graduated cum laude from Michigan Technological University with a BS in Computer Science in 1986. Since then, he has written for numerous publications, including The C Gazette, C++ Users Journal, Windows Developers Journal, and many others. He has taught college-level programming courses at Washtenaw Community College and has served on its Computer Information Science (CIS) Faculty Advisory Board for more than a decade. Volkman says Python helped him "rediscover the joy of programming again."

From Modern Software Press

Lesson Six – A Dictionary of Lists

We’ve developed our word frequency count as far as it’s going to go, so the next type of analysis we’ll add is that of an “index.” By index, I mean the type of reference you find in the back of an old-fashioned paper book, which shows each word and the number of the page on which it appears. In our case, we’ll show each word and the line number it appears on:

1:# Exercise #6: dictionary of lists

2:

3:import collections

4:

5:def openFile():

6:fh = None

7:try:

8:fh = open("c:/temp/input.txt", "r", encoding="ascii")

9:except OSError as e:

10:print("error %d reading file %s" % (e.errno, e.filename))

11:quit()

12:return fh

13:

14:def processFile(fh):

15:numWords = 0

16:wordFreq = collections.Counter()

17:wordIndex = collections.defaultdict(list)

18:lineNum = 0

19:for line in fh:

20:lineNum += 1

21:words = line.split()

22:numWords += len(words)

23:for word in words:

24:wordFreq[word] += 1

25:wordIndex[word]. append(str(lineNum))

26:fh.close()

27:return (numWords, wordFreq, wordIndex)

28:

29:def printReport(stats):

30:(numWords, wordFreq, wordIndex) = stats

31:print("I got %d words" % numWords)

32:for key in sorted(wordFreq.keys()):

33:print("key %-12s found %2d times" % (key, wordFreq[key]))

34:for key in sorted(wordIndex.keys()):

35:print("key %-12s found on lines: %s" % (key,

36:",".join(wordIndex[key])))

37:

38:def main():

39:fh = openFile()

40:stats = processFile(fh)

41:printReport(stats)

42:

43:if __name__ == "__main__":

44:main()

Okay, this code is getting kind of long, so we’ll simply focus in on the boldfaced code, which is new since the previous lesson. On line #17, we create wordIndex as a defaultdict where each entry is a list. Although we have never previously declared the data types of what’s inside a container, doing so is necessary to harness the power of defaultdict. Those of you familiar with Java and C++ are used to having to script out elaborate declarations of every type of data structure in advance. Normally with a Python dictionary, you need to test for the presence of an entry before you can increment or append an item. With defaultdict, you get a blank entry automatically generated of the type you specified (list in this case). Specifically, an empty list [ ] in this case. Technically, list is a factory function that supplies missing values.

On line #25, we’re appending the current line number in the file to the value in wordIndex which is specified by the value of word.

On lines #35-36, we’re dumping out the content of the list of lines as a comma-separated list via the join() string method. This is a handy way to produce any value-separated string from a list of strings. Because it only works on strings, we had to cast the numbers to strings back on line #25 as shown below:

25:wordIndex[word].append(str(lineNum))

Also on lines #35-36, notice that we have split the code between two lines. Normally Python requires an entire statement to fit on one line. Because we had a “live” open parenthesis on line #35, we can carry over to line #36 and keep typi...

Table of contents

• Cover Page
• Title Page
• Copyright
• Contents
• Why Python?
• Why One Hour?
• Where to Get Python?
• Lessons Overview and Goals:
• Preface to the 2nd Edition
• Lesson One – Opening Arguments
• Lesson Two – Using Your Words
• Lesson Three – When Things Go Wrong
• Lesson Four – What’s the Frequency, Kenneth?
• Lesson Five – Fun with Functions
• Lesson Six – A Dictionary of Lists
• Lesson Seven – A Touch of Class
• Lesson Eight – Keeping it Regular
• Lesson Nine – Taking a REST
• Lesson Ten - Untangling Threads
• Lesson Eleven - Spin a Web
• Lesson Twelve - No REST for the wicked
• Python Pitfalls
• Where Do We Go From Here?
• Recommended Resources
• About the Author