루비는 파이썬이 가지고 있지 않은 것과 그 반대의 것을 가지고 있습니까?

파이썬과 루비에 대한 많은 토론이 있으며, 모두 X가 왜 언어 Y를 빨아들이거나 언어 Y에 X가 없다고 주장하기 때문에 모두 도움이되지 않습니다. 실제로 그렇게합니다. 나는 왜 내가 왜 파이썬을 선호하는지 알고 있지만, 그것은 또한 주관적이며, 내가 선택한 것과 같은 맛을 가지고 있지 않을 수도 있기 때문에 아무도 선택하는 데 도움이되지 않습니다.

따라서 객관적으로 차이점을 나열하는 것이 흥미로울 것입니다. 그래서 "Python의 람다는 짜증나 지 않습니다". 대신 파이썬이 할 수없는 루비의 람다가 할 수있는 것을 설명하십시오. 주관성이 없습니다. 예제 코드가 좋습니다!

하나의 답변에 몇 가지 차이점이 없습니다. 그리고 당신이 알고있는 것을 올바른 것으로 투표하고, 당신이 알고있는 것을 부정하는 (또는 주관적인) 투표하십시오. 또한 구문의 차이는 흥미롭지 않습니다. 우리는 파이썬이 루비가 괄호와 끝으로하는 것을 들여 쓰는 것으로 알고 있으며, @는 파이썬에서 self라고 불립니다.

업데이트 : 이것은 이제 커뮤니티 위키이므로 큰 차이점을 여기에 추가 할 수 있습니다.

루비는 클래스 본문에 클래스 참조가 있습니다

Ruby에는 이미 클래스 본문에있는 클래스 (자체)에 대한 참조가 있습니다. 파이썬에서는 클래스 구성이 완료 될 때까지 클래스에 대한 참조가 없습니다.

예를 들면 :

class Kaka
  puts self
end

이 경우 self는 클래스이며이 코드는 "Kaka"를 인쇄합니다. 클래스 이름을 인쇄하거나 다른 방법으로 Python의 클래스 정의 본문에서 클래스에 액세스하는 방법은 없습니다 (메소드 정의 외부).

모든 클래스는 Ruby에서 변경 가능

이를 통해 핵심 클래스에 대한 확장을 개발할 수 있습니다. 레일 확장의 예는 다음과 같습니다.

class String
  def starts_with?(other)
    head = self[0, other.length]
    head == other
  end
end

파이썬 ( ''.startswith메소드 가 없다고 상상해보십시오 ) :

def starts_with(s, prefix):
    return s[:len(prefix)] == prefix

문자열뿐만 아니라 모든 시퀀스에서 사용할 수 있습니다. 사용하려면 명시 적으로 가져와야합니다 ( 예 :) from some_module import starts_with.

루비에는 펄 같은 스크립팅 기능이 있습니다

루비는 퍼스트 클래스 정규 표현식, $-변수, awk / perl 라인 별 입력 루프 및 텍스트 파일을 혼동 시키거나 다른 프로그램의 접착 코드로 작동하는 작은 쉘 스크립트 작성에 더 적합한 기타 기능을 제공합니다.

루비는 일류 연속을 가지고 있습니다

callcc 문에 감사합니다. 파이썬에서는 다양한 기술로 연속을 만들 수 있지만 언어에 대한 지원은 없습니다.

루비에는 블록이 있습니다

"do"문을 사용하면 Ruby에서 여러 줄 익명 함수를 작성할 수 있습니다.이 함수는 do 앞에있는 메소드에 인수로 전달되어 거기서 호출됩니다. 파이썬에서는 대신 메소드를 전달하거나 생성기를 사용 하여이 작업을 수행합니다.

루비:

amethod { |here|
    many=lines+of+code
    goes(here)
}

Python (루비 블록은 Python의 다른 구문에 해당) :

with amethod() as here: # `amethod() is a context manager
    many=lines+of+code
    goes(here)

또는

for here in amethod(): # `amethod()` is an iterable
    many=lines+of+code
    goes(here)

또는

def function(here):
    many=lines+of+code
    goes(here)

amethod(function)     # `function` is a callback

흥미롭게도, 루비에서 블록 호출에 대한 편의 문장을 "수율"이라고하며, 파이썬에서 생성기를 생성합니다.

루비:

def themethod
    yield 5
end

themethod do |foo|
    puts foo
end

파이썬 :

def themethod():
    yield 5

for foo in themethod():
    print foo

원칙은 다르지만 결과는 놀랍도록 비슷합니다.

루비는 기능적인 스타일 (파이프 같은) 프로그래밍을보다 쉽게 ​​지원합니다

myList.map(&:description).reject(&:empty?).join("\n")

파이썬 :

descriptions = (f.description() for f in mylist)
"\n".join(filter(len, descriptions))

파이썬에는 내장 생성기가 있습니다 (위에서 언급 한 것처럼 루비 블록처럼 사용됨)

파이썬은 언어로 생성기를 지원합니다. Ruby 1.8에서는 연속체를 사용하여 블록에서 생성기를 생성하는 생성기 모듈을 사용할 수 있습니다. 또는 block / proc / lambda를 사용할 수 있습니다! 또한, 루비 1.9 섬유이며, 발전기로서 사용될 수 있으며, 열거 클래스는 내장 발전기 (4)

docs.python.org 에는 다음 생성기 예제가 있습니다.

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

이것을 위의 블록 예제와 대조하십시오.

파이썬은 유연한 네임 스페이스 처리 기능을 가지고 있습니다

Ruby에서로 파일을 가져 오면 require해당 파일에 정의 된 모든 항목이 전역 네임 스페이스에있게됩니다. 네임 스페이스 오염이 발생합니다. 이에 대한 해결책은 Rubys 모듈입니다. 그러나 모듈로 네임 스페이스를 만드는 경우 포함 된 클래스에 액세스하려면 해당 네임 스페이스를 사용해야합니다.

Python에서 파일은 모듈이므로 포함 된 이름을로 가져 와서 from themodule import *원하는 경우 네임 스페이스를 오염시킬 수 있습니다. 그러나을 사용하여 선택한 이름 만 가져 오거나을 사용하여 from themodule import aname, another간단히 import themodule이름을 액세스 할 수도 있습니다 themodule.aname. 네임 스페이스에서 더 많은 레벨을 원한다면 모듈과 __init__.py파일 이있는 디렉토리 인 패키지를 가질 수 있습니다 .

파이썬에는 docstring이 있습니다

독 스트링은 모듈, 함수 및 메소드에 첨부 된 문자열이며 런타임에 검사 할 수 있습니다. 이것은 help 명령 및 자동 문서와 같은 것을 작성하는 데 도움이됩니다.

def frobnicate(bar):
    """frobnicate takes a bar and frobnicates it

       >>> bar = Bar()
       >>> bar.is_frobnicated()
       False
       >>> frobnicate(bar)
       >>> bar.is_frobnicated()
       True
    """

루비의 동등한 기능은 javadocs와 유사하며 메소드 대신 메소드 위에 있습니다. 1.9의 Method # source_location 예제 사용을 사용 하여 파일에서 런타임시 검색 할 수 있습니다.

파이썬에는 여러 상속이 있습니다

루비는 그렇지 않습니다 ( "의도적"입니다-루비의 웹 사이트를 참조하십시오 . 루비에서 어떻게되는지 살펴보십시오 ). 모듈 개념을 추상 클래스의 유형으로 재사용합니다.

파이썬에는 목록 / dict 이해력이 있습니다

파이썬 :

res = [x*x for x in range(1, 10)]

루비:

res = (0..9).map { |x| x * x }

파이썬 :

>>> (x*x for x in range(10))
<generator object <genexpr> at 0xb7c1ccd4>
>>> list(_)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

루비:

p = proc { |x| x * x }
(0..9).map(&p)

파이썬 2.7+ :

>>> {x:str(y*y) for x,y in {1:2, 3:4}.items()}
{1: '4', 3: '16'}

루비:

>> Hash[{1=>2, 3=>4}.map{|x,y| [x,(y*y).to_s]}]
=> {1=>"4", 3=>"16"}

파이썬에는 데코레이터가 있습니다

데코레이터와 비슷한 것들도 루비로 만들 수 있으며 파이썬만큼 필요하지 않다고 주장 할 수도 있습니다.

구문 차이

Ruby는 모든 범위를 닫으려면 "end"또는 "}"가 필요하지만 Python은 공백 만 사용합니다. 공백 만 들여 쓰기를 허용하려는 루비의 최근 시도가 있습니다 http://github.com/michaeledgar/seamless

루비는 블록 개념을 가지고 있는데, 이것은 코드 섹션 주위에 본질적으로 구문 설탕이다. 그것들은 클로저를 만들고 블록을 사용하거나 사용하지 않을 수있는 다른 방법으로 전달하는 방법입니다. 블록은 나중에 yield명령문 을 통해 호출 할 수 있습니다 .

예를 들어, each메소드 의 간단한 정의는 Array다음과 같습니다.

class Array
  def each
    for i in self  
      yield(i)     # If a block has been passed, control will be passed here.
    end  
  end  
end  

그런 다음 다음과 같이 호출 할 수 있습니다.

# Add five to each element.
[1, 2, 3, 4].each{ |e| puts e + 5 }
> [6, 7, 8, 9]

파이썬에는 익명의 함수 / 클로저 / 람다가 있지만 유용한 구문 설탕이 없기 때문에 블록이 없습니다. 그러나 임시 방식으로 가져 오는 방법은 최소한 하나 이상 있습니다. 예를 들어 here 참조 하십시오 .

파이썬 예제

함수는 파이썬에서 일류 변수입니다. 함수를 선언하고 객체로 전달한 다음 덮어 쓸 수 있습니다.

def func(): print "hello"
def another_func(f): f()
another_func(func)

def func2(): print "goodbye"
func = func2

이것은 현대 스크립팅 언어의 기본 기능입니다. JavaScript와 Lua도이 작업을 수행합니다. 루비는 이런 식으로 함수를 다루지 않습니다. 함수의 이름을 지정하면 호출됩니다.

물론 루비에서는 이러한 작업을 수행 할 수있는 방법이 있지만 일류 작업은 아닙니다. 예를 들어, Proc.new로 함수를 감싸서 변수로 취급 할 수 있지만 더 이상 함수가 아닙니다. "call"메소드가있는 객체입니다.

루비의 기능은 일류 객체가 아닙니다

루비 함수는 일류 객체가 아닙니다. 함수는 객체를 감싸서 감싸 야합니다. 결과 객체는 함수처럼 취급 될 수 없습니다. 기능은 일류 방식으로 할당 될 수 없습니다. 대신 컨테이너 개체의 함수를 호출하여 함수를 수정해야합니다.

def func; p "Hello" end
def another_func(f); method(f)[] end
another_func(:func)      # => "Hello"

def func2; print "Goodbye!"
self.class.send(:define_method, :func, method(:func2))
func                     # => "Goodbye!"

method(:func).owner      # => Object
func                     # => "Goodbye!"
self.func                # => "Goodbye!"    

궁극적으로 모든 답변은 어느 수준에서 주관적이며, 지금까지 게시 된 답변은 다른 언어로는 불가능한 기능 중 하나를 똑같이 좋은 (유사하지 않은 경우) 표현할 수 없음을 거의 증명합니다. 두 언어 모두 매우 간결하고 표현력이 뛰어 나기 때문입니다.

나는 파이썬의 문법을 좋아한다. 그러나 루비의 진정한 아름다움을 찾으려면 구문보다 약간 더 깊이 파고 들어야합니다. 루비의 일관성에는 선과 같은 아름다움이 있습니다. 사소한 예는 이것을 완벽하게 설명 할 수는 없지만, 여기서 의미하는 바를 설명하기 위해 하나를 생각해 보겠습니다.

이 문자열의 단어를 바꾸십시오.

sentence = "backwards is sentence This"

어떻게 할 것인지 생각할 때 다음을 수행하십시오.

1. 문장을 단어로 나눕니다.
2. 단어를 반대로
3. 단어를 다시 문자열로 다시 결합

루비에서는 이렇게 할 것입니다 :

sentence.split.reverse.join ' '

당신이 그것에 대해 생각 한대로, 같은 순서로 한 메소드가 다른 메소드를 호출합니다.

파이썬에서는 다음과 같이 보일 것입니다.

" ".join(reversed(sentence.split()))

이해하기는 어렵지만 흐름이 다릅니다. 주제 (문장)가 중간에 묻혀 있습니다. 작업은 기능과 객체 방법이 혼합되어 있습니다. 이것은 사소한 예이지만, 특히 사소하지 않은 작업에 대해 Ruby를 실제로 사용하고 이해하는 경우 다양한 예를 발견합니다.

파이썬은 "우리는 모두 성인입니다"라는 사고 방식을 가지고 있습니다. 따라서 루비에는 상수와 같은 것이 있지만 파이썬에는 그렇지 않습니다 (루비의 상수는 경고 만 발생하지만). 파이썬의 사고 방식은 무언가를 일정하게 만들고 싶다면 모든 대문자로 변수 이름을 넣고 변경하지 않아야한다는 것입니다.

예를 들어, Ruby :

>> PI = 3.14
=> 3.14
>> PI += 1
(irb):2: warning: already initialized constant PI
=> 4.14

파이썬 :

>>> PI = 3.14
>>> PI += 1
>>> PI
4.1400000000000006

Python의 모듈에서 특정 함수 만 가져올 수 있습니다. Ruby에서는 전체 메소드 목록을 가져옵니다. 루비로 "가져 오기"를 할 수는 있지만 그게 전부가 아닙니다.

편집하다:

이 Ruby 모듈을 보자 :

module Whatever
  def method1
  end

  def method2
  end
end

코드에 포함하면 :

include Whatever

당신은 둘 것을 볼 수 있습니다 방법 항목 과 방법 2는 네임 스페이스에 추가되었습니다. method1 만 가져올 수 없습니다 . 둘 다 가져 오거나 전혀 가져 오지 않습니다. 파이썬에서는 선택한 방법 만 가져올 수 있습니다. 이것이 이름을 가질 수 있다면 선택적 가져 오기라고 할 수 있습니까?

Ruby의 웹 사이트에서 :

파이썬과 마찬가지로, 루비에서는 ...

• 대화식 프롬프트 (irb라고 함)가 있습니다.
• 명령 행에서 문서를 읽을 수 있습니다 (pydoc 대신 ri 명령 사용).
• 특수 줄 종결자가 없습니다 (일반적인 줄 바꿈 제외).
• 문자열 리터럴은 파이썬의 삼중 인용 문자열과 같은 여러 줄에 걸쳐있을 수 있습니다.
• 대괄호는 목록 용이고 중괄호는 dicts 용입니다 (Ruby에서는 "해시"라고 함).
• 배열은 동일하게 작동합니다 (추가하면 하나의 긴 배열이되지만 이와 같이 구성 a3 = [ a1, a2 ]하면 배열 배열이됩니다).
• 개체는 강력하고 동적으로 형식이 지정됩니다.
• 모든 것은 객체이며 변수는 객체에 대한 참조 일뿐입니다.
• 키워드는 약간 다르지만 예외는 거의 동일합니다.
• 내장 된 문서 도구가 있습니다 (Ruby는 rdoc이라고 함).

루비에서는 파이썬과 달리 ...

• 문자열은 변경 가능합니다.
• 상수 (값을 변경하지 않으려는 변수)를 만들 수 있습니다.
• 대소 문자를 강제로 적용합니다 (예 : 클래스 이름은 대문자로 시작하고 변수는 소문자로 시작).
• 한 종류의 목록 컨테이너 (배열) 만 있으며 변경할 수 있습니다.
• 큰 따옴표로 묶인 문자열은 이스케이프 시퀀스 (예 : \ t) 및 특수한 "식 대체"구문을 허용합니다 ( "+"문자열 "+"함께 "를 추가하지 않고도 루비 식의 결과를 다른 문자열에 직접 삽입 할 수 있습니다) . 작은 따옴표로 묶인 문자열은 파이썬의 "원시 문자열"과 같습니다.
• "새로운 스타일"과 "이전 스타일"클래스는 없습니다. 딱 한 종류 야
• 속성에 직접 액세스하지 마십시오. Ruby에서는 모든 메소드 호출입니다.
• 메소드 호출의 괄호는 일반적으로 선택 사항입니다.
• 파이썬 대신 공개, 비공개 및 보호 액세스가 적용됩니다. _voluntary_ underscore __convention__ 있습니다.
• 다중 상속 대신 "mixin 's"가 사용됩니다.
• 내장 클래스의 메소드를 추가하거나 수정할 수 있습니다. 두 언어를 사용하면 언제든지 클래스를 열고 수정할 수 있지만 Python은 내장 기능의 수정을 방지합니다.
• True 및 False 대신 true 및 false가 있으며 None 대신 nil이 있습니다.
• 진실을 테스트 할 때, 거짓과 무만이 거짓 값으로 평가됩니다. 그 밖의 모든 것은 사실입니다 (0, 0.0, ""및 [] 포함).
• elif 대신 elsif입니다.
• 가져 오기 대신 필요합니다. 그렇지 않으면 사용법은 동일합니다.
• 위의 줄에 대한 일반적인 스타일 주석 (아래의 문서 문자열 대신)은 문서를 생성하는 데 사용됩니다.
• 기억해야 할 것은 많지만 빨리 배울 수있는 여러 가지 단축키가 있습니다. 그들은 루비를 재미 있고 생산적으로 만드는 경향이 있습니다.

루비가 파이썬보다 가지고있는 것은 스크립팅 언어 기능입니다. 이 컨텍스트에서 스크립팅 언어는 쉘 스크립트 및 일반 텍스트 조작에서 "접착제 코드"에 사용됩니다.

이들은 대부분 Perl과 공유됩니다. 퍼스트 클래스 내장 정규 표현식, $ -Variables, Perl (-a, -e) 등과 같은 유용한 명령 행 옵션

간결하면서도 간결한 구문과 함께 이러한 종류의 작업에 적합합니다.

Python to me는 배우기 쉽고 구문이 깔끔한 동적 유형 비즈니스 언어에 가깝습니다. 루비처럼 "쿨"한 것이 아니라 깔끔합니다. 파이썬이 루비를 능가하는 것은 다른 라이브러리에 대한 수많은 바인딩입니다. Qt 및 기타 GUI 라이브러리에 바인딩, 많은 게임 지원 라이브러리 및 및. 루비는 훨씬 적습니다. 예를 들어 데이터베이스에 많이 사용되는 바인딩은 품질이 좋지만 동일한 라이브러리에 대해 Ruby 바인딩이 있어도 틈새 라이브러리가 Python에서 더 잘 지원되는 것으로 나타났습니다.

따라서 두 언어 모두 사용되며 사용할 언어를 정의하는 작업입니다. 둘 다 배우기 쉽습니다. 나는 나란히 사용합니다. 스크립팅 용 Ruby 및 독립형 앱용 Python

"루비에는 X가 있고 파이썬에는 없지만, 파이썬에는 Y가 있고 루비에는 없습니다"가 가장 유용한 방법이라고 생각하지 않습니다. 그것들은 많은 공유 능력을 가진 상당히 유사한 언어입니다.

대부분의 차이점은 언어가 우아하고 읽기 쉬운 것입니다. 제기 한 예제를 사용하려면 이론적으로 람다가 있지만 파이썬 프로그래머는 람다를 피하는 경향이 있으며,이를 사용하여 만든 구문은 루비처럼 읽을 수 있거나 관용적이지 않습니다. 그래서 파이썬에서, 좋은 프로그래머는 실제로해서 문제 그는 루비에서와 이상을 해결하는 다른 경로를 취할하기를 원할 것 입니다 그것을 할 수있는 더 좋은 방법.

"루비는 파이썬이 가지고 있지 않은 것과 그 반대의 경우는 무엇입니까?"라는 원래 질문의 변형을 제안하고 싶습니다. "Intercal에서는 할 수없는 Ruby 나 Python으로 무엇을 할 수 있습니까?"라는 실망스러운 대답을 인정합니다. 파이썬과 루비는 모두 튜링 근사한 왕좌에 앉아있는 거대한 왕실의 일부이기 때문에 그 수준에는 아무것도 없습니다.

그러나 이것에 대해서는 :

그러한 아름다움과 훌륭한 공학으로 루비에서 할 수없는, 파이썬에서 우아하고 잘 할 수있는 일은 무엇입니까?

단순한 기능 비교보다 훨씬 흥미로울 수 있습니다.

파이썬에는 목록 이해와 생성기를위한 명시적이고 내장 된 구문이 있지만 Ruby에서는 맵과 코드 블록을 사용합니다.

비교

list = [ x*x for x in range(1, 10) ]

에

res = (1..10).map{ |x| x*x }

"대문자로 시작하는 변수는 상수가되고 수정할 수 없습니다"

잘못된. 그들은 할 수있다.

당신이 할 경우에만 경고가 나타납니다.

인프라 측면에서 약간 더 :

• Python은 Ruby보다 C ++과 Boost (Python , SIP 및 Py ++ 등을 통해)와의 통합이 훨씬 뛰어납니다 . 여기서 옵션은 Ruby 인터프리터 API에 대해 직접 작성하는 것 같습니다 (물론 Python으로도 가능함). 그러나 두 경우 모두 저수준, 지루하고 오류가 발생하기 쉬운) 또는 SWIG를 사용하거나 (많은 언어를 지원하려는 경우 작동하고 확실히 훌륭하지만 Boost.Python 또는 SIP만큼 좋지 않습니다. 특히 C ++을 바인딩하려고합니다.

• 파이썬은 많은 웹 애플리케이션 환경 (Django, Pylons / Turbogears, web.py, 아마도 적어도 6 가지 이상)을 가지고있는 반면 Ruby는 (실제로) 하나를 가지고 있습니다 : Rails. (다른 Ruby 웹 프레임 워크는 존재하지만 Rails에 대한 견인력을 얻는 데 어려움을 겪고있는 것 같습니다). 이면이 좋습니까 나쁘습니까? 말하기 어려우며 아마도 주관적 일 것입니다. 파이썬 상황이 더 좋고 루비 상황이 더 좋다는 주장을 쉽게 상상할 수 있습니다.

• 문화적으로 파이썬과 루비 커뮤니티는 다소 다르게 보이지만 루비 커뮤니티와 상호 작용 한 경험이 많지 않기 때문에 이것에 대해서만 힌트를 줄 수 있습니다. 나는 이것을 둘 다 경험이 많은 사람 이이 진술을 증폭 (또는 거부) 할 수 있기를 바랍니다.

_{뻔뻔스럽게 복사 / 붙여 넣기 : Alex Martelli 는 comp.lang.python 메일 링리스트의 " Python보다 Ruby에 더 좋은 점 "에 대한 답변입니다 .}

2003 년 8 월 18 일 오전 10시 50 분 Erik Max Francis는 다음과 같이 썼습니다.

"Brandon J. Van Every"는 다음과 같이 썼습니다.

파이썬보다 루비가 더 좋은 점은 무엇입니까? 뭔가 있다고 확신합니다. 무엇입니까?

파이썬 사람들이 아니라 루비 사람들에게 물어 보는 것이 훨씬 더 합리적이지 않습니까?

예를 들어, 자신의 목적에 파이썬 커뮤니티의 "사회 학적 연구"가 포함되어 있다면, 그 커뮤니티에 질문을하는 것이 다른 곳에 두는 것보다 그에 대한 정보가 더 많이 드러날 가능성이 높습니다. :-).

개인적으로, 나는 마지막 OSCON에서 Dave Thomas의 하루 루비 튜토리얼을 따라갈 수있는 기회를 기쁘게 생각했습니다. 구문 차이의 얇은 베니어 아래에서 Ruby와 Python이 놀랍게 유사하다는 것을 알았습니다. 어떤 언어 집합 중에서도 최소 스패닝 트리를 계산하는 경우 Python과 Ruby가 처음으로 통합되는 두 잎이 될 것입니다. 중간 노드 :-).

물론 루비에서는 각 블록의 끝에 들여 쓰기가 아닌 바보 같은 "끝"을 입력하는 것에 지치지 않지만 파이썬이 필요로하는 똑같이 바보 같은 ':'를 입력하지 않아도됩니다. 각 블록 의 시작 이므로 거의 씻습니다 :-). '@foo'대 'self.foo'와 같은 다른 구문 차이 또는 Ruby vs Python에서 대소 문자의 중요성은 실제로 나에게 거의 관련이 없습니다.

다른 사람들은 의심 할 여지없이 그러한 문제에 기초하여 프로그래밍 언어를 선택하고 가장 인기있는 논쟁을 일으킨다. 그러나 그것은 파킨슨의 법칙 중 하나에 불과하다. 실제 중요성).

편집하다 (AM 6/19/2010 11:45) : 이것은 "자전거 페인트 칠"(또는 짧게는 "자전거 흘리기"라고도 함)이라고도합니다. "사소한 주제에 대한 뜨거운 논쟁"의 전형적인 예인 자전거를 칠할 색상에 대한 (편집 끝).

내가 중요하게 생각하는 파이썬의 한 가지 차이점은 파이썬이 선호하는 것입니다. 그러나 다른 사람들은 그 반대의 생각을 할 것입니다. 파이썬 (C에서와 같이)에서 함수를 호출하려면 항상 "호출 연산자"(호출 개체 뒤에 바로 괄호)를 적용하십시오. 인수를 전달하지 않으면 괄호가 비어 있습니다). 이것은 단순한 언급을 남깁니다. 하나를특정 상황, 예외, 특별 규칙 등이없는 상황에서 객체에 대한 참조를 의미하는 것으로서 연산자가없는 객체. Ruby에서 (파스칼에서와 같이) 인수를 사용하여 함수를 호출하려면 인수를 전달합니다 (일반적으로 괄호로 묶음은 아니지만) 이것은 많은 사람들의 기대를 충족시킬 수 있습니다 (적어도, 과거 프로그래밍 경험이 파스칼이나 Visual Basic과 같은 유사한 "암시 적 호출"을 가진 다른 언어를 사용했던 사람들). 단순히 객체에 대한 언급은 객체의 유형에 따라 객체에 대한 참조 또는 객체에 대한 호출을 의미 할 수 있습니다. t 단순히 언급 만하여 객체에 대한 참조를 얻습니다. 명시적인 "이것에 대한 참조를 줘, 전화하지 마십시오!"를 사용해야합니다. 달리 필요하지 않은 연산자. 나는 이것이 함수 (또는 메소드, 또는 다른 호출 가능한 객체)의 "일등성"과 객체를 부드럽게 교환 할 수있는 가능성에 영향을 준다고 생각합니다. 따라서 나 에게이 특정 구문 차이는 Ruby에 대한 심각한 검은 표시입니다.하지만 다른 사람들이 왜 더 격렬하게 동의하지 않더라도 다른 사람들이 그렇지 않을지를 이해합니다. 함수 (또는 메소드 또는 다른 호출 가능한 객체) 및 객체를 부드럽게 교환 할 수있는 가능성. 따라서 나 에게이 특정 구문 차이는 Ruby에 대한 심각한 검은 표시입니다.하지만 다른 사람들이 왜 더 격렬하게 동의하지 않더라도 다른 사람들이 그렇지 않을지를 이해합니다. 함수 (또는 메소드 또는 다른 호출 가능한 객체) 및 객체를 부드럽게 교환 할 수있는 가능성. 따라서 나 에게이 특정 구문 차이는 Ruby에 대한 심각한 검은 표시입니다.하지만 다른 사람들이 왜 더 격렬하게 동의하지 않더라도 다른 사람들이 그렇지 않을지를 이해합니다.

문법 아래에서 우리는 기본 의미론에서 몇 가지 중요한 차이점을 발견합니다. 다시 말하지만, 이미 익숙한 것으로 주로 판단하는 사람들은 이것이 Java의 장점이라고 생각할 수 있습니다 (물론 Java 또는 C #에 익숙하지 않은 경우 :-). 필자는 불변의 문자열이 훌륭한 아이디어라고 생각합니다. (Java가 독립적으로 이미 파이썬에 있던 아이디어를 재창조했다고 생각하지는 않습니다.) (그리고 Java 자체의 "문자열 버퍼"보다 사용하기 쉬운 것이 이상적임); Java에 대해 공부하기 전에 친숙 함으로 인해이 판단을 내리지 않습니다. 모든 데이터는 불변입니다. 알고있는 모든 언어에는 가변 문자열이 있습니다. 그러나 Java에서 불변 문자열 아이디어를 처음 보았을 때 (파이썬을 배우기 전에 잘 배웠습니다) 즉시 뛰어난 우수성에 적합했습니다. 고급 프로그래밍 언어의 참조 의미론 (기계에 더 가까운 언어, C와 같은 응용 프로그램과는 다른 언어에 가장 적합한 값 의미론과는 대조적으로), 일류의 내장 문자열 (예 : 결정적) 데이터 유형.

루비는 기본 시맨틱에 몇 가지 장점이 있습니다. 예를 들어, 파이썬의 "리스트 대 튜플"을 제거하면 미묘한 차이가 있습니다. 그러나 대부분 점수는 (단순하게도 큰 플러스와 미묘하고 영리한 구별은 눈에 띄는 마이너스로) 루비에 대한 것입니다 (예 : 폐쇄 및 반 개방 간격, a..b 및 a. .B [누구가 있다고 주장하고자 분명 , 바보 -?)하는 인] -! 이럴 물론). 다시 말하지만, 언어의 핵심에서 유사하지만 미묘하게 다른 많은 것들을 마이너스가 아닌 플러스로 생각하는 사람들은 물론 내가 세는 방법에서 이러한 "다른 방법으로"를 계산할 것입니다.

이 두 언어가 매우다른, 당신을 염두에 두십시오. 그렇지 않습니다. 그러나 "capelli d' angelo"와 "spaghettini"를 비교하라는 요청을 받으면,이 두 종류의 파스타는 다른 사람과 구별 할 수없고 당신이 준비하고 싶은 접시에서 서로 바꿔 먹을 수 있다는 점을 지적한 후에 필연적으로 길이와 지름이 눈에 띄지 않게 어떻게 다른지, 가닥의 끝이 다른 경우가 아닌 테이퍼지는 방식 등의 현미경 검사로 이동하는 이유-개인적으로 카펠 리가있는 이유를 시도하고 설명하기 위해 '모든 종류의 국물에 파스타로 안젤로이지만 파스타와 같은 스파게티를 선호합니다. 오래된 얇은 파스타 형태 (올리브 오일, 다진 마늘, 다진 고추, 잘게 썬 멸치, 예를 들어-마늘과 후추를 얇게 썰지 않고 얇게 썰어 놓으면 스파게티 니의 더 얇은 소멸 대신 스파게티의 건강한 몸을 선택해야하며, 멸치를 버리고 신선한 봄 바질을 추가하는 것이 좋습니다. 또는 심지어-나는 이단자입니다 ...! -라이트 민트 ...] 잎-접시를 제공하기 전에 마지막 순간에). 죄송합니다. 해외 여행 중이며 잠시 파스타를 먹지 않은 것으로 나타났습니다. 그러나 비유는 여전히 꽤 좋습니다!-) -라이트 민트 ...] 잎-접시를 제공하기 전에 마지막 순간에). 죄송합니다. 해외 여행 중이며 잠시 파스타를 먹지 않은 것으로 나타났습니다. 그러나 비유는 여전히 꽤 좋습니다!-) -라이트 민트 ...] 잎-접시를 제공하기 전에 마지막 순간에). 죄송합니다. 해외 여행 중이며 잠시 파스타를 먹지 않은 것으로 나타났습니다. 그러나 비유는 여전히 꽤 좋습니다!-)

그래서 파이썬과 루비로 돌아가서 우리는 두 가지 큰 문제를 겪습니다 (언어의 관점에서-라이브러리를 떠나고 도구 및 환경과 같은 다른 중요한 보조 도구, 각 언어를 포함 / 확장하는 방법 등) 지금은-어쨌든 각 언어의 모든 구현에 적용되지는 않습니다 (예 : Jython vs Classic Python은 Python 언어의 두 가지 구현입니다!) :

1. 루비의 이터레이터와 코드 블록 대 파이썬의 이터레이터와 생성기;

2. 
   모든 내장 클래스를 포함하여 기존 클래스를 "재 개설"하고 런타임에 동작을 변경 하는 기능 을 포함하여 Ruby의 TOTAL, 무제한 "동 적성"( 파이썬의 방대하지만 제한된 동 적성) 내장 클래스 및 해당 인스턴스

개인적으로, 나는 1 번의 세탁을 고려 합니다 (차이가 너무 깊어서 다른 사람들이 접근하고 다른 것을 수정하는 것을 쉽게 볼 수 있었지만, 개인적으로는 플러스와 마이너스가 거의 균등 함). 그리고 2 중요한 문제-루비를 "팅킹"에 훨씬 더 적합하게 만들지 만, 파이썬은 대규모 프로덕션 응용 프로그램에 사용하기에 더 적합합니다. 두 언어가 대부분의 다른 언어보다 훨씬 역동적이므로 결국 내 POV와의 주요 차이점이 그에 달려 있어야합니다. 루비는 이와 관련하여 "11"이됩니다. 여기는 물론 "Spinal Tap"입니다. 루비에서나는 할 수있다 ! 즉, 내장 문자열 클래스를 동적으로 변경하여 a = "Hello World"b = "hello world"a == b print "equal! \ n"또는 "different! \ n"end WILL print " 같은". 파이썬에서는 내가 할 수있는 방법이 없습니다. 메타 프로그래밍의 목적, 실험 프레임 워크를 구현하는 등의 경우, 루비의 놀라운 동적 능력은 매우 정치. 그러나 우리가 많은 사람들이 개발하고 다양한 소스의 모든 종류의 라이브러리를 포함하여 더 많은 사람들이 유지 관리하고 클라이언트 사이트에서 프로덕션에 들어가야하는 대규모 응용 프로그램에 대해 이야기하고 있다면 ... 매우 역동적 인 언어, 대단히 감사합니다. 나는 어떤 라이브러리가 자신의 문자열에 의존하는 다른 관련되지 않은 다른 라이브러리를 무의식적으로 깨뜨리는 아이디어를 싫어합니다. 대규모 프로그래밍. 모든 모듈이 다른 "비밀하게"의 동작에 영향을 주도록함으로써 내장 유형의 의미를 변경하는 기능은 프로덕션 응용 프로그램 프로그래밍에 대한 나쁜 아이디어 일뿐입니다.

그러한 대규모 응용 프로그램에 Ruby를 사용해야한다면 코딩 스타일 제한, 많은 테스트 (모든 것이 변경 될 때마다 다시 실행되어야 함-전혀 관련이없는 것 등)에 의존하려고합니다. 이 언어 기능의 사용을 금지합니다. 그러나 처음에는 기능을 갖지 않는 것이 더 좋습니다. 제 생각에 특정 수의 내장 기능이 "네일 다운"될 수 있다면 파이썬 자체가 응용 프로그램 프로그래밍을위한 더 나은 언어가 될 것입니다. 예를 들어 len ( "ciao")은 4입니다 ( 내장 모듈 에서 'len'이라는 이름의 바인딩을 누군가가 변경했는지 여부에 대해 걱정하지 않아도됩니다 ). 결국 파이썬이 내장 기능을 "네일 다운"하기를 바랍니다.

그러나 내장 리 바인드 리 바인딩은 더 이상 사용되지 않으며 파이썬에서 드문 연습이므로 문제는 사소합니다. Ruby에서는 다른 언어 의 너무 강력한 매크로 기능 (예 : Dylan과 같은)이 비슷한 위험을 내 자신의 견해로 제시하는 것처럼 나를 주요하게 생각합니다 (Python이 강력한 매크로 시스템을 얻지 않기를 바랍니다. "사람들에게 언어 자체에 포함 된 도메인 고유의 작은 언어를 정의하게하는 것"의 매력과 상관없이 IMHO는 응용 프로그램 프로그래밍에 파이썬의 훌륭한 유용성을 손상시킬 것입니다. 모든 프로그래머의 마음에 숨어 있습니다 ...).

알렉스

다른 사람 :

http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-python/

(해당 페이지가 업데이트 된 후 루비 측에서 잘못 해석되었거나 변경된 부분이 있으면 누군가가 자유롭게 편집하십시오 ...)

문자열은 파이썬이 아닌 루비에서 변경할 수 있습니다 (새 문자열은 "변경"에 의해 생성됩니다).

루비에는 강제적 인 케이스 규칙이 있지만 파이썬은 그렇지 않습니다.

파이썬에는리스트와 튜플 (불변리스트)이 있습니다. 루비에는 파이썬리스트에 해당하는 배열이 있지만, 불변의 변형은 없습니다.

Python에서는 객체 속성에 직접 액세스 할 수 있습니다. 루비에서는 항상 메서드를 사용합니다.

루비에서 메소드 호출에 대한 괄호는 일반적으로 선택적이지만 파이썬에서는 아닙니다.

Ruby는 밑줄과 이름 맹 글링을 사용하는 Python의 규칙 대신 공개, 개인 및 보호를 통해 액세스를 강제합니다.

파이썬에는 여러 상속이 있습니다. 루비에는 "mixins"가 있습니다.

그리고 또 다른 관련 링크 :

http://c2.com/cgi/wiki?PythonVsRuby

특히 Alex Martelli의 또 다른 좋은 링크로 연결 되어 있으며 여기에 많은 훌륭한 자료를 게시했습니다.

http://groups.google.com/group/comp.lang.python/msg/028422d707512283

확실하지 않으므로 먼저 답변으로 추가하십시오.

파이썬은 언 바운드 메소드를 함수로 취급합니다

즉, theobject.themethod()또는 에서처럼 메소드를 호출 할 수 있습니다 TheClass.themethod(anobject).

편집 : 메소드와 함수의 차이는 Python에서는 작고 Python 3에서는 존재하지 않지만 Ruby에는 함수가 없기 때문에 Ruby에도 존재하지 않습니다. 함수를 정의 할 때 실제로 Object에 메소드를 정의합니다.

그러나 여전히 한 클래스의 메소드를 함수로 호출 할 수 없으므로 호출하려는 객체에 리 바인드해야합니다. 이는 훨씬 더 모호합니다.

하나의 객체 대 속성 "통신"을 사용자 정의 할 수있는 Python 설명자 API에 대해 언급하고 싶습니다. 또한 파이썬에서는 __getattribute__메소드 의 기본 구현을 통해 주어진 기본값을 재정 의하여 대체 프로토콜을 자유롭게 구현할 수 있습니다. 위에서 언급 한 것에 대해 더 자세히 설명하겠습니다. 기술자는 정기적으로 클래스입니다 __get__, __set__및 / 또는 __delete__방법. 인터프리터가 다음과 같은 것을 만나면 anObj.anAttr다음이 수행됩니다.

• __getattribute__의 메소드 anObj가 호출됩니다
• __getattribute__ 클래스 dict에서 Attr 객체를 검색합니다.
• 그것은 abAttr 오브젝트가 있는지 여부를 확인하여 __get__, __set__또는 __delete__호출 개체
• 컨텍스트 (즉, setter가있는 경우 후자 대신 호출자 객체 또는 클래스 및 값)가 호출 가능 객체로 전달됩니다.
• 결과가 반환됩니다.

언급했듯이 이것이 기본 동작입니다. 다시 구현하여 프로토콜을 자유롭게 변경할 수 있습니다 __getattribute__.

이 기술은 데코레이터보다 훨씬 강력합니다.

Ruby는을 사용하여 연속 지원을 내장하고 callcc있습니다.

따라서 amb-operator 와 같은 멋진 것을 구현할 수 있습니다

이 단계에서 파이썬은 여전히 ​​더 나은 유니 코드 지원을 제공합니다

파이썬에는 docstring이 있고 루비는 그렇지 않습니다 ... 그렇지 않으면 파이썬처럼 쉽게 액세스 할 수 없습니다.

추신. 메신저가 틀렸다면 예를 들어주세요. 클래스에 쉽게 몽키 패치 할 수있는 해결 방법이 있지만 "네이티브 방식"의 docstring 기능을 갖고 싶습니다.

루비는 커맨드 라인에서 입력 파일 ( '-n'플래그)에 대해 라인 별 루프를 가지므로 AWK처럼 사용할 수 있습니다. 이 루비 원 라이너 :

ruby -ne 'END {puts $.}'

AWK 원 라이너와 같은 라인을 계산합니다.

awk 'END{print NR}'

Ruby는 Perl을 통해이 기능을 제공받습니다.이 기능은 AWK에서 시스템 관리자가 Perl과 함께 작업 방식을 변경하지 않고 보드에 올리는 방법으로 가져 왔습니다.

루비에는시길과 잔가지가 있지만 파이썬에는 없습니다.

편집 : 그리고 내가 잊어 버린 매우 중요한 것 (결국 이전은 약간 :-p)이었습니다.

파이썬에는 JIT 컴파일러 ( Psyco )가 있으며, 더 빠른 코드 ( Pyrex ) 를 작성하기위한 눈에 띄게 낮은 언어이며 인라인 C ++ 코드 ( Weave ) 를 추가 할 수 있습니다 .

내 파이썬은 녹슬 었으므로 일부는 파이썬에있을 수 있으며 처음에는 기억하지 못합니다. 그러나 처음 생각한 것은 다음과 같습니다.

공백

루비는 공백을 완전히 다르게 처리합니다. 우선, 들여 쓰기를 할 필요가 없습니다 (즉, 4 개의 공백이나 1 개의 탭을 사용하더라도 상관 없습니다). 또한 스마트 라인 연속 기능을 수행하므로 다음이 유효합니다.

def foo(bar,
        cow)

기본적으로 연산자로 끝내면 무슨 일이 일어나고 있는지 파악합니다.

믹스 인

루비에는 전체 클래스 대신 인스턴스를 확장 할 수있는 믹스 인이 있습니다.

module Humor
  def tickle
    "hee, hee!"
  end
end
a = "Grouchy"
a.extend Humor
a.tickle    »   "hee, hee!"

열거 형

이것이 제너레이터와 같은지 확실하지 않지만 Ruby 1.9 루비에서는 열거 형이므로

>> enum = (1..4).to_enum
=> #<Enumerator:0x1344a8>

참고: http://blog.nuclearsquid.com/writings/ruby-1-9-what-s-new-what-s-changed

"키워드 인수"

여기에 나열된 두 항목 모두 Ruby에서 지원되지만 기본값을 건너 뛸 수는 없습니다. 당신은 순서대로 갈 수 있습니다

def foo(a, b=2, c=3)
  puts "#{a}, #{b}, #{c}"
end
foo(1,3)   >> 1, 3, 3
foo(1,c=5) >> 1, 5, 3
c          >> 5

c = 5는 실제로 호출 범위의 변수 c에 값 5를 할당하고 매개 변수 b에 값 5를 설정합니다.

또는 두 번째 문제를 해결하는 해시로 할 수 있습니다

def foo(a, others)
  others[:b] = 2 unless others.include?(:b)
  others[:c] = 3 unless others.include?(:c)
  puts "#{a}, #{others[:b]}, #{others[:c]}"
end
foo(1,:b=>3) >> 1, 3, 3
foo(1,:c=>5) >> 1, 2, 5

참조 : Ruby에 대한 실용 주의자 안내서

Ruby와 Python 모두에서 클래스 정의에 코드를 사용할 수 있습니다. 그러나 Ruby에서는 클래스 (자체)에 대한 참조가 있습니다. 파이썬에서는 클래스가 아직 정의되지 않았으므로 클래스에 대한 참조가 없습니다.

예를 들면 :

class Kaka
  puts self
end

이 경우 self는 클래스이며이 코드는 "Kaka"를 인쇄합니다. 클래스 이름을 인쇄하거나 다른 방법으로 Python의 클래스 정의 본문에서 클래스에 액세스하는 방법은 없습니다.

구문은 사소한 것이 아니라 우리의 생각에 직접적인 영향을 미칩니다. 또한 사용하는 시스템에 대해 생성 한 규칙에 직접적인 영향을 미칩니다. 예를 들어 수학 방정식이나 문장을 작성하는 방식 때문에 연산 순서가 있습니다. 수학에 대한 표준 표기법을 사용하면 여러 가지 방법으로 수학을 읽고 동일한 방정식이 주어지면 다른 답변에 도달 할 수 있습니다. 접두사 또는 접미사 표기법을 사용했다면 값을 계산하는 순서에 대한 규칙 만있는 것이 아니라 조작 할 숫자를 구별하는 규칙을 만들었을 것입니다.

표준 표기법은 모호한 계산 순서를 만드는 동안 우리가 말하는 숫자를 명확하게 만듭니다. 접두사와 접미사 표기법은 숫자를 모호하게 만들면서 일반 계산 순서를 만듭니다. 파이썬은 구문 공백으로 인한 어려움이 아니라면 이미 여러 줄의 람다를 가지고 있었을 것입니다. (명시적인 블록 구분 기호를 추가하지 않고도 이러한 종류의 작업을 수행하기위한 제안이 있습니다.)

예를 들어 Ruby 나 다른 언어의 의미 상 동등한 "if-not"구성보다 Ruby의 if 문을 사용하여 조건을 거짓 으로 작성하는 것이 훨씬 쉬운 조건 을 작성하는 것이 더 쉽다 는 것을 알게되었습니다. 오늘날 사람들이 사용하는 대부분의 언어가 힘이 동일하다면 어떻게 각 언어의 구문을 사소한 것으로 간주 할 수 있습니까? 블록 및 상속 메커니즘 등과 같은 특정 기능 후에는 구문이 언어의 가장 중요한 부분이며 거의 피상적 인 것입니다.

피상적 인 것은 우리가 구문에 비유하는 아름다움의 미학적 특성입니다. 미학은 우리의인지가 작동하는 방식, 구문이하는 것과 아무 관련이 없습니다.

루비의 "메소드 누락"메커니즘에 대해 언급 된 것이 없다는 사실에 놀랐습니다. 그 언어 기능의 힘의 예로서 Rails의 find_by _... 메소드의 예를 들겠습니다. 내 생각 엔 파이썬에서 비슷한 것을 구현할 수 있지만 내 지식으로는 기본적으로 존재하지 않습니다.

파이썬과 루비의 람다에 대한 또 다른 차이점은 Paul Graham의 Accumulator Generator 문제에 의해 설명됩니다 . 여기 재 인쇄 :

숫자 n을 취하고 숫자 i를 취하는 함수를 리턴하고 n을 i 씩 증가시키는 함수를 리턴하는 함수 foo를 작성하십시오. 참고 : (a) 정수가 아닌 숫자, (b) 더하기가 아닌 증가합니다.

루비에서는 다음과 같이 할 수 있습니다.

def foo(n)
  lambda {|i| n += i }
end

파이썬에서는 n의 상태를 유지하는 객체를 만듭니다.

class foo(object):
    def __init__(self, n):
        self.n = n
    def __call__(self, i):
        self.n += i
        return self.n

일부 사람들은 좀 더 장황하더라도 명시적인 파이썬 접근 방식을 개념적으로 더 명확하게 선호 할 수 있습니다. 당신은 다른 일을하는 것처럼 상태를 저장합니다. 호출 가능한 객체에 대한 아이디어로 머리를 감싸면됩니다. 그러나 어떤 접근 방식이 미학적으로 선호되는지에 관계없이 루비 람다는 파이썬보다 강력한 구성 요소라는 하나의 존중을 보여줍니다.

파이썬은 선택적 인수를 명명했습니다

def func(a, b=2, c=3):
    print a, b, c

>>> func(1)
1 2 3
>>> func(1, c=4)
1 2 4

AFAIK Ruby는 함수 선언에서 b = 2가 항상 추가되는 영향이므로 인수 만 배치했습니다.

루비에는 다음과 같은 문서가 내장되어 있습니다.

 =begin

 You could use rdoc to generate man pages from this documentation

 =end

http://c2.com/cgi/wiki?PythonVsRuby
http://c2.com/cgi/wiki?SwitchedFromPythonToRuby
http://c2.com/cgi/wiki?SwitchedFromRubyToPython
http://c2.com/cgi/wiki ? PythonDontNeedRuby 사용하기
http://c2.com/cgi/wiki?RubyDontNeedPython 사용하기

Ruby에서 require가있는 파일을 가져 오면 해당 파일에 정의 된 모든 항목이 전역 네임 스페이스에있게됩니다.

Cargo 를 사용하면 " 네임 스페이스를 어지럽히 지 않고 라이브러리를 요구할 수 있습니다 ".

# foo-1.0.0.rb
class Foo
  VERSION = "1.0.0"
end

# foo-2.0.0.rb
class Foo
  VERSION = "2.0.0"
end

>> Foo1 = 가져 오기 ( "foo-1.0.0")
>> Foo2 = 가져 오기 ( "foo-2.0.0")
>> Foo1 :: VERSION
=> "1.0.0"
>> Foo2 :: 버전
=> "2.0.0"