231123 Python 문제

[문제] Set 클래스를 생성해주세요. 

lst1 = [1,2,3,4,5,4,2,1]
lst2=[4,5,6,8,7,4]

s = Set(lst1, lst2)
s.union()
s.union_all()
s.intersect() 
s.minus()

 

# [내가 작성한 코드]

class Set:
    def union(self):
        print('union : {}'.format( (self.x).union(self.y) ))
    def union_all(self):
        print('union_all : {}'.format( (self.x)|(self.y) ))
    def intersect(self):
        print('intersect : {}'.format( (self.x).intersection(self.y) ))
    def minus(self):
        print('minus : {}'.format( (self.x).difference(self.y) ))

 

# [선생님 답안]

def union(x,y):
    ...
    
union(lst1, lst2)

lst1 = [1,2,3,4,5,4,2,1]
lst2 = [4,5,6,8,7,4,9]

Series(lst1).unique()

# 중복성 제거(union)

result1 = [] 
lst1
for i in lst1:
    if i not in result1:
        result1.append(i)
result1 # lst1 변수 값들중에서 유일한 값

result2 = [] 
lst2
for i in lst2:
    if i not in result2:
        result2.append(i)
result2 # lst2 변수 값들중에서 유일한 값

# unionall 

result1 + result2

# 중복제거하기 위한

result1
result2
temp = [] # 별도의 list 변수 , result1에 있는 값 중에 result2 에 없는 값만 입력
for i in result1:
    if i not in result2:
        temp.append(i)
temp

temp + result2

 

#1. union 함수 생성

def union(x,y):
    # set() 로직 구현
    x_1 = [] # result1, x의 값들 중에 중복제거 변수
    for i in x:
        if i not in x_1:
            x_1.append(i)
    y_1 = [] # result2, y의 값들 중에 중복제거 변수
    for i in y:
        if i not in y_1:
            y_1.append(i)
            
    # union 로직 구현
    result = [] # temp, x_1와 y_1 의 값들의 중복값 제거 변수
    for i in x_1:
        if i not in y_1:
            result.append(i)
    result = result + y_1
    result.sort()
    return result

union(lst1, lst2)
set(lst1).union(set(lst2))

 

#2. unionall 함수 생성

def union_all(x,y):
    result = []
    result = x + y
    result.sort()
    return result
union_all(lst1, lst2)
set(lst1).extend(set(lst2))

 

#3. intersect 함수 생성

def intersect(x,y):
    x_1 = [] # x의 값들 중에 유일한 값 변수
    for i in x:
        if i not in x_1:
            x_1.append(i)
    y_1 = [] # y의 값들 중에 유일한 값 변수
    for i in y:
        if i not in y_1:
            y_1.append(i)
            
    result = [] # temp, 
    for i in x_1:
        if i in y_1:
            result.append(i)
    result.sort()
    return result

intersect(lst1, lst2)
set(lst1).intersection(set(lst2))

 

#4 minus 함수 생성

def minus(x,y):
    x_1 = [] # x의 값들 중에 유일한 값 변수
    for i in x:
        if i not in x_1:
            x_1.append(i)
    y_1 = [] # y의 값들 중에 유일한 값 변수
    for i in y:
        if i not in y_1:
            y_1.append(i)
            
    result = [] # temp, 
    for i in x_1:
        if i not in y_1:
            result.append(i)
    result.sort()
    return result

minus(lst1, lst2)
set(lst1).difference(set(lst2))

 

## 최종 class 생성

class Set:
    def __init__(self, x, y):
        self.x = x # => 인스턴스변수(self.x) = 형식매개변수(x)
        self.y = y
        
        # 유일한 값 담을 수 있는 변수 선언
        self.result1 = [] 
        self.result2 = []
        
        for i in self.x:
            if i not in self.result1:
                self.result1.append(i)
        
        for i in self.y:
            if i not in self.result2:
                self.result2.append(i)
        
    def union(self):
        v_union = [] # local variable 
        for i in self.result1:
            if i not in self.result2:
                v_union.append(i)
        v_union = v_union + self.result2
        v_union.sort()
        return v_union
    
    def union_all(self):
        v_union_all = self.x + self.y
        v_union_all.sort()
        return v_union_all
    
    def intersect(self):
        v_intersect = []
        for i in self.result1:
            if i in self.result2:
                v_intersect.append(i)
        v_intersect.sort()
        return v_intersect
        
    def minus1(self):
        v_minus1 = []
        for i in self.result1:
            if i not in self.result2:
                v_minus1.append(i)
        v_minus1.sort()
        return v_minus1
    
    def minus2(self):
        v_minus2 = []
        for i in self.result2:
            if i not in self.result1:
                v_minus2.append(i)
        v_minus2.sort()
        return v_minus2

 

# 생성 후 test 해보자!

# 인스턴스화 하고 인스턴스화된 변수명.함수명 으로 호출

s = Set(lst1, lst2)
s.result1
s.result2

s = Set(lst1, lst2)
s.union()

s = Set(lst1, lst2)
s.union_all()

s = Set(lst1, lst2)
s.intersect()

s = Set(lst1, lst2)
s.minus1()
s.minus2()

 

[문제]_1. 아래와 같이 호출되게 코드작성하세요.

s = Set()
s.union(lst1, lst2)
s.union_all(lst1, lst2)
s.intersect(lst1, lst2)
s.minus1(lst2, lst2)
s.minus2(lst2, lst2)

 

# [내가 작성한 코드]

class Set:  
    # 유일한 값 담을 수 있는 변수 선언
    result1 = [] 
    result2 = []
        
    def union(self, x, y):
        x_1 = [] # result1, x의 값들 중에 중복제거 변수
        for i in x:
            if i not in x_1:
                x_1.append(i)
        y_1 = [] # result2, y의 값들 중에 중복제거 변수
        for i in y:
            if i not in y_1:
                y_1.append(i)
                
        # union 로직 구현
        result = [] # temp, x_1와 y_1 의 값들의 중복값 제거 변수
        for i in x_1:
            if i not in y_1:
                result.append(i)
        result = result + y_1
        result.sort()
        return result

    def union_all(self, x, y):
        result = []
        result = x + y
        result.sort()
        return result
    
    def intersect(self, x, y):
        x_1 = [] # x의 값들 중에 유일한 값 변수
        for i in x:
            if i not in x_1:
                x_1.append(i)
        y_1 = [] # y의 값들 중에 유일한 값 변수
        for i in y:
            if i not in y_1:
                y_1.append(i)
                
        result = [] # temp, 
        for i in x_1:
            if i in y_1:
                result.append(i)
        result.sort()
        return result
        
    def minus1(self, x, y):
        x_1 = [] # x의 값들 중에 유일한 값 변수
        for i in x:
            if i not in x_1:
                x_1.append(i)
        y_1 = [] # y의 값들 중에 유일한 값 변수
        for i in y:
            if i not in y_1:
                y_1.append(i)
                
        result = [] # temp, 
        for i in x_1:
            if i not in y_1:
                result.append(i)
        result.sort()
        return result
    
    def minus2(self, x, y):
        x_1 = [] # x의 값들 중에 유일한 값 변수
        for i in x:
            if i not in x_1:
                x_1.append(i)
        y_1 = [] # y의 값들 중에 유일한 값 변수
        for i in y:
            if i not in y_1:
                y_1.append(i)
                
        result = [] # temp, 
        for i in y_1:
            if i not in x_1:
                result.append(i)
        result.sort()
        return result

 

# 인스턴스화 후 호출

s = Set()
s.union(lst1, lst2)
s.union_all(lst1, lst2)
s.intersect(lst1, lst2)
s.minus1(lst1, lst2)
s.minus2(lst1, lst2)

 

# [선생님] 작성 코드

class Set:
    def unique(self, x, y):
        self.x = x # => 인스턴스변수(self.x) = 형식매개변수(x)
        self.y = y
        
        # 유일한 값 담을 수 있는 변수 선언
        self.result1 = [] 
        self.result2 = []
        
        for i in self.x:
            if i not in self.result1:
                self.result1.append(i)
        
        for i in self.y:
            if i not in self.result2:
                self.result2.append(i)
        return (self.result1, self.result2)
        
s = Set()
s.unique(lst1, lst2)
x, y = s.unique(lst1, lst2)
x
y

 

# unique 함수로 lst1,lst2 지정.  각각의 함수에 넣어주자!

class Set:
    def unique(self, x, y):
        self.x = x # => 인스턴스변수(self.x) = 형식매개변수(x)
        self.y = y
        
        # 유일한 값 담을 수 있는 변수 선언
        self.result1 = [] 
        self.result2 = []
        
        for i in self.x:
            if i not in self.result1:
                self.result1.append(i)
        
        for i in self.y:
            if i not in self.result2:
                self.result2.append(i)
        return (self.result1, self.result2)
    
    def union(self, x, y):
        v_result1, v_result2 = self.unique(x, y)
        v_union = [] # local variable 
        for i in v_result1:
            if i not in v_result2:
                v_union.append(i)
        v_union = v_union + self.result2
        v_union.sort()
        return v_union
    
    def union_all(self, x, y):
        v_union_all = x + y
        v_union_all.sort()
        return v_union_all
    
    def intersect(self, x, y):
        v_result1, v_result2 = self.unique(x, y)
        v_intersect = []
        for i in v_result1:
            if i in v_result2:
                v_intersect.append(i)
        v_intersect.sort()
        return v_intersect
        
    def minus1(self, x, y):
        v_result1, v_result2 = self.unique(x, y)
        v_minus1 = []
        for i in v_result1:
            if i not in v_result2:
                v_minus1.append(i)
        v_minus1.sort()
        return v_minus1
    
    def minus2(self, x, y):
        v_result1, v_result2 = self.unique(x, y)
        v_minus2 = []
        for i in v_result2:
            if i not in v_result1:
                v_minus2.append(i)
        v_minus2.sort()
        return v_minus2

 

# 인스턴스화 후 호출

s = Set()
s.union(lst1, lst2)
s.union_all(lst1, lst2)
s.intersect(lst1, lst2)
s.minus1(lst1, lst2)
s.minus2(lst1, lst2)