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 sanitize
class 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 Smith
1999-06-01
['1.31', '1.56']
['1.25', '1.31', '1.56']

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

from sanitize import sanitize

class 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（好东西，入门经典）。。。。。。。。。。。。。。。。。。。。。。