파이썬 중요하진 않지만 알면 좋은 것들

임승환·2024년 4월 4일

Python

목록 보기

2/20

로로 드래그 하기

Shift + alt + 드래그

여러 줄 주석 처리하기

Ctrl + /

오류 날 시
Ctrl + shift 한번 누르고 사용해 볼것

f-string 쓸 때 중괄호 출력방법

중괄호를 2개 쓴다.

f"{{70 + 4}}"
# '{70 + 4}'

명령 프롬프트에서 파이썬 깔려 있는지 확인

python -V

# python shell 실행
python -i

ctrl + space

b = ''.???(['h','e','l','l','o'])
??? 에서 ctrl + space를 하면 가능한 함수 목록을 확인할 수 있음

alt + 마우스 클릭

: 여러 줄을 선택해서 볼 수 있다.

is 비교 연산자

string = 'str'
print(type(string) is str)
integer = 5678
print(type(integer) is int)

# 결과값
True
True

is 비교 연산자. 가리키는 주소가 서로 같은 지를 비교

isinstance(확인하고자 하는 데이터 값, 확인하고자 하는 데이터 타입)함수

print(isinstance(integer, int))
isinstance(i, str) # str
isinstance(i, tuple) # tuple

# 결과값
True

Falsy 조건

조건 연산자/논리 연산자를 사용했을 때 False로 평가되는 데이터

정수 : 0, 실수 : 0.0, 빈 문자열( “” ),빈 리스트( [] ),빈 튜플( () ), 빈 세트( {} )는 FALSE 반환한다.
나머지는 다 TRUE

리스트에서 큰 값 3개 반환하기

def pra_2(tax):
    res2 = []
    for i in range(3):
        m = tax.pop(tax.index(max(tax)))
				# tax 리스트가 3보다 작을 경우 오류 발생한다.
        res2.append(m)
    return res2

print(pra_2(array_t))

리스트가 3보다 작을 경우를 고려한 코드

def pra_2(tax):
		res2 = sorted(tax)[::-1] # 크기 를정렬해 역순으로 슬라이싱한다.
    return res2[:3] # 0-3까지 반환, 리스트가 3보다 작아도 오류 발생하지 않음
print(pra_2(array_t))

애너그램 분류

words = ['eat', 'tea', 'tan', 'ate', 'nat', 'bat']
def anagram(words):
		anagrams = dict()
    result =[]
    for i in words:
				key = ''.join(sorted(list(i)))
        anagrams.setdefault(key, [])
        anagrams[key].append(i)
		return [value for value in anagrams.values()]
print(anagram(words))

# 길게 쓴 코드
def anagram(words):
    # 애너그램에 해당되는 값들을 서로 비교해서
    # 같은 그룹이라면 해당 그룹에 리스트로 포함
    # 같은 그룹임을 확인할 수 있는 '키'를 지원해준다면?
    anagrams = dict()
    result =[]
    for i in words:
        # 문자열 -> 리스트(가변)화 -> 정렬 -> 애너그램(그룹)
        m = list(i)
        m.sort()
        # 불변형 반환(tuple, str)
        key = ''.join(m)
        anagrams.setdefault(key, [])
        anagrams[key].append(i)
    for value in anagrams.values():
        result.append(value)
    return result
print(anagram(words))

‘init’을 써야 초기화됨, 없으면 기존 코드처럼 읽으며 내려간다.
아래는 다중 상속

def ws_8_1():
    class Animal:
        num_of_animal = 0

        def __init__(self):
            Animal.num_of_animal += 1

    class Dog(Animal):
        # 인스턴스가 생성될 때(초기화)
        def __init__(self):
            super().__init__()

    class Cat(Animal):
        def __init__(self):
            super().__init__()

    class Pet(Dog, Cat):
        def __init__(self):
            super().__init__()

        @classmethod
        def access_num_of_animal(cls):
            return f'동물의 수는 {cls.num_of_animal}입니다.'

    dog = Dog()
    print(Pet.access_num_of_animal())
    cat = Cat()
    print(Pet.access_num_of_animal())

ws_8_1()

다중 상속

def ws_8_4():
    class Animal:
        num_of_animal = 0

        def __init__(self):
            Animal.num_of_animal += 1

        def bark(self):
            print('...')

    class Cat(Animal):
        def __init__(self):
            super().__init__()

        def meow(self):
            print('야옹!')

    class Dog(Animal):
        def __init__(self):
            super().__init__()

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

    class Pet(Dog, Cat):
        def __init__(self, sound):
            super().__init__()
            self.sound = sound

        def make_sound(self):
            print(self.sound)

        @staticmethod
        def play():
            print('애완동물과 놀기')

    pet1 = Pet("그르르")
    pet1.make_sound()
    pet1.bark()
    pet1.meow()
    pet1.play()

ws_8_4()

메소드 안쪽에서만 super 쓸 것

class Animal1:
    def __init__(self):
        self.a1 = 1
        print("Animal1의 생성자 호출")

    def bark1(self):
        print(self.a1)

class Animal2:
    def __init__(self):
        self.a2 = 2
        print("Animal2의 생성자 호출")

    def bark2(self):
        print(self.a2)

class Cat(Animal1):
    def __init__(self):
        super().__init__()
        self.c1 = 3
        print("Cat의 생성자 호출")

    def bark3(self):
        print(self.c1)

class Dog(Animal2):
    def __init__(self):
        super().__init__()
        self.d1 = 4
        print("Dog의 생성자 호출")

    def bark4(self):
        print(self.d1)

class Pet(Cat, Dog):
    def __init__(self):
        super().__init__()
        # Dog.__init__(self) 이게 없으면 오류난다.
				# 다중상속이라서 펫 생성자에 super() 말고 부모생성자를
				# 직접 명시함
        self.p1 = 5
        print("Pet의 생성자 호출")

    def bark5(self):
        print(self.p1)

print(Pet.mro())
p = Pet()

p.bark1()
p.bark2()
p.bark3()
p.bark4()
p.bark5()

‘str’ 오버라이딩

def ws_8_5():
    class Animal:
        num_of_animal = 0

        def __init__(self):
            Animal.num_of_animal += 1

        def bark(self):
            print('...')

    class Cat(Animal):
        sound = '야옹'

        def meow(self):
            print('야옹!')

    class Dog(Animal):
        sound = '멍멍'

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

    class Pet(Dog, Cat): #Cat,Dog순으로 바꾸면 소리 값 바뀜
        def __init__(self):
            super().__init__()
            #self.sound = sound

        def make_sound(self):
            print(self.sound)

        @staticmethod
        def play():
            print('애완동물과 놀기')

        def __str__(self):
            return f'애완동물은 {self.sound} 소리를 냅니다.'

    pet1 = Pet()
    print(pet1)

ws_8_5()

Try - except문

def check_number():
    while True:
        try:
            num = int(input('숫자를 입력하세요 :'))
            if num > 0:
                print('양수입니다.')
            elif num < 0:
                print('음수입니다.')
            elif num == 0:
                print('0입니다.')
        except ValueError:
            print('잘못된 입력입니다.')
            break

check_number()

최댓값에 해당하는 요소 인덱스 반환

arr = [1, 5, 7, 43, 76, 2, 3, 5, 3, 6, 1]

# 최댓값에 해당하는 요소 인덱스를 반환하여라
mx = arr[0]
max_i = 0
for i in range(len(arr)):
    if mx < arr[i]:
        mx = arr[i]
        max_i = i


mx = arr[0]
max_i = 0
for i, val in enumerate(arr):
    if mx < arr[i]:
        mx = arr[i]
        max_i = i

print(*enumerate(arr)) # 튜플로 인덱스 값을 같이 가져온다

idx, val = max(enumerate(arr), key = lambda x: x[1]) # N
print(idx)
print(val)