python Day6

（一）对于sort，返回的是是个空值，但是会对list进行排序，所以如下代码输出的是None：

 a=[20,20,30,30,40,40,50]b=list(set(a))c=b.sort(key=a.index)print(b)print(c)[20, 30, 40, 50]None

且，sort为原地排序，会丢失原列表的顺序。

使用sorted()则是副本排序，保留原列表中元素的顺序，创建一个拥有新元素顺序的列表，

c=sorted(b, key=a.index)

a=[20,20,30,30,40,40,50]b=list(set(a))c=sorted(b, key=a.index)print(b)print(c)输出：[40, 50, 20, 30][20, 30, 40, 50]

（二）

set()

set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等,但是很奇怪的是

a=[20,20,30,30,40,40,50]b=set(a)print(b)结果：{40, 50, 20, 30}

顺序被打乱了，若要返回原始顺序，且格式为列表，则需执行如下代码：

a=[20,20,30,30,40,40,50]b=list(set(a))b.sort(key=a.index)print(b)结果[20, 30, 40, 50]

（三）

from sanitize import sanitizeclass Athlete():      def __init__ (self,a_name,a_dob=None,a_times=[]):          #list.__init__([])          self.name=a_name          self.dob=a_dob          self.times=a_times      def top3(self):          return(sorted(set([sanitize(t) for t in self.times]))[0:3])    def add_time(self,time_value):          self.times.append(time_value)      def add_times(self,list_of_time):          self.times.extend(list_of_time)  vera2=Athlete('Vera Smith','1999-06-01',['1.56'])  print(vera2)print(vera2.name)print(vera2.dob)vera2.add_time('1.31')  print(vera2.top3())  vera2.add_times(['2.01','3-02','1.25'])  print(vera2.top3())  输出：<__main__.Athlete object at 0x091F2D30>#vera2 的输出Vera Smith1999-06-01['1.31', '1.56']['1.25', '1.31', '1.56']

观察一下此段代码与下一段代码的差别，了解class的意义

from sanitize import sanitizeclass Athletelist(list):#提供一个类名，    def __init__ (self,a_name,a_dob=None,a_times=[]):        list.__init__([])#初始化所派生的类，        self.name=a_name#把参数赋至属性        self.dob=a_dob        self.times=a_times        self.extend(a_times)    def top3(self):        return(sorted(set([sanitize(t) for t in self]))[0:3])vera=Athletelist('Vera Smith','1995.06.01',['2-14'])vera.append('1.31')print(vera.name)print(vera.top3())vera.extend(['1.21','2.53','2.21','2.18'])print(vera.top3())输出：['2-14', '1.31']#vera的输出Vera Smith['1.31', '2.14']['1.21', '1.31', '2.14']

不再需要单独定义一个添加时间的time函数。

可以直接处理。

类本质上与函数并无太大区别，都是利用def定义。

使用class定义一个类，可以自定义，也可以继承，

class A:    def __init__(self,value=0):             self.thing = value#把一个value赋值给self.thing    def  b(self):             return(function(self.thing))#返回一个值

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

类的每个属性前必有self，从而将数据与其实例相关联，代表当前对象的地址，而 self.class 则指向类。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

class Point:   def __init__( self, x=0, y=0):      self.x = x      self.y = y   def __del__(self):      class_name = self.__class__.__name__      print class_name, "销毁"

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。

在python中继承中的一些特点：

• 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
• 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
• 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

#!/usr/bin/python# -*- coding: UTF-8 -*- class Parent:        # 定义父类   parentAttr = 100   def __init__(self):      print "调用父类构造函数"    def parentMethod(self):      print '调用父类方法'    def setAttr(self, attr):      Parent.parentAttr = attr    def getAttr(self):      print "父类属性 :", Parent.parentAttr class Child(Parent): # 定义子类   def __init__(self):      print "调用子类构造方法"    def childMethod(self):      print '调用子类方法' c = Child()          # 实例化子类c.childMethod()      # 调用子类的方法c.parentMethod()     # 调用父类方法c.setAttr(200)       # 再次调用父类的方法 - 设置属性值c.getAttr()          # 再次调用父类的方法 - 获取属性值

。。。。。。。。。。。。。。。。。。。转载自http://www.runoob.com/python/python-object.html（好东西，入门经典）。。。。。。。。。。。。。。。。。。。。。。