資料處理利器python與scala面向物件對比分析2-大資料ML樣本集案例實戰

摘要： 版權宣告：本套技術專欄是作者（秦凱新）平時工作的總結和昇華，通過從真實商業環境抽取案例進行總結和分享，並給出商業應用的調優建議和叢集環境容量規劃等內容，請持續關注本套部落格。QQ郵箱地址：[email protected]，如有任何學術交流，可隨時聯絡。 1 python與scala面向物...

版權宣告：本套技術專欄是作者（秦凱新）平時工作的總結和昇華，通過從真實商業環境抽取案例進行總結和分享，並給出商業應用的調優建議和叢集環境容量規劃等內容，請持續關注本套部落格。QQ郵箱地址：[email protected]，如有任何學術交流，可隨時聯絡。

1 python與scala面向物件對比分析

1.1 scala面向物件

• 定義類，包含field以及方法

  class HelloWorld {
  private var name = "leo"
  def sayHello() { print("Hello, " + name) }
  def getName = name
  }
  
  建立類的物件，並呼叫其方法
  val helloWorld = new HelloWorld
  
  helloWorld.sayHello() 
  print(helloWorld.getName())也可以不加括號，如果定義方法時不帶括號，則呼叫方法時也不能帶括號
  print(helloWorld.getName) 
  複製程式碼

• scala自動生成getter與setter

  1 定義不帶private的var field，此時scala生成的面向JVM的類時，
  會定義為private的name欄位，並提供public的getter和setter方法
  
  2 而如果使用private修飾field，則生成的getter和setter也是private的
  
  3 如果定義val field，則只會生成getter方法
  
  4 如果不希望生成setter和getter方法，則將field宣告為private[this]
  
  class Student {
  var name = "leo"
  }
  
  呼叫getter和setter方法，分別叫做name和name_ =
  val leo = new Student
  get方法
  print(leo.name)
  
  set方法1
  leo.name = "leo1"
  
  set方法2
  scala> leo.name_=("leo2")
  scala> leo.name
  res3: String = leo2
  複製程式碼

• 自定義getter與setter方法

  如果只是希望擁有簡單的getter和setter方法，那麼就按照scala提供的語法規則，根據需求為field選擇合適的修飾符就好：var、val、private、private[this]
  
  但是如果希望能夠自己對getter與setter進行控制，則可以自定義getter與setter方法
  自定義setter方法的時候一定要注意scala的語法限制，簽名、=、引數間不能有空格
  
   雖然設定私有private，單提供了公共的set和get方法，可以對外訪問
  class Student {
  private var myName = "leo"
  def name = "your name is " + myName
  def name_=(newValue: String){
  print("you cannot edit your name!!!")
  }
  }
  
  scala>val leo = new Student
  leo: Student = Student@e36bc01
  
  scala> print(leo.name)
  your name is leo
  scala> leo.name = "leo1"
  you cannot edit your name!!!leo.name: String = your name is leo
  
  一旦設定私有private，則對外將不可以訪問
  class Student {
  private var myName = "leo"
  }
  
  scala> ss.name
  <console>:26: error: value name is not a member of Student
  ss.name
  ^
  
  scala> ss.name_="asd"
  <console>:1: error: identifier expected but string literal found.
  ss.name_="asd"
  複製程式碼

• Java風格的getter和setter方法

  Scala的getter和setter方法的命名與java是不同的，是field和field_=的方式
  如果要讓scala自動生成java風格的getter和setter方法，只要給field新增@BeanProperty註解即可
  此時會生成4個方法，
  name: String、
  name_=(newValue: String): Unit
  
  getName():String、
  setName(newValue: String): Unit
  
  import scala.reflect.BeanProperty
  class Student {
  @BeanProperty var name: String = _
  }
  
  class Student(@BeanProperty var name: String)
  
  val s = new Student
  s.setName("leo")
  s.getName()
  複製程式碼

• 輔助constructor

  Scala中，可以給類定義多個輔助constructor，類似於java中的建構函式過載
  輔助constructor之間可以互相呼叫，而且必須第一行呼叫主constructor
  
  class Student {
  private var name = ""
  private var age = 0
  
  def this(name: String) {
  this()
  this.name = name
  }
  def this(name: String, age: Int) {
  this(name)
  this.age = age
  }
  }
  複製程式碼

• 主constructor(除了方法體內的程式碼都會執行)

  Scala中，主constructor是與類名放在一起的，與java不同
  而且類中，沒有定義在任何方法或者是程式碼塊之中的程式碼，就是主constructor的程式碼，這點感覺沒有java那麼清晰
  
  class Student(val name: String, val age: Int) {
  println("your name is " + name + ", your age is " + age)
  }
  
  主constructor中還可以通過使用預設引數，來給引數預設的值
  class Student(val name: String = "leo", val age: Int = 30) {
  println("your name is " + name + ", your age is " + age)
  }
  
  如果主constrcutor傳入的引數什麼修飾都沒有，比如name:
  String，那麼如果類內部的方法使用到了，則會宣告為private[this]
  name；否則沒有該field，就只能被constructor程式碼使用而已
  複製程式碼

• 伴生物件

  1 如果有一個class，還有一個與class同名的object，那麼就稱這個object是class的伴生物件
  ，class是object的伴生類
  2 伴生類和伴生物件必須存放在一個.scala檔案之中
  3 伴生類和伴生物件，最大的特點就在於，互相可以訪問private field
  
  object Person {
  private val eyeNum = 2
  def getEyeNum = eyeNum
  }
  
  class Person(val name: String, val age: Int) {
  def sayHello = println("Hi, " + name + ", I guess you are " + age + " years old!" + ", and usually you must have " + Person.eyeNum + " eyes.")
  }
  
  scala> val s =new Person("leo",12)
  s: Person = Person@4d0abb23
  
  scala> s.sayHello
  Hi, leo, I guess you are 12 years old!, and usually you must have 2 eyes.
  複製程式碼

• apply方法

  1 object中非常重要的一個特殊方法，就是apply方法，在建立伴生類的物件時，通常不會使用new Class的方式，而是使用Class()的方式，隱式地呼叫伴生物件得apply方法，這樣會讓物件建立更加簡潔
  
  比如，Array類的伴生物件的apply方法就實現了接收可變數量的引數，並建立一個Array物件的功能
  val a = Array(1, 2, 3, 4, 5)
  
  2 定義自己的伴生類和伴生物件，省略掉new操作
  class Person(val name: String)
  object Person {
  def apply(name: String) = new Person(name)
  }
  scala> Person("xin")
  res7: Person = Person@484a5ddd
  複製程式碼

• main方法

  scala中的main方法定義為def main(args: Array[String])，而且必須定義在object中
  
  除了自己實現main方法之外，還可以繼承App Trait，然後將需要在main方法中執行的程式碼，直接作為object的constructor程式碼；而且用args可以接受傳入的引數
  
  object HelloWorld extends App {
  if (args.length > 0) println("hello, " + args(0))
  else println("Hello World!!!")
  }
  複製程式碼

• extends

  子類可以覆蓋父類的field和method；但是如果父類用final修飾，field和method用final修
  飾，則該類是無法被繼承的，field和method是無法被覆蓋的
  
  class Person {
  private var name = "leo"
  def getName = name
  }
  class Student extends Person {
  private var score = "A"
  def getScore = score
  }
  複製程式碼

• override和super

  Scala中，如果子類要覆蓋一個父類中的非抽象方法，則必須使用override關鍵字,在子類覆
  蓋父類方法之後，如果我們在子類中就是要呼叫父類的被覆蓋的方法呢？那就可以使用super
  關鍵字，顯式地指定要呼叫父類的方法
  
  class Person {
  private var name = "leo"
  def getName = name
  }
  class Student extends Person {
  private var score = "A"
  def getScore = score
  override def getName = "Hi, I'm " + super.getName
  }
  複製程式碼

• 類判別

  class Person
  class Student extends Person
  
  scala> val p: Person = new Student
  p: Person = Student@683fac7e
  
  scala> p.isInstanceOf[Person]
  res10: Boolean = true
  
  scala> p.getClass == classOf[Person]
  res11: Boolean = false
  
  scala> p.getClass == classOf[Student]
  res12: Boolean = true
  複製程式碼

• 使用模式匹配進行型別判斷

  使用模式匹配，功能性上來說，與isInstanceOf一樣，也是判斷主要是該類以及該類的子類
  的物件即可，不是精準判斷的
  
  class Person
  class Student extends Person
  val p: Person = new Student
  
  scala> p match {
  |case per: Person => println("it's Person's object")
  |case _=> println("unknown type")
  |}
  it's Person's object
  複製程式碼

• 呼叫父類的constructor

  1 Scala中，每個類可以有一個主constructor和任意多個輔助constructor，而每個輔助constructor的第一行都必須是呼叫其他輔助constructor或者是主constructor；因此子類的輔助constructor是一定不可能直接呼叫父類的constructor的
  
  2 只能在子類的主constructor中呼叫父類的constructor，以下這種語法，就是通過子類的主建構函式來呼叫父類的建構函式
  
   3注意！如果是父類中接收的引數，比如name和age，子類中接收時，就不要用任何val或var來修飾了，否則會認為是子類要覆蓋父類的field
   
  class Person(val name: String, val age: Int)
  class Student(name: String, age: Int, var score: Double) extends Person(name, age) {
  def this(name: String) {
  this(name, 0, 0)
  }
  def this(age: Int) {
  this("leo", age, 0)
  }
  }
  複製程式碼

• 將trait作為介面使用

  Scala中的Triat是一種特殊的概念
   首先我們可以將Trait作為介面來使用，此時的Triat就與Java中的介面非常類似
   在triat中可以定義抽象方法，就與抽象類中的抽象方法一樣，只要不給出方法的具體實現即可
   
   類可以使用extends關鍵字繼承trait，注意，這裡不是implement，而是extends，在scala中沒有implement的概念，無論繼承類還是trait，統一都是extends
   
   類繼承trait後，必須實現其中的抽象方法，實現時不需要使用override關鍵字
   scala不支援對類進行多繼承，但是支援多重繼承trait，使用with關鍵字即可
   
   trait HelloTrait {
  def sayHello(name: String)
   }
   trait MakeFriendsTrait {
  def makeFriends(p: Person)
   }
   class Person(val name: String) extends HelloTrait with MakeFriendsTrait with Cloneable with Serializable {
  def sayHello(name: String) = println("Hello, " + name)
  def makeFriends(p: Person) = println("Hello, my name is " + name + ", your name is " + p.name)
   }
  複製程式碼

• 在Trait中定義具體欄位

  Scala中的Triat可以定義具體field，此時繼承trait的類就自動獲得了trait中定義的field
   但是這種獲取field的方式與繼承class是不同的：如果是繼承class獲取的field，實際是定
   義在父類中的；而繼承trait獲取的field，就直接被新增到了類中。
   
   trait Person {
  val eyeNum: Int = 2
   }
   
   class Student(val name: String) extends Person {
  def sayHello = println("Hi, I'm " + name + ", I have " + eyeNum + " eyes.")
   }
  複製程式碼

• 在Trait中定義抽象欄位

  // Scala中的Triat可以定義抽象field，而trait中的具體方法則可以基於抽象field來編寫
  // 但是繼承trait的類，則必須覆蓋抽象field，提供具體的值
  
  trait SayHello {
  val msg: String
  def sayHello(name: String) = println(msg + ", " + name)
  }
  
  class Person(val name: String) extends SayHello {
  val msg: String = "hello"
  def makeFriends(p: Person) {
  sayHello(p.name)
  println("I'm " + name + ", I want to make friends with you!")
  }
  }
  複製程式碼

• 為例項混入trait（如果不使用With，trait方法不會執行）

  trait Logged {
  def log(msg: String) {}
  }
  trait MyLogger extends Logged {
  override def log(msg: String) { println("log: " + msg) }
  }
  class Person(val name: String) extends Logged {
  def sayHello { println("Hi, I'm " + name); 
  log("sayHello is invoked!") }
  }
  
  val p1 = new Person("leo")
  p1.sayHello
  val p2 = new Person("jack") with MyLogger
  p2.sayHello
  
  scala> val p1 = new Person("leo")
  p1: Person = Person@75b3ef1a
  
  scala> p1.sayHello
  Hi, I'm leo
  
  scala> val p2 = new Person("jack") with MyLogger
  p2: Person with MyLogger = $anon$1@703eead0
  
  scala> p2.sayHello
  Hi, I'm jack
  log: sayHello is invoked!
  複製程式碼

• trait呼叫鏈

  Scala中支援讓類繼承多個trait後，依次呼叫多個trait中的同一個方法，只要讓多個trait的同一個方法中，在最後都執行super.方法即可。
   
   類中呼叫多個trait中都有的這個方法時，首先會從最右邊的trait的方法開始執行，然後依次往左執行，形成一個呼叫鏈條
   
   這種特性非常強大，其實就相當於設計模式中的責任鏈模式的一種具體實現依賴
   
   trait Handler {
  def handle(data: String) {}
   }
   
   trait DataValidHandler2 extends Handler {
  override def handle(data: String) {
  println("check data2: " + data)
  super.handle(data)
  } 
   }
   
   
   trait DataValidHandler1 extends Handler {
  override def handle(data: String) {
  println("check data1: " + data)
  super.handle(data)
  } 
   }
   trait SignatureValidHandler extends Handler {
  override def handle(data: String) {
  println("check signature: " + data)
  super.handle(data)
  }
   }
   class Person(val name: String) extends SignatureValidHandler with DataValidHandler1 with DataValidHandler2 {
  def sayHello = { println("Hello, " + name); handle(name) }
   }
   
   scala> val p = new Person("person")
   p: Person = Person@7a85454b
   
   scala> p.sayHello
   Hello, person
   check data2: person
   check data1: person
   check signature: person
  複製程式碼

• 在trait中覆蓋抽象方法

  在trait中，是可以覆蓋父trait的抽象方法的
   但是覆蓋時，如果使用了super.方法的程式碼，則無法通過編譯。因為super.方法就會去掉用父trait的抽象方法，此時子trait的該方法還是會被認為是抽象的
   此時如果要通過編譯，就得給子trait的方法加上abstract override修飾
   
   trait Logger {
  def log(msg: String)
   }
   
   trait MyLogger extends Logger {
  abstract override def log(msg: String) { super.log(msg) }
   }
  複製程式碼

• trait的構造機制（從左到右執行）

  class Person { println("Person's constructor!") }
   trait Logger { println("Logger's constructor!") }
   trait MyLogger extends Logger { println("MyLogger's constructor!") }
   trait TimeLogger extends Logger { println("TimeLogger's constructor!") }
   
   class Student extends Person with MyLogger with TimeLogger {
  println("Student's constructor!")
   }
   
   scala> val s = new Student
   Person's constructor!
   Logger's constructor!
   MyLogger's constructor!
   TimeLogger's constructor!
   Student's constructor!
   s: Student = Student@34a99d8
  複製程式碼

1.2python面向物件

• 定義類並建立例項

  按照 Python 的程式設計習慣，類名以大寫字母開頭，緊接著是(object)，表示該類是從哪個類繼承下來的。
   class Person(object):
  pass
  
   省掉new建立例項
   xiaoming = Person()
   xiaohong = Person()
  複製程式碼

• 由於Python是動態語言，對每一個例項，都可以直接給他們的屬性賦值，臨時追加屬性

  xiaoming = Person()
   xiaoming.name = 'Xiao Ming'
   xiaoming.gender = 'Male'
   xiaoming.birth = '1990-1-1'
   
   print(xiaoming.name)
   Xiao Ming
  
   xiaohong.grade = xiaohong.grade + 1
  複製程式碼

• 初始化例項屬性

  init() 方法的第一個引數必須是self（也可以用別的名字，但建議使用習慣用法），
   後續引數則可以自由指定，和定義函式沒有任何區別，相應地，建立例項時，就必須要提供除
   self 以外的引數
   
  class Person(object):
  def __init__(self, name, gender, birth):
  self.name = name
  self.gender = gender
  self.birth = birth
  
  xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
  xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
  
  print (xiaoming.name)
  Xiao Ming
  複製程式碼

• 例項屬性訪問限制

  Python對屬性許可權的控制是通過屬性名來實現的，如果一個屬性由雙下劃線開頭(__)，
  該屬性就無法被外部訪問
  
  class Person(object):
  def __init__(self, name):
  self.name = name
  self._title = 'Mr'
  self.__job = 'Student'
  
  p = Person('Bob')
  print p.name
  # => Bob
  print(p._title)
  # => Mr
  print p.__job
  
  ---------------------------------------------------------------------------
  AttributeErrorTraceback (most recent call last)
  <ipython-input-28-13a5b5479af8> in <module>()
  ----> 1 print(p.__job)
  
  AttributeError: 'Person' object has no attribute '__job'
  複製程式碼

• 建立類屬性

  類本身也是一個物件，如果在類上繫結一個屬性，則所有例項都可以訪問類的屬性
  class Person(object):
  address = 'Earth'
  def __init__(self, name):
  self.name = name
  
  print (Person.address)
  Earth
  
  p1 = Person('Bob')
  p2 = Person('Alice')
  print p1.address
  # => Earth
  print p2.address
  # => Earth
  
  由於Python是動態語言，類屬性也是可以動態新增和修改的
  Person.address = 'China'
  print p1.address
  # => 'China'
  print p2.address
  # => 'China'
  
  類屬性和例項實型名字衝突怎麼辦?當例項屬性和類屬性重名時，例項屬性優先順序高，它將遮蔽掉對類屬性的訪問。
  class Person(object):
  address = 'Earth'
  def __init__(self, name):
  self.name = name
  
  p1 = Person('Bob')
  p2 = Person('Alice')
  
  print 'Person.address = ' + Person.address
  
  p1.address = 'China'
  print ('p1.address = ' + p1.address)
  p1.address = China
  
  print ('p2.address = ' + p2.address)
  p2.address = Earth
  複製程式碼

• 定義例項方法

  一個例項的私有屬性就是以__開頭的屬性，無法被外部訪問，例項的方法就是在類中定義的
  函式，它的第一個引數永遠是 self，雖然name是私有的不能被訪問，
  但是get_name就可以被訪問。
  
  class Person(object):
  
  def __init__(self, name):
  self.__name = name
  
  def get_name(self):
  return self.__name
  
  p1 = Person('Bob')
  print(p1.get_name())
  Bob
  複製程式碼

• 把方法追加到類上

  import types
  
  def fn_get_grade(self):
  if self.score >= 80:
  return 'A'
  if self.score >= 60:
  return 'B'
  return 'C'
  
  class Person(object):
  def __init__(self, name, score):
  self.name = name
  self.score = score
  
  p1 = Person('Bob', 90)
  p1.get_grade = types.MethodType(fn_get_grade, p1)
  print (p1.get_grade())
  
  A
  複製程式碼

• 定義類方法

  class Person(object):
  count = 0
  @classmethod
  def how_many(cls):
  return cls.count
  def __init__(self, name):
  self.name = name
  Person.count = Person.count + 1
  
  print(Person.how_many())
  0
  
  p1 = Person('Bob')
  print(Person.how_many())
  3
  複製程式碼

• 繼承一個類

  class Person(object):
  def __init__(self, name, gender):
  self.name = name
  self.gender = gender
  
  class Student(Person):
  def __init__(self, name, gender, score):
  super(Student, self).__init__(name, gender)
  self.score = score
  
  class Teacher(Person):
  def __init__(self, name, gender, course):
  super(Teacher, self).__init__(name, gender)
  self.course = course
  
   p = Person('Tim', 'Male')
   s = Student('Bob', 'Male', 88)
   t = Teacher('Alice', 'Female', 'English')
   
   isinstance(s, Student)
   True
   
   isinstance(p , Person)
   True
   
   isinstance(t , Student)
   False
  複製程式碼

• 特殊方法

  1str和repr
  class Person(object):
  def __init__(self, name, gender):
  self.name = name
  self.gender = gender
  def __str__(self):
  return '(Person: %s, %s)' % (self.name, self.gender)
  
   p = Person('Bob', 'male')
   print(p)
   (Person: Bob, male)
   
   2 Python的 sorted() 按照預設的比較函式 cmp 排序
   
   class Student(object):
  def __init__(self, name, score):
  self.name = name
  self.score = score
  def __str__(self):
  return '(%s: %s)' % (self.name, self.score)
  __repr__ = __str__
   
  def __cmp__(self, s):
  if self.name < s.name:
  return -1
  elif self.name > s.name:
  return 1
  else:
  return 0
   
   L = [Student('Tim', 99), Student('Bob', 88), Student('Alice', 77)]
   print(L)
   [(Tim: 99), (Bob: 88), (Alice: 77)]
   
   3 len
   class Students(object):
  def __init__(self, *args):
  self.names = args
  def __len__(self):
  return len(self.names)
  
   ss = Students('Bob', 'Alice', 'Tim')
   print (len(ss))
   3
  複製程式碼

• 在Python中，函式其實是一個物件

  class Person(object):
  def __init__(self, name, gender):
  self.name = name
  self.gender = gender
  
  def __call__(self, friend):
  print ('My name is %s...' % self.name)
  print ('My friend is %s...' % friend)
  
  p = Person('Bob', 'male')
  p('Tim')
  
  My name is Bob...
  My friend is Tim...
  複製程式碼

2 總結

通過Python技術棧與Spark大資料資料平臺整合，必然需要本文進行詳細對比，粗陋成文，在於作者複習，勿怪。

秦凱新 於深圳 201812132319

版權宣告：本套技術專欄是作者（秦凱新）平時工作的總結和昇華，通過從真實商業環境抽取案例進行總結和分享，並給出商業應用的調優建議和叢集環境容量規劃等內容，請持續關注本套部落格。QQ郵箱地址：[email protected]，如有任何學術交流，可隨時聯絡。