PL03, Syntax and semantics

type(10)

type(10 * 5)

type(10.0)

type(0.1)

type(10.0 * 5)

type(10 / 5)

type(123e2)    # 12300.0

type(123e-2)   # 1.23

type(123.456e-3)   # 0.123456

0.1

# method1
%precision 55   
0.1

# method2
'%.55f'%0.1

0.1 + 0.2 == 0.3

round(0.1 + 0.2, 5) == round(0.3, 5)

int(1.0)

int(3.14)

int(3.9)

int(-3.9)

float(1) 

float("NaN")

float("Inf")

float("-Inf")

numbers = dict(x=5, y=0)
print('numbers =', numbers)
print(type(numbers))

empty = dict()
print('empty =', empty)
print(type(empty))

a = {1:'korea',2:'USA',3:'china'}

print(a.get(1), a)
print(a[1], a)
print(a.pop(1), a)

a = {1:'korea',2:'USA',3:'china'}

print(a.popitem(), a)
print(a.popitem(), a)
print(a.popitem(), a)

a = {1:'korea',2:'USA',3:'china'}

print(list(a))
print(list(a.keys()))
print(list(a.values()))
print(list(a.items()))

dict = {}
dict['name'] = 'ailever'
dict['age'] = 19

for i, j in dict.items():
     print(i, j)

s = {1, 2, 3}
s |= {4}
s

s = {1, 2, 3}
s |= {4,5,6}
s

s = {1, 2, 3}
s.remove(2)
s

s = {1,2,3}
q = {3,4,5}

print(s & q)  # {3}, s.intersection(q) 
print(s | q)  # {1,2,3,4,5}, s.union(q)
print(s - q)  # {1,2}, s.difference(q)

a = 1

print(a is 1)
print(a == 1)
print(id(a))
print(id(1))

a = 257

print(a is 257)
print(a == 257)
print(id(a))
print(id(257))

a = 10
b = {a > 0 : 1,
     a == 0 : 0}.get(True, -1)
b

a = 10

if a > 0:
    b = 1
elif a == 0:
    b = 0
else:
    b = -1
    
b

a = 10
b = 1 if a > 0 else ( 0 if a==0 else -1)
b

for i in range(10) : print(i)

try:
    raise ZeroDivisionError()
except ZeroDivisionError:
    print('error')

def hello(a,b,c):
    print(a)
    print(b)
    print(c)

x = [1,2,3]
y = (1,2,3)
hello(*x)   # hello(*[1,2,3])
hello(*y)   # hello(*(1,2,3))

def hello(*args):
    print(args)

x = [1,2,3]
y = (1,2,3)
hello(*x)   # hello(*[1,2,3])
hello(*y)   # hello(*(1,2,3))

def hello(name,age,address):
    print('name',name)
    print('age',age)
    print('address',address)

x = {'name':'ailever', 'age':27, 'address':312321}
hello(*x)
hello(**x)

def hello(**kwargs):
    print(kwargs)
    
x = {'name':'ailever', 'age':27, 'address':312321}
hello(**x)

class Person:
    pass

p1 = Person()
p2 = Person()

class Person:
   def lee(self, x):
            print(x)
            
m = Person()
m.lee(10)              # instance name space = bound
Person.lee(m, 10)      # class name sapce = unbound

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0

p1 = Person()
p1.name = 'bob'
p1.age = 21

p2 = Person()
p2.name = 'cathy'
p2.age = 25

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

p1 = Person('bob', 21)
p1.name
p1.age

p2 = Person('cathy', 25)
p2.name
p2.age

class Person:
    def __init__(self):
        self.__age = 0
 
    @property
    def age(self):           # getter
        return self.__age
 
    @age.setter
    def age(self, value):    # setter
        self.__age = value
 
james = Person()
james.age = 20      # 인스턴스.속성 형식으로 접근하여 값 저장
print(james.age)    # 인스턴스.속성 형식으로 값을 가져옴

class Person:
    age = 23
    name = 'Adam'

person = Person()

print('Person has age?:', hasattr(person, 'age'))
print('Person has salary?:', hasattr(person, 'salary'))

class CLASS:
    @staticmethod
    def func(*args, **kwargs):
        pass

CLASS.func()

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return 'x={}, y={}'.format(self.x, self.y)

    def __len__(self):
        return int(self.x**2 + self.y**2)

    def __abs__(self):
        return math.sqrt(self.x**2 + self.y**2)

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            return -1

    def __add__(self, point):
        new_x = self.x + point.x
        new_y = self.y + point.y
        return (new_x, new_y)

    def __sub__(self, point):
        new_x = self.x - point.x
        new_y = self.y - point.y
        return (new_x, new_y)

    def __mul__(self, point):
        if type(point) == int:
            return Point(point*self.x, point*self.y)
        elif type(point) == Point:
            return self.x*point.x + self.y*point.y

    def __eq__(self, point):
        return self.x == point.x and self.y == point.y

    def __ne__(self, point):
        return not (self.x == point.x and self.y == point.y)


p1 = Point(1.1,2.2)
p2 = Point(4.4,5.5)

print('__str__ : ',p1, p2)
print('__len__ : ',len(p1),len(p2))
print('__getitem__ :', p1[0],p1[1],p1[2])
print('__add__ : ',p1 + p2)
print('__sub__ : ',p1 - p2)
print('__mul__ : ',p1 * 3)
print('__mul__ : ',p1 * p2)
print('__eq__ : ',p1 == p1, p1 == p2)
print('__ne__ : ',p1 != p1, p1 != p2)
print('__abs__: ', abs(p1))

class Person:
    def greeting(self):
        print('hello')

class Student(Person):
    def study(self):
        print('study')

james = Student()
james.greeting()
james.study()

class Person:
    def __init__(self):
        print('Person')
        self.hello = 'hello'
    
class Student(Person):
    def __init__(self):
        print('Student')
        super().__init__()
        self.school = 'school'
        
james = Student()
print(james.school)
print(james.hello)

class A:
    def greeting(self):
        print('hello, A')
        
class B(A):
    def greeting(self):
        print('hello, B')
        
class C(A):
    def greeting(self):
        print('hello, C')
        
class D(B,C):    # left side has a priority
    pass
        
x = D()
x.greeting()

class Person:
    def greeting(self):
        print('hello')

class PersonList():
    def __init__(self):
        self.person_list = []
        
    def append_person(self, person):
        self.person_list.append(person)

recode = PersonList()
james = Person()
recode.append_person(james)
recode.person_list

class Person:
    def greeting(self):
        print('hello, Person')

class Student(Person):
    def greeting(self):
        print('hello, Student')

james = Student()
james.greeting()

class Person:
    def greeting(self):
        print('hello, Person')

class Student(Person):
    def greeting(self):
        super().greeting()
        print('hello, Student')

james = Student()
james.greeting()

from abc import *   # abc : abstract base class

class StudentBase(metaclass=ABCMeta):
    @abstractmethod
    def study(self):
        pass
    
    @abstractmethod
    def go_to_school(self):
        pass
    
class Student(StudentBase):
    def study(self):
        print('study')

    def go_to_school(self):
        print('go to school')
        
james = Student()
james.study()
james.go_to_school()

# class = type('name_of_class', (base_class), {property:method})

Hello = type('Hello',(),{})
h = Hello()
h

def replace(self, old, new):
    while old in self:
        self[self.index(old)] = new

AdvancedList = type('AdvancedList', (list,), {'desc':'improved list', 'replace':replace})

x = AdvancedList([1,2,3,1,2,3,1,2,3])
x.replace(1,100)
print(x)
print(x.desc)

class MakeCalc(type):
    def __new__(metacls, name, bases, namespace):
        namespace['desc'] = 'calc class'
        namespace['add'] = lambda self, a, b : a + b
        return type.__new__(metacls, name, bases, namespace)
    
Calc = MakeCalc('Calc', (), {})
c = Calc()
print(c.desc)
print(c.add(1,2))

# Singleton

class Singleton(type):
    __instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls.__instances:
            cls.__instances[cls] = super().__call__(*args, **kwargs)
        return cls.__instances[cls]
    
class Hello(metaclass=Singleton):
    pass

a = Hello()
b = Hello()
print(a is b)

class A:
    pass

a = A()

None;                     print(f'* a', vars(a))
setattr(a, 'x', 1);       print(f'* setattr : ', vars(a))
hasattr(a, 'x');          print(f'* hasattr : {hasattr(a, "x")}')
getattr(a, 'x');          print(f'* getattr : {getattr(a, "x")}')
delattr(a, 'x');          print(f'* delattr : ', vars(a))                       

import os
import sys

sys.path.append(os.path.dirname(os.path.abspath(os.path.dirname(__file__))))

if __name__ == "__main__":
    pass

help(object)

class DoorException(Exception):
    pass

class DoorOpenedException(DoorException):
    pass

class DoorClosedException(DoorException):
    pass


class Door:
    def __init__(self):
        self.is_opened = True
    
    def state(self):
        raise DoorException('being preparing')

    def open(self):
        if self.is_opened:
            raise DoorOpenedException('already opened')
        else:
            print('open')
            self.is_opened = True

    def close(self):
        if not self.is_opened:
            raise DoorClosedException('already closed')
        else:
            print('close')
            self.is_opened = False
            
door = Door()
door.close()
door.open()
door.state()

try:
    x = int(input('enter number : '))
    y = 10 / x 
except ZeroDivisionError:    # if exception is occured
    print('cannot divide')
else:                        # if exception is not occured
    print(y)
finally:                     # always
    print('end')

abs(3)

abs(-3)

abs(-1.2)

all([1, 2, 3])

all([1, 2, 3, 0])

any([1, 2, 3, 0])

any([0, ""])

chr(97)

chr(48)

dir([1, 2, 3])

dir({'1':'a'})

divmod(7, 3)

for i, name in enumerate(['body', 'foo', 'bar']):
    print(i, name)

eval('1+2')

eval("'hi' + 'a'")

eval('divmod(4, 3)')

hex(234)

hex(3)

>>> a = 3
>>> id(3)

id(a)

b = a
id(b)

>>> a = input()
hi
>>> a
'hi'

>>> b = input("Enter: ")
Enter: hi
>>> b
'hi'

int('3')

int(3.4)

class Person: pass

a = Person()
isinstance(a, Person)

b = 3
isinstance(b, Person)

len("python")

len([1,2,3])

len((1, 'a'))

list("python")

list((1,2,3))

# two_times.py
def two_times(numberList):
    result = [ ]
    for number in numberList:
        result.append(number*2)
    return result

result = two_times([1, 2, 3, 4])
print(result)

def two_times(x): 
    return x*2

list(map(two_times, [1, 2, 3, 4]))

max([1, 2, 3])

max("python")

min([1, 2, 3])

min("python")

oct(34)

oct(12345)

f = open("binary_file", "rb")
f.close()

with open("binary_file","rb") as f:
    pass

fread = open("read_mode.txt", 'r')
fread2 = open("read_mode.txt")

fappend = open("append_mode.txt", 'a')

ord('a')

ord('0')

pow(2, 4)

pow(3, 3)

list(range(5))

list(range(5, 10))

list(range(1, 10, 2))

list(range(0, -10, -1))

round(4.6)

round(4.2)

round(5.678, 2)

sorted([3, 1, 2])

sorted(['a', 'c', 'b'])

sorted("zero")

sorted((3, 2, 1))

str(3)

str('hi')

str('hi'.upper())

sum([1,2,3])

sum((4,5,6))

tuple("abc")

tuple([1, 2, 3])

tuple((1, 2, 3))

type("abc")

type([ ])

type(open("test", 'w'))

list(zip([1, 2, 3], [4, 5, 6]))

list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))

list(zip("abc", "def"))

import sys
print(sys.argv)

import sys

print('hello1')
sys.exit()
print('hello2')

import sys

print(sys.path)

import sys

sys.path.append('C:/doit/mymod')
print(sys.path)

import argparse

parser = argparse.ArgumentParser(description="set your environment")
parser.add_argument('--env1', required=False, help="env 1")
parser.add_argument('--env2', required=False, help="env 2")
args = parser.parse_args()

print(args.env1)
print(args.env2)

import argparse

def option():
    parser = argparse.ArgumentParser(description="set your environment")   
    parser.add_argument('--env1', type=str, required=False, help="env 1")
    parser.add_argument('--env2', type=str, required=False, help="env 2")
    args = parser.parse_args()
    return args

def main(opt):
    print(opt.env1)
    print(opt.env2)

if __name__ == "__main__":
    opt = option()
    main(opt)

import pickle

f = open("test.txt", 'wb')
data = {1: 'python', 2: 'you need'}
pickle.dump(data, f)
f.close()

import pickle

f = open("test.txt", 'rb')
data = pickle.load(f)
print(data)

import os

os.environ

import os

os.chdir("C:\WINDOWS")

import os

os.getcwd()

import copy

def description(a,b,c,d):
    print('a value:',a,': original(a)',
          ',\n a id:',id(a))
    print('b value:',b,': simple(b = a)',
          ',\n b id:',id(b))
    print('c value:',c,': shallow(c = copy.copy(a)) ',
          ',\n c id:',id(c))
    print('d value:',d,': deep(d = copy.deepcopy(d))',
          ',\n d id:',id(d))
    print()    

a = 1
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
description(a,b,c,d)

import copy

def description(a,b,c,d):
    print('a value:',a,': original(a)',
          ',\n a id:',id(a),', a[0] id:',id(a[0]))
    print('b value:',b,': simple(b = a)',
          ',\n b id:',id(b),', b[0] id:',id(b[0]))
    print('c value:',c,': shallow(c = copy.copy(a)) ',
          ',\n c id:',id(c),', c[0] id:',id(c[0]))
    print('d value:',d,': deep(d = copy.deepcopy(d))',
          ',\n d id:',id(d),', d[0] id:',id(d[0]))
    print()
    
a = [1]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
description(a,b,c,d)

import copy

def description(a,b,c,d):
    print('a value:',a,': original(a)',
          ',\n a id:',id(a),', a[0] id:',id(a[0]),', a[1] id:',id(a[1]))
    print('b value:',b,': simple(b = a)',
          ',\n b id:',id(b),', b[0] id:',id(b[0]),', b[1] id:',id(b[1]))
    print('c value:',c,': shallow(c = copy.copy(a)) ',
          ',\n c id:',id(c),', c[0] id:',id(c[0]),', c[1] id:',id(c[1]))
    print('d value:',d,': deep(d = copy.deepcopy(d))',
          ',\n d id:',id(d),', d[0] id:',id(d[0]),', d[1] id:',id(d[1]))
    print()
    
a = [1, [2]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
description(a,b,c,d)

b[0] = 2
description(a,b,c,d)

b[1] = [3]
description(a,b,c,d)

import copy

def description(a,b,c,d):
    print('a value:',a,': original(a)',
          ',\n a id:',id(a),', a[0] id:',id(a[0]),', a[1] id:',id(a[1]))
    print('b value:',b,': simple(b = a)',
          ',\n b id:',id(b),', b[0] id:',id(b[0]),', b[1] id:',id(b[1]))
    print('c value:',c,': shallow(c = copy.copy(a)) ',
          ',\n c id:',id(c),', c[0] id:',id(c[0]),', c[1] id:',id(c[1]))
    print('d value:',d,': deep(d = copy.deepcopy(d))',
          ',\n d id:',id(d),', d[0] id:',id(d[0]),', d[1] id:',id(d[1]))
    print()    

    
a = [1, [2]]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
description(a,b,c,d)

b[0] = 2
description(a,b,c,d)

b[1][0] = 3
description(a,b,c,d)