面向对象——运算符重载

Defining Custom Classes

• 创建一个球员类，一个球队类：

class Player():
    # The special __init__ function is run whenever a class is instantiated.
    # The init function can take arguments, but self is always the first one.
    # Self is just a reference to the instance of the class. It is automatically
    #     passed in when you instantiate an instance of the class.
    def __init__(self, data_row):
        self.player_name = data_row[0]
        self.position = data_row[1]
        self.age = data_row[2]
        self.team = data_row[3]

# Initialize a player using the first row of our dataset
first_player = Player(nba[0])

# Implement the Team class
class Team():
    def __init__(self, team_name):
        self.team_name = team_name
spurs = Team("San Antonio Spurs")

More Interesting Instance Properties

• 为team新增一个属性roster ：该队的球员对象

class Player():
    def __init__(self, data_row):
        self.player_name = data_row[0]
        self.position = data_row[1]
        self.age = int(data_row[2])
        self.team = data_row[3]
class Team():
    def __init__(self, team_name):
        self.team_name = team_name
        self.roster = []
        for row in nba:
            if row[3] == self.team_name:
                self.roster.append(Player(row))
spurs = Team("San Antonio Spurs")
'''
print(spurs.roster[0].player_name )
Jeff Ayres
'''

Instance Methods

• 上面创建了类以及类的属性，现在创建类的方法。添加一个求球队人数的方法，以及求球队平均年龄的方法。

class Player():
    def __init__(self, data_row):
        self.player_name = data_row[0]
        self.position = data_row[1]
        self.age = int(data_row[2])
        self.team = data_row[3]
class Team():
    def __init__(self, team_name):
        self.team_name = team_name
        self.roster = []
        for row in nba:
            if row[3] == self.team_name:
                self.roster.append(Player(row))
    def num_players(self):
        return len(self.roster)
    def average_age(self):
        return sum([player.age for player in self.roster])/len(self.roster)


spurs = Team("San Antonio Spurs")
spurs_num_players = spurs.num_players()
spurs_avg_age = spurs.average_age()

Class Methods

• @classmethod这一行必须写在类函数前面，表明这是一个类方法。

传统的面向对象编程中，几乎一切都是对象，整数是对象，布尔数据是对象，虽然python不是这样一种面向对象的语言，但是python中的对象也是很丰富的。比如math.floor就是累math中的一个类函数（Class Method），这个类函数是作用在整个类上的，而不是某个实例对象，像这样的类函数作用优点类似于功能函数、

• 创建一个类函数：返回两个球队中平均年龄更大的那个球队

import math

class Player():
    def __init__(self, data_row):
        self.player_name = data_row[0]
        self.position = data_row[1]
        self.age = int(data_row[2])
        self.team = data_row[3]
class Team():
    def __init__(self, team_name):
        self.team_name = team_name
        self.roster = []
        for row in nba:
            if row[3] == self.team_name:
                self.roster.append(Player(row))

    def num_players(self):
        count = 0
        for player in self.roster:
            count += 1
        return count

    def average_age(self):
        return math.fsum([player.age for player in self.roster]) / self.num_players()

    @classmethod
    def older_team(self, team1, team2):
        if team1.average_age() > team2.average_age():
            return team1
        else:
            return team2

old_team = Team.older_team(Team("New York Knicks"), Team("Miami Heat"))

Inheritance

• 继承是面向对象中一个很重要的概念，当不指出父类时，默认是一个通用的类object,通常显示的指出它比较好

Overloading

通常子类继承父类的时候回继承父类所有的方法和属性，但是子类可以对这些方法或者属性做一些修改，这就是重载，比如下面这段代码，继承了父类，因此继承的最基本的逻辑运算符操作。但是在父类中>, <, ==, !=, >=,以及<=只支持数值型数据以及字符串数据，因为字符串数据中已经重载了这些运算，使得可以进行操作，而在这个子类中，想要进行对象的比较是不行的，因此重载了逻辑运算符。

• 运算符重载

'''
(__eq__，__ne__，__lt__，__lt__，__gt__，____）这是比较排序的所有留个操作，是object中实现了的。
'''
class Player(object):
    def __init__(self, data_row):
        self.player_name = data_row[0]
        self.position = data_row[1]
        self.age = int(data_row[2])
        self.team = data_row[3]
    def __lt__(self, other):
        return self.age < other.age
    def __gt__(self, other):
        return self.age > other.age
    def __le__(self, other):
        return self.age <= other.age
    def __ge__(self, other):
        return self.age >= other.age
    def __eq__(self, other):
        return self.age == other.age
    def __ne__(self, other):
        return self.age != other.age
carmelo = Player(nba[17])
kobe = Player(nba[68])
result = carmelo != kobe
'''
result : True
'''

Comparing Average Ages

• 这段代码同上，在Team类中重载了比较函数，因此调用max內建函数，它里面调用的还是这些比较函数，因此可以正常运行。

import math
class Team(object):
    def __init__(self, team_name):
        self.team_name = team_name
        self.roster = []
        for row in nba:
            if row[3] == self.team_name:
                self.roster.append(Player(row))
    def num_players(self):
        count = 0
        for player in self.roster:
            count += 1
        return count
    def average_age(self):
        return math.fsum([player.age for player in self.roster]) / self.num_players()
    def __lt__(self, other):
        return self.average_age() < other.average_age()
    def __gt__(self, other):
        return self.average_age() > other.average_age()
    def __le__(self, other):
        return self.average_age() <= other.average_age()
    def __ge__(self, other):
        return self.average_age() >= other.average_age()
    def __eq__(self, other):
        return self.average_age() == other.average_age()
    def __ne__(self, other):
        return self.average_age() != other.average_age()

jazz = Team("Utah Jazz")
pistons = Team("Detroit Pistons")
older_team = max([jazz, pistons])

Oldest NBA Team

• 效果同上，只是这次比较的是很多个对象，发现很多比较的函数的基础还是基于最基本的留个比较函数，因此只要在我们自己的里面重载好这几个函数，就可以很方便的调用很多内建函数。

import math

class Team(object):
    def __init__(self, team_name):
        self.team_name = team_name
        self.roster = []
        for row in nba:
            if row[3] == self.team_name:
                self.roster.append(Player(row))
    def num_players(self):
        count = 0
        for player in self.roster:
            count += 1
        return count
    def average_age(self):
        return math.fsum([player.age for player in self.roster]) / self.num_players()
    def __lt__(self, other):
        return self.average_age() < other.average_age()
    def __gt__(self, other):
        return self.average_age() > other.average_age()
    def __le__(self, other):
        return self.average_age() <= other.average_age()
    def __ge__(self, other):
        return self.average_age() >= other.average_age()
    def __eq__(self, other):
        return self.average_age() == other.average_age()
    def __ne__(self, other):
        return self.average_age() != other.average_age()

team_names = ["Boston Celtics", "Brooklyn Nets", "New York Knicks", "Philadelphia 76ers", "Toronto Raptors", 
         "Chicago Bulls", "Cleveland Cavaliers", "Detroit Pistons", "Indiana Pacers", "Milwaukee Bucks",
         "Atlanta Hawks", "Charlotte Hornets", "Miami Heat", "Orlando Magic", "Washington Wizards",
         "Dallas Mavericks", "Houston Rockets", "Memphis Grizzlies", "New Orleans Pelicans", "San Antonio Spurs",
         "Denver Nuggets", "Minnesota Timberwolves", "Oklahoma City Thunder", "Portland Trail Blazers", "Utah Jazz",
         "Golden State Warriors", "Los Angeles Clippers", "Los Angeles Lakers", "Phoenix Suns", "Sacramento Kings"]
# 创建了一个Team对象列表
teams = list([Team(name) for name in team_names])
oldest_team = max(teams)
youngest_team = min(teams)
sorted_teams = sorted(teams)