Language compare

class StringCreate {
  public static void main(String[] args) {
    String greeting = "Hello World!";
    System.out.println(greeting);
  }
}

greeting = 'Hello World!'
print(greeting)

class StringConcat {
  public static void main(String[] args) {
    System.out.println("Don't worry," + " be happy");
  }
}

print("Don't worry," + ' be happy')

first = "Don't worry,"
second = 'be happy'
print('%s %s' % (first, second))

class StringRemove {
  public static void main(String[] args) {
    String s = "This is not funny! I am not like him!";
    System.out.println(s.replaceAll("not ", ""));
  }
}

print('This is not funny! I am not like him!'.replace('not ', ''))

class StringReplace {
  public static void main(String[] args) {
    String s = "You should work";
    System.out.println(s.replaceAll("work", "rest"));
  }
}

print('You should work'.replace('work', 'rest'))

import java.util.Arrays;

class StringSplit {
  public static void main(String[] args) {
    String s = "I like beer";
    String[] arr = s.split(" ");
    System.out.println(Arrays.toString(arr));
  }
}

print('I like beer'.split())

class StringRemoveWhitespace {
  public static void main(String[] args) {
    System.out.println(" eh? ".trim());
  }
}

print(' eh? '.strip())

class StringCompare {
  public static void main(String[] args) {
    System.out.println("string".equals("string"));
    System.out.println(!"string".equals("string"));
  }
}

print('string' == 'string')
print('string' != 'string')

import java.util.regex.*;

class StringRegex {
  public static void main(String[] args) {
    System.out.println(Pattern.compile("^b").matcher("apple").find());
    System.out.println(Pattern.compile("^a").matcher("apple").find());
  }
}

import re

print(re.search('^b', 'apple'))
print(re.search('^a', 'apple'))

class NumberIncrement {
  public static void main(String[] args) {
    int i = 9;
    i++;
    System.out.println(i);
  }
}

i = 9
i += 1
print(i)

class NumberCompare {
  public static void main(String[] args) {
    System.out.println(1 < 2 && 2 < 3);
    System.out.println(5 == 5);
    System.out.println(5 != 5);
  }
}

print(1 < 2 < 3)
print(5 == 5)
print(5 != 5)

import java.util.concurrent.ThreadLocalRandom;

class NumberRandom {
  public static void main(String[] args) {
    System.out.println(ThreadLocalRandom.current().nextInt(1, 2 + 1));
  }
}

import random

print(random.randint(1, 2))

class NumberFloat {
  public static void main(String[] args) {
    System.out.println(9 / 2);
    System.out.println(9 / 2.0);
    System.out.println(Math.floor(9 / 2.0));
    System.out.println(Math.round(9 / 2.0));
  }
}

import math

print(9 // 2)
print(9 / 2)
print(math.floor(9 / 2))
print(round(9 / 2))  # rounds half to even

class TypeGetType {
  public static void main(String[] args) {
    System.out.println("hi".getClass());
    System.out.println(new Integer(1).getClass());
  }
}

print(type('hi'))
print(type(1))

class TypeIntToFloat {
  public static void main(String[] args) {
    System.out.println((float) 10);
  }
}

print(float(10))

class TypeIntToString {
  public static void main(String[] args) {
    System.out.println(Integer.toString(10));
  }
}

print(str(10))

class TypeStringToInt {
  public static void main(String[] args) {
    System.out.println(Integer.parseInt("10"));
  }
}

print(int('5'))

class TypeIsString {
  public static void main(String[] args) {
    System.out.println("10" instanceof String);
  }
}

print(isinstance('10', str))

import java.util.*;

class TypeNullTrueFalse {
  public static void main(String[] args) {
    List<String> emptyArray = new ArrayList<String>();
    System.out.println(emptyArray.isEmpty());

    String emptyString = "";
    System.out.println(emptyString.isEmpty());

    String nullVar = null;
    System.out.println(nullVar == null);
  }
}

def check(label, fn, values):
    print(label)
    for value in values:
        try:
            result = 'true' if fn(value) else 'false'
        except TypeError as e:
            result = 'error: %s' % e
        print("  %-9r - %s" % (value, result))
    print()

values = ['string', '', [1, 2, 3], [], 5, 0, True, False, None]

check('if value:', lambda v: v, values)
check('if value is None:', lambda v: v is None, values)
check('if len(value):', lambda v: len(v), values)

import java.util.*;

class ArrayCreatePopulated {
  public static void main(String[] args) {
    List<String> arr = Arrays.asList("first", "second");
    System.out.println(arr);
  }
}

arr = ['first', 'second']
print(arr)

import java.util.*;

class ArrayAdd {
  public static void main(String[] args) {
    List<String> arr = new ArrayList<String>();
    arr.add("first");
    arr.add("second");
    System.out.println(arr);
  }
}

arr = []
arr.append('first')
arr.append('second')
print(arr)

import java.util.*;

class ArrayDifferentTypes {
  public static void main(String[] args) {
    System.out.println(Arrays.asList("first", 1));
  }
}

print(['first', 1])

import java.util.*;

class ArrayIsInclude {
  public static void main(String[] args) {
    System.out.println(Arrays.asList(1, 2).contains(1));
  }
}

print(1 in [1, 2])

import java.util.*;

class ArrayIterate {
  public static void main(String[] args) {
    for (int num : Arrays.asList(1, 2)) {
      System.out.println(num);
    }
  }
}

for num in [1, 2]:
  print(num)

import java.util.*;

class ArrayIterateWithIndex {
  public static void main(String[] args) {
    List<String> arr = Arrays.asList("one", "two");
    for (int i = 0; i < arr.size(); i++) {
      System.out.println(arr.get(i));
      System.out.println(i);
    }
  }
}

for i, num in enumerate(['one', 'two']):
  print(num)
  print(i)

import java.util.*;

class ArrayGetFirstAndLast {
  public static void main(String[] args) {
    List<String> arr = Arrays.asList("one", "two");
    System.out.println(arr.get(0));
    System.out.println(arr.get(arr.size() - 1));
  }
}

arr = ['one', 'two']
print(arr[0])
print(arr[-1])

import java.util.*;

class ArrayFind {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 5, 10, 20);
    int first = 0;
    for (int n : arr) {
      if (n % 2 == 0) {
        first = n;
        break;
      }
    }
    System.out.println(first);
  }
}

arr = [1, 5, 10, 20]
print(next(i for i in arr if i % 2 == 0))

import java.util.*;

class ArraySelect {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 5, 10, 20);
    List<Integer> all = new ArrayList<Integer>();
    for (int n : arr)
      if (n % 2 == 0)
        all.add(n);
    System.out.println(all);
  }
}

arr = [1, 5, 10, 20]
print([i for i in arr if i % 2 == 0])

import java.util.*;

class ArrayMap {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 5, 10, 20);
    List<Integer> mapped = new ArrayList<Integer>();
    for (int n : arr)
      mapped.add(n * 2);
    System.out.println(mapped);
  }
}

arr = [1, 5, 10, 20]
print([num * 2 for num in arr])

import java.util.*;

class ArrayConcat {
  public static void main(String[] args) {
    List<Integer> arr1 = Arrays.asList(1, 2);
    List<Integer> arr2 = Arrays.asList(3, 4);
    List<Integer> concated = new ArrayList<Integer>(arr1);
    concated.addAll(arr2);
    System.out.println(concated);
  }
}

print([1, 2] + [3, 4])

import java.util.*;

class ArraySort {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(4, 2, 3, 1);
    Collections.sort(arr);
    System.out.println(arr);
  }
}

print(sorted([4, 2, 3, 1]))

import java.util.*;

class ArrayMulti {
  public static void main(String[] args) {
    List<List<String>> arr = new ArrayList<List<String>>();
    arr.add(Arrays.asList("first", "second"));
    arr.add(Arrays.asList("third", "forth"));
    System.out.println(arr.get(1).get(1));
  }
}

multi = [['first', 'second'], ['third', 'forth']]
print(multi[1][1])

import java.util.*;

class ArraySize {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 2, 3);
    System.out.println(arr.size());
  }
}

print(len([1, 2, 3]))

import java.util.*;

class ArrayCount {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 11, 111);
    int count = 0;
    for (int n : arr)
      if (n > 10)
        count++;
    System.out.println(count);
  }
}

arr = [1, 11, 111]
print(sum(1 for i in arr if i > 10))

import java.util.*;

class ArrayReduce {
  public static void main(String[] args) {
    int sum = 0;
    for (int n : Arrays.asList(1, 2, 3))
      sum += n;
    System.out.println(sum);
  }
}

import functools, operator

print(functools.reduce(operator.add, [1, 2, 3]))
print(sum([1, 2, 3]))  # a more Pythonic example

import java.util.*;

class ArrayIndexOfElement {
  public static void main(String[] args) {
    List<String> arr = Arrays.asList("a", "b", "c");
    System.out.println(arr.indexOf("c"));
  }
}

print(['a', 'b', 'c'].index('c'))

import java.util.*;

class ArrayDeleteElement {
  public static void main(String[] args) {
    List<String> arr = new LinkedList<String>(Arrays.asList("a", "b", "c"));
    Iterator<String> iter = arr.iterator();
    while(iter.hasNext()) {
      if(iter.next().equalsIgnoreCase("b"))
        iter.remove();
    }
    System.out.println(arr);
  }
}

arr = ['a', 'b', 'c']
arr.remove('b')
print(arr)

import java.util.*;

class ArrayUnique {
  public static void main(String[] args) {
    List<String> arr = Arrays.asList("a", "b", "a");
    Set<String> unique = new LinkedHashSet<>(arr);
    System.out.println(unique);
  }
}

print(set(['a', 'b', 'a']))

import java.util.*;

class HashCreatePopulated {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>() {{
      put("fontSize", "10");
      put("fontFamily", "Arial");
    }};
    System.out.println(options);
  }
}

options = {'font_size': 10, 'font_family': 'Arial'}
print(options)

import java.util.*;

class HashAdd {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>();
    options.put("fontSize", "10");
    options.put("fontFamily", "Arial");
    System.out.println(options);
  }
}

options = {}
options['font_size'] = 10
options['font_family'] = 'Arial'
print(options)

import java.util.*;

class HashIterate {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>() {{
      put("fontSize", "10");
      put("fontFamily", "Arial");
    }};
    for (Map.Entry<String, String> entry : options.entrySet()) {
      System.out.println(entry.getKey());
      System.out.println(entry.getValue());
    }
  }
}

for key, value in {'font_size': 10, 'font_family': 'Arial'}.items():
  print(key, value)

import java.util.*;

class HashIsInclude {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>() {{
      put("fontSize", "10");
      put("fontFamily", "Arial");
    }};
    System.out.println(options.containsKey("fontSize"));
  }
}

options = {'font_size': 10, 'font_family': 'Arial'}
print('font_size' in options)

import java.util.*;

class HashGetValue {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>() {{
      put("fontSize", "10");
      put("fontFamily", "Arial");
    }};
    System.out.println(options.get("fonSize"));
  }
}

options = {'font_size': 10, 'font_family': 'Arial'}
print(options['font_size'])

import java.util.*;

class HashSize {
  public static void main(String[] args) {
    Map<String, String> options = new HashMap<String, String>() {{
      put("fontSize", "10");
      put("fontFamily", "Arial");
    }};
    System.out.println(options.size());
  }
}

options = {'font_size': 10, 'font_family': 'Arial'}
print(len(options))

class OtherStructureBoolean {
  public static void main(String[] args) {
    boolean tryIt = true;
    if (tryIt)
      System.out.println("Garlic gum is not funny");
  }
}

try_it = True
if try_it:
    print('Garlic gum is not funny')

class OtherStructureConstant {
  public static void main(String[] args) {
    final int COST = 100;
    COST = 50;
    System.out.println(COST);
  }
}

COST = 100
COST = 50
print(COST)

enum Color {
  RED("#FF0000"),
  GREEN("#00FF00");

  private String color;

  private Color(String color) {
    this.color = color;
  }

  public String toString() {
    return color;
  }
}

class OtherStructureConstantList {
  public static void main(String[] args) {
    System.out.println(Color.GREEN);
  }
}

class Colors:
    RED = '#FF0000'
    GREEN = '#00FF00'

print(Colors.GREEN)

import collections

class Customer(collections.namedtuple('Customer', 'name address')):
    def greeting(self):
        return "Hello %s!" % self.name

print(Customer('Dave', '123 Main').greeting())

class ConditionalIf {
  public static void main(String[] args) {
    if (true)
      System.out.println("Hello");
  }
}

if True:
    print('Hello')

class ConditionalUnless {
  public static void main(String[] args) {
    boolean angry = false;
    if (!angry)
      System.out.println("smile!");
  }
}

angry = False
if not angry:
    print('smile!')

class ConditionalIfElse {
  public static void main(String[] args) {
    if (true)
      System.out.println("work");
    else
      System.out.println("sleep");
  }
}

if True:
  print('work')
else:
  print('sleep')

class ConditionalAndOr {
  public static void main(String[] args) {
    if (true && false)
      System.out.println("no");
    if (true || false)
      System.out.println("yes");
  }
}

if True and False:
    print('no')
if True or False:
    print('yes')

class ConditionalSwitch {
  public static void main(String[] args) {
    String s = "Hello!";
    switch (s) {
      case "Bye!":
        System.out.println("wrong");
        break;
      case "Hello!":
        System.out.println("right");
        break;
      default: break;
    }
  }
}

foo = 'Hello!'
if foo in range(1, 6):
    print("It's between 1 and 5")
elif foo in (10, 20):
    print('10 or 20')
elif foo == 'And':
    print('case in one line')
elif isinstance(foo, str):
    print("You passed a string %r" % foo)
else:
    print("You gave me %r" % foo)

score = 76
grades = [
    (60, 'F'),
    (70, 'D'),
    (80, 'C'),
    (90, 'B'),
]
print(next((g for x, g in grades if score < x), 'A'))

class ConditionalTernary {
  public static void main(String[] args) {
    String s = false ? "no" : "yes";
    System.out.println(s);
  }
}

print('no' if False else 'yes')

result = 'a' if True else 'b'
print(result)

class LoopFor {
  public static void main(String[] args) {
    for (int i = 1; i <= 3; i++)
      System.out.println(i + ". Hi");
  }
}

for i in range(1, 4):
    print('%d. Hi' % i)

class LoopForWithStep {
  public static void main(String[] args) {
    for (int i = 0; i <= 4; i += 2)
      System.out.println(i);
  }
}

for i in range(0, 5, 2):
    print(i)

class LoopTimes {
  public static void main(String[] args) {
    for (int i = 0; i < 3; i++)
      System.out.println("Hi");
  }
}

for i in range(3):
  print('Hi')

class LoopWhile {
  public static void main(String[] args) {
    int i = 0;
    while (i < 3)
      i++;
    System.out.println(i);
  }
}

i = 0
while i < 3:
  i += 1
print(i)

class LoopUntil {
  public static void main(String[] args) {
    int i = 0;
    while (i != 3)
      i++;
    System.out.println(i);
  }
}

i = 0
while i != 3:
    i += 1
print(i)

greetings = ["%d. Hello!" % time for time in range(1, 4)]
print(greetings)

class LoopBreak {
  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      System.out.println((i + 1) + ". Hi");
      if (i == 1)
        break;
    }
  }
}

for time in range(1, 4):
  print("%d. Hi" % time)
  if time == 2:
    break

class LoopNext {
  public static void main(String[] args) {
    for (int i = 0; i < 3; i++) {
      if (i == 1)
        continue;
      System.out.println((i + 1) + ". Hi");
    }
  }
}

for time in range(1, 4):
  if time == 2:
      continue
  print("%d. Hi" % time)

import java.util.*;

class MathMaxMin {
  public static void main(String[] args) {
    List<Integer> arr = Arrays.asList(1, 2, 3);
    System.out.println(Collections.min(arr));
    System.out.println(Collections.max(arr));
  }
}

arr = [1, 2, 3]
print(min(arr))
print(max(arr))

class MathSqrt {
  public static void main(String[] args) {
    System.out.println(Math.sqrt(9));
  }
}

import math

print(math.sqrt(9))

class ErrorTryCatch {
  public static void main(String[] args) {
    try {
      int i = 1 / 0;
    } catch (Exception e) {
      System.out.println("Can't divide");
    } finally {
      System.out.println("But that's ok");
    }
  }
}

try:
  1 / 0
except:
  print("Can't divide")
finally:
  print("But that's ok")

class ErrorWithAMessage {
  public static void main(String[] args) {
    try {
      int i = 1 / 0;
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

try:
  1 / 0
except Exception as e:
  print(e)

def divide(num1, num2):
  try:
    num1 / num2
  except Exception as e:
    print(e)
divide(1, 0)

class ErrorThrow {
  public static void main(String[] args) {
    try {
      throw new Exception("An error!");
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

try:
  raise Exception('An error!')
except Exception as e:
  print(e)

import java.io.*;

class FileRead {
  public static void main(String[] args) throws IOException {
    String filePath = System.getProperty("user.dir") + "/code/file.txt";
    String content;
    try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
      StringBuilder sb = new StringBuilder();
      String line = br.readLine();
      while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
      }
      content = sb.toString();
    }
    System.out.println(content);
  }
}

import os

with open(os.path.join(os.getcwd(), 'code', 'file.txt')) as f:
    print(f.read())

import java.io.*;

class FileWrite {
  public static void main(String[] args) throws IOException {
    String filePath = System.getProperty("user.dir") + "/code/output.txt";
    try (Writer writer = new BufferedWriter(new OutputStreamWriter(
        new FileOutputStream(filePath), "utf-8"))) {
      writer.write("Some glorious content");
    }
  }
}

import pathlib

with (pathlib.Path(__file__).parent / 'output.txt').open('w') as f:
    f.write('Some glorious content')

class FileGetWorkingDir {
  public static void main(String[] args) {
    System.out.println(System.getProperty("user.dir"));
  }
}

import os

print(os.getcwd())

import java.net.*;

class FilePath {
  public static void main(String[] args) {
    URL location = FilePath.class.getProtectionDomain().getCodeSource().getLocation();
    System.out.println(location.getFile() + "FilePath.class");
  }
}

print(__file__)

import java.net.*;

class FileDirPath {
  public static void main(String[] args) {
    URL location = FileDirPath.class.getProtectionDomain().getCodeSource().getLocation();
    System.out.println(location.getFile());
  }
}

import pathlib

print(pathlib.Path(__file__).parent)

import java.net.*;
import java.io.*;

class FileParentDirPath {
  public static void main(String[] args) {
    URL location = FileParentDirPath.class.getProtectionDomain().getCodeSource().getLocation();
    String parentPath = new File(location.getFile()).getParent();
    System.out.println(parentPath);
  }
}

import pathlib

print(pathlib.Path(__file__).parents[1])

import java.net.*;
import java.io.*;

class FileSisterDirPath {
  public static void main(String[] args) throws IOException {
    URL location = FileSisterDirPath.class.getProtectionDomain().getCodeSource().getLocation();
    String parentPath = new File(location.getFile() + ".." + "/java").getCanonicalPath();
    System.out.println(parentPath);
  }
}

import pathlib

print(pathlib.Path(__file__).parents[1] / 'ruby')

class MethodDeclare {
  public static void main(String[] args) {
    new MethodDeclare().hey();
  }

  public void hey() {
    System.out.println("How are you?");
  }
}

def hey():
  print('How are you?')
hey()

import java.util.*;

class MethodMultiArg {
  public static void main(String[] args) {
    new MethodMultiArg().sweets(true, "snickers", "twix", "bounty");
  }

  public void sweets(boolean buy, String... brands) {
    if (buy)
      System.out.println(Arrays.toString(brands));
  }
}

def sweets(buy, *brands):
  if buy:
      print(brands)
sweets(True, 'snickers', 'twix', 'bounty')

def send(abroad=False):
  print('Send abroad' if abroad else 'Send locally')
send()
send(True)

class MethodReturn {
  public static void main(String[] args) {
    MethodReturn obj = new MethodReturn();
    System.out.println(obj.divide(0, 10));
    System.out.println(obj.divide(10, 5));
  }

  public int divide(int a, int b) {
    if (a == 0)
      return 0;
    return a / b;
  }
}

def multiply(a, b):
    return a * b

def divide(a, b):
    return 0 if a == 0 else a / b

def default_value():
    pass

print(multiply(2, 3))
print(divide(0, 10))
print(default_value())

square = lambda x: x * x
print(list(map(square, [2, 3])))

greeting = lambda: print('Hello World!')
greeting()

def select(arr):
    yield from arr

def select_filter(arr, filter):
    for a in arr:
        if filter(a):
            yield a

print([x for x in select([1, 5, 10]) if x < 6])
print(list(select_filter([1, 5, 10], lambda x: x < 6)))

class Action:
  name = 'Ann'

  @staticmethod
  def say(sentence):
    print(sentence())


class Person:
  def __init__(self, name):
    self.name = name

  def greet(self):
    Action.say(lambda: "My name is %s!" % self.name)


Person('Alex').greet()

class ProccessElements:
  def __init__(self):
    def element(el_name):
      def render(content):
        return '<{0}>{1}</{0}>'.format(el_name, content)
      return render

    for el_name in self.elements:
      setattr(self, el_name, element(el_name))


class HtmlELements(ProccessElements):
  elements = ('div', 'span')

print(HtmlELements().div('hello'))

class Greetings:
  def hey(self):
    print('How are you?')
  hi = hey

Greetings().hi()

class Animal {
  public void walk() {
    System.out.println("I'm walking");
  }
}

class ClassDeclare {
  public static void main(String[] args) {
    new Animal().walk();
  }
}

class Animal:
  def walk(self):
    print("I'm walking")

Animal().walk()

class Animal {
  private String name;

  public Animal(String name) {
    this.name = name;
  }

  public void walk() {
    System.out.println("My name is " + this.name + " and I'm walking");
  }
}

class ClassConstructor {
  public static void main(String[] args) {
    new Animal("Kelya").walk();
  }
}

class Animal:
  def __init__(self, name):
    self.name = name

  def walk(self):
    print("My name is %s and I'm walking" % self.name)

Animal('Kelya').walk()

class Animal {
  public void walk() {
    bark();
    guard();
    System.out.println("I'm walking");
  }

  public void bark() {
    System.out.println("Wuf!");
  }

  private void guard() {
    System.out.println("WUUUF!");
  }
}

class ClassMethodCall {
  public static void main(String[] args) {
    new Animal().walk();
  }
}

class Animal:
  def walk(self):
    self.bark()
    self._guard()
    print("I'm walking")

  def bark(self):
    print('Wuf!')

  # Private by convention
  def _guard(self):
    print('WUUUF!')

Animal().walk()

class Animal {
  public static void feed() {
    System.out.println("Om nom nom");
  }
}

class ClassClassMethod {
  public static void main(String[] args) {
    Animal.feed();
  }
}

class Animal:
  @classmethod
  def feed(cls):
    print('Om nom nom')

Animal.feed()

class Animal {
  public void eat(String food) {
    if (isMeat(food))
      System.out.println("Om nom nom");
  }

  private boolean isMeat(String food) {
    return food.equals("meat");
  }
}

class ClassPrivateMethod {
  public static void main(String[] args) {
    new Animal().eat("meat");
  }
}

class Animal:
  def eat(self, food):
    if self._is_meat(food):
      print('Om nom nom')

  def _is_meat(self, food):
    return food == 'meat'

Animal().eat('meat')

class Animal {
  private String name;

  public Animal(String name) {
    this.name = name;
    greet();
  }

  private void greet() {
    System.out.println("Hello! My name is " + this.name);
  }
}

class ClassPrivateMethodAccessInstance {
  public static void main(String[] args) {
    new Animal("Kelya");
  }
}

class Animal:
  def __init__(self, name):
    self.name = name
    self._greet()

  def _greet(self):
    print("Hello! My name is %s" % self.name)

Animal('Kelya')

class Animal {
  private String toy;

  public void take(String toy) {
    this.toy = toy;
  }

  public void play() {
    System.out.println("I'm playing with " + this.toy);
  }
}

class ClassField {
  public static void main(String[] args) {
    Animal animal = new Animal();
    animal.take("a ball");
    animal.play();
  }
}

class Animal:
  def take(self, toy):
    self.toy = toy

  def play(self):
    print("I'm playing with %s" % self.toy)

animal = Animal()
animal.take('a ball')
animal.play()

class Animal {
  private String name;

  public void setName(String name) {
    this.name = name;
  }

  public String getName() {
    return this.name;
  }
}

class ClassGetSet {
  public static void main(String[] args) {
    Animal animal = new Animal();
    animal.setName("Kelya");
    System.out.println(animal.getName());
  }
}

class Animal:
  name = None

animal = Animal()
animal.name = 'Kelya'
print(animal.name)

class Animal {
  public void walk() {
    System.out.println("I'm walking");
  }
}

class Dog extends Animal {
  public void sing() {
    System.out.println("Bark!");
  }
}

class ClassInheritance {
  public static void main(String[] args) {
    new Dog().walk();
  }
}

class Animal:
  def walk(self):
    print("I'm walking")

class Dog(Animal):
  def sing(self):
    print('Bark!')

Dog().walk()

class Moving:
  def walk(self):
    print("%s is walking" % self.__class__.__name__)

class Interacting:
  def talk(self):
    print("%s is talking" % self.__class__.__name__)

class Human(Moving, Interacting):
    pass

human = Human()
human.walk()
human.talk()

import java.lang.reflect.*;

class Animal {
  public void walk() {
    System.out.println("I'm walking");
  }
}

class ClassHasMethod {
  public static void main(String[] args) {
    Animal animal = new Animal();
    boolean hasMethod = false;
    for (Method m : animal.getClass().getMethods()) {
      if (m.getName().equals("walk")) {
        hasMethod = true;
        break;
      }
    }
    System.out.println(hasMethod);
  }
}

class Animal:
  def walk(self):
    print("I'm walking")

animal = Animal()
print(hasattr(animal, 'walk'))

class OtherComment {
  public static void main(String[] args) {
    // it's a comment
  }
}

# it's a comment

speed = 0
speed = 15 if speed is None else speed
print(speed)