注：本文整理自 http://www.slideshare.net/MattHarrison4/learn-90

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Three Python‘isms to Remember

●dir

●help

●colon/indent shuffle

一、hello world

print "hello world"

from interpreter

$ python

>>> print "hello world"

hello world

REPL

Read, Eval, Print, Loop

$ python

>>> 2 + 2  # read, eval

4 # print

>>>   # repeat (loop)

Many developers keep a REPL handy during programming

From script
Make file hello.py with print "hello world"
Run with: python hello.py

(unix) script
Make file hello with
#!/usr/bin/env python
print "hello world"
Run with:
chmod +x hello
./hello

Python 3 hello world
printis no longer a statement, but a function
print("hello world")

二、Objects

Everything in Python is an object that has:

●an identity(id)

●a value(mutable or immutable)

id
>>> a = 4
>>> id(a)
6406896

Value
●Mutable:When you alter the item, the  id is still the same. Dictionary, List
●Immutable:String, Integer, Tuple

Mutable
>>> b =[]
>>> id(b)
140675605442000
>>> b.append(3)
>>> b
[3]

>>> id(b)
140675605442000 # SAME!

Immutable
>>> a = 4
>>> id(a)
6406896
>>> a =a + 1
>>> id(a)
6406872 # DIFFERENT!

三、Variables

a = 4  # Integer
b = 5.6  # Float
c = "hello"  # String
a = "4"  # rebound to String

Long

>>> import sys
>>> sys.maxint
9223372036854775807
>>> sys.maxint + 1
9223372036854775808L

四、Naming

●lowercase

●underscore_between_words

●don‘t start with numbers

See PEP 8

PEP：Python Enhancement Proposal (similar to JSR in Java)

+, -, *, /, **(power), %(modulo)

Careful with integer division
>>> 3/4
0
>>> 3/4.
0.75
(In Python 3 // is integer division operator)

name = ‘matt‘
with_quote = "I ain‘t gonna"
longer = """This string has
multiple lines
in it"""

String escaping
Escape with \
>>> print ‘He said, "I\‘m sorry"‘
He said, "I‘m sorry"
>>> print ‘‘‘He said, "I‘m sorry"‘‘‘
He said, "I‘m sorry"
>>> print """He said, "I‘m sorry\""""
He said, "I‘m sorry"

String formatting
c-like
>>> "%s %s" %(‘hello‘, ‘world‘)
‘hello world‘
PEP 3101 style
>>> "{0} {1}".format(‘hello‘, ‘world‘)
‘hello world‘

String Methods 

●s.endswith(sub)
Returns True if endswith sub
●s.find(sub)
Returns index of subor -1
●s.format(*args)
Places args in string

●s.index(sub)
Returns index of subor exception
●s.join(list)
Returns listitems separated by string
●s.strip()
Removes whitespace from start/end

dir
Lists attributes and methods:
>>> dir("a string")
[‘__add__‘, ‘__class__‘, ..., ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]

dunder methods
dunder(double under) or "special/magic"  methods determine what will happen  when +(__add__) or /(__div__) is  called.

help
>>> help("a string".startswith)
Help on built-in function startswith:
startswith(...)
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.

Comments follow a #

No multi-line comments

None
Pythonic way of saying NULL. Evaluates to False.
c = None

booleans
a = True
b = False

sequences
●lists
●tuples
●sets

十、Lists

Hold sequences.
How would we find out the attributes & methods of a list?

>>> dir([])
[‘__add__‘, ‘__class__‘, ‘__contains__‘,... ,‘__iter__‘,... ‘__len__‘,... , ‘append‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, 
‘reverse‘, ‘sort‘]

>>> a =[]
>>> a.append(4)
>>> a.append(‘hello‘)
>>> a.append(1)
>>> a.sort() # in place
>>> print a
[1, 4, ‘hello‘]

How would we find out documentation for a method?

>>> help([].append)
Help on built-in function append:
append(...)

L.append(object) -- append object to end

List methods

●l.append(x)
Insert x at end of list
●l.extend(l2)
Add l2 items to list
●l.sort()

In place sort

●l.reverse()
Reverse list in place
●l.remove(item)
Remove first item found
●l.pop()
Remove/return item at end of list

十一、Dictionaries

Also called hashmap or associative array elsewhere
>>> age ={}
>>> age[‘george‘] = 10
>>> age[‘fred‘] = 12
>>> age[‘henry‘] = 10
>>> print age[‘george‘]
10

Find out if ‘matt‘ in age
>>> ‘matt‘ in age
False

in statement
Uses __contains__dunder method to determine membership. (Or __iter__as fallback)

.get
>>> print age[‘charles‘]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘charles‘
>>> print age.get(‘charles‘, ‘Not found‘)
Not found

deleting keys
Removing ‘charles‘ from age
>>> delage[‘charles‘]

del not in dir.   .pop is an alternative

十二、Functions

def add_2(num):

""" return 2

more than num

"""

return num + 2

five =add_2(3)

●def
●function name
●(parameters)
●:+ indent
●optional documentation
●body
●return

whitespace
Instead of { use a : and indent consistently (4 spaces)

invoke python -tt to error out during inconsistent tab/space usage in a file

default (named) parameters
def add_n(num, n=3):

"""default to

adding 3"""

return num +n

five =add_n(2)
ten =add_n(15, -5)

__doc__
Functions have docstrings. Accessible via .__doc__or help

>>> def echo(txt):

...   "echo back txt"

...   return txt

>>> help(echo)
Help on function echo in module __main__:
<BLANKLINE>
echo(txt)

echo back txt

<BLANKLINE>

naming
●lowercase
●underscore_between_words
●don‘t start with numbers
●verb
See PEP 8

十三、Conditionals

if grade > 90:

print "A"

elif grade > 80:

print "B"

elif grade > 70:

print "C"

else:

print "D"

Remember the colon/whitespace!

十四、Operators

Comparison Operators
Supports (>, >=, <, <=, ==, !=)
>>> 5 > 9
False
>>> ‘matt‘ != ‘fred‘
True
>>> isinstance(‘matt‘, basestring)
True

>>> type("matt")
<type ‘str‘>

Boolean Operators
and, or, not(for logical), &, |, and ^(for bitwise)
>>> x = 5
>>> x < -4 or x > 4
True

Boolean note
Parens are only required for precedence
if (x > 10):

print "Big"

same as
if x > 10:

print "Big"

Chained comparisons

if 3 <x < 5:

print "Four!"

Same as
if x > 3 and x < 5:

print "Four!"

十五、Iteration

for number in [1,2,3,4,5,6]:

print number

for number in range(1, 7):

print number

range note
Python tends to follow half-open interval ([start,end)) with range and slices.
●end - start = length

●easy to concat ranges w/o overlap

Java/C-esque style of object in array, access (BAD):
animals =["cat", "dog", "bird"]
for index in range(len(animals)):

print index, animals[index]

If you need indices, use enumerate

animals =["cat", "dog", "bird"]
for index, value in enumerate(animals):

print index, value

Can breakout of nearest loop

for item insequence:

# process until first negative

if item < 0:

break

# process item

Can continue to skip over items

for item in sequence:

if item < 0:

continue

# process all positive items

Can loop over lists, strings, iterators, dictionaries... sequence like things:

my_dict ={ "name": "matt", "cash": 5.45}
for key inmy_dict.keys():

# process key

for value inmy_dict.values():

# process value

for key, value inmy_dict.items():

# process items

pass
pass is a null operation
for i in range(10):

# do nothing 10 times

pass

Hint: Don‘t modify list or dictionary contents while looping over them

十六：Slicing

Sequences (lists, tuples, strings, etc) can be sliced to pull out a single item

my_pets =["dog", "cat", "bird"]

favorite =my_pets[0]

bird =my_pets[-1]

Negative Indexing

Proper way to think of [negative indexing] is to reinterpret a[-X] as a[len(a)-X]

Slices can take an end index, to pull out a list of items
my_pets =["dog", "cat", "bird"] 
# a list
cat_and_dog =my_pets[0:2]
cat_and_dog2 =my_pets[:2]
cat_and_bird =my_pets[1:3]

cat_and_bird2 =my_pets[1:]

Slices can take a stride
my_pets =["dog", "cat", "bird"] 
# a list
dog_and_bird =my_pets[0:3:2]
zero_three_etc = range(0,10)[::3]

Just to beat it in
veg = "tomatoe"
correct =veg[:-1]
tmte =veg[::2]
eotamot =veg[::-1]

十八：File IO

File Input
Open a file to read from it (old style):
fin = open("foo.txt")
for line in fin:

# manipulate line

fin.close()

File Output
Open a file using ‘w‘ to writeto a file:
fout = open("bar.txt", "w")
fout.write("hello world")
fout.close()

Always remember to close your files!

closing with with implicit close(new 2.5+ style)
with open(‘bar.txt‘) as fin:
for line in fin:

# process line

十九：Classes

class Animal(object):

def __init__(self, name):

self.name =name

def talk(self):

print "Generic Animal Sound"

animal =Animal("thing")
animal.talk()

notes:
●object(base class) (fixed in 3.X)
●dunder init (constructor)
●all methods take self as first parameter

Subclassing
class Cat(Animal):

def talk(self):

print ‘%ssays, "Meow!"‘ %(self.name)

cat =Cat("Groucho")
cat.talk() # invoke method

class Cheetah(Cat):

"""classes can hav

docstrings"""

def talk(self):

print "Growl"

naming
●CamelCase
●don‘t start with numbers

●Nouns

二十、Debugging

Poor mans
print works a lot of the time

Remember Clean up print statements. If you really need them, use logging or write to sys.stdout

pdb
import pdb; pdb.set_trace()

pdb commands
●h- help
●s- step into
●n- next
●c- continue
●w- where am I (in stack)?
●l- list code around me

90% of python in 90 minutes