LEARN PYTHON THE HARD WAY 自学笔记

x="There are %d type of people." % 10
binary="binary"
do_not="don't"
y="Those who know %s and those who %s." %(binary,do_not)


**字符串赋值时既可以使用占位符，并且可以引用变量**
print x
print y

print "I said: %r."% x
print "I also said: '%s'." %y

""" %r和%s是不一样的，%r使用rper()方法处理字符串，返回结果会多一个引号,前者通常用来debug"""

hilarious=False
joke_evaluation="Isn't that joke so funny?! %r"

print joke_evaluation% hilarious


w="This is the left side of..."
e="a string with a right side."

print w + e #字符串合并

formatter = "%r %r %r %r"

print formatter % (1, 2, 3, 4)
print formatter % ("one", "two", "three", "four")
print formatter % (True, False, False, True)
print formatter % (formatter, formatter, formatter, formatter)
print formatter % (
    "I had this thing.",
    "That you could type up right.",
    "But it didn't sing.",
    "So I said goodnight."
)
print "%r" %"哦"#如果用%r会打印'\xe5\x93\xa6\xef\xbc\x9
print "%s" %"哦"#仍然有乱码，但是已经是中文了
print u"你好世界" #可以正常输出中文

# Here's some new strange stuff, remember type it exactly.

months = "Jan\nFeb\nMar\nApr\nMay\nJun\nJul\nAug"
print "Here are the months: ", months
print "Here are the days:%r"% (months)#不会换行，而是打印\n

print """
There's something going on here.
With the three double-quotes.
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.
"""

print "Here are the months: ", months
print "Here are the days:%r"% (months)

print """
There's something going on here.
With the three double-quotes.
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.
"""
print "\n123\n123\n123"

print type(raw_input())#返回str

print type(input())
"""
会自动转换类型，但是有安全风险，比如
abc
是会出现错误的，应该是"abc"，需要让用户小心输入
"""

python -m pydoc raw_input

"""
unpack:
Take whatever is in argv, unpack it, and assign it to all of these variables on the left in order
"""

from sys import argv
script, first, second, third = argv
print "The script is called:", script
print "Your first variable is:", first
print "Your second variable is:", second
print "Your third variable is:", third

from sys import argv

script, user_name = argv
prompt = '> '

print "Hi %s, I'm the %s script." % (user_name, script)
print "I'd like to ask you a few questions."
print "Do you like me %s?" % user_name
likes = raw_input(prompt)

print """
Alright, so you said %r about liking me.
""" % (likes)

from sys import argv
script, filename = argv
txt = open(filename)
print "Here's your file %r:" % filename
print txt.read()
txt.close()

from sys import argv
script, filename = argv
print "We're going to erase %r." % filename
print "If you don't want that, hit CTRL-C (^C)."
print "If you do want that, hit RETURN."
raw_input("?")
print "Opening the file..."
target = open(filename, 'w')
print "Truncating the file.  Goodbye!"
target.truncate()

print "Now I'm going to ask you for three lines."

line = raw_input("line: ")
print "I'm going to write these to the file."

target.write(line)
target.write("\n")

print "And finally, we close it."
target.close()

from sys import argv
from os.path import exists

script, from_file, to_file = argv

print "Copying from %s to %s" % (from_file, to_file)
# we could do these two on one line too, how?
in_file = open(from_file)
indata = in_file.read()
print "The input file is %d bytes long" % len(indata)
print "Does the output file exist? %r" % exists(to_file)
raw_input()

out_file = open(to_file, 'w')
out_file.write(indata)

out_file.close()
in_file.close()

#返回值是炒年糕1970年1月1日算起的
print os.path.getctime('C:\Users\\asus\Desktop\python\\1.txt')
#转换为可理解形式
print time.ctime(os.path.getctime('C:\Users\\asus\Desktop\python\\1.txt'))

def print_two(*args):
    arg1, arg2 = args
    print "arg1: %r, arg2: %r" % (arg1, arg2)

# this one is like your scripts with argv
def print_two(*args):
    arg1, arg2 = args
    print "arg1: %r, arg2: %r" % (arg1, arg2)

# ok, that *args is actually pointless, we can just do this
def print_two_again(arg1, arg2):
    print "arg1: %r, arg2: %r" % (arg1, arg2)

# this just takes one argument
def print_one(arg1):
    print "arg1: %r" % arg1

# this one takes no arguments
def print_none():
    print "I got nothin'."


print_two("Zed","Shaw")
print_two_again("Zed","Shaw")
print_one("First!")
print_none()

#coding: utf-8
from sys import argv

script, input_file = argv

def print_all(f):
    print f.read()

def rewind(f):
    f.seek(0)

def print_a_line(line_count, f):
    print line_count, f.readline()

current_file = open(input_file)

print "First let's print the whole file:\n"

print_all(current_file)

print "Now let's rewind, kind of like a tape."

rewind(current_file)

print "Let's print three lines:"
"""
current_line = 1
print_a_line(current_line, current_file)

current_line = current_line + 1
print_a_line(current_line, current_file)

current_line = current_line + 1
print_a_line(current_line, current_file)
"""
#文件迭代器
line_num=1
for current_line in current_file:
    print line_num , current_line
    line_num+=1

def secret_formula(started):
    jelly_beans = started * 500
    jars = jelly_beans / 1000
    crates = jars / 100
    return jelly_beans, jars, crates
"""注意多返回值"""

def break_words(stuff):
    """This function will break up words for us."""
    words = stuff.split(' ')
    return words

def sort_words(words):
    """Sorts the words."""
    return sorted(words)

def print_first_word(words):
    """Prints the first word after popping it off."""
    word = words.pop(0)
    print word

def print_last_word(words):
    """Prints the last word after popping it off."""
    word = words.pop(-1)
    print word

def sort_sentence(sentence):
    """Takes in a full sentence and returns the sorted words."""
    words = break_words(sentence)
    return sort_words(words)

def print_first_and_last(sentence):
    """Prints the first and last words of the sentence."""
    words = break_words(sentence)
    print_first_word(words)
    print_last_word(words)

def print_first_and_last_sorted(sentence):
    """Sorts the words then prints the first and last one."""
    words = sort_sentence(sentence)
    print_first_word(words)
    print_last_word(words)

#coding: utf-8
import ex25 #不能是25.py
sentence = "All good things come to those who wait."
words = ex25.break_words(sentence)
print words

sorted_words = ex25.sort_words(words)
print sorted_words

print ex25.print_first_word(words)
print ex25.print_last_word(words)

print words

print "All good things come to those who wait.".split(' ')
print "All,good,things,come,to,those,who,wait.".split(',')
print "All<>good<>things<>come<>to<>those<>who<>wait.".split('<>')
print "All<>good<>things<>come<>to<>those<>who<>wait.".split(' ')
print '1<>2<>3'.split('<>')

if cars > people:
    print "We should take the cars."
elif cars < people:
    print "We should not take the cars."
else:
    print "We can't decide."

the_count = [1, 2, 3, 4, 5]
for number in the_count:
    print "This is count %d" % number
# we can also build lists, first start with an empty one
elements = []
# then use the range function to do 0 to 5 counts
for i in range(0, 6):
    print "Adding %d to the list." % i
    #列表方法：追加
    elements.append(i)

#同时遍历多个列表
for i in mylist,the_count:
    print i

if "c" in string:
    print string

"""
.join()
.append()
.pop()
"""
ten_things = "Apples Oranges Crows Telephone Light Sugar"

print "Wait there's not 10 things in that list, let's fix that."

stuff = ten_things.split(' ')
more_stuff = ["Day", "Night", "Song", "Frisbee", "Corn", "Banana", "Girl", "Boy"]

while len(stuff) != 10:
    next_one = more_stuff.pop()
    print "Adding: ", next_one
    stuff.append(next_one)
    print "There's %d items now." % len(stuff)

print "There we go: ", stuff

print "Let's do some things with stuff."

print stuff[1]
print stuff[-1] # whoa! fancy
print stuff.pop()
print ' '.join(stuff) # what? cool!
print '#'.join(stuff[3:5]) # super stellar!

dist=src[:]

stuff['city'] = "San Francisco"

cities['NY'] = 'New York'

del stuff['city']

# safely get a abbreviation by state that might not be there
state = states.get('Texas')

if not state:
    print "Sorry, no Texas."

# get a city with a default value
city = cities.get('TX', 'Does Not Exist')
print "The city for the state 'TX' is: %s" % city

class MyStuff(object):
    def __init__(self):#类似构造函数
        self.tangerine = "And now a thousand years between"
    def apple(self):
        print "I AM CLASSY APPLES!"

class Song(object):

    def __init__(self, lyrics):
        self.lyrics = lyrics

    def sing_me_a_song(self):
        for line in self.lyrics:
            print line
# you're passing a list of strings as the lyrics.
happy_bday = Song(["Happy birthday to you",
                   "I don't want to get sued",
                   "So I'll stop right there"])

bulls_on_parade = Song(["They rally around the family",
                        "With pockets full of shells"])

happy_bday.sing_me_a_song()
bulls_on_parade.sing_me_a_song()

~
class Parent(object):
    def implicit(self):
        print "PARENT implicit()"
class Child(Parent):
    pass
dad = Parent()
son = Child()
dad.implicit()
son.implicit()#子类同样可以使用implicit方法

class Parent(object):
    def override(self):
        print "PARENT override()"
class Child(Parent):
    def override(self):
        print "CHILD override()"

dad = Parent()
son = Child()
dad.override()
son.override()

class Parent(object):
    def altered(self):
        print "PARENT altered()"
class Child(Parent):
    def altered(self):
        print "CHILD, BEFORE PARENT altered()"
        super(Child, self).altered()
        print "CHILD, AFTER PARENT altered()"
dad = Parent()
son = Child()
dad.altered()
son.altered()

class Child(Parent):
    def __init__(self, stuff):
        self.stuff = stuff
        super(Child, self).__init__()

class Other(object):
    def override(self):
        print "OTHER override()"
    def implicit(self):
        print "OTHER implicit()"
    def altered(self):
        print "OTHER altered()"
class Child(object):
    def __init__(self):
        self.other = Other()
    def implicit(self):
        self.other.implicit()
        #调用另一个类的函数来实现自己
    def override(self):
        print "CHILD override()"
    def altered(self):
        print "CHILD, BEFORE OTHER altered()"
        self.other.altered()
        print "CHILD, AFTER OTHER altered()"
son = Child()
son.implicit()
son.override()
son.altered()

"""
这是lexicon_test.py中的一个函数，nose会依次调用，
每个函数负责一个测试，但是一个测试可以包含不同的项目
"""
def test_directions():
    assert_equal(lexicon.scan("north"), [('direction', 'north')])
    #项目1：assert_equal(para1,para2)
    #当para1=para2时，测试通过
    result = lexicon.scan("north south east")
    assert_equal(result, [('direction', 'north'),
                          ('direction', 'south'),
                          ('direction', 'east')])

stuff = raw_input('> ')
words = stuff.split()
#split()可以带参数，不带参数默认是以任意空白符分割

first_word = ('direction', 'north')
second_word = ('verb', 'go')
sentence = [first_word, second_word]

def convert_number(s):
    try:
        return int(s)
    except ValueError:
        return None

def scan(user_sentence):
    sentence=[]
    user_words=user_sentence.split()
    words_copy=user_words
    for word in words_copy:
        if word in lexicon["direction"] :
            sentence.append(('direction',word))
        elif  word in lexicon["verb"]:
            sentence.append(('verb',word))
        elif word in lexicon["stop"]:
            sentence.append(('stop',word))
        elif word in lexicon["noun"]:
            sentence.append(('noun',word))
        else:
            try:
                int(word) #如果不是数字的话，int()会引发异常
                #这里如果用if来判断的话，是没办法进行的，因为int失败时并不会返回异常，用if无法检测
                sentence.append(('number',int(word)))
            except:
            #如果发生异常，说明word不是数字，也不是前面那些分类，就是错误的词语了
                sentence.append(('error',word))
        #else :
    return sentence

class ParserError(Exception):
    pass

def parse_verb(word_list):
    skip(word_list, 'stop')

    if peek(word_list) == 'verb':
        return match(word_list, 'verb')
    else:
        raise ParserError("Expected a verb next.")

assert_raises(exception, callable, parameters)
#使用callable调用parameters，必须引发exception才能通过测