python入门知识总结

推荐一个入门python的网站，就是写一些基本的python程序，挺好的。

http://codingbat.com/

暑假没回家 ，一不小心培训了python，反正免费的不听白不听，总比呆在寝室无聊好的多，庆幸的是坚持下来了，现在回想起来虽然学习时间很短，但确实感触蛮大的，因此写这篇文章总结一下。第一节课就被授课者吓到了，python处理TB级的数据，是Hadoopj级别的，而拥有者能力的语言只有R，Ruby等少数语言，以后用几个库Scipy，Numpy，Matplotlib，可以做数值计算等，Matlab的绝大部分功能都可以用python写出来 ， 与MATLAB相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。能不能别再吓我的，我的小心脏受不了~~这里 主要是以经典的python为例，即python2.x，另外听说EVE主要是用python写的~~，不得不说有点难以置性。

    首先接触python就被它的另类所吓到了，啥，简单粗暴没括号，吓死我了。那怎么玩啊，在python中没有分号，单引号和双引号是不区分的，不像C中单个字符用单引号，字符串用双引号。python的代码段是靠缩进来表示的，不能用大括号。通过四个空格符或一个Tab键即可，不过在函数开头后应有冒号，来表示下面的代码是其内部的内容。其次有些条件语句中的括号是可以省略的，如: if a>b:(Tab)...当然加了括号也正确。而且不用写main函数，也不用导入isotream或是stdio.h之类的库。
                                       Python 简介
1.免费开源
2.简单易学
3.解释性语言，与C/C++等编译性语言不同
4. 可移植，这个估计是流行起来的很重要的一个因素吧。python的程序都可以无需任何修改地移植到现今主流的系统平台上。包括Windows，Linux，Macintosh，Solaris，OS/2，Android等等
5.同是支持面向对象和面向过程编程，类似C++。至于其面向对象的编程，python还有世界上最强大的类库。
6.嵌入性：可以作为脚本语言嵌入到其他程序中，比如C/C++
7.可扩展性：python开发周期短，由于python是基于c开发的，所以用C/C++来编写Python的扩展，现在也有支持Java实现的Jpython。
8.丰富的类库：

9.内存管理器
这个特别棒，再也不用要先给变量申请内存了，也不用想着用完后释放等等这些麻烦死了的东西。
10.python的应用有系统编程，图形处理，数字处理，文本处理，数据库编程，网络编程，Web编程，多媒体应用，他们也用python写串口之类的。。
                                         关于python版本的问题
    我想很多人都会果断用最新的python3.4.1（写文章时是2014.7.31，估计几年后如果这篇文章有幸被别人看到，对方肯定会呵呵的），人都是这样，喜欢最新版本的。但是python3.x和python2.x不兼容，也就是说你写的python3.x的程序不能在python2.x IDEL中运行，反过来也是如此。很多库不支持python3.0之后的版本，很多扩展库都没有，你还怎么快乐玩耍。。比如python语言web框架的Django就不支持。再说了网上很多优秀代码都是用python2.x写的，优秀的代码直接拿过来用就可以了，你自己写的费事费时，还不一定好用。看到一本书上的建议：目前大多数的应用是python2.5/2.6居多。windows建议学2.6，Linux就玩2.5，怪不得前几天有个人在群里说他还在用2.5，估计是玩Linux的。在本人学习时，他们授课是用python2.7.8的，是python2.x的最新版本（此时python3.x的最新版本是python3.4.1）。还是那句话吧，python2和python3并不是100%不兼容，只不过语法上做了一些修缮，更加精炼罢了。会python2的人对python3是不感冒的。
        下面是python的print问题：
书上明明写的是print 'hello world'，会出错，必须写成print ('hello world'),其实这就是版本问题，前一种是python2的语法，后一种是pyhton3的语法。书上大部分是python2，所以如果你用python3的话，很多资料的代码你都要进行改写，很是麻烦。 
     
                                                                                           
                                              
                                                                                             一些基本内容  
1.round是四舍五入的函数，如round（-9.1）=-9，round（10.7）=11
2.赋值可以多个同时进行，如a,b=3,6，而且类似a<b<7,运行显示True。a<7<b，运行显示False。这一点与C不一样，由此可见python的人性化啊~ ~
3.浮点数转化成整数是直接截断，并非四舍五入
4.python的变量是不能指定其类型的，他是通过所附的值来决定的，故int a=4是错误的，而应该写成a = 4，此外，long型整数没有最大的长度，具体取决于你的机器配置，一般几百位的整数显示时会在后面加一个L来表示其为long型。
5.‘+’可实现数字的相加或是字符串或是列表的相加，特别方便。如>>>a=[1,'hello']+[2,'Mike']，则a就成了[1,'hello',2,'Mike']   
6.用‘\’来实现转义，方法同C
7.逗号可以使print（不是print，python中的输出函数是print）函数不换行的输出。如print a,b   这和C比起来不知简单多上倍啊，要是打印个列表，python直接一个print 就出来了。。。
8.*可以实现字符串或列表的重复

>>> a='hello'
>>> b=a*4
>>> b
'hellohellohellohello'
>>> list1=[1,'d']
>>> list2=list1*3
>>> list2
[1, 'd', 1, 'd', 1, 'd']
另外**是乘方，python还支持复数，如：1-2j 
9.输入与输出，其中输入时通过input函数，例：str1=input（'提示性语句')    此时str1的类型取决于输入类型。还有一个函数是raw_input，可以将输入以字符串的形式处理。    
输出时可以直接在print后加变量名或表达式，
如： >>>print 'The area of the circle is",area,'sq cm'
        The area of the circle is 80 sq cm
另外也可以用C语言的风格输出，不过有一点差异。
print  'The area of the circle is %f",area,'sq cm' %area   (注意，最末尾的百分号前面只有一个空格，否则会出错），如果有多个参数则%（参1，参2，...)
10.通过range可以方便的实现一个特殊的整数列表
range（下限，上限，步长），左闭右开，同list的切片。
如：0~100 : range(0,101)，或简写成range（101）
50~100的偶数： range（0,101,2）
在表示C/C++语言中常用的循环时，利用range可以很方便。
如：C/C++     for(int i =0;i<100;i++)
                      {
                            ....
                      }

      Python     for i in range(100):
                          ...
这个i 是局部变量，进行range列表的迭代，可以实现 i 从0到99共100次循环。是不是感觉有点小震撼。。
11.一些循环操作：
break：跳出循环
continue：跳过后面的语句，跳回循环体的顶部
pass：啥都不做
另外：和C相比python中没有++，和- - ，else if用elif来代替，条件语句的（）可以省略，条件后需有：。最后逻辑关系 &&用and，||用or , !用not 表示。
                                                                             字符串操作 
1.capitalize()，使字符串首字母大写
2.find（s,beg,end)beg和end之间首次出现参数s的索引
3.islower()和isupper()  测试所有字符是否均小/大写
4.replace(old,new) 将old替换成new
5.split（） 将空格分隔的单词以列表形式返回，同理如果是split（'a'），则会将字符串进行如下处理，每当碰到a字符则作为前一个字符串的结束，a字符相当于空格。
如： >>> colors='red orange green'
     >>> colors.split(a)
     ['red or', 'nge green']
6.strip()是删除字符串中首尾的空格符
如：  >>> a='      hello Kitty    '
          >>> a.strip()
          'hello Kitty'
                                                                                        列表操作
1 . 通过for i in list1：来对list1列表的元素进行迭代，赋值给i
2 .如果要同时获取i的索引可以用enumerate函数
如：>>> list1=['Jim','Kitty',"Tom"]
>>> for i,j in enumerate(list1):
print i,j
0 Jim
1 Kitty
2 Tom 
注意 i和j之间本来是有（）的，原型为（i,j)，这里省略了括号，所以i和j之间除了有逗号没有空格符
3 .列表的一些操作：
切片：咋说呢，其实list和str都可以“切片”， 简单地说str[1:-1]就是去掉字符串的第一个字母和最后一个字符。str[1:]就是去掉第一个字符。切片方式和list是一样一样的，都是左闭右开，支持负索引，从0开始。
list1=['a','b','c','d','e','f']
list2=list[0:4]
则list2为['a','b','c','d']  区间是左闭右开的，即list2包括了list1[0]到list1[3]的所有元素
另两种特殊的简化形式
list2=list1[:4]等同于list2=list1[0:4]         list2=list1[4:]等同于list2=list1[4:6]
    此外python的列表还支持负数索引，
如>>> list2=list1[-3:-1]
>>> list2
['d', 'e'] 依旧是左闭右开
当想表示从倒数第三个到结束则可以用以下两种方式

>>> list4=list1[-3:6]
>>> list4
['d', 'e', 'f']
>>> list5=list1[-3:]
>>> list5['d', 'e', 'f'] 
其他情况则会返回空列表
4 . 列表具有别名机制（相当于引用）
如：list1=[...]
list2=list1
当list1更改时，list2也会更改，而字符串不具有别名机制，故字符串的别名是很安全的。
5 .常见列表方法
append(v):列表后追加v
insert(i,v)： v插入索引i
remove(v): 移除第一次找到的v值
reverse(): 反转
sort(): 升序排列（字符串则以字母表顺序为准）
pop(): 移除最后一个元素并返回
注意：除了pop外，所有的方法都只会返回一个特殊值None，列表只有一个，所有的方法都只会修改原列表而不会创建新的列表
如：>>>ted_colors=colors.sort()
>>>print  sorted_colors
None
6 .列表中的元素可以是列表
>>>life=[['Canada',76.5],['United States',75.5]]
>>>canada=life[0]
>>>canada[1]=80
>>>life
[['Canada',80],['United States',75.5]]
这里的canada是别名，对其操作会影响到主列表life
7.上文知道了如何将字符串转化成列表了（别跟我说你已经忘了。。split 呗~~），那么如何将列表转化成字符串呢？用 join，字面意思就是将列表中的字符连接以来。那用什么连接呢？你可以用 ’，‘  ’%‘ 或是其他任何你喜欢的字符或字符串都可以。列表放在join后的括号中，那用于连接的字符或字符串怎么写呢？给个例子
如： >>> list1=['2','34','good','Hi']

       >>> ','.join(list1)

       '2,34,good,Hi'
这一点很特殊是用   字符（串）.join(列表）
注意点：
1.如果要进行转换操作，则对类表的元素有要求，必须全部是 字符（串），否则会出错。

>>> list3=[2,34,'good','Hi']

>>> ','.join(list3)

Traceback (most recent call last):

  File "<pyshell#6>", line 1, in <module>

    ','.join(list3)

TypeError: sequence item 0: expected string, int found
 2.可以用其他连接的哦，如：
>>> list1=['2','34','good','Hi']
>>> 'fool'.join(list1)

'2fool34foolgoodfoolHi'

 

8.特殊的列表：元组
元组是不可以直接更改的列表，其运行效率更高，元组用‘（）’来表示
>>>life=(['Canada',76.5],['United States',75.5])
实际上元组中的对象仍旧可以更改如：life[0][1]=80.0，但不可以更改life[0]。

                                                                              文件操作
1.标准文件输入格式
如data.txt中的内容为：
Mercury
Venus
Earth
data=open/file('data.txt','r')
for line in data:
    print len(line)

8
6
5
为什么会长度多1呢？因为文件中读取的每一行末尾都有一个结束符，用string.strip()，即可去掉该空白字符。前面字符串的方法已介绍过该方法。
data=open/file('data.txt','r')
for line in data:
    line=line.strip() 
    print len(line)
data.close（）
     

7
5
4
当该表参数‘r’，改成‘w’是直接写如，而‘a’是追加
2.当要打开网站上的文件时需导入urllib模块，通过其中的urlopen函数打开目标网页，并返回一个对象，就像操作本地文件一样。
import urllib
url='...'
web_page=urlopen(url)
for i in web_page:
    line=line.strip()
    print line
web_page.close()
                                                                               集合和字典
1.集合可以使用元组或是列表
set((2,3,5))等价于set((2,2,3,5,5)),等价于set([2,3,3,5]),简单的说集合只有一个元素，该元素是列表或是元组都可。
2.集合的操作
并（union），交（intersection)，添加（add）和移除(remove)，注意，只有add，remove和clear是修改当前集合，其余都会创建一个新的集合。
eg：ten=set(range(10)),  lows=set([0,1,2,3,4]),  odds=set([1,3,5,7,9])
_____________________________________________________________________________________________________________________________________lows.add(9)              None
lows.clear()             None
(由于add并不会创建一个新集合，故为None，要想得到预期的效果，则需>>>lows=set([0,1,2,3,4])    >>>lows.add(9)     >>>lows) 

lows.differece(odds)         A
lows.intersection(odds)      B
lows.issubset(ten)           True  包含于
lows.issuperset(odds)        False  包含
lows.symmetric_difference(odds) 
A+C     对称差
lows.union(odds)    A+B+C  并

另一种更简单的方法直接用数学符号表示即可
different set1-set2
intersection  set1&set2
issubset     set1<=set2
issuperset    set1>=set2
symmetric_different    set1^set2
union                  set1 |set2
                                                                                字典
1.用‘{ }’表示字典，{字符串：值，...}
如：
>>>birds={‘canada goose’：3，‘northern fulmar’：1}
>>>birds[‘canada goose']
3
2.通过赋值来直接对字典进行扩展（若原字典中无该键）或修改键值（原字典中已有该键）
>>>birds={}
>>>birds['snow goose']=3
>>>birds
{'snow goose':3}
3.删除键
del birds['snow goose']
4.对字典的循环，返回的不是键值，而是键！这一点非常重要
for x in birds:
    print x,birds[x]
-->'snow goose' 3
5.其他一些常用方法
get（key,value1):            注意，若dict中有key，则返回dict[key],否则返回value1
keys（）：                   以列表形式返回键
items（）：                  返回（key，value）列表
values（）：                 以列表形式返回键值
update（temp）：             temp字典对原字典进行更新
上诉方法其实一看名称也就明白用途了。。
6.字典的迭代
用iteritems函数
如：for (key,value) in dictionary.iteritems():
        ...

                                                                                Lambda表达式
这个特别有意思啊，当你写函数时经常会遇到，给个啥名字好呢？你感觉写一大堆单词上去总怕表达不精练什么的，有可能还会写错单词字母（啥，你英语水平很好，不可能写错。。好吧，我错了），而且只在局部用到，这时候用Lambda函数太棒了。Lambda函数是匿名函数，没有名字。
形式：>>>m=lambda a,b:a+b
           >>>m(5,4)
           9
lambda 参1，参2，...：表达式 （注意缩进，否则会出现unexcepted error) 

                                                                                          几个特殊的函数
 1.filter（函数，可迭代对象如列表等），他是个过滤器，列表中的符合函数规则的元素过滤出来，以列表形式返回。
如： def mod1 (a):

           return (a%2==0)

        list2=filter(mod1,range(1,10))

       print list2       
-->  [2, 4, 6, 8]
2.map （函数，可迭代对象如列表等）,其的作用是对整个列表的元素进行检查是否满足函数，并且以列表形式返回True或False
如  def mod1 (a):

           return (a%2==0)                                                      

      list3=map(mod1,range(1,10))

     print list3
      [False, True, False, True, False, True, False, True, False]
 3.reduce（函数， 可迭代对象如列表等），其可以实现连续处理功能。其作用是 先把列表中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给 function，然后只返回一个结果。
话不多说，给个例子吧
计算1+2+3+...+100
python里就一句话
a=reduce((lambda x, y:x+y),range(1,101))

print a
-->5050   (好吧，我错了，写了两句。。）
首先将range（1,101）即列表（1,2,...,100）的第一个元素1，和第二个元素2，拿出来进行+运算，再把返回值3和列表中的第三个元素3相加，然后把返回值6再与列表中第四个元素4相加。。如此不断下去，直至全部加完为止。如果用C的话，大概要十行吧。。
将上诉例子的+换成*就可以计算100！，very easy吧。可以试试计算10000！来测试你的机器性能啊，我的机器只能算到1w!了，10w！等几分钟都不会出结果。。
这里有一个求素数的代码，如果是C/C++的话,起码二十行吧，这里也是一行
0~100的素数代码：
print [x for x in range(1,101) if not [y for y in range(2,x/2+1)if x%y==0]]

                                                                                      异常

1.try和except
类似if和else，如果未发生错误，先执行完try块中的代码，并完全跳过except，若发生错误，则跳到except块开始执行代码，称为“异常被捕获了”。注意：try代码块只执行到第一句发生错误的代码
try:
    ①x=1/0.3 
    ②print 'reciprocal of 0.3 is',x
    ③x=1/0.0
    ④print 'receprocal of 0.0 is',x
except:
    ⑤print 'error: no reciprocal'
⑥    ...
执行顺序：①②③⑤⑥
在try/except后可添加else块，来告诉python在无异常时发生的事。
注意：只有try中所有代码被正确执行，才会执行else块中的代码。
2.异常对象
python在引发一个异常后，会创建一个用于存放错误信息的对象，可以在except中指定具体的异常
values=[-1,0,1]
for i in range(4):
    try:
        r=1.0/values[i]
        print 'reciprocal of',values[i],'at',i,'is',r
    except IndexError:
        print ’Index',i,'out of range'
    except ArithmeticError:
        print 'unable to calculate reciprocal of',values[i]
如果要知道具体的异常，可以把异常赋给变量
    except IndexError,e:
        print 'error:',e
3.自己引发异常，通过raise
def divide(top,butttom):
    if buttom==0:
        raise ValueError('divisor is zero')
    else:
        return top/bottom
for i in range(-1,2):
    try:
        print divide(1,i)
    except ValueError,e:
        print 'Caught except for',i
                                                                               面向对象编程OOP 
1.类中的方法至少有一个参数self，函数前都有def，没有返回值类型，这一点太棒了，直接在末尾return 任何东西都可以，返回字符串啊，甚至是列表，还可以是一句话。。如果在C/C++中那肯定要跪，你肯定要写很多其他的东西才能实现该功能。
一些内置函数：
def __init__(self,a,b,c):
    self.a=a
    self.b=b
    self.c=c
因为python会自动将对象本身的引用当做参数传给方法的第一个参数，类似的还有
def __str__(self):
    return '...'  (此函数是类中的输出函数，最好用return把。。）
实例化直接传参就可以了
如：time1=Time（10,2,45）
2.运算法重载
python中的运算符重载比C++中简单多了。。直接在类中传递一个self,还有另一个参数即可。适用于单目和双目运算符的重载
例如重载实例：

def __add__(self,other):   #reload std        return "%s : %s : %s" %(self.hour +other.hour,self.minute+other.minute,self.second+other.second)

def __lt__(self,other):  #  "<"        pass

def __call__(self,index):   # __builtin__  "()" reload
        if (index=="Hour"):
            print "~~"
        else:
            print ".."
def __getitem__(self,index):  #__builtin__ "[]" reload        return index *2   
注意重载的运算法只能在类的实例中使用
3.类的继承

class People:
    def __init__(self,num,name):   #成员变量初始化函数
        self.num=num
        self.name=name
    ...
class Teacher(People):
    def __init__(self,num,name,colledge):
        People.__init__(self,num,name)
        self.college=college 只有在很复杂的情况下才会用到私有继承，默认是共有继承，直接把父类放入括号中，若有多个父类，用逗号隔开
                                                                                    GUI图形用户界面
1.                                    利用 Tkinter 模块 
from Tkinter import *
import Tkinter as tk        (这样写后面的Tkinter就可以用tk替代）
import sys (用于导入退出程序的函数等，如sys.exit())
一些插件：
Button，Canvas，Checkbutton(复选框），Radiobutton（单选框），Entry（单行文本框），Text（多行文本框） Label（显示文本的单个行），Listbox(下拉列表），Menu（下拉菜单），Message（显示文本多个行）
========================================================================================================================                                        Label
Label是最简单的插件，显示一小条文本，需置入父插件中
from Tkinter import *
window=Tk（）
label=Label(window,text='hello').pack()
首先得先制造处窗口，通过tk.Tk()即可，然后所有的子插件都嵌套在window中。对window这个窗口可以进行设置，通过 

window.geometry("300x400+120+100")  #windows' scale and its positionwindow.title("This is just a window...")
注意geometry内是字符串，第一个是length，第二个是width，之间用x（不是乘号，而是字母x），接下来第三第四个是窗口左上角的位置坐标，用加号连接。

2.要注意插件的配置一旦确立，若要更改则需用config方法修改插件的很多属性
这里有一个动态显示Label文本的方法
...
import time
...
label=Lable(window,text='Hello')
time.sleep(2)
label.config(text='Kitty')

3.要让插件的值发生变化，可以用可变类型来实现
共有四种：IntVar（），StringVar(),BooleanVar(),DoubleVar()
可变类型的值是通过set和get方法来设置和获取的。
 from Tkinter import *
window=Tk()
data=StringVar()
data.set('Data to display')  #设置初始值
label=Label(window,textvariable=data).pack()
window.mainloop()

4.上面的是把插件直接一股脑的丢进window一个窗口上，为了更好的安排插件的位置，可以利用Frame（框架）来将一些插件置于frame内，其实就是在窗口画出一个框来。
显然，将插件置于frame框中只需将window改成frame即可
如：frame=Frame(window).pack()
first=Label(frame,text='first Label').pack()
有时候第一个说明父插件的参数可以省略。默认是window

5.可以将frame修改参数让其可见，修改boardwidth（默认为0）值即可。同时可以更改样式relief，改成‘ sunken’，‘raised’，‘groove’等，这些属性在其他的一些插件如Entry，Text中也有。

6.一些其他的样式处理
eg：
label=Label（window,text="hello",bg='green',fg='white',font=('Curier',14,'bold italic').pack()
bg是background，设置背景颜色，fg是fontground ？？设置字体颜色。bold是粗体，对应的normal是细，italic是斜体，roman是不倾斜的。

7.插件的布局
可以看到所有的插件都会有.pack()，当然window就没有了。pack函数是将子插件置入父插件中，父插件是传入的第一个参数，pack内可传入side=‘left’等参数，从而确定该插件的具体安放位置。

另一中方法是grid(row=100,column=100)，用于确定具体的网格以便与安放插件。

但两种方法不可以混用。

8.函数：更好的实现交互
为了实现某些插件（如按钮等）的功能，需要用到函数 .(...,command=函数名）即可。注意：等号后面的函数是不允许带参数的，目的是以同一种方式调用他们。
如：
from Tkinter import *

window = Tk()
counter=IntVar()
counter.set(0)        #设置计数器初值
def click(var,value):
    var.set(var.get()+value)                                                                                                   
frame=Frame(window)
frame.pack()
button1=Button(frame,text="Up",command=lambda:click(counter,1)).pack()
button1=Button(frame,text="Down",command=lambda:click(counter,-1)).pack()
label=Label(frame,textvariable=counter).pack()
window.mainloop()

上面的代码功能：通过点击“Up”和“Down”两个按钮来实现对计数器counter的加1或减1操作，并将counter的值传给Lable的textvariable，从而在label中显示。

在 click函数中，有两个参数，其中形参Var会由实参IntVar型的counter代替，value则会被1或-1代替。
在前面说过command后面的函数是不带参数的，故这里用lambda函数，否则你就要写连个command=clickup，command=clickdown。lambda函数是没有名字的函数，常用于定义动作，可以避免全局变量的使用。

9.其他一些插件
① Text
text=Text(frame,heigth=10,width=10).pack()
Text插件还有很多其他的方法，这里略去
②Checkbutton
checkbutton=Checkbutto(frame,text='...',variable=...).pack()
③ Radiobutton
 Radiobutton(root, text = j, value = i,variable = food).pack()  
  ④Scale 进度条

scale = Scale(root , from_= 1, to = 20 ,resolution = 1 ,orient='horizontal',variable = speed)

scale.pack(side = "left")

注意：Scale插件中是 from_=下限，to=上限，resolution是精度，orient 来定义横放竖放，默认是竖放。
⑤  tkMessageBox
这是弹出一个新的对话框，前面需有 import tkMessageBox
tkMessageBox.askquestion("Who is Naruto?","\n A main role in a famous cantoon",icon = "warning")   

最后附上自己写的第一个GUI程序源码，第一次写，虽然很挫，功能很少，有很多界面上的功能都是骗人的。。但还是不加修改的直接拿上来了，权当纪念一下我的8天python之旅吧。。 

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

import Tkinter as tk

from Tkinter import *

import sys                                                                                                                            

import tkMessageBox

root=tk.Tk()

root.geometry('300x440+200+330')

root.title("Your Favorite Person")

_nameNum=IntVar()

wordsAC = StringVar()

points=StringVar()

wordsinput=StringVar()

def _chooseBox():

    tkMessageBox.askquestion(" ","You should click OK not this button...",icon="warning")

    print _nameNum.get()

def _wordAfterChoosing(): 

    tkMessageBox.askquestion("Your choose",'Waw,I like the role too!',icon="warning")   #第一行是标签，第二行是输出

def authorDisplay():

    tkMessageBox.askquestion("Your choose",'Yan Chuan',icon="warning")

def Advice():

    tkMessageBox.askquestion("Advice",'Your advice have already sent to the Author\n Haha, I lied to you!',icon="warning")

def Points():

    print points.get()

def textBox():

    print wordsinput.get()

tk.Label(fg='purple',text='Who is your favorite?').pack()

tk.Button(fg='blue', text='please choose yours',command=_chooseBox).pack()

namelist=['Naruto','Sasuke','Sakura','Haku ','Tsunade','Gaara ','Itachi ','Others']

for i ,j in enumerate(namelist):

    tk.Radiobutton(root,fg='blue',text=j,value=i,variable=_nameNum).pack()

tk.Button(fg='red',text='OK',command=_wordAfterChoosing).pack()

tk.Button(fg='red',text='Author',command=authorDisplay).pack(side='left')

tk.Button(fg='blue',text='Advice',command=Advice).pack(side='left')

tk.Label(fg='red',text="Please give a point for the software").pack()

scale=Scale(root,from_=1,to=5,resolution=1,orient='horizontal',variable=points).pack()

tk.Entry(relief="sunken",textvariable=wordsinput).pack()

Button(fg="blue",text="submit",command=textBox).pack()

tk.Button(fg="red",text='exit',command=sys.exit).pack()

tk.mainloop  
 
                
最后如果发现错误，还请大家提一下，毕竟水平有限。对了，忘记说了，电脑同时可以安装python2和python3的。。。你可以两个同时玩。。