python基础总结(基于2.7版本也适用于3.4)

言语介绍：

Python（英语发音：/?pa?θ?n/）, 是一种面向对象、解释型计算机程序设计语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年，Python 源代码同样遵循 GPL(GNU General Public License)协议^[1]。Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。

由于Python语言的简洁、易读以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python教授程序设计课程。例如卡耐基梅隆大学的编程基础和麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。

特点：

优点

简单：Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样。它使你能够专注于解决问题而不是去搞明白语言本身。

易学：Python极其容易上手，因为Python有极其简单的说明文档^[5]。

速度快：Python 的底层是用 C 语言写的，很多标准库和第三方库也都是用 C 写的，运行速度非常快。^[2]

免费、开源：Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。

高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

可移植性：由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE、PocketPC、Symbian以及Google基于linux开发的android平台。

解释性：一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。

运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行 程序。

在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。

面向对象：Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。

可扩展性：如果需要一段关键代码运行得更快或者希望某些算法不公开，可以部分程序用C或C++编写，然后在Python程序中使用它们。

可嵌入性：可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。

丰富的库：Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

规范的代码：Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。

缺点

单行语句和命令行输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。

独特的语法

这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。最常见的情况是tab和空格的混用会导致错误，而这是用肉眼无法分别的。

运行速度慢：这里是指与C和c++相比

系统编程：提供API（Application Programming Interface应用程序编程接口），能方便进行系统维护和管理，Linux下标志性语言之一，是很多系统管理员理想的编程工具^[6]。

图形处理：有PIL、Tkinter等图形库支持，能方便进行图形处理。

数学处理：NumPy扩展提供大量与许多标准数学库的接口。

文本处理：python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。

数据库编程：程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，MySQL、SQLite等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。

网络编程：提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。很多大规模软件开发计划例如Zope，Mnet 及BitTorrent. Google都在广泛地使用它。

Web编程：应用的开发语言，支持最新的XML技术。

多媒体应用：Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。

pymo引擎：PYMO全称为python memories off，是一款运行于Symbian S60V3,Symbian3,S60V5, Symbian3, Android系统上的AVG游戏引擎。因其基于python2.0平台开发，并且适用于创建秋之回忆（memories off）风格的AVG游戏，故命名为PYMO。

黑客编程：python有一个hack的库,内置了你熟悉的或不熟悉的函数，但是缺少成就感。

用Python写简单爬虫

首先，要通过urllib2这个Module获得对应的HTML源码。

import urllib2  #调用urllib2  
url=‘http://www.baidu.com/s?wd=cloga‘ #把等号右边的网址赋值给url
html=urllib2.urlopen(url).read()   #html随意取名 等号后面的动作是打开源代码页面，并阅读
print html #打印

通过上面这三句就可以将URL的源码存在content变量中，其类型为字符型。

接下来是要从这堆HTML源码中提取我们需要的内容。用Chrome查看一下对应的内容的代码（也可以用Firefox的Firebug）。

可以看到url的信息存储在span标签中，要获取其中的信息可以用正则式。

开发工具pydev插件安装和配置开发

PyDev

http://www.pydev.org/updates

Package以及数据类型1：

1. 自带package和外部package
1. 自带package举例：os; osgetpwd();
2. 
2. 外部package以及管理系统介绍：easy_install ,pip (comes with python 3.4)
1. 如：
2. 如：安装requests网络请求库；
3. 
3. 环境变量中配置easy_install ,pip
4. 使用easy_install ,pip 安装package 举例

碰到中文乱码问题：

# -*- coding: UTF-8 -*-

或者

#coding=utf-8

注：此语句一定要添加在源代码的第一行）

也可以直接设置项目为utf-8格式：

考虑到版本兼容下问题；现在在eclipse安装最新的python版本；

#coding=utf-8
‘‘‘
Created on 2015-5-3

@author: Administrator
‘‘‘
import os
import requests

print("hello samy by pydev")
print(os.getcwd())
r = requests.get("http://www.baidu.com")
# r = requests.get("http:www.google.com")
print(r.url)
print(r.encoding)

1. 总体：numerics，sequences，mappings，classes，instancees，and exceptions;
2. Number Types：int(包括boolean)，float，complex;
3. int:ulimited length ;float:实现用double in C,可以查看 sys.float_info,complex:real(实部) &imaginary（虚部） ，用z.real和z.imag来取两部分；

一、基本概念

　　1. python中数有五种类型：整数、长整数、浮点数和复数还有个布尔型(bool)。

• 整数， 如 1
• 长整数 是比较大的整数
• 浮点数 如 1.23、3E-2
• 复数 如 1 + 2j、 1.1 + 2.2j
• bool型

      例如：0，1，-1,1009，-290这些等等都是int型；

      例如：87887l,-87887l,234567l这些等等都是long型；

      例如：2.7788,3.277,8.88这些等等都是float型；

      例如：bool型只有两个：一个是True,一个是False；

      例如：4+2j,-9+20j,56+7j这些等等都是复数型；

　　2. 字符串（字符的序列）

• python中单引号和双引号使用完全相同。
• 使用三引号(‘‘‘或""")可以指定一个多行字符串。
• 转义符 ‘\‘
• 自然字符串， 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• python允许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"。
• 字符串是不可变的。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

例如：‘‘‘

samy.zhang

‘‘‘

　　3. 标识符的命名

• 第一个字符必须是字母表中字母或下划线‘_‘。
• 标识符的其他的部分有字母、数字和下划线组成。
• 标识符对大小写敏感。

　　4. 对象

　　　　python程序中用到的任何“东西”都成为“对象”。

　　5. 逻辑行和物理行

　　　　物理行是我们在编写程序时看到的，逻辑行则是python看到的。

　　　　python中分号;标识一个逻辑行的结束，但是实际中一般每个物理行只写一个逻辑行，可以避免使用分号。

　　　　多个物理行中可以写一个逻辑行，如下：

s = "peter is \

writing this article"

　　　　上面\的使用被称为‘明确的行连接’， 又如：

print "peter"

　　6. 缩进

　　　　空白在python是非常重要的，行首的空白是最重要的，又称为缩进。行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而决定语句

　　分组。这意味着同一层次的语句必须有相同的缩进，每一组这样的语句称为一个块。

　　注意：不要混合使用空格和制表符来缩进，因为在跨越不同的平台时无法正常工作。

#coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
字符串演示部分
@author: samy
‘‘‘
# 单引号，双引号，三引号；
print(‘hello world‘)
print("hello world")
print(‘‘‘hello world‘‘‘)

age = 3
name = "samy"
# format()字符串
print("{0} was {1} year old ".format(name,age))
# 联合
print(name +" was "+str(age)+" year old ")
#换行符
print("What‘s your name?\n Samy")

# 字面常量
# 可以直接以字面意义使用它们
print(3.45e-3)#0.00345


#变量
# 命名规则：
# 第一个字符必须是字母或者下划线，其余字符可以是字母，数字，或者下划线；区分大小写；

#coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
数字演示部分
@author: samy
‘‘‘
import sys

a = 3
b = 4

c = 5.66
d = 9.0

e = complex(c,d)
f = complex(float(a),float(b))

print("a is type:  ",type(a))
print("c is type:  ",type(c))
print("e is type:  ",type(e))

print(a + b)
print(d / c)
print(b / a)
print(b // a)#这里摸了两次

print(e)#实数和虚数构造
print(e + f)

print(sys.float_info)#查看当前类型的最大或最小范围

二、运算符与表达式

　　1. 运算符与其用法

　　2. 运算符优先级（从低到高）

# coding=utf-8
‘‘‘
    优先级记忆口诀表：
函数寻址下标一；
幂运算小二小嘻嘻；
全体单元第三位； # 比如翻转运算~，正负号等。单位运算符，就是一个操作对象的运算符
乘除求余四千里；
乘除完了五加减；
六娃玩耍左右移；
七是按位或跟与； # 同时包括异或
八仙生气要比敌； # 比较运算符
倒数第一逻辑或非与；

lambda表达式在刚开始的时候很少遇到，遇到的时候很容易将其放到最低优先级，所以这里为了记忆方便，将常见的逻辑或非与放到最后即可

 * @dec:运算符与表达式演示
 * @author: samy([email protected])
 * @datetime: 2015-05-23  14:31
‘‘‘
print "=============+:两个数字相加================"
a = 7 + 8
print a

print "=============-:取一个数字的相反或者实现两个数字相减================"
a = -7
print a
b = -(-8)
print b
c = 19 - 1
print c

print "=============*:两个数相乘或者字符串重复================"
a = 4*7
print a
b = "samy\t"*7
print b

print "=============*:两个数字相除================"
a = 7/2
print a
b = 7.0/2
print b
c = 7/2.0
print c

print "=============**:求幂运算================"
# 相当于2的3次幂，就是2*2*2
a = 2**3
print a

print "=============<:小于符号，返回一个bool值================"
a = 3 < 7
print a
b = 3 < 3
print b

print "=============<:大于符号，返回一个bool值================"
a = 3 > 7
print a
b = 3 > 3
print b

print "=============!=:不等于符号，返回一个bool值================"
a = 2 != 3
print a
b = 2 != 2
print b

print "=============//:除法运算，然后返回其商的整数部分，舍掉余数================"
a = 10 // 3
print a

print "=============%:除法运算，然后返回其商的余数部分，舍掉商跟//相反================"
a = 10 % 3
print a
# 没有余数的时候返回什么0
b = 10 % 1
print b

a = 10 // 3  # a为商的整数部分
b = 10 % 3  # b为商的余数部分
c = 3*a + b
print c


print "========&：按位与运算，所谓的按位与就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00000010,然后我们将00000010转化为十进制得到2
‘‘‘
a = 7 & 18  # 执行一下；为什么7跟18会得到2呢；
print a

print "========|：按位或运算，所谓的按位或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00010011,然后我们将00010011转化为十进制得到23
‘‘‘
a = 7 | 18
print a


print "========^：按位异或运算（不同则为1，相同则为0），所谓的按位异或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算========="
‘‘‘
7    00000111
18   00010010按位进行与运算，
结果:00010001,然后我们将00010011转化为十进制得到21
‘‘‘
a = 7 ^ 18
print a


print "========~：按位翻转运算（~x=-(x+1)）========="
# ~18 = -(18+1) = -19
a = ~18
print a

print "===============<<:左移====================="
‘‘‘
比如18左移就是将他的二进制形式00010010左移，即移后成为00100100,即成为36,左移动2个单位相当于乘以4,左移动3个单位相当于乘以8,左移动n个单位相当于乘以2的n次幂,
‘‘‘
a = 18 << 1  # 36
print a
b = 3 << 3  # 24
print b

print "===============>>:右移====================="
‘‘‘
比如18右移就是将他的二进制形式00010010右移，即移后成为00100100,即成为36,右移动2个单位相当于乘以4,右移动3个单位相当于乘以8,右移动n个单位相当于除以2的n次幂,
‘‘‘
a = 18 >> 1  # 9
print a
b = 3 >> 3  # 0
print b


print "==========<=:小于或等于,返回一个bool值==========="
a = 3 <= 3
print a
b = 4 <= 3
print b

print "==========>=:大于或等于,返回一个bool值==========="
a = 3 >= 3
print a
b = 4 >= 3
print b

print "============:等于,返回一个bool值==========="
a = 3 == 3
print a
b = "samy" == "samy"
print b


print "============and:逻辑与==========="
‘‘‘
True and True 等于 True
True and False 等于 False
False and True 等于 False
‘‘‘
a = True and True
print a


print "============or:逻辑或==========="
‘‘‘
True and True 等于 True
True and False 等于 True
False and False 等于 False
‘‘‘
a = True and False
print a

print "============not:逻辑非==========="
a = True
b = not a
print b
c = False
print not c

E:\ProgramFiles\Python27\python.exe D:/samy/web/python/workspace/python_base/BaseOperator.py
=============+:两个数字相加================
15
=============-:取一个数字的相反或者实现两个数字相减================
-7
8
18
=============*:两个数相乘或者字符串重复================
28
samy	samy	samy	samy	samy	samy	samy	
=============*:两个数字相除================
3
3.5
3.5
=============**:求幂运算================
8
=============<:小于符号，返回一个bool值================
True
False
=============<:大于符号，返回一个bool值================
False
False
=============!=:不等于符号，返回一个bool值================
True
False
=============//:除法运算，然后返回其商的整数部分，舍掉余数================
3
=============%:除法运算，然后返回其商的余数部分，舍掉商跟//相反================
1
0
10
========&：按位与运算，所谓的按位与就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算=========
2
========|：按位或运算，所谓的按位或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算=========
23
========^：按位异或运算（不同则为1，相同则为0），所谓的按位异或就是指一个数字转化为二进制，然后这些二进制的数按位来进行与运算=========
21
========~：按位翻转运算（~x=-(x+1)）=========
-19
===============<<:左移=====================
36
24
===============>>:右移=====================
9
0
==========<=:小于或等于,返回一个bool值===========
True
False
==========>=:大于或等于,返回一个bool值===========
True
True
============:等于,返回一个bool值===========
True
True
============and:逻辑与===========
True
============or:逻辑或===========
False
============not:逻辑非===========
False
True

Process finished with exit code 0

　　3. python 控制台输出 使用print

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
输入输出演示部分
接收用户的输入： input()
输出格式：str(),format

input：会根据用户的输入来做类型的转换
raw_input：则会把用户的输入都作为一个字符串来处理
@author: samy
‘‘‘

str_1 = input("enter a string:")
str_2 = input("enter another string:")

print("str_1 is :" + str_1 + " str_2 is :" +str_2)
print("str_1 is :{} str_2 is :{}".format(str_1, str_2))

print ("abc" )#打印abc并换行
print ("abc%s" % "d")#打印abcd
print("abc%s --> %s" % ("d", "g"))#打印abcd --->g

三、控制流

　　1. if 语句

　　2. while语句

　　3. for 循环 for..in

　　注：当for循环结束后执行else语句；

　　　　range(a, b)返回一个序列，从a开始到b为止，但不包括b，range默认步长为1，可以指定步长，range(0,10,2)；

　　4. break语句

　　　　终止循环语句，如果从for或while中终止，任何对应循环的else将不执行。

　　5. continue语句

　　　　continue语句用来调过当前循环的剩余语句，然后继续下一轮循环。

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
控制流演示部分
　　1. if 语句
 　　2. while语句
    3.range语句(其实不属于控制流里面的东东)
 　　3. for 循环 for..in
 　　4. break语句
 　　终止循环语句，如果从for或while中终止，任何对应循环的else将不执行。
 　　5. continue语句
     continue语句用来调过当前循环的剩余语句，然后继续下一轮循环。
@author: samy
‘‘‘

print("=====================if 语句演示：note:please input 59===============")
number = 59
#这里要求的必须的int型，要不然就会报错 
guess = int(input("Enter on integer :"))

if guess == number:
    print("Bingo! you guessed it right.")
    print("(but you do not win any prizes)")
elif guess < number:
    print("No, the number is higher than that")
else:
    print("No, the number is lower than that")
print("Done")


print("===================== while语句演示===============")
guess_flag = False
while guess_flag == False:
    guess = int(input("Enter on integer :"))
    if guess == number:
        guess_flag = True
    elif guess < number:
        print("No, the number is higher than that")
    else:
        print("No, the number is lower than that")
print("Bingo! you guessed it right.")
print("(but you do not win any prizes)")
print("Done")


print("===================== range语句演示===============")
num_chances = 3
print("you have only 3 chances to guess!")
for i in range(1,num_chances +1):
    print("chance "+ str(i))
    guess = int(input("Enter on integer :"))
    if guess == number:
        print("Bingo! you guessed it right.")
        print("(but you do not win any prizes)")
        break
    elif guess < number:
        print("No, the number is higher than that, keep guessing, you have "+ str(num_chances-i)+" chances left")
    else:
        print("No, the number is lower than that, keep guessing, you have "+ str(num_chances-i)+" chances left")
print("Done")



print("=====================for 循环 for..in演示===============")
# 当for循环结束后执行else语句；
#  range(a, b)返回一个序列，从a开始到b为止，但不包括b，
# range默认步长为1，可以指定步长，range(0,10,2)；
for i in range(1,10):
    print(i)
else:
#     pass
    print("the for loop is over")
    
print("=====================for循环遍历list,tuple,dict===============")
a_list = [1,3,5,7,9]
for i in a_list:
    print(i)
    
a_tuple = (1,3,5,7,9)
for i in a_tuple:
    print(i)
    
a_dict = {"Samy":"1111","Tom":"4444","Jenny":"3333"}
for i in a_dict:
    print(i)
    print(a_dict[i])
for key in a_dict.keys(): #　keys()　　---返回一个包含字典中所有键的列表
    print (key)    
for value in a_dict.values():#values()　　---返回一个包含字典中所有值的列表
    print (value)
for key ,vale in a_dict.items():
    print(key,vale)


print("=====================break语句和 continue语句演示===============")
while True:
# while guess_flag == False:
    guess = int(input("Enter on integer :"))
    if guess == number:
#         guess_flag = True
        break
    elif guess < number:
        print("No, the number is higher than that")
        continue
    else:
        print("No, the number is lower than that")
        continue
print("Bingo! you guessed it right.")
print("(but you do not win any prizes)")
print("Done")

# Python continue 语句跳出本次循环，而break跳出整个循环。
# continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
# continue 语句用在while和for循环中。
# Python pass是空语句，是为了保持程序结构的完整性。
print("=====================continue语句和pass 语言的不同演示===============")
a_list2 = [0,1,4]
print("using continue:")
for i in a_list2:
    if not i:#
        continue
    print(i)
    
print("using pass:")
for i in a_list2:
    if not i:
       pass
    print(i)
# using continue:
# 1
# 4
# using pass:
# 0
# 1
# 4

for letter in ‘Python‘: 
   if letter == ‘h‘:
      pass
      print (‘This is pass block‘)
   print (‘Current Letter :‘, letter)
print ("Good bye!")

四、函数

　　函数通过def定义。def关键字后跟函数的标识符名称，然后跟一对圆括号，括号之内可以包含一些变量名，该行以冒号结尾；接下来是一块语句，即函数体。

　　1. 函数形参

　　　　函数中的参数名称为‘形参’，调用函数时传递的值为‘实参’

　　2. 局部变量

　　　　在函数内定义的变量与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是局部的。这称为变量的作用域。

　　　　global语句， 为定义在函数外的变量赋值时使用global语句。

#全局变量与局部变量
print("====================全局变量与局部变量==============")
x =60
def foo(x):
    print("x is : "+str(x))#60
    x = 3
    print("change local x to : "+str(x))#3
foo(x)
print("x is still: "+str(x))#60

y =60
def foo2():
    global y #　global语句， 为定义在函数外的变量赋值时使用global语句。
    print("y is : "+str(y))#60
    y = 3
    print("change local y to : "+str(y))#3
foo2()
print("y is still: "+str(y))#3

　　3. 默认参数

　　　　通过使用默认参数可以使函数的一些参数是‘可选的’。

#有默认参数，返回值
print("====================有默认参数，返回值==============")
def repeat_str1(str,times = 1):
    repeated_strs = str*times
    return repeated_strs
repeated_strs = repeat_str1("samy haha! ")  
print(repeated_strs)

repeated_strs = repeat_str1("samy haha! ",3)  
print(repeated_strs)

　　　　注意：只有在形参表末尾的那些参数可以有默认参数值，即不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参，只是因为赋给形参的值是根据位置而赋值的。

　　4. 关键参数

　　　　如果某个函数有很多参数，而现在只想指定其中的部分，那么可以通过命名为这些参数赋值（称为‘关键参数’）。

　　　　优点：不必担心参数的顺序，使函数变的更加简单；假设其他参数都有默认值，可以只给我们想要的那些参数赋值。

#关键字参数：调用函数时，选择性的传入部分参数
#不能在有默认参数后面跟没有默认参数
#f(a ,b =2) 合法
#f(a = 2 ,b) 不合法
print("====================关键字参数：调用函数时，选择性的传入部分参数=============")
def func2(a, b=4,c=8):
    print("a is ",a, "and b is", b, "and c is ", c)
func2(13, 17)
func2(125, c= 24)
func2(c = 40, a = 80)

　　5. return 语句

　　　　return语句用来从一个函数返回，即跳出函数。可从函数返回一个值。

　　　　没有返回值的return语句等价于return None。None表示没有任何东西的特殊类型。

　　6. DocStrings (文档字符串)

#DocStrings (文档字符串)
print("============DocStrings (文档字符串)=========")
def func():
    ‘‘‘This is self-defined function

Do nothing‘‘‘
    pass

print (func.__doc__)

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-5
函数演示部分
函数：程序中可重复使用的程序段
给一段程序起一个名字，用这个名字来执行一段程序，反复使用（调用函数）

用关键字“def”来定义，identifier(参数)
identifier

参数list
return statement
局部变量VS全局变量

@author: samy
‘‘‘
#没有参数和返回的函数
print("====================没有参数和返回的函数==============")
def say_hi():
    print("hi")
say_hi()
say_hi()

#有参数，没有返回值 
print("====================有参数，没有返回值 ===============")
def print_sum_two(a,b):
    c = a+ b
    print(c)
print_sum_two(3,6)

#有参数，没有返回值
print("====================有参数，有返回值===============")
def repeat_str(str,times):
    repeated_strs = str*times
    return repeated_strs
repeated_strs = repeat_str("samy haha! ",5)  
print(repeated_strs)

#有默认参数，返回值
print("====================有默认参数，返回值==============")
def repeat_str1(str,times = 1):
    repeated_strs = str*times
    return repeated_strs
repeated_strs = repeat_str1("samy haha! ")  
print(repeated_strs)

repeated_strs = repeat_str1("samy haha! ",3)  
print(repeated_strs)


#DocStrings (文档字符串)
print("============DocStrings (文档字符串)=========")
def func():
    ‘‘‘This is self-defined function

Do nothing‘‘‘
    pass

print (func.__doc__)

#关键字参数：调用函数时，选择性的传入部分参数
#不能在有默认参数后面跟没有默认参数
#f(a ,b =2) 合法
#f(a = 2 ,b) 不合法
print("====================关键字参数：调用函数时，选择性的传入部分参数=============")
def func2(a, b=4,c=8):
    print("a is ",a, "and b is", b, "and c is ", c)
func2(13, 17)
func2(125, c= 24)
func2(c = 40, a = 80)


#VarArgs 参数
print("=======================VarArgs 参数=================")
def print_paras(fpara, *nums,**words):
    print("fpara: " +str(fpara))
    print("nums: " +str(nums))
    print("words: " +str(words))
print_paras("samy",1,3,4,45, word = "python", anther_word = "java")

#全局变量与局部变量
print("====================全局变量与局部变量==============")
x =60
def foo(x):
    print("x is : "+str(x))#60
    x = 3
    print("change local x to : "+str(x))#3
foo(x)
print("x is still: "+str(x))#60

y =60
def foo2():
    global y #　global语句， 为定义在函数外的变量赋值时使用global语句。
    print("y is : "+str(y))#60
    y = 3
    print("change local y to : "+str(y))#3
foo2()
print("y is still: "+str(y))#3

五、模块

　　模块就是一个包含了所有你定义的函数和变量的文件，模块必须以.py为扩展名。模块可以从其他程序中‘输入’(import)以便利用它的功能。

　　在python程序中导入其他模块使用‘import‘, 所导入的模块必须在sys.path所列的目录中，因为sys.path第一个字符串是空串‘‘即当前目录，所以程序中可导入当前目录的模块。

　　1. 字节编译的.pyc文件

　　　　导入模块比较费时，python做了优化，以便导入模块更快些。一种方法是创建字节编译的文件，这些文件以.pyc为扩展名。

　　　　pyc是一种二进制文件，是py文件经编译后产生的一种byte code，而且是跨平台的（平台无关）字节码，是有python虚拟机执行的，类似于

　　java或.net虚拟机的概念。pyc的内容，是跟python的版本相关的，不同版本编译后的pyc文件是不同的。

　　2. from .. import

　　　　如果想直接使用其他模块的变量或其他，而不加‘模块名+.‘前缀，可以使用from .. import。

　　　　例如想直接使用sys的argv，from sys import argv 或 from sys import *

　　3. 模块的__name__

　　　　每个模块都有一个名称，py文件对应模块名默认为py文件名，也可在py文件中为__name__赋值；如果是__name__，说明这个模块被用户

　　单独运行。

　　4. dir()函数

　　　　dir(sys)返回sys模块的名称列表；如果不提供参数，即dir()，则返回当前模块中定义名称列表。

　　　　del -> 删除一个变量/名称，del之后，该变量就不能再使用。

六、数据结构

　　python有三种内建的数据结构：列表、元组和字典、集合。

python最基本的数据类型就是数和字符串；python没有数组的概念。python中跟数组最接近的概念就是列表和元组；

　　1. 列表

　　　　list是处理一组有序项目的数据结构，列表是可变的数据结构。列表的项目包含在方括号[]中，eg: [1, 2, 3]， 空列表[]。判断列表中是否包含某项可以使用in， 比如 l = [1, 2, 3]; print 1 in l; #True；支持索引和切片操作；索引时若超出范围，则IndexError；使用函数len()查看长度；使用del可以删除列表中的项，eg: del l[0] # 如果超出范围，则IndexError

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
列表List演示部分
List
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘
from filecmp import cmp

‘‘‘
创建List
‘‘‘
print("======================创建List======================")
number_list = [1, 3, 5, 7, 10]
print("number_list: " + str(number_list))

# 注意这里用print打印时里面有字符串时，其他字符串都得转换成String型：str(***)
string_list = ["abc", "python", "java"]
print("string_list: " + str(string_list))

mixed_list = [1, 3, 5, "abc", "python", "java"]
print("mixed_list: " + str(mixed_list))

‘‘‘
访问List中元素数据
‘‘‘
print("======================访问List中元素数据======================")
second_num = number_list[1]
third_string = string_list[2]
fourth_mixed = mixed_list[3]
print("second_num:{0}; third_string:{1};  fourth_mixed:{2};".format(second_num, third_string, fourth_mixed))

‘‘‘
更新List中元素数据
‘‘‘
print("======================更新List中元素数据======================")
print("number_list before" + str(number_list))
number_list[1] = 50
print("number_list after" + str(number_list))

‘‘‘
删除List中元素数据
‘‘‘
print("======================删除List中元素数据======================")
print("number_list before" + str(number_list))
del number_list[0]
print("number_list after" + str(number_list))

‘‘‘
Python脚本语言
‘‘‘
print("======================Python脚本语言======================")
print("长度:", str(len([1, 2, 3])))
print("组合:" + str([1, 2, 3] + [4, 5, 8]))
print("重复:" + str(["Samy" * 4]))
print("某个元素在列表中:" + str(3 in[1, 2, 3]))

‘‘‘
列表的截取
‘‘‘
print("======================列表的截取======================")
abcd_list = ["a", "b", "c", "d"]
print(abcd_list[2])
print(abcd_list[2:])  # 输出数组中位置2以后的元素,返回的是一个数组
print(abcd_list[-2])  # 注意这里从倒序取数据

‘‘‘
列表操作包含以下函数
‘‘‘
print("======================列表操作包含以下函数======================")
# number1 = 23
# number2 = 23
# print(cmp(number1,number2))#比较两个列表的元素
# print(list(seq))#将元组转换成列表
print(max(number_list))
print(min(number_list))

print(number_list.append(133))  # 在列表末尾添加新的对象
print(number_list)
print(number_list.count(7))  # 统计某个元素在列表中出现的次数
number_list2 = [13,24]
number_list.extend(number_list2)  # 在列表末尾一次性追加一个序列中的多个值（用新列表扩展原来的列表）
print(number_list)
number_list.index(7) # 　index(value, [start, [stop]])　　---返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError
# number_list.index(0,100) # 　insert(i, value)向列表i位置插入项vlaue，如果没有i，则添加到列表尾部
print(number_list)
number_list.insert(0, "samy")  # 将对象插入列表
print(number_list)
number_list.remove(10) # 移除列表中某个值得第一个匹配项
print(number_list)
number_list.reverse()  # 反向列表中元素列表反转
print(number_list)
# 　pop([i])--返回i位置项，并从列表中删除；如果不提供参数，则删除最后一个项；如果提供，但是i超出索引范围，则异常IndexError
l = [0, 1, 2, 3, 4, 5]
print (l.pop())# 5
print (l.pop(1)) #1
# try:
#     l.pop(100)
# except IndexError, ie:
#     print ("index out of range")

# print(number_list.sort(key=None, reverse=True))  # 对原列表进行排序

l5 = [10, 5, 20, 1, 30]
l5.sort()
print (l5) #[1, 5, 10, 20, 30]

l6 = ["bcd", "abc", "cde", "bbb"]
# l6.sort(cmp = lambda s1, s2: cmp(s1[0],s2[1]))//cmp这个还有点问题
print (l6) #[‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]

l7 = ["bcd", "abc", "cde", "bbb", "faf"]
l7.sort(key = lambda s: s[1])
print (l7) #[‘faf‘, ‘abc‘, ‘bbb‘, ‘bcd‘, ‘cde‘]

2. 元组

　　　　tuple和list十分相似，但是tuple是不可变的，即不能修改tuple，元组通过圆括号中用逗号分割的项定义；支持索引和切片操作；可以使用 in

　　查看一个元素是否在tuple中。空元组()；只含有一个元素的元组("a",) #需要加个逗号

　　　　优点：tuple比list速度快；对不需要修改的数据进行‘写保护’，可以是代码更安全

　　　　tuple与list可以相互转换，使用内置的函数list()和tuple()。

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
元组Tuple演示部分
Tuple
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘

‘‘‘
创建Tuple
‘‘‘
print("======================创建Tuple======================")
number_tuple = (1, 3, 5, 7, 10)
print("number_tuple: " + str(number_tuple))

# 注意这里用print打印时里面有字符串时，其他字符串都得转换成String型：str(***)
string_tuple = ("abc", "python", "java")
print("string_tuple: " + str(string_tuple))

mixed_tuple = (1, 3, 5, "abc", "python", "java")
print("mixed_tuple: " + str(mixed_tuple))

‘‘‘
访问Tuple中元素数据
‘‘‘
print("======================访问Tuple中元素数据======================")
second_num = number_tuple[1]
third_string = string_tuple[2]
fourth_mixed = mixed_tuple[3]
print("second_num:{0}; third_string:{1};  fourth_mixed:{2};".format(second_num, third_string, fourth_mixed))

‘‘‘
更新Tuple中元素数据(Tuple数据不能更新修改)
‘‘‘
print("======================更新Tuple中元素数据:Tuple数据不能更新修改=====================")
# print("number_tuple before" + str(number_tuple))
# # TypeError: ‘tuple‘ object does not support item assignment
# tuple[1] = 50
# number_tuple[1] = 50
# print("number_tuple after" + str(number_tuple))

‘‘‘
删除Tuple中元素数据（Tuple数据不能删除单个元素，但是可以删除整个）
‘‘‘
print("======================删除Tuple数据不能删除单个元素，但是可以删除整个=====================")
print("number_tuple before" + str(number_tuple))
# TypeError: ‘tuple‘ object doesn‘t support item deletion
# del number_tuple[0]
# 这个可以实现；为了后面演示，故先在这里注释掉；
# del number_tuple;
print("number_tuple after" + str(number_tuple))

‘‘‘
Python脚本语言
‘‘‘
print("======================Python脚本语言======================")
print("长度:", str(len((1, 2, 3))))
print("组合:" + str((1, 2, 3) + (4, 5, 8)))
print("重复:" + str(("Samy" * 4)))
print("某个元素在元组中:" + str(3 in(1, 2, 3)))

‘‘‘
元组的截取
‘‘‘
print("======================元组的截取======================")
abcd_Tuple = ("a", "b", "c", "d")
print(abcd_Tuple[2])
print(abcd_Tuple[2:])  # 输出数组中位置2以后的元素,返回的是一个数组
print(abcd_Tuple[-2])  # 注意这里从倒序取数据

‘‘‘
元组操作包含以下函数
Tuple不存在的方法
您不能向tuple增加元素。Tuple没有append或extend方法。和insert,reverse
您不能向tuple增加元素。Tuple没有remove或pop方法。
然而，您可以使用in来查看一个元素是否存在tuple中。
‘‘‘
print("======================元组操作包含以下函数======================")
# # number1 = 23
# # number2 = 23
# # print(cmp(number1,number2))#比较两个元组的元素
# # print(Tuple(seq))#将元组转换成元组
print(max(number_tuple))
print(min(number_tuple))
# 
# print(number_tuple.append(133))  # 在元组末尾添加新的对象(不支持)
# print(number_tuple)
print(number_tuple.count(7))  # 统计某个元素在元组中出现的次数
number_Tuple2 = [13, 24]
# number_tuple.extend(number_Tuple2)  # 在元组末尾一次性追加一个序列中的多个值（用新元组扩展原来的元组）（不支持）
print(number_tuple)
number_tuple.index(7)  # 从元组中找出某个值第一个匹配顶的索引位置
# number_tuple.index(7,[3,5] )#返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError

print(number_tuple)
# number_tuple.insert(0, "samy")  # 将对象插入元组（不支持）
# print(number_tuple)
# # print(number_tuple.pop(number_tuple[1]))  # 移除元组中的一个元素（默认最后一个元素），并且返回该元素的值（不支持）
# number_tuple.remove(10) # 移除元组中某个值得第一个匹配项（不支持）
# print(number_tuple)
# number_tuple.reverse()  # 反向元组中元素（不支持）
# print(number_tuple)
# print(number_tuple.sort(key=None, reverse=True))  # 对原元组进行排序

数组list和元组tuple的比较：

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-3
列表List和Tuple对比比较演示部分;同时也用到Modle引入部分
List and Tuple
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘
# 注意这里应用其他类的东东，必将会调用其里面的方法
from BaseTuple import  mixed_tuple

‘‘‘
Touple部分
‘‘‘
print("======================List和Touple比较部分=====================")
#创建只包含一个元素的tuple；只含有一个元素的元组("a",) #需要加个逗号
a_tuple = (2,)

#Tuple中的list
mixed_tuple  = (1,2,["a", "b"])
print("mixed_tuple: " + str(mixed_tuple))

# 复制替换list里面数据
mixed_tuple[2][0] = ‘java‘
mixed_tuple[2][1] = ‘samy‘
# 记住这里不是修改tuple中的数据，而是看做修改其中的List数据
print("mixed_tuple after: " + str(mixed_tuple))
‘‘‘
Tuple是不可变list。一旦创建了一个tuple就不能以任何方式改变它；

Tuple与list的相同之处
1：定义tuple与定义list的方式相同，除了整个元素是用小括号包围的而不是方括号
2：Tuple的元素与list一样按定义的次序进行排序。Tuples的索引与list一样从0开始。所以一个
3：非空tuple的第一个元素总是t[0]
4：负数索引与list一样从tuple的尾部开始计数。
5：与list一样分片（slice）也可以使用。注意当分割一个list时，会得到一个新的list;当分割一个tuple时
会得到一个新的tuple。

Tuple不存在的方法
您不能向tuple增加元素。Tuple没有append或extend方法。
您不能向tuple增加元素。Tuple没有remove或pop方法。
然而，您可以使用in来查看一个元素是否存在tuple中。

用Tuple的好处
Tuple比list操作速度快。如果您定义一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用tuple替换listview。
如果对不需要修改的数据进行“保护”，可以使代码更安全。使用tuple而不是list如同拥有一个隐含的assert语句。
说明这一数据是常量。如果必须要改变这些值。则需要执行tuple到list转换。

Tuple与list的转换；tuple与list可以相互转换，使用内置的函数list()和tuple()。
Tuple可以转换成list。反之依然。内置的tuple函数接收一个list,并返回一个有着相同元素的tuple;
而list函数接收一个tuple返回一个list。从效果上看，tuple冻结一个list。而list解冻一个tuple

Tuple的其他应用
一次赋多值
v = ("a","b","e")
(x,y,z) = v
解释：v是一个三元素的tuple，并且（x,y,z）是一个三变量的tuple。将一个tuple赋值给另一个tuple,
        会按顺序将v的每一个值赋值给每个变量
‘‘‘

print("=====================list和tuple数据转换=======================")
t = tuple(mixed_tuple)
print(t)
l = list(t)
print(l)

   　3. 字典

　　　　字典由键值对组成，键必须是唯一的；eg: d = {key1:value1, key2:value2}；空字典用{}表示；字典中的键值对是没有顺序的，如果想要

　　一个特定的顺序，那么使用前需要对它们排序；d[key] = value，如果字典中已有key，则为其赋值为value，否则添加新的键值对key/value；使

　　用del d[key] 可以删除键值对；判断字典中是否有某键，可以使用in 或 not in；

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-5
字典演示部分
Dict
    创建
    访问
    更新
    删除
    脚本操作符
    函数方法
@author: samy
‘‘‘

‘‘‘
创建Dict
‘‘‘
print("======================创建Dict======================")
phone_book = {"Tom":123,"samy":455,"hong":788}
mixed_dict = {"Tom":"samy",23:23.55}

del_test = {}
del_test["1"] = "one"
del_test["2"] = "two"
del_test["3"] = "three"


‘‘‘
访问Dict中元素数据
‘‘‘
print("======================访问Dict中元素数据======================")
print("samy has number: " + str(phone_book["samy"]))
print("mixed_dict: " + str(mixed_dict))

for key, value in del_test.items():
    print("%s --> %s" % (key, value))
    
d6 = {1:"one", 2:"two", 3:"three"}#　has_key(key)　　---判断字典中是否有键key
# print (d6.has_key(1))  #True 好像3.0以上版本没有这个属性；AttributeError: ‘dict‘ object has no attribute ‘has_key‘
# print (d6.has_key(5))  #False

d7 = {1:"one", 2:"two", 3:"three"}
for item in d7.items(): #items()　　---返回一个包含字典中(键, 值)对元组的列表
    #打印默认键值对格式
    print(item)
    
for key, value in d7.items():
    #打印自己想要的格式
    print ("%s -- %s" % (key, value))

d8 = {1:"one", 2:"two", 3:"three"}
for key in d8.keys(): #　keys()　　---返回一个包含字典中所有键的列表
    print (key)    
for value in d8.values():#values()　　---返回一个包含字典中所有值的列表
    print (value)
‘‘‘
更新Dict中元素数据
‘‘‘
print("======================更新Dict中元素数据======================")
#添加数据
phone_book["Heath"] = "Health"
print("the added book is: " + str(phone_book))
#修改数据
phone_book["samy"] = 999
print("samy has number: " + str(phone_book["samy"]))

‘‘‘
删除Dict中元素数据
‘‘‘
print("======================删除Dict中元素数据======================")
del phone_book["Tom"]
print("the phone_book after del is: " + str(phone_book))

phone_book.clear()#删除字典中所有元素
print("the phone_book after del is: " + str(phone_book))
del phone_book #其后面注释掉，为了后面程序运行，表示这个Dict全部清空
# print("the phone_book after del all is: " + str(phone_book))#表示已经删除后，后面肯定查看不到数据；NameError: name ‘phone_book‘ is not defined
del del_test["3"]
# 遍历Dict map的键值对；
for key, value in del_test.items():
    print("%s --> %s" % (key, value))
    

‘‘‘
Dict的特性
‘‘‘
print("======================Dict的特性======================")
# 不允许同一个值出现多次；后面的数据会把前面的数据冲突掉
rep_test = {"name":"samy","age":5,"name":"samy33"}
print("rep_test: " +str(rep_test))
#键必须不可变，所以可以用书，字符串或者元组充当，列表list不可以；
# list_dict= {["Name"]:"samy","Age":23}#TypeError: unhashable type: ‘list‘
list_dict= {("Name"):"samy","Age":23}

‘‘‘
字典内置函数&方法
‘‘‘
# Python字典包含了以下内置函数：
#　pop(key, [default])　　---若字典中key键存在，删除并返回dict[key]，若不存在，且未给出default值，引发KeyError异常
d9 = {1:"one", 2:"two", 3:"three"}
print (d9.pop(1)) #one
print (d9) #{2: ‘two‘, 3: ‘three‘}
print (d9.pop(5, None)) #None
# try:
#    print(d9.pop(5))  # raise KeyError
# except KeyError, ke:
#     print  "KeyError:", ke #KeyError:5

#popitem()　　---删除任意键值对，并返回该键值对，如果字典为空，则产生异常KeyError
d10 = {1:"one", 2:"two", 3:"three"}
print (d10.popitem())  #(1, ‘one‘)
print (d10)  #{2: ‘two‘, 3: ‘three‘}

#setdefault(key,[default])　　---若字典中有key，则返回vlaue值，若没有key，则加上该key，值为default，默认None
d = {1:"one", 2:"two", 3:"three"}
print (d.setdefault(1))  #one
print (d.setdefault(5))  #None
print (d)  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None}
print (d.setdefault(6, "six")) #six
print (d)  #{1: ‘one‘, 2: ‘two‘, 3: ‘three‘, 5: None, 6: ‘six‘}

#update(dict2)　　---把dict2的元素加入到dict中去，键字重复时会覆盖dict中的键值
d = {1:"one", 2:"two", 3:"three"}
d2 = {1:"first", 4:"forth"}
d.update(d2)
print (d)  #{1: ‘first‘, 2: ‘two‘, 3: ‘three‘, 4: ‘forth‘}

# 　viewitems()　　---返回一个view对象，（key, value）pair的列表，类似于视图。
# 优点是，如果字典发生变化，view会同步发生变化。在迭代过程中，字典不允许改变，否则会报异常
d = {1:"one", 2:"two", 3:"three"}
# for key, value in d.viewitems():#这儿在高版本3有点问题；AttributeError: ‘dict‘ object has no attribute ‘viewitems‘
#     print ("%s - %s" % (key, value))

#viewkeys()　　---返回一个view对象，key的列表    
# for key in d.viewkeys():
#     print (key) #这儿在高版本3有点问题； AttributeError: ‘dict‘ object has no attribute ‘viewkeys‘

#viewvalues()　　---返回一个view对象，value的列表
# for value in d.viewvalues():
#     print (value) #这儿在高版本3有点问题； AttributeError: ‘dict‘ object has no attribute ‘viewvalues‘


‘‘‘
序列部分演示
　序列类型是指容器内的元素从0开始的索引顺序访问，一次可以访问一个或者多个元素；列表、元组和字符串都是序列；序列的两个主要特点是
　索引操作符和切片操作符；索引可以得到特定元素；切片可以得到部分序列；

　切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。 如果不指定第一个数，Python就从
　　序列首开始。如果没有指定第二个数，则Python会停止在序列尾。 注意，返回的序列从开始位置 开始 ，刚好在结束位置之前 结束。即开始位置是
　　包含在序列切片中的，而结束位置被排斥在切片外。 可以用负数做切片。负数用在从序列尾开始计算的位置。
‘‘‘
print("======================序列部分演示======================")
numbers = ["zero", "one", "two", "three", "four"]

print (numbers[1]) # one
print (numbers[-1]) # four
#print numbers[5] # raise IndexError

print (numbers[:]) # [‘zero‘, ‘one‘, ‘two‘, ‘three‘, ‘four‘]
print (numbers[3:]) # [‘three‘, ‘four‘]
print (numbers[:2]) # [‘zero‘, ‘one‘]
print (numbers[2:4]) # [‘two‘, ‘three‘]
print (numbers[1:-1]) # [‘one‘, ‘two‘, ‘three‘]

‘‘‘
字典中其他的内置方法
‘‘‘
print("======================字典中其他的内置方法=====================")

dict = {"name":"samy","age":5,"name":"samy33"}
# cmp(dict1,dict2)#比较两个字典元素
print (len(dict))#计算字典元素格式，即键的总数
print (type(dict))
print (dict.copy())#返回一个字典的浅复制
# dict.fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值；
# dict.has_key("1")

‘‘‘
绑定
　　当创建一个对象并给它赋一个变量的时候，这个变量仅仅“指向”那个对象，而不是表示这个对象本身！ 也就是说，变量名指向计算机中存储那个
　　对象的内存，这被称作名称到对象的绑定。
　　如果要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单对象），那么必须使用切片操作符来取得拷贝。
‘‘‘

‘‘‘
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])
将x转换为一个整数

long(x [,base] )
将x转换为一个长整数

float(x)
将x转换到一个浮点数

complex(real [,imag])
创建一个复数

str(x)
将对象 x 转换为字符串

repr(x)
将对象 x 转换为表达式字符串

eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s)
将序列 s 转换为一个元组

list(s)
将序列 s 转换为一个列表

set(s)
转换为可变集合

dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s)
转换为不可变集合

chr(x)
将一个整数转换为一个字符

unichr(x)
将一个整数转换为Unicode字符

ord(x)
将一个字符转换为它的整数值

hex(x)
将一个整数转换为一个十六进制字符串

oct(x)
将一个整数转换为一个八进制字符串
‘‘‘

集合部分：

# coding=utf-8
‘‘‘
 * @dec:集合的演示；
集合主要有两大功能：
1：建立关系；
2：消除重复元素
 * @author: samy([email protected]) 
 * @datetime: 2015-05-23  10:34
‘‘‘  

a = set("abcddmedddsamy")
b = set("cdddzhan")
# lista = {"samy", "jenny", "zhang"} #这个设置显示的set集合；而不是字典；
# 交集
print "a&b交集: "+str(a & b)
print "a|b并集: "+str(a | b)
print "a-b差集: "+str(a - b)
print "ab集合去除重复元素"+str(set(a))

七、面向对象编程

　　python支持面向对象编程；类和对象是面向对象编程的两个主要方面，类创建一个新的类型，对象是这个类的实例。

　　对象可以使用普通的属于对象的变量存储数据，属于对象或类的变量被称为域；对象也可以使用属于类的函数，这样的函数称为类的方法；域和方法可以合称为类的属性。

　　域有两种类型--属于实例的或属于类本身；它们分别被称为实例变量和类变量。

　　类使用关键字class创建，类的域和方法被列在一个缩进块中。

　　类的方法必须有一个额外的第一个参数，但是在调用时不为这个参数赋值，这个特殊变量指对象本身，按照惯例它的名称是self，类似C#中的this。

class Animal:
    pass #empty block

　　__init__方法　　在类的一个对象被创建时调用该方法；相当于c++中的构造函数。

　　__del__方法　　在类的对象被销毁时调用该方法；相当于c++中的析构函数。在使用del删除一个对象时也就调用__del__方法。

　　Python中所有的类成员(包括数据成员)都是public的；只有一个例外，如果使用的数据成员以双下划线为前缀，则为私有变量。

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
面向对象类（Class）和装饰器（Decorator）部分

__init__方法　　在类的一个对象被创建时调用该方法；相当于c++中的构造函数。
__del__方法　　在类的对象被销毁时调用该方法；相当于c++中的析构函数。在使用del删除一个对象时也就调用__del__方法。
Python中所有的类成员(包括数据成员)都是public的；只有一个例外，如果使用的数据成员以双下划线为前缀，则为私有变量。
@author: samy
‘‘‘

print("====================类配置基本配置用法================")
class Student1:
    def __init__(self, name, gradle):
        self.name = name
        self.gradle = gradle
    def instroduce(self):
        print("hi! I‘m " + str(self.name))
        print("my grade is: " + str(self.gradle))
    def improve(self, amount):
        self.gradle = self.gradle + amount

samy = Student1("samy", 28)
samy.instroduce()

samy.improve(10)
samy.instroduce()

print("====================属性配置================")
class Person:
    Count = 0
    def __init__(self, name, age):
        Person.Count += 1
        self.name = name
        self.__age = age  # __age表示age为Person私有属性

p = Person("samy", 25)
p1 = Person("jenny", 20)

print (Person.Count)  # 2
print (p.name)  # peter
# print (p.__age) #AttributeError: Person instance has no attribute ‘__age‘

print("=====================方法的配置巧妙用法===================")
def add_candles(cake_func):
    def insert_candles():
        return cake_func() + " candles"
    return insert_candles

# 方法一实现；
# def make_cake():
#     return "cake"
# gift_func = add_candles(make_cake)

# 方法二实现；（注意这里的使用配置说明）
@add_candles
def make_cake():
    return "cake"
# gift_func = add_candles(make_cake)

print(make_cake())
# print(gift_func())

print("===================继承：为了使用继承，基类的名称作为一个元组跟在类名称的后面；python支持多重继承。==================")
class SchoolMember:
    ‘‘‘Represent any school member.‘‘‘
    def __init__(self, name, age):
        self.name = name
        self.age = age
    print ("Initializing a school member.")
    
    def tell(self):
        ‘‘‘Tell my details‘‘‘
        print ("Name: %s, Age: %s, " % (self.name, self.age))

# 继承类
class Teacher(SchoolMember):
    ‘‘‘Represent a teacher.‘‘‘
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
    print ("Initializing a teacher")
 
    def tell(self):
         SchoolMember.tell(self)
         print ("Salary: %d" % self.salary)
 
class Student(SchoolMember):
    ‘‘‘Represent a student.‘‘‘
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print ("Initializing a student")
 
    def tell(self):
        SchoolMember.tell(self)
        print ("Marks: %d" % self.marks)


print (SchoolMember.__doc__)
print (Teacher.__doc__)
print (Student.__doc__)

t = Teacher("Mr. Li", 30, 9000)
s = Student("samy", 25, 90)

# 这里用法很好，借鉴下
members = [t, s]
 
for m in members:
     m.tell()
     
# 注意下这里的输出顺序
# Initializing a school member.
# Initializing a teacher
# Represent any school member.
# Represent a teacher.
# Represent a student.
# Initializing a student

八、输入/输出

　　程序与用户的交互需要使用输入/输出，主要包括控制台和文件；对于控制台可以使用raw_input和print，也可使用str类。raw_input(xxx)输入xxx然后读取用户的输入并返回。

　　1. 文件输入/输出

　　　　可以使用file类打开一个文件，使用file的read、readline和write来恰当的读写文件。对文件读写能力取决于打开文件时使用的模式，常用模式

　　有读模式("r")、写模式("w")、追加模式("a")，文件操作之后需要调用close方法来关闭文件。

　　2. 存储器

　　　　python提供一个标准的模块，成为pickle，使用它可以在一个文件中存储任何python对象，之后可以完整的取出来，这被称为持久地存储对象；还有另外一个模块成为cPickle，它的功能和pickle完全一样，只不过它是用c写的，要比pickle速度快(大约快1000倍)。

总结

对象 -> 文本 -> 文件

pickle.dump(), pickle.load(), cPickle

cPickle包的功能和用法与pickle包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于cPickle是基于c语言编写的，速度是pickle包的1000倍。对于上面的例子，如果想使用cPickle包，我们都可以将import语句改为:

import cPickle as pickle

就不需要再做任何改动了。

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
Fiel IO演示部分
@author: samy
‘‘‘
import pickle
# import cPickle
import pickle as cPickle
print("========================文件操作演示部分=====================")

some_sentences = ‘‘‘\n I love learning python \n because python is fun \n and also easy to use ‘‘‘

#写入文件信息
# f = open("sentences.txt", mode=‘r‘, buffering=_1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
f = open("sentences.txt","w")
f.write(some_sentences)
f.close()
print("写入文件成功")

#读取文件信息
# f = open("sentences.txt")
f = open("sentences.txt","r")
while True:
    line = f.readline()
    if len(line) == 0:
        break
    print(line)
f.close
print("读取文件成功")

print("=========================存储器=========================")
# 对于上述过程，最常用的工具是Python中的pickle包。

# define class
class Bird(object):
    have_feather = True
    way_of_reproduction  = ‘egg‘

summer       = Bird()                 # construct an object
picklestring = pickle.dumps(summer)   # serialize object


print("==========================pickle类操作文件存储部分===================")

# 在python中，一般可以使用pickle类来进行python对象的序列化，而cPickle提供了一个更快速简单的接口，如python文档所说的：“cPickle -- A faster pickle”。
# cPickle可以对任意一种类型的python对象进行序列化操作，比如list，dict，甚至是一个类的对象等。而所谓的序列化，我的粗浅的理解就是为了能够完整的保存并能够完全可逆的恢复。
# 在cPickle中，主要有四个函数可以做这一工作，下面使用例子来介绍。

# 1， dump： 将python对象序列化保存到本地的文件。
data = range(1000)
# dump函数需要指定两个参数，第一个是需要序列化的python对象名称，第二个是本地的文件，需要注意的是，在这里需要使用open函数打开一个文件，并指定“写”操作。
cPickle.dump(data,open("data.pkl","wb")) 

# 2. load：载入本地文件，恢复python对象
# 同dump一样，这里需要使用open函数打开本地的一个文件，并指定“读”操作
data = cPickle.load(open("data.pkl","rb"))

# 3. dumps：将python对象序列化保存到一个字符串变量中。
data_string = cPickle.dumps(data)

# 4. loads：从字符串变量中载入python对象
data = cPickle.loads(data_string)

print(data)

#这几个目前还有问题数据
datafile = "data.pkl"
namelist = ["samy", "john", "king"]
 
f = open(datafile, "wb")
cPickle.dump(namelist, f)
f = open(datafile,"rb")

# storednamelist = cPickle.load(f)
# 错误的使用了pickle.load，在文件为新文件-没有内容时去强行load。应该先成功写入后才能读取。加入判断句子
storednamelist = cPickle.loads(f.read())
print(storednamelist)#[‘samy‘, ‘john‘, ‘king‘]
f.close()

del namelist

九、异常

　　当程序中出现某些异常的状况时，异常就发生了。python中可以使用try ... except 处理。

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-6
错误和异常演示部分

Python有两种错误类型：
1：语法错误（Syntax Errors）
2：异常（Exceptions）

首先，try语句下的（try和except之间的代码）被执行
如果没有出现异常，excepton语句将被忽略
如果try语句之间出现了异常，try之下异常之后的代码被忽略，直接跳跃到except语句
如果异常出现，但不属于except中定义的异常类，程序将执行外围一层的try语句，
如果异常没有被处理，将产生unhandled exception 的错误；

@author: samy
‘‘‘
import time

print("========================1：语法错误（Syntax Errors）====================")
# while True print("hello world")
# while True :
#     print("hello world")

print("========================2：异常（Exceptions）====================")
# print(8/0)#ZeroDivisionError: division by zero

# print(hello * 4)#NameError: name ‘hello‘ is not defined

num = 6
# print("Hello world" + num)#TypeError: Can‘t convert ‘int‘ object to str implicitly
print("Hello world " + str(num))

print("========================Handling exceptios====================")
# while True:
#     try:
#         x = int(input("please enter a number: "))
#         break
#     except ValueError:
#         print("Not valid input, try again.....")
#        

print("========================Try catch 部分===================")
try:
    print(1 / 0)
except ZeroDivisionError as e:
    print (e)
except:
    print ("error or exception occurred.")

#  try:
#     f = open("myfile.txt")
#     s = f.readline()
#     i = int(s.strip())
#  except OS as err:
#      print("OS error: {0}".format(err))
#  except ValueError:
#      print("Could not convert data to an integer")


print("================可以让try ... except 关联上一个else，当没有异常时则执行else。===========================")
# 　我们可以定义自己的异常类，需要继承Error或Exception。
class ShortInputException(Exception):
    ‘‘‘A user-defined exception class‘‘‘
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = input("enter someting-->")
    if len(s) < 3:
        raise ShortInputException(len(s), 3)
except EOFError:
    print ("why you input an EOF?")
except ShortInputException as ex:
    print ("The lenght of input is %d, was expecting at the least %d" % (ex.length, ex.atleast))
else:
    print ("no exception")
# The lenght of input is 1, was expecting at the least 3

print("====================try...finally======================")
try:
    f = open("sentences.txt")
#     f = file("test.txt")
    while True:
        line = f.readline()
        if len(line) == 0:
            break
#         休眠2秒
        time.sleep(2)
        print(line)
finally:
    f.close()
    print ("Cleaning up...")

十、Python标准库

　　Python标准库是随Pthon附带安装的，包含了大量极其有用的模块。

　　1. sys模块　　sys模块包含系统对应的功能

• sys.argv　　---包含命令行参数，第一个参数是py的文件名
• sys.platform　　---返回平台类型
• sys.exit([status])　　---退出程序，可选的status(范围：0-127)：0表示正常退出，其他表示不正常，可抛异常事件供捕获
• sys.path　　　　---程序中导入模块对应的文件必须放在sys.path包含的目录中，使用sys.path.append添加自己的模块路径
• sys.modules　　---This is a dictionary that maps module names to modules which have already been loaded
• sys.stdin,sys.stdout,sys.stderr　　---包含与标准I/O 流对应的流对象

s = sys.stdin.readline()

sys.stdout.write(s)

　　2. os模块　　该模块包含普遍的操作系统功能

• 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.sep 操作系统特定的路径分割符
• os.path.split()函数返回一个路径的目录名和文件名
• os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录
• os.path.existe()函数用来检验给出的路径是否真地存在

十一、其他

　　1. 一些特殊的方法

　　下面的类中定义了上表中的方法：

class Array:
    __list = []

    def __init__(self):
        print "constructor"def __del__(self):
        print "destructor"def __str__(self):
        return "this self-defined array class"def __getitem__(self, key):
        return self.__list[key]

    def __len__(self):
        return len(self.__list)

    def Add(self, value):
        self.__list.append(value)

    def Remove(self, index):
        del self.__list[index]

    def DisplayItems(self):
        print "show all items----"for item in self.__list:
            print item

arr = Array()   #constructorprint arr    #this self-defined array classprint len(arr)   #0arr.Add(1)
arr.Add(2)
arr.Add(3)
print len(arr)   #3print arr[0]   #1arr.DisplayItems()
#show all items----
#1
#2
#3arr.Remove(1)
arr.DisplayItems()
#show all items----
#1
#3
#destructor

　　2. 综合列表

　　　　通过列表综合，可以从一个已有的列表导出一个新的列表。

list1 = [1, 2, 3, 4, 5]
list2 = [i*2 for i in list1 if i > 3]

print list1  #[1, 2, 3, 4, 5]print list2  #[8, 10]

　　3. 函数接收元组/列表/字典

　　　　当函数接收元组或字典形式的参数的时候，有一种特殊的方法，使用*和**前缀。该方法在函数需要获取可变数量的参数的时候特别有用。

　　　　由于在args变量前有*前缀，所有多余的函数参数都会作为一个元组存储在args中。如果使用的是**前缀，多余的参数则会被认为是一个字典

　　的键/值对。

def powersum(power, *args):
    total = 0
    for i in args:
        total += pow(i, power)
    return total

print powersum(2, 1, 2, 3)   #14 

def displaydic(**args):
    for key,value in args.items():
        print "key:%s;value:%s" % (key, value)

displaydic(a="one", b="two", c="three")
#key:a;value:one
#key:c;value:three
#key:b;value:two

　　4. lambda

　　　　lambda语句被用来创建新的函数对象，并在运行时返回它们。lambda需要一个参数，后面仅跟单个表达式作为函数体，而表达式的值被这个

　　新建的函数返回。 注意，即便是print语句也不能用在lambda形式中，只能使用表达式。

func = lambda s: s * 3
print func("peter ")  #peter peter peter
func2 = lambda a, b: a * b
print func2(2, 3)  #6

　　5. exec/eval

　　　　exec语句用来执行储存在字符串或文件中的Python语句；eval语句用来计算存储在字符串中的有效Python表达式。

cmd = "print ‘hello world‘"exec cmd   #hello world
expression = "10 * 2 + 5"print eval(expression)    #25

　　6. assert

　　　　assert语句用来断言某个条件是真的，并且在它非真的时候引发一个错误--AssertionError。

flag = True

assert flag == True

try:
    assert flag == False
except AssertionError, err:
    print "failed"else:
    print "pass"

　　7. repr函数

　　　　repr函数用来取得对象的规范字符串表示。反引号（也称转换符）可以完成相同的功能。

　　　　注意，在大多数时候有eval(repr(object)) == object。

　　　　可以通过定义类的__repr__方法来控制对象在被repr函数调用的时候返回的内容。

arr = [1, 2, 3]
print `arr`    #[1, 2, 3]print repr(arr)    #[1, 2, 3]

十二、GUI

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-7
图形界面（GUI）和猜字游戏
GUI:Graphical User Interface
thinter: GUI library for  Python
@author: samy
‘‘‘

from tkinter import *

import tkinter.simpledialog as dl
import tkinter.messagebox as mb

#设置GUI
root = Tk()
w = Label(root, text = "Lable Title")
w.pack()

mb.showinfo("welcome", "welcome message")
guess = dl.askinteger("Number", "Enter a number:")

output = "this is output message"
mb.showinfo("Output:",output)

十三、练习

1：猜字游戏；

# coding=utf-8 #显示或打印文字信息
‘‘‘
Created on 2015-5-7
项目演示
1：猜字游戏
# 2：网页图片
# 3：通讯录增删改查
@author: samy
‘‘‘

from tkinter import *

import tkinter.simpledialog as dl
import tkinter.messagebox as mb


print("====================1：猜字游戏====================")
#设置GUI
root = Tk()
w = Label(root, text = "Guess Number Game")
w.pack()

# 设置消息
mb.showinfo("welcome", "welcome to Guess Number Game")

#处理消息
number  = 59
while True:
    guess = dl.askinteger("Number", "what‘s you guess")
    if guess == number:
        output = "Bingo! you guessed it right.(but you do not win any prizes)"
        mb.showinfo("Hint: ", output)
        break
    elif guess < number:
        output = "No, the number is higher than that"
        mb.showinfo("Hint: ", output)
    else:
        output = "No, the number is lower than that"
        mb.showinfo("Hint: ", output)
print("Done")

2：通讯录项目（目前在3.4版本还有点问题）

　　　　实现一个通讯录，主要功能：添加、删除、更新、查询、显示全部联系人。

# coding=utf-8 #显示或打印文字信息
‘‘‘
# -*- coding: utf-8 -*-
Created on 2015-5-7
项目演示
联系人的增删改查
实现一个通讯录，主要功能：添加、删除、更新、查询、显示全部联系人。

@author: samy
‘‘‘
# import cPickle
import pickle as cPickle
import os
import sys

class Contact:
    def __init__(self, name, phone, mail):
        self.name = name
        self.phone = phone
        self.mail = mail
 
    def update(self, name, phone, mail):
        self.name = name
        self.phone = phone
        self.mail = mail
 
    def display(self):
        print ("name:%s, phone:%s, mail:%s" % (self.name, self.phone, self.mail))
 
 
# begin 
 
# file to store contact data
data = os.getcwd() + os.sep + "contacts.data"
 
while True:
    print ("-----------------------------------------------------------------------")
#     可以看出这里2.7和3.4开发有很大的区别
#     operation = raw_input("input your operation(add/delete/modify/search/all/exit):")
    operation = input("input your operation(add/delete/modify/search/all/exit):")
 
    if operation == "exit":
        sys.exit()
 
    if os.path.exists(data):
        if os.path.getsize(data) == 0:
            contacts = {}
        else:
#              f = file(data)
            f = open(data)
# 错误的使用了pickle.load，在文件为新文件-没有内容时去强行load。应该先成功写入后才能读取。加入判断句子
#             contacts = cPickle.load(f)
#             contacts = cPickle.loads(f)
            contacts = cPickle.loads(f.read())
            f.close()
    else:
        contacts = {}
 
    if operation == "add":
        flag = False
        while True:
#              name = raw_input("input name(exit to back choose operation):")
            name = input("input name(exit to back choose operation):")
            if name == "exit":
                flag = True
                break
            if name in contacts:
                print ("the name already exists, please input another or input ‘exit‘ to back choose operation")
                continue
            else:
                phone = input("input phone:")
                mail = input("input mail:")
                c = Contact(name, phone, mail)
                contacts[name] = c
#                  f = file(data, "w")
#                 f = open(data, "w")
#                 3.0以上对这个不兼容,得设置为wb
# f = open(newf,‘r‘,encoding= ‘gbk‘)
                f = open(data, "wb")
                cPickle.dump(contacts, f)
                f.close()
                print ("add successfully.")
                break
    elif operation == "delete":
        name = input("input the name that you want to delete:")
        if name in contacts:
            del contacts[name]
            f = open(data, "wb")
#             f = open(data, "wb",encoding = ‘utf-8‘)
            cPickle.dump(contacts, f)
            f.close()
            print ("delete successfully.")
        else:
            print ("there is no person named %s" % name)
    elif operation == "modify":
        while True:
            name = (input("input the name which to update or exit to back choose operation:"))
            if name == "exit":
                break
            if not name in contacts:
                print ("there is no person named %s" % name)
                continue
            else:
                phone = (input("input phone:"))
                mail = (input("input mail:"))
                contacts[name].update(name, phone, mail)
                f = open(data, "wb")
                cPickle.dump(contacts, f)
                f.close()
                print ("modify successfully.")
                break
    elif operation == "search":
        name = input("input the name which you want to search:")
        if name in contacts:
            contacts[name].display()
        else:
            print ("there is no person named %s" % name)
    elif operation == "all":
        for name, contact in contacts.items():
            contact.display()
    else:
        print ("unknown operation") 

我们都知道python从2.x升级到3.x的过程中有一些不兼容的改动，但是有时还我们不得不将2.x的程序升级到3.x。

主要不兼容如下图：

移植过程：

1) 确保存在的代码有足够的测试覆盖。从2.x到3.x的升级工作量并不是很大，但是包含了很多的微小的不兼容，必须通过测试来确保升级后的程序仍然保持原有的功能。完全的测试覆盖不是被建议的，但是确实是需要的。

2) 用python 2.6 的 -3 命令行选项来运行程序，从而发现和去除明显的不兼容问题。

3) 使用2to3转化工具来自动地将程序转化为3.x版本，很多的不兼容问题会在转化的过程中被fix，同时一些需要手动升级的不兼容会被指出。
4) 使用python 3.x来运行新版本的程序，然后fix一些错误。同时也可能需要对测试代码进行相应的fix。直到所有的代码和测试代码通过。