继承、多态及排序（python/java版）

 继承：

  （1）Java：继承实质为多态，多态解决继承的尴尬

      单继承，对象实例化过程很简单

      对象实例化的过程：从祖父到自己的第一个构造方法实例化的过程

   A

    B extend A

    C extendBnew 

    C() Object--A--B--C

 

  （2）Python：继承代码的复用

多继承：默认子类不会调用父类的构造方法

                子类调用父类的构造方法：

（1）B1.__init__(self)           #任意指明调用

        （2）#super(C,self).__init__()    #从左的第一个

多态：方法重写:从左（从下往上）到右重写方法

如python继承代码练习中：class C(B,B1)，c.foo()

调用foo（）顺序：先到父类B中找是否有foo()如果有就调用

     如果没有，到父类B1中找是否有foo（）如果有就调用

     如果没有

在Python中构造方法不能重载

 

63.6和2.7版本的cmp函数：

python3 sorted取消了对cmp的支持。

sorted(iterable，key=None,reverse=False)

 

key接受一个函数，这个函数只接受一个元素，默认为None

reverse是一个布尔值。如果设置为True，列表元素将被倒序排列，默认为False

着重介绍key的作用原理：

key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None 。 

例1：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]

sorted(students,key=lambda s: x[2]) #按照年龄来排序

结果：[('dave','B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

例2.这是一个字符串排序，排序规则：小写<大写<奇数<偶数
s = 'asdf234GDSdsf23'  #排序:小写-大写-奇数-偶数

print("".join(sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x))))

原理：先比较元组的第一个值，FALSE<TRUE，如果相等就比较元组的下一个值，以此类推。

先看一下Boolean value 的排序：

print(sorted([True,Flase]))===>结果[False,True]

Boolean 的排序会将 False 排在前，True排在后. 

 

1.x.isdigit()的作用是把数字放在前边,字母放在后边.

 

 

2.x.isdigit() and int(x) % 2 == 0的作用是保证奇数在前，偶数在后。

 

 

3.x.isupper()的作用是在前面基础上,保证字母小写在前大写在后.

 

 

4.最后的x表示在前面基础上,对所有类别数字或字母排序。

 

 

最后结果：addffssDGS33224

 

例3：一道面试题：

list1=[7, -8, 5, 4, 0, -2, -5]
#要求1.正数在前负数在后 2.整数从小到大 3.负数从大到小

sorted(list1,key=lambda x:(x<0,abs(x)))

解题思路：先按照正负排先后，再按照大小排先后。

 

通过例子来说明sorted的用法： 

 

1. 对由tuple组成的List排序 

Python代码  

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]  

 

 

用key函数排序(lambda的用法见 注释1) 

Python代码  

>>> sorted(students, key=lambda student : student[2])   # sort by age  

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  

 

 

用cmp函数排序 

Python代码  

>>> sorted(students, cmp=lambda x,y : cmp(x[2], y[2])) # sort by age  

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]  

 

 

用 operator 函数来加快速度, 上面排序等价于:(itemgetter的用法见 注释2) 

Python代码  

>>> from operator import itemgetter, attrgetter  

>>> sorted(students, key=itemgetter(2))  

 

 

用 operator 函数进行多级排序 

Python代码  

>>> sorted(students, key=itemgetter(1,2))  # sort by grade then by age  

[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]  

 

 

 

2. 对由字典排序 

Python代码  

>>> d = {'data1':3, 'data2':1, 'data3':2, 'data4':4}  

>>> sorted(d.iteritems(), key=itemgetter(1), reverse=True)  

[('data4', 4), ('data1', 3), ('data3', 2), ('data2', 1)]

8迭代：

Yeild迭代生成器

__iter__()

__next__()

 

排序案例按照姓名年纪排序demo：

java版：

 按姓名排序，姓名相同的按照age升序排列（排序原理:按照阿斯科码a=97 b=96）

 public class demo{

static class Person  implements Comparable<Person>{

private String name;

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

@Override

public String toString(){

return String.format("我是%s，我今年%d岁!!",name,age);

}

@Override

public int compareTo(Person o) {

// TODO Auto-generated method stub

return this.name.compareTo(o.name)+o.age-this.age;相等返回0大于返回1小于返回-1

}

}

public static void main(String[] args) {

List<Person> ps=new ArrayList<>();

ps.add(new Person("张三",19));

ps.add(new Person("李四",17));

ps.add(new Person("张三",21));

ps.add(new Person("王五",23));

for(Person p:ps){

System.out.println(p);

}

System.out.println("-----------------排序后---------------");

Collections.sort(ps);

for (Person p:ps){

System.out.println(p);

}

}

运行结果：

-----------------排序前---------------

我是张三，我今年19岁!!

我是李四，我今年17岁!!

我是张三，我今年21岁!!

我是王五，我今年23岁!!

-----------------排序后---------------

我是张三，我今年21岁!!

我是张三，我今年19岁!!

我是李四，我今年17岁!!

我是王五，我今年23岁!!

----------华丽的分割线  

python版

class person:

    def __init__(self,name=None,age=None):

        self.name=name

        self.age=age

    def __str__(self):

        return "我是{0}，今年{1}岁啦！！".format(self.name,self.age)

    def __add__(self, other):

        return person(self.name+other.name,self.age+other.age)

    def __cmp__(self, other):

        return self.name

p=person(name="张三",age=19)

p1=person(name="张三",age=19)

print(str(p)+"   "+str(p1))

print(p+p1)

print("\n")

print("-----------------未排序------------------")

ps=[person("张三",19),person("李四",17),person("王五",21),person("张三",23),]

for p1 in ps:

    print(p1)

print("-----------------排序后------------------")

for p1 in sorted(ps):

    print(p1)