Python to scala

簡介
● inwinSTACK
● Openstack contributor
○ Openstack Kolla core member
● kjellytw at gmail dot com
● http://www.blackwhite.
tw/

Java to Scala
● Java to Scala

Python
● Object-oriented,
● Imperative
● Dynamic type
● Interpreted languages
● Support shell

Scala
● Functional programming
● Static type
● Object-oriented
● Type inference
● Lazy (non-strict) evaluation
● Compiled languages
● Support shell

python vs scala
● statement,
expression.
● a + b => a.__add__
(b)
● f(a,b) => f.__call__
(a,b)
● everything
"evaluates" to a
value.
● a + b => a.+(2)
● f(a,b) => f.apply(a,
b)

variable - python vs scala
a = 1 ● The return value of
expression is `()`.
var a = 1
var a: Int = 1

const - python vs scala
● python doesn’t
support const.
● The return value of
expression is `()`.
val a = 1
val a: Int = 1

lazy
● Not support in native python. (Maybe some
library support it.
● Initialization is deferred until it is accessed
for the first time
● Check whether the value has already been
initialized before a lazy value is accessed.

lazy
● lazy var words = scala.io.Source.fromFile
("/usr/share/dict/words").mkString
● lazy val fibs: Stream[BigInt] = BigInt(0) #::
BigInt(1) #:: fibs.zip(fibs.tail).map { n => n.
_1 + n._2 }

if-else
● statement
if a > 5:
print(a)
else:
print()
● expression
val x = if(a>5) {1} else 2
val y = if(1!=1) 1 //y == ()

while
while a > 5:
print(a)
a -= 1
● The return value of
expression is `()`.
while ( a > 5) {
print(a)
a -= 1
}

def loop(x: Int, xs: List[Int]): Int = {
var max_value = x
var rest = xs
while (rest != Nil) {
if (max_value < rest.head) max_value = rest.
head
rest = rest.tail
}
max_value

tail recursion
def loop(lst: List[Int], maxValue: Int): Int =
lst match {
case Nil => maxValue
case x :: xs => if (x > maxValue) loop(xs,
x) else loop(xs, maxValue)
}

tail recursion
def max(lst: List[Int]): Int = {
lst match {
case Nil => 0
case x :: xs => loop(xs, x)
}
}

tail recursion
● a tail call might lead to the same
subroutine being called again later in the
call chain.
● a tail recursive function is transformed into
a loop by the compiler.
● use `@tailrec`

do while
● Not support do {
println(a)
a -= 1
while( a > 5)

list comprehension vs for yield
python
scala: the syntax is similar with for.

generator vs stream
They are not the same. But they are similar in
some case.

function
● You can define
many function with
the same name. But
only the function
which is executed in
last time will be
called.
● Support overloading

scala function
def func(a: Int, b: Int) :Unit = {
1
}

scala function
1. def fun = 1 // for pure function
2. def fun() {println(“S”)} # for side effect

function argument
● support variable-
length argument,
keyworded
argumen, default
argument.
● support variable-
length argument,
default argument,
call-by-name
argument.

variable-length , keyworded , default
argument
def func(a, b=1, *args, **kwargs):
pass
def func(a: Int, b: Int = 1, args: Int*) = {
1
}

call-by-name argument
● python doesn’t support call-by-name.
● def mywhile(condition: => Boolean, body: => Unit)

def mywhile(condition: => Boolean, body: => Unit): Int = {
def loop(count: Int): Int = {
if (condition) {
body; loop(count + 1)
} else count
}
loop(0)
}

var a = 1
print(mywhile({ a < 5 }, { a += 1 }))

function return
● use `return` if you
want to return
something.
● if there are no
return in function
body, it will return
`None`.
● avoid to use
`return` keyword.
● if there are no
return in function
body, it will return
the value of the
last expression

match-case
● python doesn’t support match-case.

match-case
x.asInstanceOf[Any] match {
case x :: xs => println(x)
case (a, b, c) => println(a)
case p @ Some(v) if v == 2 => println(p)
case x: Int if x != 2 => println(x)
case _ => println(“None”)
}

class
1. multi inheritance
2. public
3. Not support
overloading
1. single inheritance
2. public, protect,
private
3. Support overloading

class constructor
class My(object):
def __init__(self, x):
self.x = x
self.odd = x%2 ==0
def print_x(self):
print(self.x)
class My(var x: Int) {
var odd = x % 2 ==0
def print_x() {
println(x)
}
}

scala auxiliary constructor
class Length(val length: Int) {
def this(str: String) { this(str.length) }
def this(list: List[Any]) { this(list.length) }
}
new Length(5)
new Length(“Hi”)
new Length(List(1,2))

duck typing
class Length1(val length: Int) {
def this(o: {def length:Int}) {
this(o.length)
}
}
● All thing is
duck typing
in python.
● scala support duck typing.

scala companion object
● singleton object
● companion object

Singleton object
object Main {
def sayHi() {
println("Hi!");
}
}

companion object
class Main {
def sayHelloWorld() {
println("Hello
World");
}
}
object Main {
def sayHi() {
println("Hi!");
}
method，used for
instance
static method,
used for class

How to create instance?
class A(object):pass
a = A()
class A {}
val a = new A
class B{}
object B{def apply() = new B}
val bB = B()
Python
Scala

Type checking and cast
1. isinstance(a, str)
2. issubclass(A,
object)
3. a.__class__
1. "S".isInstanceOf[String]
2.
3.
4. "S".asInstanceOf
[String]

Type checking and cast
if isinstance(a, int):
print(“int”)
elif isinstance(a, str):
print(“str”)
a mtach {
case _: Int =>
println(“int”)
case _: String =>
println(“Str”)
}

class inheritance
● Method Resolution
Order
● class X(A, B):pass
● X.__mro__
● single inheritance
● need `override` when
overriding
● class X extends Any

scala trait
● trait is like java interface but allows
concrete implementations.
● class A extends B with C with D
○ extends + class|trait
○ with + trait

case class
● python doesn’t support case class.
● case class generate the following method:
○ equals
○ apply for companion object .
○ unapply for companion object.

Why we need case class?
def Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
person = Person(“bill”, 5)

Why we need case class?
case class Person(var name:String, var age:Int)
val person = Person(“Bill”, 5)

More case calss
person match {
case Person(name, age) if name == "X" =>
s"$name,$age"
case _ => "Nothing"
}

Python hierarchy
I don’t care.

package
● folder with
`__init__.py` file
● package com.abc.
name

import
● the way to use the
code in other file.
● use short name

Implicit
● python doesn’t support implicit.
● Implicit Conversions
○ implicit defwrapString(s: String): WrappedString
● Implicit Parameters
○ implicit val n: Int = 5
○ def add(x: Int)(implicit y: Int) = x + y
● more thing ...

Scala type parameters
● List[String](); def drop1[A](l: List[A]) = l.tail

Scala type parameters
● List[String](); def drop1[A](l: List[A]) = l.tail
● more thing about:
○ Bounds -> def biophony[T <: Animal]
○ Quantification -> def count(l: List[_]) = l.size
○ Variance

Int
● int, long
● nerver overflow
● Int(32-bit signed) or
Long(64-bit signed)
or BigInt
● BitInt supports +,%,*
● care for overflow

Boolean
● True and False
● False or True
● not True
● true && false
● true || false
● !true
● short-circuit

String
● no char
● one line string:
○ “string”
○ ‘string’
● multiline string:
○ “””dddd”””
○ ‘’’ccc’’’
○ “abcd”[1]
● char => ‘c’
● string => “c”
● “abcd”(1)

String format
● "%s %d" % ("Hi", 5)
● '{0}'.format('a')
● 'Coordinates:
{latitude}'.format
(latitude='37.24N',)
● i"{names}" #P0510
● "%s".format
(firstName)
● s"Hello, $name"

List in python vs ArrayBuffer in scala
1. List(1, 2, 3, 4)
2. [1, 2, 3, 4]
3. a[3]
4. a[-1]
5. a[1:-1]
6. a[1:-1:-1]
7. a[1] = 1
1. ArrayBuffer(1,2,3,4)
2. new ArrayBuffer[Int]()
3. a(3)
4.
5. a.slice(1, a.length-1)
6.
7. a(1) = 1

1. map(a, lambda x:
x+1)
2. b = [i + 1 for i in a if
i % 2 ==0]
1. a.map(_ + 1)
2. val b = for(i <- a if i
% 2 ==0) yield i + 1

a.map(x:Int => {x + 1})
a.map(x => {x+1})
a.map(x => x+ 1)
a.map(_ + 1)

1. a.__getitem__
2. a.__setitem__
1. a.apply
2. a.update

ArrayBuffer
new ArrayBuffer(5) vs ArrayBuffer(5)

Scala List
● Linked list
● Optimal for last-in-first-out (LIFO), stack-
like access patterns
● Immutable
● `Nil` means empty list.

Scala List
● List(1, 2, 3)
● 1 :: 2 :: 3 :: Nil
● Nil.::(3).::(2).::(1)

Scala List
def max(lst: List[Int]): Int = {
lst match {
case Nil => 0
case x :: xs => loop(xs, x)
}
}

Scala Async
Future.apply[T](body: ⇒ T)(implicit executor:
ExecutionContext): Future[T]

def combined: Future[Int] = async {
val future1 = slowCalcFuture
await(future1) + await(future2)
}

def combined: Future[Int] = for {
r1 <- future1
r2 <- future2
} yield r1 + r2

django vs play framework2
● python web
framework
● MVT
● support ORM
● scala/java web
framework
● MVC
● support type
checking in views.

django class-based views vs play
controller
def index = Logging {
Action {
Ok("Hello World")
}
}
class MyView(TemplateView):
template_name = "about.html"
Play
Django

play view
● type checking
● view as function.
○ views.html.list(List
(“1”))
function
argument
function
body
call main
function
list.scala.html

Thank you
The slide will update continuously.

Python to scala

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Python to scala

Similar to Python to scala (20)

More from kao kuo-tung

More from kao kuo-tung (13)

Recently uploaded

Recently uploaded (20)

Python to scala