【超简单】Python入门实用教程

Python 入门教程 1 ---- Python Syntax

Python是一个高效的语言，读和写的操作都是很简单的，就像普通的英语一样
Python是一个解释执行的语言，我们不需要去编译，我们只要写出代码即可运行
Python是一个面向对象的语言，在Python里面一切皆对象
Python是一门很有趣的语言
5 变量：一个变量就是一个单词，只有一个单一的值
练习：设置一个变量my_variable，值设置为10

#Write your code below!  
my_variable = 10

第一节
Python里面有三种数据类型 interage , floats , booleans
Python是一个区分大小写的语言
练习
1 把变量my_int 值设置为7
2 把变量my_float值设置为1.23
3 把变量my_bool值设置为true

#Set the variables to the values listed in the instructions!  
my_int = 7  
my_float = 1.23  
my_bool = True

Python的变量可以随时进行覆盖
练习：my_int的值从7改为3，并打印出my_int

#my_int is set to 7 below. What do you think  
#will happen if we reset it to 3 and print the result?  
my_int = 7  
#Change the value of my_int to 3 on line 8!  
my_int = 3  
#Here's some code that will print my_int to the console:  
#The print keyword will be covered in detail soon!  
print my_int

Pyhton的声明和英语很像
Python里面声明利用空格在分开
练习：查看以下代码的错误

def spam():  
eggs = 12  
return eggs   
print spam()  
 
9 Python中的空格是指正确的缩进
    2 练习： 改正上一节中的错误
[python]  
def spam():  
    eggs = 12  
    return eggs  
          
print spam()

Python是一种解释执行的语言，只要你写完即可立即运行
练习：设置变量spam的只为True，eggs的值为False

spam = True  
eggs = False

Python的注释是通过“#”来实现的，并不影响代码的实现
练习：给下面的代码加上一行注释

#this is a comments for Python  
mysterious_variable = 42

Python的多行注释是通过“ “”" “”" ”来实现的
练习：把下面的代码加上多行

""" 
this is a Python course 
"""  
a = 5

Python有6种算术运算符+,-,*,/,**(幂),%
练习：把变量count_to设置为1+2

#Set count_to equal to 1 plus 2 on line 3!  
count_to = 1+2  
print count_to

Python里面求x^m，写成x**m
练习：利用幂运算，把eggs的值设置为100

#Set eggs equal to 100 using exponentiation on line 3!  
eggs = 10**2  
print eggs

练习：
1 写一行注释
2 把变量monty设置为True
3 把变量python值设置为1.234
4 把monty_python的值设置为python的平方

#this is a Python  
monty = True  
python = 1.234  
monty_python = python**2

Python 入门教程 2 Tip Calculator

把变量meal的值设置为44.50

#Assign the variable meal the value 44.50 on line 3!  
meal = 44.50

把变量tax的值设置为6.75%

meal = 44.50  
tax = 6.75/100

设置tip的值为15%

#You're almost there! Assign the tip variable on line 5.  
meal = 44.50  
tax = 0.0675  
tip = 0.15

把变量meal的值设置为meal+meal*tax

#Reassign meal on line 7!  
meal = 44.50  
tax = 0.0675  
tip = 0.15  
meal = meal+meal*tax

设置变量total的值为meal+meal*tax

#Assign the variable total on line 8!  
meal = 44.50  
tax = 0.0675  
tip = 0.15  
meal = meal + meal * tax  
total = meal + meal * tip  
print("%.2f" % total)

Python 入门教程 3 ---- Strings and Console Output

Python里面还有一种好的数据类型是String
一个String是通过’’ 或者 "“包成的串
设置变量brian值为"Always look on the bright side of life!”

#Set the variable brian on line 3!  
brian = "Always look on the bright side of life!"

练习
1 把变量caesar变量设置为Graham
2 把变量praline变量设置为john
3 把变量viking变量设置为Teresa

#Assign your variables below, each on its own line!  
caesar = "Graham"  
praline = "John"  
viking = "Teresa"  
#Put your variables above this line  
print caesar  
print praline  
print viking

Python是通过\来实现转义字符的
练习
把’Help! Help! I’m being repressed!’ 中的I’m中的’进行转义

#The string below is broken. Fix it using the escape backslash!  
'Help! Help! \'\m being repressed!'

我们可以使用""来避免转义字符的出现
练习：把变量fifth_letter设置为MONTY的第五个字符

""" 
The string "PYTHON" has six characters, 
numbered 0 to 5, as shown below: 
 
+---+---+---+---+---+---+ 
| P | Y | T | H | O | N | 
+---+---+---+---+---+---+ 
  0   1   2   3   4   5 
 
So if you wanted "Y", you could just type 
"PYTHON"[1] (always start counting from 0!) 
"""  
fifth_letter = "MONTY"[4]  
  
print fifth_letter

介绍String的第一种方法，len()求字符串的长度
练习：
把变量parrot的值设置为"Norweigian Blue"，然后打印parrot的长度

parrot = "Norwegian Blue"  
print len(parrot)

介绍String的第二种方法,lower()把所有的大写字母转化为小写字母
练习：
把parrot中的大写字母转换为小写字母并打印

parrot = "Norwegian Blue"  
print parrot.lower()

介绍String的第三种方法,upper()把所有的大写字母转化为小写字母
练习：把parrot中的小写字母转换为大写字母并打印

parrot = "norwegian blue"  
print parrot.upper()

第八节
介绍String的第四种方法,str()把非字符串转化为字符串，比如str(2)是把2转化为字符串"2"
练习:
设置一个变量pi值为3.14 , 把pi转化为字符串

"""Declare and assign your variable on line 4, 
then call your method on line 5!"""  
  
pi = 3.14  
print str(pi)

主要介绍“.” 的用处，比如上面的四个String的四个方法都是用到了点
练习：
利用“.”来使用String的变量ministry的函数len()和upper()，并打印出

ministry = "The Ministry of Silly Walks"  
  
print len(ministry)  
print ministry.upper()

介绍print的作用
练习：
利用print输出字符串"Monty Python"

"""Tell Python to print "Monty Python" 
to the console on line 4!"""  
  
print "Monty Python"

介绍print来打印出一个变量
练习：
把变量the_machine_goes值赋值"Ping!"，然后打印出

"""Assign the string "Ping!" to 
the variable the_machine_goes on 
line 5, then print it out on line 6!"""  
  
the_machine_goes = "Ping!"  
print the_machine_goes

介绍我们可以使用+来连接两个String
练习：利用+把三个字符串"Spam "和"and "和"eggs"连接起来输出

 
# Print the concatenation of "Spam and eggs" on line 3!  
  
print "Spam " + "and " + "eggs"

介绍了str()的作用是把一个数字转化为字符串
练习：利用str()函数把3.14转化为字符串并输出

# Turn 3.14 into a string on line 3!  
  
print "The value of pi is around " + str(3.14)

第十四节
介绍了字符串的格式化，使用%来格式化，字符串是%s
举例：有两个字符串，利用格式化%s来输出

string_1 = "Camelot"  
string_2 = "place"  
  
print "Let's not go to %s. 'Tis a silly %s." % (string_1, string_2)

练习
1 设置变量my_string的值
2 打印出变量的长度
3 利用upper()函数并且打印变量值

# Write your code below, starting on line 3!  
  
my_string = "chenguolin"  
print len(my_string)  
print my_string.upper()  
Python 入门教程 4 ---- Date and Time

介绍得到当前的时间datetime.now()
练习
1 设置变量now的值为datetime.now()
2 打印now的值

<span style="font-size:18px">from datetime import datetime  
now = datetime.now()  
print now</span>

介绍从datetime.now得到的信息中提取出year,month等
练习:
从datetime.now中得到的信息中提取出year,month,day

<span style="font-size:18px">from datetime import datetime  
now = datetime.now()  
  
print now.month  
print now.day  
print now.year</span>

介绍把输出日期的格式转化为mm//dd//yyyy，我们利用的是+来转化
练习：
打印当前的日期的格式为mm//dd//yyyy

<span style="font-size:18px">from datetime import datetime  
now = datetime.now()  
  
print str(now.month)+"/"+str(now.day)+"/"+str(now.year)</span>

介绍把输出的时间格式化为hh:mm:ss
练习：
打印当前的时间的格式为hh:mm:ss

<span style="font-size:18px">from datetime import datetime  
now = datetime.now()  
  
print str(now.hour)+":"+str(now.minute)+":"+str(now.second)</span>

第五节
1 练习：把日期和时间两个连接起来输出
[python]
from datetime import datetime
now = datetime.now()

print str(now.month) + “/” + str(now.day) + “/” + str(now.year) + " "\
+str(now.hour) + “:” + str(now.minute) + “:” + str(now.second)

Python 入门教程 5 ---- Conditionals & Control Flow

30 介绍Python利用有6种比较的方式 == , != , > , >= , < , <=
2 比较后的结果是True或者是False
3 练习
1 把bool_one的值设置为 17 < 118%100
2 把bool_two的值设置为 100 == 333 + 1
3 把bool_two的值设置为 19 <= 2**4
4 把bool_four的值设置为 -22 >= -18
5 把bool_five的值设置为 99 != 98+1
[python]
#Assign True or False as appropriate on the lines below!
bool_one = 17 < 118%100
bool_two = 100 == 333+1
bool_three = 19 <= 2**4
bool_four = -22 >= -18
bool_five = 99 != 98+1

31 介绍了比较的两边不只是数值，也可以是两个表达式
2 练习
1 把bool_one的值设置为 20 + -102 > 10%3%2
2 把bool_two的值设置为 (10+17)2 == 36
3 把bool_two的值设置为 123 <= -(-(-1))
4 把bool_four的值设置为 40/204 >= -42
5 把bool_five的值设置为 1000.5 != 6+4
[python]

Assign True or False as appropriate on the lines below!

bool_one = 20±102 > 10%3%2
bool_two = (10+17)2 == 36
bool_three = 123 <= -(-(-1))
bool_four = 40/204 >= -42
bool_five = 1000.5 != 6+4

32 介绍了Python里面还有一种数据类型是booleans，值为True或者是False
2 练习：根据题目的意思来设置右边的表达式
[python]

Create comparative statements as appropriate on the lines below!

Make me true!

bool_one = 1 <= 2

Make me false!

bool_two = 1 > 2

Make me true!

bool_three = 1 != 2

Make me false!

bool_four = 2 > 2

Make me true!

bool_five = 4 < 5

33 介绍了第一种连接符and的使用，只有and的两边都是True那么结果才能为True
2 练习
1 设置变量bool_one的值为False and False
2 设置变量bool_two的值为-(-(-(-2))) == -2 and 4 >= 160.5
3 设置变量bool_three的值为19%4 != 300/10/10 and False
4 设置变量bool_four的值为-(12) < 2**0 and 10%10 <= 20-10*2
5 设置变量bool_five的值为True and True
[python]
bool_one = False and False

bool_two = -(-(-(-2))) == -2 and 4 >= 16**0.5

bool_three = 19%4 != 300/10/10 and False

bool_four = -(12) < 20 and 10%10 <= 20-10*2

bool_five = True and True

34 介绍了第二种连接符or的使用，只要or的两边有一个True那么结果才能为True
2 练习
1 设置变量bool_one的值为23 == 108%100 or ‘Cleese’ == ‘King Arthur’
2 设置变量bool_two的值为True or False
3 设置变量bool_three的值为1000.5 >= 50 or False
4 设置变量bool_four的值为True or True
5 设置变量bool_five的值为1100 == 1001 or 321 != 3+2+1
[python]
bool_one = 2**3 == 108%100 or ‘Cleese’ == ‘King Arthur’

bool_two = True or False

bool_three = 100**0.5 >= 50 or False

bool_four = True or True

bool_five = 1100 == 1001 or 321 != 3+2+1

35 介绍第三种连接符not , 如果是not True那么结果为False，not False结果为True
2 练习
1 设置变量bool_one的值为not True
2 设置变量bool_two的值为not 34 < 43
3 设置变量bool_three的值为not 10%3 <= 10%2
4 设置变量bool_four的值为not 32+42 != 5**2
5 设置变量bool_five的值为not not False
[python]
bool_one = not True

bool_two = not 34 < 43

bool_three = not 10%3 <= 10%2

bool_four = not 32+42 != 5**2

bool_five = not not False

36 介绍了由于表达式很多所以我们经常使用()来把一些表达式括起来，这样比较具有可读性
2 练习
1 设置变量bool_one的值为False or (not True) and True
2 设置变量bool_two的值为False and (not True) or True
3 设置变量bool_three的值为True and not (False or False)
4 设置变量bool_four的值为not (not True) or False and (not True)
5 设置变量bool_five的值为False or not (True and True)
[python]
bool_one = False or (not True) and True

bool_two = False and (not True) or True

bool_three = True and not (False or False)

bool_four = not (not True) or False and (not True)

bool_five = False or not (True and True)

第八节
1 练习：请至少使用and，or，not来完成以下的练习
[python]

Use boolean expressions as appropriate on the lines below!

Make me false!

bool_one = not ((1 and 2) or 3)

Make me true!

bool_two = not (not((1 and 2) or 3))

Make me false!

bool_three = not ((1 and 2) or 3)

Make me true!

bool_four = not (not((1 and 2) or 3))

Make me true!

bool_five = not (not((1 and 2) or 3)

37 介绍了条件语句if
38 if的格式如下, 比如
[python]
if 8 < 9:
print “Eight is less than nine!”
3 另外还有这elif 以及else，格式如下
[python]
if 8 < 9:
print “I get printed!”
elif 8 > 9:
print “I don’t get printed.”
else:
print “I also don’t get printed!”

 4 练习：设置变量response的值为'Y'

[python]
response = ‘Y’

answer = “Left”
if answer == “Left”:
print “This is the Verbal Abuse Room, you heap of parrot droppings!”

Will the above print statement print to the console?

Set response to ‘Y’ if you think so, and ‘N’ if you think not.

第十节
1 介绍了if的格式
[python]
if EXPRESSION:
# block line one
# block line two
# et cetera

2 练习：在两个函数里面加入两个加入条件语句，能够成功输出

[python]
def using_control_once():
if 1 > 0:
return “Success #1”

def using_control_again():
if 1 > 0:
return “Success #2”

print using_control_once()
print using_control_again()

39 介绍了else这个条件语句
2 练习：完成函数里面else条件语句
[python]
answer = “'Tis but a scratch!”

def black_knight():
if answer == “'Tis but a scratch!”:
return True
else:
return False # Make sure this returns False

def french_soldier():
if answer == “Go away, or I shall taunt you a second time!”:
return True
else:
return False # Make sure this returns False

40 介绍了另外一种条件语句elif的使用
2 练习：在函数里面第二行补上answer > 5，第四行补上answer < 5 , 从而完成这个函数
[python]
def greater_less_equal_5(answer):
if answer > 5:
return 1
elif answer < 5:
return -1
else:
return 0

print greater_less_equal_5(4)
print greater_less_equal_5(5)
print greater_less_equal_5(6)

第十三节
1 练习：利用之前学的比较以及连接符以及条件语句补全函数。所有的都要出现至少一次
[python]
def the_flying_circus():
# Start coding here!
if 1 < 2 and not False:
return True
elif 1 == 1 or 1 != 2 or 1 < 2 or 1 <= 2 or 1 > 2 or 1 >= 2:
return True
else:
return False

Python 入门教程 6 ---- PygLatin

1 练习：使用Python来输出这句话"Welcome to the English to Pig Latin translator!"
[python]
print “Welcome to the English to Pig Latin translator!”

41 介绍了Python的输入，Python里面我们可以通过raw_input来实现出入
2 比如我们使用name = raw_ijnput(“what’s your name”) , 那么这里将会在what’s your name提示我们输入，并把结果保存到name里面
3 练习：使用original变量来接受任何的输入
[python]
print “Welcome to the English to Pig Latin translator!”
original = raw_input(“welcome to the Python:”)

42 介绍了我们在输入的时候经常出现输入空字符串的情况，因此我们需要去检查是否是空字符串
2 练习：在上一节的输入的值进行判断，如果不是空字符串那么打印这个值，否则直接输出"empty"
[python]
print “Welcome to the English to Pig Latin translator!”
original = raw_input(“welcome to the Python:”)
if len(original) > 0:
print original
else:
print “empty”

43 介绍了怎样判断一个字符串是数字的方法，我们可以通过isalpha()来判断
如果是阿拉伯数字，则isalpha的值为false ，否则为TRUE
2 比如有一个变量为x = “123”，那么x.isalpha()是True
3 练习：通过变量original的输入值来判断是否是一个数字串
[python]
print “Welcome to the English to Pig Latin translator!”
original = raw_input(“welcome to the Python:”)

if original.isalpha():
print “True”
else:
print “False”

第五节
1 练习：利用多次的输入来判断是否是数字串和非空字符串
[python]
print “Welcome to the English to Pig Latin translator!”
original = raw_input(“welcome to the Python:”)
if original.isalpha():
print “True”
else:
print “False”

original = raw_input(“welcome to the Python:”)
if len(y) == 0:
print “empty”
else:
print “no empty”

第六节
1 回顾了一下之前的String的lower()函数
2 练习
1 设置变量word等于original.lower()
2 设置变量first等于word的第一个字符
[python]
pyg = ‘ay’

original = raw_input(‘Enter a word:’)
word = original.lower()
first = word[0]
if len(original) > 0 and original.isalpha():
print original
else:
print ‘empty’

第六节
1 介绍了if语句里面还可以嵌套语句
2 练习：判断上一节里面的first字符是否是元音字符是的话输出"vowel"，否则输出"consonant"
[python]
pyg = ‘ay’

original = raw_input(‘Enter a word:’)
word = original.lower()
first = word[0]
if len(original) > 0 and original.isalpha():
if first == ‘a’ or first == ‘i’ or first == ‘o’ or first == ‘u’ or first == ‘e’:
print “vowel”
else:
print “consonant”
else:
print ‘empty’

第七节
1 利用String的+操作，产生一个新的变量new_word等于word+pyg
2 练习：把print "vowel"替换成print new_word
[python]
pyg = ‘ay’
original = raw_input(‘Enter a word:’)
word = original.lower()
first = word[0]
new_word = word+pyg

if len(original) > 0 and original.isalpha():
if first == ‘a’ or first == ‘i’ or first == ‘o’ or first == ‘u’ or first == ‘e’:
print new_word
else:
print “consonant”
else:
print ‘empty’

44 介绍了String中得到子串的方法，比如我们有一个字符串s = “foo”，现在s[0:2]就是"fo"
45 如果结束是末尾，那么可以直接写成这样s[i:]，省略第二个数
2 练习：在嵌套的if语句里面设置new_word的值为word从第1位到最后一位+变量pyg
[python]
pyg = ‘ay’
original = raw_input(‘Enter a word:’)
word = original.lower()
first = word[0]
new_word = word+pyg

if len(original) > 0 and original.isalpha():
if first == ‘a’ or first == ‘i’ or first == ‘o’ or first == ‘u’ or first == ‘e’:
new_word = word[1:]+pyg
print new_word
else:
print “consonant”
else:
print ‘empty’

Python 入门教程 7 ---- PygLatin

46 介绍了Python的函数组成有三部份，函数头，函数体
2 函数的举例
[python]
def ni_sayer():
“”“Prints ‘Ni!’ to the console.”“”
print “Ni!”
3 练习：写一个函数，输出字符串"Eggs!"，函数体增加一行注释
[python]

Define your spam function starting on line 5. You

can leave the code on line 11 alone for now–we’ll

explain it soon!

def spam():
“”“this is a zhushi”“”
print “Eggs!”

Define the spam function above this line.

spam()

47 介绍了函数的调用，就是直接函数名
2 练习：调用函数spam(10)
[python]
def square(n):
“”“Returns the square of a number.”“”
squared = n**2
print “%d squared is %d.” % (n, squared)
return squared

Call the square function on line 9! Make sure to

include the number 10 between the parentheses.

square(10)

48 介绍了函数可以使用参数的传递
2 比如函数no_one(sentence)的使用，传入字符串作为参数
[python]
def no_one(sentence):
print sentence

no_one(“The Spanish Inquisition”)
3 练习：把函数的参数改为base,exponent。调用函数传入37和4
[python] view plaincopy
def power(base,exponent): # Add your parameters here!
result = base**exponent
print “%d to the power of %d is %d.” % (base, exponent, result)

power(37,4) # Add your arguments here!

49 介绍了的用法，比如我们传入一个字符串，那么我们可以使用name接收，然后可以利用name来输出。不一定使用name，可以是任何的名字
2 练习
[python]
def favorite_actors(*name):
“”“Prints out your favorite actorS (plural!)”“”
print “Your favorite actors are:” , name

favorite_actors(“Michael Palin”, “John Cleese”, “Graham Chapman”)

50 介绍了函数体里面还可以调用另外的函数
2 比如我们在第二个函数里面调用了第一个函数
[python]
def fun_one(n):
return n * 5

def fun_two(m):
return fun_one(m) + 7
3 练习：把第二个函数调用第一个函数并输出
[python]
def one_good_turn(n):
return n + 1

def deserves_another(n):
return n + one_good_turn(2)

第六节
1 练习
1 定义第一个函数cube()，有一个参数num，返回num的3次方
2 定义另外一个函数by_three()，有一个参数num，如果num能够被3整除那么调用cube并返回值，否则返回False
3 调用函数by_three(9) 和 by_three(4)
[python]
def cube(num):
return num**3

def by_three(num):
if(num%3 == 0):
return cube(num)
else:
return False

by_three(9)
by_three(4)

51 介绍了Python里面可以导入很多的系统的模块，就像c语言的include
2 假设我们没有导入math模块的时候，那么执行print sqrt(25)的时候会报错
3 练习
1 导入math模块，import math
2 执行print math.sqrt(25)，加了一个math说明调用系统的库函数
[python]

Ask Python to print sqrt(25) on line 3.

import math
print math.sqrt(25)

52 Import 我们还可以只是单独的导入模块里面的方法
2 比如from moduleimport
function
3 练习：从math模块里面值导入sqrt函数
[python]

Import just the sqrt function from math on line 3!

from math import sqrt
print sqrt(25)

53 Import 使用from module import *来表示从模块里面导入所有的函数，这样调用的时候就直接调用即可
2 练习：从math模块里面导入所有的方法，然后随便选择一个函数来测试
[python]

Import everything from the math module on line 3!

from math import *
print sqrt(25)

54 Import from module import *方法的缺点就是，如果我们导入了很多的模块，那么可能导致出现相同的函数名，因此我们最好是使用import module，然后使用module.name
2 测试以下代码的结果
[python]
import math # Imports the math module
everything = dir(math) # Sets everything to a list of things from math
print everything # Prints 'em all!

第十一节
1 介绍了第一个函数max()，比如max(1,2,3)返回的是3 （min函数是类似的）
2 max()函数的参数是一个数组，返回数组中的最大值
3 练习：使用max函数来得到一个数组的最大值
[python]

Set maximum to the max value of any set of numbers on line 3!

maximum = max(4,0,-3,78)
print maximum

55 介绍了第二个函数abs()返回的值永远是正数，比如abs(-5)返回的是5
2 练习：测试输出abs(-42)的值
[python]
absolute = abs(-42)
print absolute

56 介绍了type函数的使用，type函数返回的是当前这种数据的类型，比如int , float等
2 type函数的使用举例
[python]
print type(42)
print type(4.2)
print type(‘spam’)
print type({‘Name’:‘John Cleese’})
print type((1,2))

<type ‘int’>
<type ‘float’>
<type ‘unicode’>
<type ‘dict’>
<type ‘tuple’>
3 练习：使用type函数至少得到int，float，unicode三种类型
[python]

Print out the types of an integer, a float,

and a string on separate lines below.

print type(4)
print type(4.2)
print type(‘spam’)

Python 入门教程 8 ---- Python Lists and Dictionaries

57 介绍了Python的列表list
2 列表的格式list_name = [item1 , item2]，Python的列表和C语言的数组很像
3 列表可以为空，就是empty_list = []，比如数组为空
4 举例
[python]
zoo_animals = [“pangolin”, “cassowary”, “sloth”, “dog”];

One animal is missing!

if len(zoo_animals) > 3:
print "The first animal at the zoo is the " + zoo_animals[0]
print "The second animal at the zoo is the " + zoo_animals[1]
print "The third animal at the zoo is the " + zoo_animals[2]
print "The fourth animal at the zoo is the " + zoo_animals[3]

58 介绍了我们可以使用下标来访问list的元素，就像数组一样
2 下标从0开始，比如list_name[0]是第一个元素
3 练习：输出列表numbers的第二个和第四个数的和
[python]
numbers = [5, 6, 7, 8]

print “Adding the numbers at indices 0 and 2…”
print numbers[0] + numbers[2]
print “Adding the numbers at indices 1 and 3…”

Your code here!

print numbers[1] + numbers[3]

59 介绍了我们可以使用下标来对第几个元素进行赋值
2 比如lisy_name[2] = 2，就是把列表的第三个值赋值为2
3 练习：把列表zoo_animals中的tiger换成其它的动物
[python]
zoo_animals = [“pangolin”, “cassowary”, “sloth”, “tiger”]

Last night our zoo’s sloth brutally attacked

#the poor tiger and ate it whole.

The ferocious sloth has been replaced by a friendly hyena.

zoo_animals[2] = “hyena”

What shall fill the void left by our dear departed tiger?

Your code here!

zoo_animals[3] = “dog”

60 介绍了list中添加一个item的方法append()
2 比list_name.append(item)，求列表list_name中有几项就是利用len(list_name)
3 练习：在列表suitcase在增加三项，然后求出它的元素的个数
[python]
suitcase = []
suitcase.append(“sunglasses”)

Your code here!

suitcase.append(“a”)
suitcase.append(“b”)
suitcase.append(“c”)

Set this to the length of suitcase

list_length = len(suitcase)

print “There are %d items in the suitcase.” % (list_length)
print suitcase

61 介绍了list列表怎样得到子列表list_name[a:b]，将得到下标a开始到下标b之前的位置
2 比如列表my_list = [1,2,3,4]，那么my_list[1:3]得到的将是[2,3]
[python]
my_list = [0, 1, 2, 3]
my_slice = my_list[1:3]
print my_list

Prints [0, 1, 2, 3]

print my_slice

Prints [1, 2]

 3 如果我们默认第二个值，那么将会直接到末尾那个位置。如果默认第一个值，值是从头开始

[python]
my_list[:2]

Grabs the first two items

my_list[3:]

Grabs the fourth through last

 4 练习：把first列表设置为suitcase的前两项，把middle列表设置为suitcase的中间两项，把last列表设置为suitcase的后两项

[python]
suitcase = [“sunglasses”, “hat”, “passport”, “laptop”, “suit”, “shoes”]

The first two items

first = suitcase[0:2]

Third and fourth items

middle = suitcase[2:4]

The last two items

last = suitcase[4:]

62 介绍了不仅列表可以得到子串，字符串也满足
2 比如string[a:b]是得到从下标a开始到b之前的子串
3 练习：把三个变量分别设置为对应的子串
[python]
animals = “catdogfrog”

The first three characters of animals

cat = animals[:3]

The fourth through sixth characters

dog = animals[3:6]

From the seventh character to the end

frog = animals[6:]

63 介绍了列表的两种方法index(item)和insert(index , item)
2 index(item)方法是查找item在列表中的下标，使用方法list_name.index(item)
3 insert(index,item)是在下标index处插入一个item，其余的后移，使用方法list_name.insert(index , item)
4 练习：使用index()函数找到列表中的"duck"，然后在当前位置插入"cobra"
如果我们使用print list_name，就是直接输出列表的所有元素
[python]
animals = [“aardvark”, “badger”, “duck”, “emu”, “fennec fox”]

Use index() to find “duck”

duck_index = animals.index(“duck”)

Your code here!

animals.insert(duck_index,“cobra”)

Observe what prints after the insert operation

print animals

64 介绍我们可以使用for循环来遍历列表的每一个元素
2 比如for variable in list_name:
statement
这样我们可以枚举列表的每一个元素
3 练习：打印列表的每一个元素的值*2
[python]
my_list = [1,9,3,8,5,7]

for number in my_list:
# Your code here
print 2*number

65 介绍了列表的另外一种方法sort()，可以对列表进行排序，默认是从小到打排序
2 使用的方法是list_name.sort()
3 列表中删除一个item的方法list_name.remove(item)
[python]
beatles = [“john”,“paul”,“george”,“ringo”,“stuart”]
beatles.remove(“stuart”)
print beatles

[“john”,“paul”,“george”,“ringo”]
4 练习：利用for循环把没一项的值的平方加入列表square_list，然后对square_list排序输出
[python]
start_list = [5, 3, 1, 2, 4]
square_list = []

Your code here!

for numbers in start_list:
square_list.append(numbers**2)
print square_list.sort()

66 介绍了Python中的字典，字典的每一个item是一个键值对即key:value
注意：字典是无序的，所以for I in dec：中 i指的是Key值，而dec[i]则是value值
2 比如字典d = {‘key1’ : 1, ‘key2’ : 2, ‘key3’ : 3}，有三个元素
3 Python的字典和C++里面的map很像，我们可以使用d[“key1”]来输出key1对应的value
4 练习：打印出’Sloth’和’Burmese Python’对应的value
注意在脚本语言里面可以使用单引号也可以使用双引号来表示字符串
[python]

Assigning a dictionary with three key-value pairs to residents:

residents = {‘Puffin’ : 104, ‘Sloth’ : 105, ‘Burmese Python’ : 106}

Prints Puffin’s room number

print residents[‘Puffin’]

Your code here!

print residents[‘Sloth’]
print residents[‘Burmese Python’]

67 字典和列表一样可以是空的，比如d = {}就是一个空的字典
68 字典里面添加一个键值对或者是改变已有key的value，使用这种方法 dict_name[key] = value
69 我们也可以使用len(dict_name)求出字典的元素的个数
2 练习：至少添加3个键值对到字典menu中
[python]

Empty dictionary

menu = {}

Adding new key-value pair

menu[‘Chicken Alfredo’] = 14.50
print menu[‘Chicken Alfredo’]

Your code here: Add some dish-price pairs to menu!

menu[“a”] = 1
menu[“b”] = 2
menu[“c”] = 3

print you code

print “There are " + str(len(menu)) + " items on the menu.”
print menu

70 介绍了我们可以删除字典中的键值对
2 我们使用del dict_name[key]，这样将删除键值为key的键值对
3 练习：删除key为"Sloth"和"Bengal Tiger"，并且设置key为"Rockhopper Penguin"的val和之前的不一样
[python]

key - animal_name : value - location

zoo_animals = { ‘Unicorn’ : ‘Cotton Candy House’,
‘Sloth’ : ‘Rainforest Exhibit’,
‘Bengal Tiger’ : ‘Jungle House’,
‘Atlantic Puffin’ : ‘Arctic Exhibit’,
‘Rockhopper Penguin’ : ‘Arctic Exhibit’}

A dictionary (or list) declaration may break across multiple lines

Removing the ‘Unicorn’ entry. (Unicorns are incredibly expensive.)

del zoo_animals[‘Unicorn’]

Your code here!

del zoo_animals[“Sloth”]
del zoo_animals[“Bengal Tiger”]
zoo_animals[“Rockhopper Penguin”] = “aa”

print you code

print zoo_animals

71 介绍了字典中一个key可以对应不止一个的value
2 比如my_dict = {“hello”:[“h”,“e”,“l”,“l”,“o”]}，那么key为"hello"对应的value有5个，我们可以使用my_dict[“hello”][index]来取得下标为index的value，比如index为1的时候是"e"
3 对于一个key对应多个value的话，我们应该要用list来保存这些value
4 对于一个key对应多个value的话，我们还可以对这个key的val进行排序，比如my_dict[“hello”].sort()
4 练习
1 在字典inventory中添加一个key为’pocket’，值设置为列表[“seashell” , “strange berry” , “lint”]
2 对key为’pocket’的value进行排序
3 删除字典inventory中key为’backpack’的键值对
4 把字典inventory中key为’gold’的value加一个50
[python]

Assigned a new list to ‘pouch’ key

inventory = {‘gold’ : 500,
‘pouch’ : [‘flint’, ‘twine’, ‘gemstone’],
‘backpack’ : [‘xylophone’,‘dagger’, ‘bedroll’,‘bread loaf’]}

Adding a key ‘burlap bag’ and assigning a list to it

inventory[‘burlap bag’] = [‘apple’, ‘small ruby’, ‘three-toed sloth’]

Sorting the list found under the key ‘pouch’

inventory[‘pouch’].sort()

Here the dictionary access expression takes the place of a list name

Your code here

inventory[‘pocket’] = [“seashell” , “strange berry” , “lint”]
inventory[‘pocket’].sort()
del inventory[‘backpack’]
inventory[‘gold’] = [500 , 50]

外记1：sort（）函数的深度使用
Python语言内置了sort方法，可以很方便地对某个List进行排序：
L = [6, 5, 1, 3, 4, 2]
L.sort()
print L

———- Run Python Program ———-
[1, 2, 3, 4, 5, 6]
某些时候，我们希望按照自己定义的排序规则来排序（例如，按关键词的权重排序，按人的年龄排序，等等）。在Java语言中，我们可以自定义Comparator来实现，Python中也提供了类似的办法。
若List中每个元素都是2-tuple，tuple中第一个元素为String类型的keyword，第二个元素为该字符串对应的权重（int类型），希望按照权重排序（从高到低），则可以这样：
def my_cmp(E1, E2):
return -cmp(E1[1], E2[1]) #compare weight of each 2-tuple
#return the negative result of built-in cmp function
#thus we get the descend order

L = [(‘a’, 0), (‘b’, 1), (‘c’, 2), (‘d’, 3)]
L.sort(my_cmp)
print L

———- Run Python Program ———-
[(‘d’, 3), (‘c’, 2), (‘b’, 1), (‘a’, 0)]
正因为可以自定义cmp方法，我们不妨探究一下，built-in的sort方法，到底是采用的哪一种排序算法：
from random import shuffle

def my_cmp(E1, E2):
print ‘E1:’, E1, ‘E2:’, E2
return cmp(E1, E2)

L = range(0, 10)
shuffle(L)
print L
L.sort(my_cmp)

———- Run Python Program ———-
[5, 3, 7, 6, 2, 8, 9, 4, 1, 0]
E1: 3 E2: 5
E1: 7 E2: 3
E1: 7 E2: 5
E1: 6 E2: 5
E1: 6 E2: 7
E1: 2 E2: 6
E1: 2 E2: 5
E1: 2 E2: 3
E1: 8 E2: 5
E1: 8 E2: 7
E1: 9 E2: 6
E1: 9 E2: 8
E1: 4 E2: 6
E1: 4 E2: 3
E1: 4 E2: 5
E1: 1 E2: 6
E1: 1 E2: 4
E1: 1 E2: 3
E1: 1 E2: 2
E1: 0 E2: 5
E1: 0 E2: 3
E1: 0 E2: 2
E1: 0 E2: 1
可以看到，每次调用my_cmp，E1依次是List中的第2、3、4……直到最后一个元素，可以肯定sort不是采用的分治法（devide-and-conqure）
看前三次调用，可以发现sort采用的是典型的插入排序——也就是说，将新元素插入已排序部分的合适位置，查找位置时采用的似乎是从后向前线形探察的办法。从元素6开始，新元素不再直接与已排序部分的最后元素比较，而是先与中间值比较，采用二分检索探察合适位置，这样，可以把时间代价从n缩小到log(n)。
至此，我们可以认为，built-in的sort方法，采用的是“二分法插入排序”（binary insertion）的算法。
为了检测这个结论，可以输入一个已排序的数组，看看结果。
L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
L.sort(my_cmp)

———- Run Python Program ———-
E1: 1 E2: 0
E1: 2 E2: 1
E1: 3 E2: 2
E1: 4 E2: 3
E1: 5 E2: 4
E1: 6 E2: 5
E1: 7 E2: 6
E1: 8 E2: 7
E1: 9 E2: 8
E1: 10 E2: 9
结果发现，比较的次数非常少，插入每个元素的时候，只会与它之前紧邻的元素比较，而不是二分检索。这真是个有意思的现象。
改一改程序
L = [0, 1, 2, 3, 4, 5, 6, 8, 7, 9, 10]
L.sort(my_cmp)

———- Run Python Program ———-
E1: 1 E2: 0
E1: 2 E2: 1
E1: 3 E2: 2
E1: 4 E2: 3
E1: 5 E2: 4
E1: 6 E2: 5
E1: 8 E2: 6
E1: 7 E2: 8
E1: 7 E2: 4
E1: 7 E2: 6
E1: 7 E2: 8
E1: 9 E2: 4
E1: 9 E2: 7
E1: 9 E2: 8
E1: 10 E2: 5
E1: 10 E2: 8
E1: 10 E2: 9
可以看到，在数字8以前，List中的元素都是有序的，于是sort算法也只比较欲插入元素和已排序序列的最后一个元素；一旦发现输入序列不是自然有序之后，就采用二分插入排序算法。
这样的混合排序算法，相对单纯的插入排序，保证了最好条件下时间代价最低，也减小了一般情况下的时间代价。
p.s.
写完之后查阅Python的文档，发现sort采用的是混合（hybrid）排序，规模小的时候采用binary insertion，规模大的时候采用samplesort（据说是quicksort的一个变种，我没接触过，汗….）

外记2：Python的url编码函数使用的一个小问题
python的url编码函数是在类urllib库中，使用方法是：
编码：urllib.quote(string[, safe])，除了三个符号“_.-”外，将所有符号编码，后面的参数safe是不编码的字符，使用的时候如果不设置的话，会将斜杠，冒号，等号，问号都给编码了。
print urllib.quote(“http://neeao.com/index.php?id=1”)
print urllib.quote(“http://neeao.com/index.php?id=1”,“:?=/”)

结果如下：
http%3A//neeao.com/index.php%3Fid%3D1
http://neeao.com/index.php?id=1

外记3：python对文件进行读写操作

python进行文件读写的函数是open或file
file_handler = open(filename,mode）
Table mode
模式描述
r 以读方式打开文件，可读取文件信息。
w 以写方式打开文件，可向文件写入信息。如文件存在，则清空该文件，再写入新内容
a 以追加模式打开文件（即一打开文件，文件指针自动移到文件末尾），如果文件不存在则创建
r+ 以读写方式打开文件，可对文件进行读和写操作。
w+ 消除文件内容，然后以读写方式打开文件。
a+ 以读写方式打开文件，并把文件指针移到文件尾。
b 以二进制模式打开文件，而不是以文本模式。该模式只对Windows或Dos有效，类Unix的文件是用二进制模式进行操作的。

Table 文件对象方法
方法描述
f.close() 关闭文件，记住用open()打开文件后一定要记得关闭它，否则会占用系统的可打开文件句柄数。
f.fileno() 获得文件描述符，是一个数字
f.flush() 刷新输出缓存
f.isatty() 如果文件是一个交互终端，则返回True，否则返回False。
f.read([count]) 读出文件，如果有count，则读出count个字节。
f.readline() 读出一行信息。
f.readlines() 读出所有行，也就是读出整个文件的信息。
f.seek(offset[,where]) 把文件指针移动到相对于where的offset位置。where为0表示文件开始处，这是默认值；1表示当前位置；2表示文件结尾。
f.tell() 获得文件指针位置。
f.truncate([size]) 截取文件，使文件的大小为size。
f.write(string) 把string字符串写入文件。
f.writelines(list) 把list中的字符串一行一行地写入文件，是连续写入文件，没有换行。

例子如下：
读文件
Python代码
1.read = open(result)
2. line=read.readline()
3. while line:
4. print line
5. line=read.readline()#如果没有这行会造成死循环
6. read.close
写文件
Python代码
1.read = file(result,‘a+’)
2. read.write(“\r\n”)
3. read.write(“thank you”)
4. read.close
其它
Python代码
1.#-- encoding:UTF-8 --
2.filehandler = open(‘c:\111.txt’,‘r’) #以读方式打开文件，rb为二进制方式(如图片或可执行文件等)
3.
4.print ‘read() function:’ #读取整个文件
5.print filehandler.read()
6.
7.print ‘readline() function:’ #返回文件头，读取一行
8.filehandler.seek(0)
9.print filehandler.readline()
10.
11.print ‘readlines() function:’ #返回文件头，返回所有行的列表
12.filehandler.seek(0)
13.print filehandler.readlines()
14.
15.print ‘list all lines’ #返回文件头，显示所有行
16.filehandler.seek(0)
17.textlist = filehandler.readlines()
18.for line in textlist:
19. print line,
20.print
21.print
22.
23.print ‘seek(15) function’ #移位到第15个字符，从16个字符开始显示余下内容
24.filehandler.seek(15)
25.print ‘tell() function’
26.print filehandler.tell() #显示当前位置
27.print filehandler.read()
28.
29.filehandler.close() #关闭文件句柄

外记4：python数组的使用

python数组的使用
2010-07-28 17:17
1、Python的数组分三种类型：
(1) list 普通的链表，初始化后可以通过特定方法动态增加元素。
定义方式：arr = [元素]

(2) Tuple 固定的数组，一旦定义后，其元素个数是不能再改变的。
定义方式：arr = (元素)

(2) Dictionary 词典类型，即是Hash数组。
定义方式：arr = {元素k:v}

2、下面具体说明这些数组的使用方法和技巧：

(1) list 链表数组
a、定义时初始化
a = [1,2,[1,2,3]]

b、定义时不初始化
一维数组：
arr = []

多维数组：
arr = [i for i in range(10), 1,[]] #注意， i for in xx 这个必须放在第一个位置，否则要先定义i，

如:
arr = [i for i in range(5), j for j in range(5), []]
这是错误的
i = 0
j = 0
arr = [i for i in range(5), j for j in range(5), []]
这是正确的

c、del 语句和 : 的用法
可以用 start : end 表示数组里的一个区间 ( i >= start and i < end)
del 删除数组里的指定元素
如： del arr[0]
del arr[0, 2]
newarr = arr[0, 2]

d、遍历数组：
for k, v in enumerate(arr):
print k, v

e、增加元素：
一维
arr.append(‘aaa’)
二维
arr[0].append(‘aaa’)
如果要在任意位置插入用 arr.insert(n, 值)
此外还有一种特殊的用法是：
arr += [数组元素]
在不指定下标的情况下，是允许用 += 增加数组元素的。

(2) Tuple 固定数组
Tuple 是不可变 list，一旦创建了一个 tuple 就不能以任何方式改变它。
下面拿具体示例说明：

t = (“a”, “b”, “c”, “d”, “e”) #[1] 用小括号包围来定义
t
(‘a’, ‘b’, ‘c’, ‘d’, ‘e’)
t[0] #[2] 直接列出某下标的元素
‘a’
t[-1] #[3] 负数表示，从后面倒数的索引 -1 为倒数第一个， 0是顺数第一个
‘example’
t[1:3] #[4] 这里 1:3 是 i>=1 and i<3 的区间
(‘b’, ‘mpilgrim’)

Tuple 没有的方法：
[1] 不能向 tuple 增加元素，没有 append 、 extend 、insert 等方法。
[2] 不能从 tuple 删除元素，没有 remove 或 pop 方法。
[3] 不能在 tuple 中查找元素，没有 index 方法（index是查找而不是索引，索引直接用下标即可，如：t[0]）。

使用 tuple 的好处：

Tuple 比 list 操作速度快。如果您定义了一个值的常量集, 并且唯一要用它做的是不断地遍历它, 请使用 tuple 代替 list。
如果对不需要修改的数据进行 “写保护”, 可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句, 说明这一数据是常量。如果必须要改变这些值, 则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)。
还记得我说过 dictionary keys 可以是字符串, 整数和 “其它几种类型”吗? Tuples 就是这些类型之一。 Tuples 可以在 dictionary 中被用做 key, 但是 list 不行。实际上, 事情要比这更复杂。Dictionary key 必须是不可变的。Tuple 本身是不可改变的, 但是如果您有一个 list 的 tuple, 那就认为是可变的了，用做 dictionary key 就是不安全的。只有字符串, 整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。

Tuple 可以转换成 list，反之亦然。
转换方式为：
t = list( t )
反之：
arr = tuple( arr )

(2) Dictionary (哈希数组)词典数组

#Dictionary 的用法比较简单，它可以存储任意值，并允许是不同类型的值，下面实例来说明：
#下面例子中 a 是整数， b 是字符串, c 是数组，这个例子充分说明哈希数组的适用性。
dict_arr = {‘a’: 100, ‘b’:‘boy’, ‘c’:[‘o’, ‘p’, ‘q’]}

#可以直接增加一个元素，如果同名，则会改变原来的key的元素的值
dict_arr[‘d’] = ‘dog’

#输出所有的key
print dict_arr.keys()

#输出所有的value
print dict_arr.values()

#遍历数组
import types
for k in dict_arr:
v = dict_arr.get(k)
if type(v) is types.ListType: #如果数据是list类型，继续遍历
print k, ‘—’
for kk, vv in enumerate(v):
print kk, vv
print ‘—’
else:
print dict_arr.get(k)
list的方法
L.append(var) #追加元素
L.insert(index,var)
L.pop(var) #返回最后一个元素，并从list中删除之
L.remove(var) #删除第一次出现的该元素
L.count(var) #该元素在列表中出现的个数
L.index(var) #该元素的位置,无则抛异常
L.extend(list) #追加list，即合并list到L上
L.sort() #排序
L.reverse() #倒序
list 操作符:,+,*，关键字del
a[1:] #片段操作符，用于子list的提取
[1,2]+[3,4] #为[1,2,3,4]。同extend()
[2]*4 #为[2,2,2,2]
del L[1] #删除指定下标的元素
del L[1:3] #删除指定下标范围的元素
list的复制
L1 = L #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的
L1 = L[:] #L1为L的克隆，即另一个拷贝。

list comprehension
[ for k in L if ]

2、dictionary：字典（即C++标准库的map）
dict = {‘ob1′:’computer’, ‘ob2′:’mouse’, ‘ob3′:’printer’}
每一个元素是pair，包含key、value两部分。key是Integer或string类型，value 是任意类型。
键是唯一的，字典只认最后一个赋的键值。

dictionary的方法
D.get(key, 0) #同dict[key]，多了个没有则返回缺省值，0。[]没有则抛异常
D.has_key(key) #有该键返回TRUE，否则FALSE
D.keys() #返回字典键的列表
D.values()
D.items()

D.update(dict2) #增加合并字典
D.popitem() #得到一个pair，并从字典中删除它。已空则抛异常
D.clear() #清空字典，同del dict
D.copy() #拷贝字典
D.cmp(dict1,dict2) #比较字典，(优先级为元素个数、键大小、键值大小)
#第一个大返回1，小返回-1，一样返回0

dictionary的复制
dict1 = dict #别名
dict2=dict.copy() #克隆，即另一个拷贝。

3、tuple：元组（即常量数组）
tuple = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)
可以用list的 [],:操作符提取元素。就是不能直接修改元素。

4、string：字符串（即不能修改的字符list）
str = “Hello My friend”
字符串是一个整体。如果你想直接修改字符串的某一部分，是不可能的。但我们能够读出字符串的某一部分。
子字符串的提取
str[:6]
字符串包含判断操作符：in，not in
“He” in str
“she” not in str

string模块，还提供了很多方法，如
S.find(substring, [start [,end]]) #可指范围查找子串，返回索引值，否则返回-1
S.rfind(substring,[start [,end]]) #反向查找
S.index(substring,[start [,end]]) #同find，只是找不到产生ValueError异常
S.rindex(substring,[start [,end]])#同上反向查找
S.count(substring,[start [,end]]) #返回找到子串的个数

S.lowercase()
S.capitalize() #首字母大写
S.lower() #转小写
S.upper() #转大写
S.swapcase() #大小写互换

S.split(str, ‘ ‘) #将string转list，以空格切分
S.join(list, ‘ ‘) #将list转string，以空格连接

处理字符串的内置函数
len(str) #串长度
cmp(“my friend”, str) #字符串比较。第一个大，返回1
max(‘abcxyz’) #寻找字符串中最大的字符
min(‘abcxyz’) #寻找字符串中最小的字符

string的转换

oat(str) #变成浮点数，float(“1e-1″) 结果为0.1
int(str) #变成整型， int(“12″) 结果为12
int(str,base) #变成base进制整型数，int(“11″,2) 结果为2
long(str) #变成长整型，
long(str,base) #变成base进制长整型，

字符串的格式化（注意其转义字符，大多如C语言的，略）
str_format % (参数列表)

列表切片操作
a = [1,2,3,4,5]
a[::2] # iterate over the whole list in 2-increments
[1,3,5]
列表逆序
a[::-1]
[5,4,3,2,1]
利用字典格式化字符串
view plaincopy to clipboardprint?
print “The %(foo)s is %(bar)i.” % {‘foo’: ‘answer’, ‘bar’:42}
The answer is 42.
foo, bar = ‘question’, 123
print “The %(foo)s is %(bar)i.” % locals()
The question is 123.
保留精确数因为round()返回指类型为浮点数，所以需要加上str()

view plaincopy to clipboardprint?

str(round(1234.5678, -2))
‘1200.0’
str(round(1234.5678, 2))
‘1234.57’
and/or 条件选择
view plaincopy to clipboardprint?
x = is_ok() and “Yes” or “No”
等价于
if is_ok():
x = “Yes”
else:
x = “No”

列表赋值y = x 相当于指针传递；y = x[:]相当于值传递。

view plaincopy to clipboardprint?

x = [1,2,3]
y = x
y[2] = 7
y
[1, 2, 7]
x
[1, 2, 7]
y = x[:]
y[2] = 8
y
[1, 2, 8]
x
[1, 2, 7]

外记5：python操作Excel读写–使用xlrd

原文地址：http://www.cnblogs.com/lhj588/archive/2012/01/06/2314181.html
一、安装xlrd模块
到python官网下载http://pypi.python.org/pypi/xlrd模块安装，前提是已经安装了python 环境。
二、使用介绍
1、导入模块
import xlrd
2、打开Excel文件读取数据
data = xlrd.open_workbook(‘excelFile.xls’)
3、使用技巧
获取一个工作表
table = data.sheets()[0] #通过索引顺序获取
table = data.sheet_by_index(0) #通过索引顺序获取
table = data.sheet_by_name(u’Sheet1’)#通过名称获取
获取整行和整列的值（数组）
table.row_values(i)
table.col_values(i)
获取行数和列数
nrows = table.nrows
ncols = table.ncols
循环行列表数据
for i in range(nrows ):
print table.row_values(i)
单元格
cell_A1 = table.cell(0,0).value
cell_C4 = table.cell(2,3).value
使用行列索引
cell_A1 = table.row(0)[0].value
cell_A2 = table.col(1)[0].value

简单的写入
row = 0
col = 0

类型 0 empty,1 string, 2 number, 3 date, 4 boolean, 5 error

ctype = 1 value = ‘单元格的值’
xf = 0 # 扩展的格式化
table.put_cell(row, col, ctype, value, xf)
table.cell(0,0) #单元格的值’
table.cell(0,0).value #单元格的值’
三、Demo代码
Demo代码其实很简单，就是读取Excel数据。

1 # -- coding: utf-8 --
2 import xdrlib ,sys
3 import xlrd
4 def open_excel(file= ‘file.xls’):
5 try:
6 data = xlrd.open_workbook(file)
7 return data
8 except Exception,e:
9 print str(e)
10 #根据索引获取Excel表格中的数据参数:file：Excel文件路径 colnameindex：表头列名所在行的所以，by_index：表的索引
11 def excel_table_byindex(file= ‘file.xls’,colnameindex=0,by_index=0):
12 data = open_excel(file)
13 table = data.sheets()[by_index]
14 nrows = table.nrows #行数
15 ncols = table.ncols #列数
16 colnames = table.row_values(colnameindex) #某一行数据
17 list =[]
18 for rownum in range(1,nrows):
19
20 row = table.row_values(rownum)
21 if row:
22 app = {}
23 for i in range(len(colnames)):
24 app[colnames[i]] = row[i]
25 list.append(app)
26 return list
27
28 #根据名称获取Excel表格中的数据参数:file：Excel文件路径 colnameindex：表头列名所在行的所以，by_name：Sheet1名称
29 def excel_table_byname(file= ‘file.xls’,colnameindex=0,by_name=u’Sheet1’):
30 data = open_excel(file)
31 table = data.sheet_by_name(by_name)
32 nrows = table.nrows #行数
33 colnames = table.row_values(colnameindex) #某一行数据
34 list =[]
35 for rownum in range(1,nrows):
36 row = table.row_values(rownum)
37 if row:
38 app = {}
39 for i in range(len(colnames)):
40 app[colnames[i]] = row[i]
41 list.append(app)
42 return list
43
44 def main():
45 tables = excel_table_byindex()
46 for row in tables:
47 print row
48
49 tables = excel_table_byname()
50 for row in tables:
51 print row
52
53 if name==“main”:
54 main()

Python正则表达式指南

原址：http://www.cnblogs.com/huxi/archive/2010/07/04/1771073.html
本文介绍了Python对于正则表达式的支持，包括正则表达式基础以及Python正则表达式标准库的完整介绍及使用示例。本文的内容不包括如何编写高效的正则表达式、如何优化正则表达式，这些主题请查看其他教程。
注意：本文基于Python2.4完成；如果看到不明白的词汇请记得百度谷歌或维基，whatever。l

正则表达式基础
1.1. 简单介绍
正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。
下图展示了使用正则表达式进行匹配的流程：

正则表达式的大致匹配过程是：依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很好理解的，看下图中的示例以及自己多使用几次就能明白。下图列出了Python支持的正则表达式元字符和语法：

1.2. 数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*“如果用于查找"abbbc”，将找到"abbb"。而如果使用非贪婪的数量词"ab*?“，将找到"a”。
1.3. 反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"“作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”“，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\“：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r”\“表示。同样，匹配一个数字的”\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
1.4. 匹配模式
正则表达式提供了一些可用的匹配模式，比如忽略大小写、多行匹配等，这部分内容将在Pattern类的工厂方法re.compile(pattern[, flags])中一起介绍。
2. re模块
2.1. 开始使用re
Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 # encoding: UTF-8
import re

将正则表达式编译成Pattern对象

pattern = re.compile(r’hello’)

使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None

match = pattern.match(‘hello world!’)

if match:
# 使用Match获得分组信息
print match.group()

输出

hello

re.compile(strPattern[, flag]):
这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式，取值可以使用按位或运算符’|‘表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern’, re.I | re.M)与re.compile(’(?im)pattern’)是等价的。
可选值有：
re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变’^‘和’$‘的行为（参见上图）
S(DOTALL): 点任意匹配模式，改变’.‘的行为
L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：
1
2
3
4 a = re.compile(r"“”\d + # the integral part
. # the decimal point
\d * # some fractional digits"“”, re.X)
b = re.compile(r"\d+.\d*")
re提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码，但同时也无法复用编译后的Pattern对象。这些方法将在Pattern类的实例方法部分一起介绍。如上面这个例子可以简写为：
1
2 m = re.match(r’hello’, ‘hello world!’)
print m.group()
re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。
2.2. Match
Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。
属性：
1.string: 匹配时使用的文本。
2.re: 匹配时使用的Pattern对象。
3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
方法：
1.group([group1, …]):
获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2.groups([default]):
以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3.groupdict([default]):
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4.start([group]):
返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5.end([group]):
返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6.span([group]):
返回(start(group), end(group))。
7.expand(template):
将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符’0’，只能使用\g<1>0。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 import re
m = re.match(r’(\w+) (\w+)(?P.*)', ‘hello world!’)

print “m.string:”, m.string
print “m.re:”, m.re
print “m.pos:”, m.pos
print “m.endpos:”, m.endpos
print “m.lastindex:”, m.lastindex
print “m.lastgroup:”, m.lastgroup

print “m.group(1,2):”, m.group(1, 2)
print “m.groups():”, m.groups()
print “m.groupdict():”, m.groupdict()
print “m.start(2):”, m.start(2)
print “m.end(2):”, m.end(2)
print “m.span(2):”, m.span(2)
print r"m.expand(r’\2 \1\3’):", m.expand(r’\2 \1\3’)

output

m.string: hello world!

m.re: <_sre.SRE_Pattern object at 0x016E1A38>

m.pos: 0

m.endpos: 12

m.lastindex: 3

m.lastgroup: sign

m.group(1,2): (‘hello’, ‘world’)

m.groups(): (‘hello’, ‘world’, ‘!’)

m.groupdict(): {‘sign’: ‘!’}

m.start(2): 6

m.end(2): 11

m.span(2): (6, 11)

m.expand(r’\2 \1\3’): world hello!

2.3. Pattern
Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。
Pattern不能直接实例化，必须使用re.compile()进行构造。
Pattern提供了几个可读属性用于获取表达式的相关信息：
1.pattern: 编译时用的表达式字符串。
2.flags: 编译时用的匹配模式。数字形式。
3.groups: 表达式中分组的数量。
4.groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。
import re
p = re.compile(r’(\w+) (\w+)(?P.*)', re.DOTALL)

print “p.pattern:”, p.pattern
print “p.flags:”, p.flags
print “p.groups:”, p.groups
print “p.groupindex:”, p.groupindex

output

p.pattern: (\w+) (\w+)(?P.*)

p.flags: 16

p.groups: 3

p.groupindex: {‘sign’: 3}

实例方法[ | re模块方法]：
1.match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]):
这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。
pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。
注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$'。
示例参见2.1小节。
2.search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]):
这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。
pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。

# encoding: UTF-8

import re

将正则表达式编译成Pattern对象

pattern = re.compile(r’world’)

使用search()查找匹配的子串，不存在能匹配的子串时将返回None

这个例子中使用match()无法成功匹配

match = pattern.search(‘hello world!’)

if match:
# 使用Match获得分组信息
print match.group()

输出

world

3.split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。
import re

p = re.compile(r’\d+')
print p.split(‘one1two2three3four4’)

output

[‘one’, ‘two’, ‘three’, ‘four’, ‘’]

4.findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):
搜索string，以列表形式返回全部能匹配的子串。
import re

p = re.compile(r’\d+')
print p.findall(‘one1two2three3four4’)

output

[‘1’, ‘2’, ‘3’, ‘4’]

5.finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。
import re

p = re.compile(r’\d+')
for m in p.finditer(‘one1two2three3four4’):
print m.group(),

output

1 2 3 4

6.sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。
import re

p = re.compile(r’(\w+) (\w+)')
s = ‘i say, hello world!’

print p.sub(r’\2 \1’, s)

def func(m):
return m.group(1).title() + ’ ’ + m.group(2).title()

print p.sub(func, s)

output

say i, world hello!

I Say, Hello World!

7.subn(repl, string[, count]) |re.sub(pattern, repl, string[, count]):
返回 (sub(repl, string[, count]), 替换次数)。
import re

p = re.compile(r’(\w+) (\w+)')
s = ‘i say, hello world!’

print p.subn(r’\2 \1’, s)

def func(m):
return m.group(1).title() + ’ ’ + m.group(2).title()

print p.subn(func, s)

output

(‘say i, world hello!’, 2)

(‘I Say, Hello World!’, 2)

以上就是Python对于正则表达式的支持。熟练掌握正则表达式是每一个程序员必须具备的技能，这年头没有不与字符串打交道的程序了。笔者也处于初级阶段，与君共勉，^_
另外，图中的特殊构造部分没有举出例子，用到这些的正则表达式是具有一定难度的。有兴趣可以思考一下，如何匹配不是以abc开头的单词，^_

python os 命令
原网址：http://www.cnblogs.com/finallyliuyu/archive/2010/08/04/1791949.html
http://developer.51cto.com/art/201003/190580.htm
Python的标准库中的os模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤为重要的。即它允许一个程序在编写后不需要任何改动，也不会发生任何问题，就可以在Linux和Windows下运行。
下面列出了一些在os模块中比较有用的部分。它们中的大多数都简单明了。
os.sep 可以取代操作系统特定的路径分割符。
os.name字符串指示你正在使用的平台。比如对于Windows，它是’nt’，而对于Linux/Unix用户，它是’posix’。
os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。
os.getenv()和os.putenv()函数分别用来读取和设置环境变量。
os.listdir()返回指定目录下的所有文件和目录名。
os.remove()函数用来删除一个文件。
os.system()函数用来运行shell命令。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用’\r\n’，Linux使用’\n’而Mac使用’\r’。
os.path.split()函数返回一个路径的目录名和文件名。
os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。
os.path.existe()函数用来检验给出的路径是否真地存在
os和os.path模块
os.listdir(dirname)：列出dirname下的目录和文件
os.getcwd()：获得当前工作目录
os.curdir:返回但前目录（‘.’)
os.chdir(dirname):改变工作目录到dirname

Python os.getcwd()函数获得当前的路径时，你对Python os.getcwd()函数获得当前的路径的原型是否了解，以下的文章就是对其原型的具体分析，以下就是文章的相关内容的具体介绍。
在Python os.getcwd()函数获得当前的路径。其原型如下所示。
os.getcwd()
该函数不需要传递参数，它返回当前的目录。需要说明的是，当前目录并不是指脚本所在的目录，而是所运行脚本的目录。例如，在PythonWin中输入如下脚本。
1.>>> import os
2.>>> print 'current directory is ',os.getcwd()
3.current directory is D:\Python25\Lib\site-packages\pythonwin
这里是PythonWin的安装目录如果将上述内容写入pwd.py，假设pwd.py位于E:\book\code目录，运行Windows的命令行窗口，进入E:\book目录，输入code\pwd.py，输出如下所示。
1.E:\book>code\pwd.py
2.current directory is E:\book
获得目录中的内容
在Python中可以使用os.listdir()函数获得指定目录中的内容。其原型如下所示。
1.os.listdir(path)
其参数含义如下。· path 要获得内容目录的路径。以下实例获得当前目录的内容。
1.>>> import os
2.>>> os.listdir(os.getcwd())
获得当前目录中的内容
1.[‘dde.pyd’, ‘license.txt’, ‘Pythonwin.exe’,
‘scintilla.dll’, ‘win32ui.pyd’, ‘win32uiole.
pyd’, ‘pywin’]
以上的内容就是对Python中文件和目录操作以及Python os.getcwd()函数获得当前的路径在实际应用的想过步骤的介绍。

python:open/文件操作
原网址：http://www.cnblogs.com/dkblog/archive/2011/02/24/1980651.html
open/文件操作
f=open(‘/tmp/hello’,‘w’)

#open(路径+文件名,读写模式)

#读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

如:‘rb’,‘wb’,'r+b’等等
读写模式的类型有：
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )

注意：
1、使用’W’，文件若存在，首先要清空，然后（重新）创建，
2、使用’a’模式，把所有要写入文件的数据都追加到文件的末尾，即使你使用了seek（）指向文件的其他地方，如果文件不存在，将自动被创建。

f.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)

file.readline() 返回一行

file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行

for line in f: print line #通过迭代器访问

f.write(“hello\n”) #如果要写入字符串以外的数据,先将他转换为字符串.

f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

f.seek(偏移量,[起始位置])

用来移动文件指针

偏移量:单位:比特,可正可负

起始位置:0-文件头,默认值;1-当前位置;2-文件尾

f.close() 关闭文件

Code:

#!/usr/bin/env python

Filename: using_file.py

poem=‘’‘\Programming is funWhen the work is doneif you wanna make your work also fun: use Python!’‘’
f=file(‘poem.txt’,‘w’) # open for 'w’riting
f.write(poem) # write text to file
f.close() # close the file
f=file(‘poem.txt’)

if no mode is specified, 'r’ead mode is assumed by default

while True:
line=f.readline()
if len(line)==0: # Zero length indicates EOF
break
print line,

Notice comma to avoid automatic newline added by Python

f.close()

close the file

Python中的一些异常—关于keyerro之类

其实异常就是不正常，就是不和我们想象一样去执行。它是因为程序出现了错误而在正常控制流以外采取的行为。Python出现异常，就是因为检查了一个错误时，Python解释器无法继续继续执行下去，这时候抛出了异常。往往这个错误分为语法上和逻辑上(不擅长说概念，-_-! )，看看几个例子，总结一下：
1、NameError：尝试访问一个未声明的变量任何可访问的变量必须在名称空间列出，访问变量需要由解释器进行搜索，如果请求的名字没有在任何名称空间里找到，那么将会生成一个 NameError异常
2、ZeroDivisionError：除数为零任何数值被零除都会导致一个ZeroDivisionError的异常
3、SyntaxError：Python解释器语法错误 SynaxError异常是唯一不是在运行时候发生的异常，它表示Python代码中有不正确的结构，因此无法正常执行。很明显，这个错误是在编译时候产生的，Python解释器无法将该脚本转化为Python字节代码。
4、IndexError：请求的索引超出了序列范围举例子： >>> aList = [1 ,3] >>> aList[0] 1 >>> aList[1] 3 >>> aList[2] Traceback (most recent call last): File “”, line 1, in IndexError: list index out of range
5、KeyError：请求一个不存在的字典关键字字典中用key访问value，如果使用不存在的key，就是抛出KeyError异常 >>> aList ={‘a’:1,‘b’:2} >>> aList[‘a’] 1 >>> aList[‘c’] Traceback (most recent call last): File “”, line 1, in KeyError: ‘c’
6、IOError：输入/输出错误如果尝试打开一个不存在或者无权限的文件等操作，就会引发操作系统I/O错误。这个错误可以多种
7、AttributeError：尝试访问未知对象属性
8、ValueError：赋值异常例如: >>> int(123.23) 123 >>> int(‘a’) Traceback (most recent call last): File “”, line 1, in ValueError: invalid literal for int() with base 10: ‘a’ 由于参数的值是字符，不可转化为整形。同时还有类似的TypeError类似的异常。
上面只是一部分，对于异常情况，无论是在任何编程语言中都很重要，作为程序员，不仅要懂得怎么去检测这些异常，还应该具备异常发生时采取可靠补救措施的能力。一如既往，作为记录，仅此而已。