관리 메뉴

HAMA 블로그

Scala 과 Python 를 동시에 배워보자. 본문

Python

Scala 과 Python 를 동시에 배워보자.

[하마] 이승현 (wowlsh93@gmail.com) 2015.05.04 21:36



Scala 와 Python 의 비교를 통해서 이 언어들의  기초적인 언어 스타일링에 대해서 빠르게 훑어보도록 하겠습니다.



                                             Scala vs  Python  



Scala 


스칼라(Scala)는 객체 지향 프로그래밍 언어와 함수형 프로그래밍의 요소가 결합된 다중패러다임 프로그래밍 언어이다. C++ 가 C의 요소를 가져오긴 했지만 객체지향을 지향하듯이 스칼라도 함수형으로 개발하는것을 지향한다. 스칼라의 이름은 <skah-lah>라고 발음하며 'Scalable Language'에서 따왔다. 적은 양의 코드로도 방대한 규모의 시스템을 작성할 수 있다는 특징이 있다.[2] 자바의 자바 가상 머신 에서 실행 할 수 있으며 자바의 API도 그대로, 혹은 스칼라의 형식에 맞춰 약간 수정한 형태로 사용 할 수 있다. 대중화를 위한 굉장히 큰 장점이다.스칼라의 주요 특징은 함수도 객체라는것과 숫자도 객체 즉 모든 것이 객체인것이 자바와는 가장 크게 다른 점이다.



Python :

파이썬도 절차지향,객체 지향, 함수형 프로그래밍의 요소가 결합된 다중패러다임 프로그래밍 언어이다

파이썬[1](Python)은 1991년[2] 프로그래머인 귀도 반 로섬(Guido van Rossum)[3] 이 발표한 고급 프로그래밍 언어로, 플랫폼 독립적이며 인터프리터식, 객체지향적, 동적 타이핑(dynamically typed) 대화형 언어이다. 파이썬이라는 이름은 귀도가 좋아하는 코미디 〈Monty Python's Flying Circus〉에서 따온 것이다.


파이썬은 비영리의 파이썬 소프트웨어 재단이 관리하는 개방형, 공동체 기반 개발 모델을 가지고 있다. C언어로 구현된 C파이썬 구현이 사실상의 표준이다. 표준 파이썬은 아무래도 느린감이 있지만 분산,병렬로 어느정도 카바 가능하다. 엄청나게 속도 크리티컬한 프로그램에선 쓸 수 없지만 pypy 등 속도를 향상시킨 파이썬 버전을 이용하여 속도라는 토끼도 잡을 수 있다. 개인적으로 그렇게 쓸 바엔 C++ 이나 RUST 쓰겠다. 




                                      이 표는 좀 오래된것 같군요. 몇가지가 빠진듯..Flask 같은..



   

1. 기본 구조 및 HelloWorld 


Scala) 


object HelloWorld {

  def main(args: Array[String]) {

    println("Hello, world!")

  }

}


HelloWorld.scala 로 저장



Python) 


class HelloWorld:

        def f(self):

                print "Hello, world!"

hw = HelloWorld()

hw.f()


print "HelloWorld"  라고 그냥 해도 됨. 클래스 안 만들고 말이죠.


Helloworld.py 로 저장.



Scala 의 main 함수는 static이 아니다. Scala에는 정적 멤버(함수,필드 모두) 라는 개념이 존재하지 않는다.
object선언은 싱글턴 객체를 생성하는데, 정적개념이 필요하면 싱글턴객체 안에 넣으면 된다. 


Python 은 구조상 특이점은 { }가 없다는것과 들여쓰기를 통한 단락의 구분과 : (콜론) 의 사용이다. 하위 레벨의 코드는 들여쓰기가 한 단계 깊어지고 상위레벨은 콜론으로 끝나야한다. 자바나 c++ 에서의 This 를 명시적으로 self 로 사용하는게 이채롭다. 



2. 주석 스타일 


Scala) 


// 한 줄 주석


/* 

여러 줄 주석  

*/




Python) 


# 한 줄 주석


‘’’ 

여러 줄 주석

‘’’


Scala 는 자바와 같고  

Python 은 여러 줄 일 경우 따옴표 3개 혹은 쌍따옴표 3개를 배치하면 된다.  



3. 기본 자료형  


Scala) 


Byte   8 bit . Range from -128 to 127

Short 16 bit . Range -32768 to 32767

Int        32 bit . Range -2147483648 to 2147483647

Long   64 bit

Float 32 bit IEEE 754 single-precision float

Double 64 bit IEEE 754 double-precision float

Char         16 bit unsigned Unicode character.

String A sequence of Chars

Boolean Either the literal true or the literal false

Unit         Corresponds to no value

Null         null or empty reference

Nothing The subtype of every other type;

Any          The supertype of any type; 

AnyRef  The supertype of any reference type




Python) 


Numbers (int, float etc.)

String

Dictionary

Tuple

List


a=’76.3’

b=float(a)     # 숫자로 형변환 

c = str(b)     # 문자로 형변환 


strLesson = ‘This is Python strings lesson’

StrLessonTriple = """This

is

string

Lesson"""   




4. 기본 자료구조  


Scala) 


val 변경불가
var 변경가능

 

val scor    =  Map(“Alice” → 10, “Bob” → 3)

val scores = scala.collection.mutable.Map()

scoes(“Bob”) = 10

scores += (“Bob”->1, “Fred”->7)




Python) 


Dictionary

Tuple

List

   


dict = {‘Mike’: 1233456,’John’: 567890}


list_mixed = [1, ‘this’, 2, ‘is’, 3, ‘list’, 4, ‘chapter’]

list_list      = [1, ‘this’, [ 5, ‘hell’], 9’]


tuple_strings = (‘this’, ‘is’, ‘tuple’, ‘lesson’)

tuple_mixed = (1, ‘this’, 2, ‘is’, 3, ‘tuple’, 4, ‘chapter’)


print “=” * 50





5. 연산자 


Scala) 


인식자 

변수,함수, 클래스등의 이름을 총체적으로 인식자라고부른다. 추가적으로 일련의 연산자문자도 사용가능 

val √ = scala.math.sqrt _

√ (2)

val ‘val’ = 42


삽입 연산자 (a identifier b)

a to 10

a.to(10)

1->10

1.->(10)


단항 연산자 (a identifier)

1 toString

1.toString() 


할당연산자  (a operator=b)

a+=b

a= a+b


apply/  update / unapply 

함수호출문법을 함수아닌값에도사용가능 

f(arg1,arg2, …)

f.apply(arg1,arg2,...)

f(arg1,arg2, …) = value

f.update(arg1,arg2,... value) 


unapply는 어떤 객체에서 값을 추출한다고 보면된다.

Case Fraction(a,b) =>   하면 Fraction 객체안의 값이 옵션으로 리턴됨. Option[(Int,Int)]




Python) 


1) 산술 연산자 : +, -, *, **, /, //, %


2) 관계 연산자 : <, >, <=, >=, ==, !=, <>


3) 논리 연산자 : not, and, or

    - 0, 0.0, 0L, 0.0+0.0j, (), {}, [], None, ""은 모두 거짓으로 간주

    - 나머지는 모두 참

    - 'and'와 'or'이 포함된 논리식은 식의 결과 값을 판정하는데 최종적으로 기여한 객체의 값을 식의 값으로 리턴


4) 비트 단위 연산자 : <<, >>, &, |, ^, ~


3. 수치 연산 함수

  1) 내장 수치 연산 함수

    - abs(x) : x의 절대값

    - int(x) : x를 int(정수)형으로 변환

    - long(x) :  x를 long형으로 변환

    - float(x) : x를 float형(실수형)으로 변환

    - complex(re, im) : 실수부 re와 허수부 im를 가지는 복소수

    - c.conjugate() : 복소수 c의 켤레 복소수

    - divmod(x, y) : (x//y, x%y) 쌍

    - pow(x, y) : x의 y승

  2) math 모듈 : math(실수 연산), cmath(복소수 연산)



5. 조건문 


Scala) 


var result = ""

if(marks >= 50)

  result = "passed"

else

  result = "failed"


------------------------------

result match {

  case "A" | "B" => println("Congratulations!")

  case "C" => println("There is room ..")

  case _ => println("We are ...")

}




Python) 



var = 100

if var == 200:

   print "1 - Got a true expression value"

   print var

elif var == 150:

   print "2 - Got a true expression value"

   print var

elif var == 100:

   print "3 - Got a true expression value"

   print var

else:

   print "4 - Got a false expression value"

   print var


Python 에는 switch 문이 없다. 



6. 반복문 


Scala) 


object Test {

   def main(args: Array[String]) {

      var a = 0;

      // for loop execution with a range

      for( a <- 1 to 10){

         println( "Value of a: " + a );

      }

   }

}

----------------------------------   

  var a = 0;

  val numList = List(1,2,3,4,5,6);


  for( a <- numList ){

     println( "Value of a: " + a );

  }

   



Python) 



for i in a:

  print I


# 0~3까지 범위

for i in range(4):

  print I


# 지정한 하한/상한의 범위에서만. (1씩 증가)

for i in range(1000, 1010):

  print I


# 지정한 하한/상한의 범위에서만. (2씩 증가)

# range()의 3번째 파라이터가, 건너뛸 숫자

for i in range(1, 14, 2):

  print I


# 지정한 숫자에서만

for i in 123, 341, 0, 666:

  print I


myList = ['cat', 'dog', 'rabbit']

 

for a in myList:

    print(a)




7. 배열 


Scala) 



var z = new Array[String](3)


z(0) = "Zara"

z(1) = "Nuha"

z(2) = "Ayan"


var z = Array("Zara", "Nuha", "Ayan")

var myList = Array(1.9, 2.9, 3.4, 3.5)

var myMatrix = ofDim[Int](3,3)


import Array._

object Test {

   def main(args: Array[String]) {

      var myMatrix = ofDim[Int](3,3)

      

      // build a matrix

      for (i <- 0 to 2) {

         for ( j <- 0 to 2) {

            myMatrix(i)(j) = j;

         }

      }


      var myList1 = Array(1.9, 2.9, 3.4, 3.5)

      var myList2 = Array(8.9, 7.9, 0.4, 1.5)


      var myList3 =  concat( myList1, myList2)


      var myList1 = range(10, 20, 2)

      var myList2 = range(10,20)

      




Python) 



MyList=[1,2,3,4,5,6]


MyList[2]=100


MyList[2:5]  #  from myList[2] to myList[4]. 


MyList[5:]     #  List[5] to the end of the list 


MyList[:5]     #  not including myList[5]


mi=MyList.index(m) 


myList=[i for i in range(10)]


myList=[]

for i in range(10):

 myList.append(1)  or myList[i]=1


b=[[0]*3 for i in range(3)]


B[0][0]=1


myArray=[[0 for j in range(3)] for i in range(3)]



8. 문자열 


Scala) 


var greeting = "Hello world!";

or

var greeting:String = "Hello world!";


var palindrome = "Dot saw I was Tod";

var len = palindrome.length();


"My name is ".concat("Zara");


object Test {

   def main(args: Array[String]) {

      var str1 = "Dot saw I was ";

      var str2 =  "Tod";

      println("Dot " + str1 + str2);

   }

}


object Test {

   def main(args: Array[String]) {

      var floatVar = 12.456

      var intVar = 2000

      var stringVar = "Hello, Scala!"

      var fs = printf("The value of the float variable is " +

                   "%f, while the value of the integer " +

                   "variable is %d, and the string " +

                   "is %s", floatVar, intVar, stringVar)

      println(fs)

   }

}




Python) 



food = "Python's favorite food is perl"

say = '"Python is very easy." he says.'

food = 'Python\'s favorite food is perl'


>>> head = "Python"

>>> tail = " is fun!"

>>> print(head + tail)

Python is fun!


>>> a = "python"

>>> print(a * 2)

Pythonpython


>>> a = "Life is too short, You need Python"

>>> a[3]

'e'


>>> a[0:4]

'Life'


>>> a[5:7]

'is'


>>> a[19:]

'You need Python'


>>> print("I eat %d apples." % 3)

I eat 3 apples.


>>> number = 10

>>> day = "three"

>>> print("I eat %d apples. so I was sick for %s days." % (number, day))

I eat 10 apples. so I was sick for three days.



9. 예외 


Scala) 


import java.io.FileReader

import java.io.FileNotFoundException

import java.io.IOException


object Test {

   def main(args: Array[String]) {

      try {

         val f = new FileReader("input.txt")

      } catch {

         case ex: FileNotFoundException => {

            println("Missing file exception")

         }

         case ex: IOException => {

            println("IO Exception")

         }

      } finally {

         println("Exiting finally...")

      }

   }

}



Python) 


        try:

...         result = x / y

...     except ZeroDivisionError:

...         print "division by zero!"

...     else:      ( 예외가 실행되지 않으면 실행)

...         print "result is", result

...     finally:     (예외가발생하던 말던 실행)

...         print "executing finally clause"



    try:

...     raise NameError, 'HiThere'

... except NameError:

...     print 'An exception flew by!'

...     raise



10. 클래스 


Scala) 


import java.io._


class Point(val xc: Int, val yc: Int) {

   var x: Int = xc

   var y: Int = yc

   def move(dx: Int, dy: Int) {

      ...

   }

}



class Time {

  private[this] var h = 12

  private[this] var m = 0

      

  def hour: Int = h

  def hour_=(x: Int){ h = x }

      

  def minute: Int = m

  def minute_=(x: Int){ m = x }

}




Python) 




class Service:

...     secret = "영구는 배꼽이 두 개다"

...     def __init__(self, name):

...         self.name = name

...     def sum(self, a, b):

...         result = a + b

...         print("%s님 %s + %s = %s입니다." % (self.name, a, b, result))


>>> pey = Service("홍길동”)

>>> pey.sum(1, 1)



11. 함수 


Scala) 



object Test {

   def main(args: Array[String]) {

        println( "Returned Value : " + addInt(5,7) );

   }

   def addInt( a:Int, b:Int ) : Int = {

      var sum:Int = 0

      sum = a + b


      sum

   }

}



Python) 



>>> def fib(n):    # write Fibonacci series up to n

...     "Print a Fibonacci series up to n"

...     a, b = 0, 1

...     while b < n:

...         print b,

...         a, b = b, a+b

... 

>>> # Now call the function we just defined:

... fib(2000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597


>>> def fib2(n): # return Fibonacci series up to n

...     "Return a list containing the Fibonacci series up to n"

...     result = []

...     a, b = 0, 1

...     while b < n:

...         result.append(b)    # see below

...         a, b = b, a+b

...     return result

... 

>>> f100 = fib2(100)    # call it

>>> f100                # write the result

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]



12. Import  방법 


Scala) 


Import clauses


An import clause has the form import p.I where the import expression I determines a set of names of members of p which are made available without qualification. For example:

The clause makes available without qualification..

import p._ all members of p (this is analogous to import p.* in Java).

import p.x the member x of p.

import p.{x => a} the member x of p renamed as a.

import p.{x, y} the members x and y of p.

import p1.p2.z the member z of p2, itself member of p1.



Python) 


import 모듈이름


>>> import mod1 

>>> print(mod1.sum(3,4))

7


mod1.py에 다음의 함수를 추가 시켜 보자.

def safe_sum(a, b): 

    if type(a) != type(b): 

        print("더할수 있는 것이 아닙니다.")

        return 

    else: 

        result = sum(a, b) 

    return result


>>> import mod1 

>>> print(mod1.safe_sum(3, 4))

7


>>> from mod1 import sum         // 모듈내의 기능을 바로 사용할수있게한다. 

>>> sum(3, 4) 

7


from mod1 import *



13. 콘솔 입출력   


Scala) 



object ScannerTest {

  def main(args: Array[String]) {

    var ok = true

    while (ok) {

      val ln = readLine()

      ok = ln != null

      if (ok) println(ln)

    }

  }

}


object ScannerTest {

  def main(args: Array[String]) {

    for (ln <- io.Source.stdin.getLines) println(ln)

  }

}


object Test {

   def main(args: Array[String]) {

      print("Please enter your input : " )

      val line = Console.readLine

      

      println("Thanks, you just typed: " + line)

   }

}



Python) 



>>> a = input() 

Life is too short, you need python 

>>> a 

Life is too short, you need python 

>>>


>>> number = input("숫자를 입력하세요: ") 

숫자를 입력하세요:


>>> a = 123 

>>> print(a)

123 

>>> a = "Python" 

>>> print(a) 

Python 

>>> a = [1, 2, 3] 

>>> print(a) 

[1, 2, 3]



14. 파일  입출력   


Scala) 


import java.io._


object Test {

   def main(args: Array[String]) {

      val writer = new PrintWriter(new File("test.txt" ))


      writer.write("Hello Scala")

      writer.close()

   }

}


import scala.io._


object ReadFile extends Application {

  val s = Source.fromFile("some_file.txt")

  s.getLines.foreach( (line) => {

    println(line.trim.toUpperCase)

  })

}



Python) 



f = open("C:/Python/새파일.txt", 'w')


f = open("새파일.txt", 'w')


for i in range(1, 11): 

    data = "%d 번째 줄입니다.\n" % i 

    f.write(data) 


f.close()


f = open("새파일.txt", 'r') 

line = f.readline() 

print(line)

f.close()


f = open("새파일.txt", 'r')


while 1: 

    line = f.readline()

    if not line: break 

    print(line)


f.close()


f = open("새파일.txt", 'r') 

lines = f.readlines()


for line in lines: 

    print(line)


f.close()




15. 컨테이너 (컬렉션) 


Scala) 


// Define List of integers.

val x = List(1,2,3,4)


// Define a set.

var x = Set(1,3,5,7)


// Define a map.

val x = Map("one" -> 1, "two" -> 2, "three" -> 3)


// Create a tuple of two elements.

val x = (10, "Scala")


// Define an option

val x:Option[Int] = Some(5)


object Test {

   def main(args: Array[String]) {

      val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")

      

      println("show(capitals.get( \"Japan\")) : " +  

                                          show(capitals.get( "Japan")) )

      println("show(capitals.get( \"India\")) : " +  

                                          show(capitals.get( "India")) )

   }

   

   def show(x: Option[String]) = x match {

      case Some(s) => s

      case None => "?"

   }

}



 var s = Some("abc")          // Scala can infer the type

    var t: Option[String] = None // Type must be explicit


def chooseFile(): Option[File] = { ... }



The most general way to use an Option is with a match:


    chooseFile() match {

      case Some(f) => // Do something with file f

      case None =>    // Do something when there is no file

    } 


You can check if an Option value is defined by comparing it with None, or by using the isDefined or isEmpty method:


    if (t isDefined) println(t)

    if (t isEmpty) println("Nothing here!")

You can extract the value of an Option, but only if you provide some default value for the None case:


    val w = t.getOrElse("Nothing here!")



Python) 


dict = {‘Mike’: 1233456,’John’: 567890}


list_mixed = [1, ‘this’, 2, ‘is’, 3, ‘list’, 4, ‘chapter’]

list_list      = [1, ‘this’, [ 5, ‘hell’], 9’]


tuple_strings = (‘this’, ‘is’, ‘tuple’, ‘lesson’)

tuple_mixed = (1, ‘this’, 2, ‘is’, 3, ‘tuple’, 4, ‘chapter’)







16. 상속 


Scala) 


class ScientificCalculator(brand: String) extends Calculator(brand) {
  def log(m: Double, base: Double) = math.log(m) / math.log(base)
}

Python) 


class Person:

    def __init__(self, name, age, gender):

        self.Name = name

        self.Age = age

        self.Gender = gender

    def aboutMe(self):

        print("저의 이름은 " + self.Name + "이구요, 제 나이는 " + self.Age + "살 입니다.")

         

class Employee(Person):

    def __init__(self, name, age, gender, salary, hiredate):

        Person.__init__(self, name, age, gender)

        self.Salary = salary

        self.Hiredate = hiredate

    def doWork(self):

        print("열심히 일을 합니다.")

    def aboutMe(self):

        Person.aboutMe(self)

        print("제 급여는 " + self.Salary + "원 이구요, 제 입사일은 " + self.Hiredate + " 입니다.")

 




17. 쓰레드 

Scala) 


scala> val hello = new Thread(new Runnable {

  def run() {

    println("hello world")

  }

})

hello: java.lang.Thread = Thread[Thread-3,5,main]


scala> hello.start

hello world 

------------------------------


import java.net.{Socket, ServerSocket}

import java.util.concurrent.{Executors, ExecutorService}

import java.util.Date


class NetworkService(port: Int, poolSize: Int) extends Runnable {

  val serverSocket = new ServerSocket(port)


  def run() {

    while (true) {

      // This will block until a connection comes in.

      val socket = serverSocket.accept()

      (new Handler(socket)).run()

    }

  }

}


class Handler(socket: Socket) extends Runnable {

  def message = (Thread.currentThread.getName() + "\n").getBytes


  def run() {

    socket.getOutputStream.write(message)

    socket.getOutputStream.close()

  }

}


(new NetworkService(2020, 2)).run


---------------------------------------


import java.net.{Socket, ServerSocket}

import java.util.concurrent.{Executors, ExecutorService}

import java.util.Date


class NetworkService(port: Int, poolSize: Int) extends Runnable {

  val serverSocket = new ServerSocket(port)

  val pool: ExecutorService = Executors.newFixedThreadPool(poolSize)


  def run() {

    try {

      while (true) {

        // This will block until a connection comes in.

        val socket = serverSocket.accept()

        pool.execute(new Handler(socket))

      }

    } finally {

      pool.shutdown()

    }

  }

}


class Handler(socket: Socket) extends Runnable {

  def message = (Thread.currentThread.getName() + "\n").getBytes


  def run() {

    socket.getOutputStream.write(message)

    socket.getOutputStream.close()

  }

}


(new NetworkService(2020, 2)).run



Python) 


from thread import start_new_thread


def heron(a):

    """Calculates the square root of a"""

    eps = 0.0000001

    old = 1

    new = 1

    while True:

        old,new = new, (new + a/new) / 2.0

        print old, new

        if abs(new - old) < eps:

            break

    return new


start_new_thread(heron,(99,))

start_new_thread(heron,(999,))

start_new_thread(heron,(1733,))


c = raw_input("Type something to quit.")


--------------------

import time

from threading import Thread


def sleeper(i):

    print "thread %d sleeps for 5 seconds" % i

    time.sleep(5)

    print "thread %d woke up" % i


for i in range(10):

    t = Thread(target=sleeper, args=(i,))

    t.start()


--------------------


class PrimeNumber(threading.Thread):

    prime_numbers = {} 

    lock = threading.Lock()

    

    def __init__(self, number): 

        threading.Thread.__init__(self) 

        self.Number = number

        PrimeNumber.lock.acquire() 

        PrimeNumber.prime_numbers[number] = "None" 

        PrimeNumber.lock.release() 

 

    def run(self): 

        counter = 2

        res = True

        while counter*counter < self.Number and res: 

            if self.Number % counter == 0: 

               res = False 

            counter += 1 

        PrimeNumber.lock.acquire() 

        PrimeNumber.prime_numbers[self.Number] = res 

        PrimeNumber.lock.release() 

threads = [] 

while True: 

    input = long(raw_input("number: ")) 

    if input < 1: 

        break 

 

    thread = PrimeNumber(input) 

    threads += [thread] 

    thread.start() 

 

for x in threads: 

    x.join()


18.  클로저  (외부의 변수에 자유로이 접근하라~) 


Scala) 


object Test {

   def main(args: Array[String]) {

      println( "muliplier(1) value = " +  multiplier(1) )

      println( "muliplier(2) value = " +  multiplier(2) )

   }

   var factor = 3

   val multiplier = (i:Int) => i * factor

}


C:/>scalac Test.scala

C:/>scala Test

muliplier(1) value = 3

muliplier(2) value = 6




19.  패턴 매칭  ( 스마트한 Switch 문 ) 


Scala) 

object Test {

   def main(args: Array[String]) {

      println(matchTest(3))


   }

   def matchTest(x: Int): String = x match {

      case 1 => "one"

      case 2 => "two"

      case _ => "many"

   }

}


C:/>scalac Test.scala

C:/>scala Test

many




20.  트레잇   ( 다중상속 가능 객체 , 공통적으로 사용되는 것들이 현실에 존재함..) 


Scala) 


 trait Equal {

  def isEqual(x: Any): Boolean

  def isNotEqual(x: Any): Boolean = !isEqual(x)

}


class Point(xc: Int, yc: Int) extends Equal {

  var x: Int = xc

  var y: Int = yc

  def isEqual(obj: Any) =

    obj.isInstanceOf[Point] &&

    obj.asInstanceOf[Point].x == x

}


object Test {

   def main(args: Array[String]) {

      val p1 = new Point(2, 3)

      val p2 = new Point(2, 4)

      val p3 = new Point(3, 3)


      println(p1.isNotEqual(p2))

      println(p1.isNotEqual(p3))

      println(p1.isNotEqual(2))

   }

}




21.  정규표현식 


Scala) 



import scala.util.matching.Regex


object Test {

   def main(args: Array[String]) {

      val pattern = new Regex("(S|s)cala")

      val str = "Scala is scalable and cool"

      

      println((pattern findAllIn str).mkString(","))

   }

}





Python) 


import re

programming = ["Python", "Perl", "PHP", "C++"]


pat = "^B|^P|i$|H$"


for lang in programming:

    

    if re.search(pat,lang,re.IGNORECASE):

        print lang , "FOUND"

    

    else:

        print lang, "NOT FOUND"



The output of above script will be:


Python FOUND

Perl FOUND

PHP FOUND

C++ NOT FOUND



22.  함수형 고계함수들


 Scala) 

val nums = List(1, 2, 3, 4, 5)

//map
val nums_map = nums.map(x => x * 10)
println(nums_map)//List(10, 20, 30, 40, 50)

//reduce
val nums_reduce = nums.reduce( _ + _ )
println(nums_reduce)//15

//filter
val nums_filter = nums.filter( x => x < 3)
println(nums_filter)//List(1, 2)

//fold
val nums_fold = nums.fold(1){ (sum , x) => sum + x}
println(nums_fold)//16

//group
val nums_trans = nums.groupBy(x => x < 3)
println(nums_trans) //Map(false -> List(3, 4, 5), true -> List(1, 2))


Python) 

nums = [1, 2, 3, 4, 5]


#map
nums_map = map(lambda x : x * 10, nums)
print(nums_map)

#reduce
nums_reduce = reduce(lambda x , y : x + y , nums)
print(nums_reduce)

#filter
nums_filter = filter(lambda x : x < 3 , nums)
print(nums_filter)

#fold
nums_fold = reduce(lambda x , y : x + y, nums, 1)
print(nums_fold)

#group
from itertools import groupby
for key, igroup in groupby(nums, lambda x: x < 3):
print key, list(igroup)

# True [1, 2]
# False [3, 4, 5]


0 Comments
댓글쓰기 폼