补2月的内容，因为放假的缘故——DataQuest 学习记录

Dataquest missions

机器学习评估指标——分类

-    Accuracy

-    Precisionfpr 预测为正的样本中有多少是真正的正样本P = TP/(TP+FP)

-    Recall  tpr 样本中的正例有多少被预测正确了，包含两种一个是正确的预测正例，一个是错误预测成了负例R = TP/(TP+FN)

-    F1Score

-    ROCCurve

-    PRCurve

-    AUC

	Positive	Negative
1	TP	TN
0	FP	FN

 

-     

数据结构

数据结构是组织数据的形式，如列表Lists和字典dictionaries等。

-    数据结构的选择要素：首先是我们如何存储的，第二是插入删除和查找的时间复杂度。

-    Array：一个包含item的list

-    很多语言都有一个内置的原始数组形式，但是python不具有原始的固定长度的数组，但是python的list时一个动态数组

-    动态数组是数组的一种风格，我们可以扩展以适应尽可能多的元素。这些在数据科学中比固定大小的数组更有用

•  一个长的存储空间链（along chain of memory slots）：每个元素依次保存在存储空间中

•  当删除或增加元素时，所有的元素都需要依次的移动，导致该类操作非常耗时

•  无法扩展初始定义的长度，如果是个10个元素的array，则不会改变

              players.insert(0, "Jeff Adrien")

              print(players)

              players.remove("Reggie Jackson")

              print(players)

-    2D数组：矩阵遍历复杂度O(m*n)

•  hash table 哈希表：通过散列表的形式，降低时间复杂度，增加了空间复杂度，因为大部分哈希表内的格子是空闲的

 

递归

函数调用自己

-    定义一个basecase 用于判断合适停止，否则会导致无限调用自己

-    deffib(n):

-        if n == 0:

-            return 0

-        if n == 1:

-            return 1

-       return fib(n-1) +  fib(n-2)

-    fib1= fib(1)

-    fib5= fib(5)

-    fib25= fib(25)

-    linkedlists：递归的数据结构

•  因为每个node都与第二个node相连，所以采用递归的方式处理这种数据结构是合理的，而对应的采用loop会很奇怪

•  当需要查找链表时，由于不知道确定的index，必须一个接一个的查找，所以查找效率不太高

•  但是当发生修改少量节点操作时，比如删除或插入，消耗的时间复杂度和空间复杂度都很小。是线性的。

•   # First person's name

•   first_item = people.head().get_data()

•    

•   # Getting the length of the linked list usingiteration

•   def length_iterative(ls):

•      count = 0

•       while notls.is_empty():

•           count =count + 1

•          ls = ls.tail()

•       return count

•   people_length = length_iterative(people)

-    

Class 类

面向对象的编程：一个合格的工程师需要考虑复杂度问题、选择最优化的解决方案，包括制定详细的计划、一些试验和错误，另外还有经验。

-   class Player():

-       # The special __init__ function runswhenever a class is instantiated

-       # The init function can take arguments, butself is always the first one

-       # Self is just a reference to the instanceof the class

-       # It's automatically passed in when youinstantiate an instance of the class

-       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

-           # Team roster initially empty

-            self.roster = []

-           # Find the players for the roster inthe data set

-           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

-       # Implement the average_age() instance method

-       def average_age(self):

-            age = 0

-           for player in self.roster:

-                age += player.age

-           return age/self.num_players()

-        

-        

-    spurs= Team("San Antonio Spurs")

-   spurs_num_players= spurs.num_players()

-   spurs_avg_age= spurs.average_age()

-    classmethod 类方法：在传统的面向对象的编程中，一切（是的，所有）都是一个对象。整数是对象，布尔值也是。尽管Python并不是这种面向对象的，但Python语言中的对象仍然很丰富。例如，math.floor函数实际上只是数学类的一个类方法。类方法作用于整个类，而不是一个特定的实例。我们经常将它们用作实用功能。

-     

-    请注意，在起始代码中，我们重写了使用数学类的average_age（）方法以及列表理解。这是一些高级的Python代码，但你以前看过。math.fsum方法作用于数学类，获取可迭代的（即列表或类列表）参数，并将列表中的值相加以产生结果。

-     

-    另请注意，我们已经开始为您编写一个类方法。出现在它上面的@classmethod行告诉Python解释器该方法是一个类方法。无论何时声明类方法，都需要遵循此模式。

•   import math

•   

•   class Player():

•       # Thespecial __init__ function runs whenever a class is instantiated

•       # The initfunction can take arguments, but self is always the first one

•       # Self isjust a reference to the instance of the class

•       # It'sautomatically 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 = 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))

•      

•       defnum_players(self):

•          count = 0

•           forplayer in self.roster:

•              count += 1

•           returncount

•     

•       defaverage_age(self):

•           returnmath.fsum([player.age for player in self.roster]) / self.num_players()

•      

•       @classmethod

•       defolder_team(self, team1, team2):

•           ifteam1.average_age() > team2.average_age():

•              return team1

•          else:

•              return team2

•   

•  old_team =Team.older_team(Team("New York Knicks"), Team("MiamiHeat"))

 

-    继承inheritance父类parent

•  在面向对象的编程中，继承的概念使我们能够在树状层次结构中组织类，其中父类具有传递给其后代的一些特征。当我们定义一个类时，我们指定一个它继承的父类。从类继承意味着父对象的行为也存在于子对象中，但子对象仍然可以定义其自己的附加行为。

•  考虑一个具有关于NBA球员的一般信息的球员类。这会非常有用，因为玩家有很多共同点。但是，我们可能还想为不同的职位添加特定的行为。我们可以定义像Center，Forward或Point Guard这样的类，每个类都具有特定于该位置的行为。这些类将分别指定Player作为其父类。他们都是兄弟姐妹 - 每个人都会从Player类继承相同的行为，同时也具有自己的特殊行为。

•  在Python 3中，每个类都是通用对象类的子类。虽然这种情况在我们没有指定祖先时自动发生，但有时候明确的做法是很好的做法。对于这个任务的其余部分，我们将在代码时指定一个类的对象作为它的父对象。这是一个很好的编程习惯- 如果我们养成了指定类的祖先的习惯，那么当它不是对象时，我们不会忘记指定父类。这只是形成良好习惯的一种方式。

-    重载overloading

•  当一个类继承自一个父类时，它获得了该父类的所有行为。有些时候，我们不想要所有这些行为，或者想为我们的自定义类稍微修改它。我们使用称为重载的技术来实现这一点。

•  重载继承行为涉及将新行为分配给我们的自定义类。为了达到这个目的，我们只是重新定义了我们新课程的方法。

•  我们将改变我们的Player类以支持使用这些运算符的比较：

-    > 

-    < 

-    ==

-    ！=

-    >=

-    <=

•  这些方法默认存在于对象类中，我们使用这些运算符来比较整数，浮点数（小数）和字符串。操作符的工作原因是字符串等类已经专门实现了它们。但是，要理解为什么对象类需要使用这些方法有点困难。围绕这个问题的最好方法就是通过一个例子。

•  让我们考虑加法运算符（+）。对象类已经定义了添加方法。sum（）函数是使用这种加法方法定义的，但对象类并不真正知道如何特别添加整数或浮点数。

•  但是，整型和浮点类定义了它们自己的加法方法（从而重载了对象的加法方法），并且sum（）函数将正确地将这些值相加。这种体系结构非常强大，因为即使sum（）只需要定义一次，我们也可以在多个类上调用它，这会导致正确的行为。这是继承和重载的一个例子。

-   classPlayer(object):

-       # The special __init__ function runswhenever a class is instantiated

-       # The init function can take arguments, butself is always the first one

-       #Self is just a reference to the instance of the class

-       # It is automatically passed in when youinstantiate an instance of the class

-       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

-       # Implement the rest of the comparisonoperators here

-       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

-    重载没看懂啊~~

-    我们已经看到，我们可以重载运算符来定制类。在最后一个屏幕上，我们可以使用几个比较运算符（>，<，==等）按年龄比较NBA球员。超载行为的能力非常强大，因为许多内置的Python函数使用这些简单的运算符。 如果我们在自定义类上实现它们，我们可以在我们的Player类的实例上使用像min和max这样的函数。 min取一个值列表并返回最小值。 max获取一个值列表并返回最大值。

-     

-    我们最初的目标是根据平均年龄比较NBA球队。我们看到我们如何在Player类中重载方法，现在是时候为我们的Team类做同样的事情了。

•   import math

•   

•   class Team(object):

•       def__init__(self, team_name):

•          self.team_name = team_name

•          self.roster = []

•           for rowin nba:

•              if row[3] == self.team_name:

•                  self.roster.append(Player(row))

•       defnum_players(self):

•          count = 0

•           forplayer in self.roster:

•              count += 1

•           returncount

•       defaverage_age(self):

•           return math.fsum([player.agefor player in self.roster]) / self.num_players()

•       def__lt__(self, other):

•           returnself.average_age() < other.average_age()

•       # Implementthe rest of the comparison operators here

•       def__gt__(self,other):

•           return self.average_age()> other.average_age()

•       def__le__(self,other):

•           returnself.average_age() <= other.average_age()

•       def__ge__(self,other):

•           returnself.average_age() >= other.average_age()

•       def__eq__(self,other):

•           returnself.average_age() == other.average_age()

•       def__ne__(self,other):

•           returnself.average_age() != other.average_age()

•       # Defineoperators here

•         

•  jazz = Team("Utah Jazz")

•  pistons =Team("Detroit Pistons")

•   older_team = max([jazz, pistons])

•  现在我们已经可以获得许多有趣的信息，我们已经实施了比较操作。这是因为Python使用这些比较来实现许多实用功能。 现在我们可以使用这些功能来分析新设置中的数据。 通过重载方法，我们可以访问强大的函数，而无需执行乏味的逻辑。

•   import math

•   

•   class Team(object):

•       def__init__(self, team_name):

•          self.team_name = team_name

•          self.roster = []

•           for rowin nba:

•              if row[3] == self.team_name:

•                  self.roster.append(Player(row))

•       defnum_players(self):

•          count = 0

•           forplayer in self.roster:

•              count += 1

•           returncount

•       def average_age(self):

•           returnmath.fsum([player.age for player in self.roster]) / self.num_players()

•       def__lt__(self, other):

•           returnself.average_age() < other.average_age()

•       def__gt__(self, other):

•           returnself.average_age() > other.average_age()

•       def__le__(self, other):

•           returnself.average_age() <= other.average_age()

•       def__ge__(self, other):

•           returnself.average_age() >= other.average_age()

•       def__eq__(self, other):

•           returnself.average_age() == other.average_age()

•       def__ne__(self, other):

•           returnself.average_age() != other.average_age()

•   

•   team_names = ["Boston Celtics","Brooklyn Nets", "New York Knicks", "Philadelphia76ers", "Toronto Raptors",

•            "Chicago Bulls","Cleveland Cavaliers", "Detroit Pistons", "IndianaPacers", "Milwaukee Bucks",

•            "Atlanta Hawks","Charlotte Hornets", "Miami Heat", "OrlandoMagic", "Washington Wizards",

•            "Dallas Mavericks","Houston Rockets", "Memphis Grizzlies", "New OrleansPelicans", "San Antonio Spurs",

•            "Denver Nuggets","Minnesota Timberwolves", "Oklahoma City Thunder","Portland Trail Blazers", "Utah Jazz",

•            "Golden State Warriors","Los Angeles Clippers", "Los Angeles Lakers", "PhoenixSuns", "Sacramento Kings"]

•   

•   # Alter this list comprehension

•   teams = list([Team(name) for name in team_names])

•   oldest_team = max(teams)

•   youngest_team = min(teams)

•   sorted_teams = sorted(teams)

•  为了解决我们的问题，我们选择了一个将玩家与团队的想法完全分开的实现。通过这样做，我们编写了有组织且合理的代码，这些代码不难追踪。

•   

•  通过实施比较运营商，我们能够以非常有效的方式识别最老和最年轻的团队。我们甚至可以用一行代码按年龄排列NBA球队。这是面向对象编程的力量，它突出了明智选择我们实现的重要性。