플광노트

"""
    FileName: My_Error.py
    Created: 2023-05-09
    Description :
        내가 맘대로 정의한 예외 클래스

"""

class MyError(Exception):
    pass

"""
    FileName: LottoNumberMaker.py
    Created: 2023-05-09
    Description :
        로또 추출기 클래스
"""
import random
from My_Error import MyError


class LottoExtractor():
    def __init__(self):
        self.extracted_list = []

    def get_new_lotto_num_list(self):
        self.lotto_num_reset()
        return self.extracted_list

    def lotto_num_reset(self):
        self.extracted_list = random.sample(range(1, 46), 7)

    def lotto_result(self, list_):
        self.verifying_input_list(list_)
        same_count = 0
        has_bonus = False
        for user_num in list_:
            if user_num in self.extracted_list[:6]:
                same_count += 1
            if user_num == self.extracted_list[6]:
                has_bonus = True

        if same_count == 6:
            return 1
        elif same_count == 5:
            if has_bonus is True:
                return 2
            else:
                return 3
        elif same_count == 4:
            return 4
        elif same_count == 3:
            return 5
        else:
            return 6

    def verifying_input_list(self, list_):
        if len(list_) != 6:
            raise MyError("6개의 숫자가 들어와야합니다.")

        for i in list_:
            if type(i) != "int":
                raise MyError("숫자가 아닙니다.")

"""
    FileName: my_first_unit_test.py
    Created: 2023-05-09
    Description :
        로또 추출기 클래스에 대한 테스트 케이스
"""
from unittest import TestCase
from LottoNumberMaker import LottoExtractor
from My_Error import MyError


class MyTests(TestCase):

    def setUp(self) -> None:
        """
        로또 추출기 객체 생성, 테스트마다 새로운 객체로 매번 갱신됨
        :return:
        """
        self.extractor = LottoExtractor()

    def test_lotto_making_seven_elements(self):
        """
        로또 추출기는 7자리 수를 만들어내야한다.
        :return: None
        """
        self.extractor = LottoExtractor()
        lotto_num_list_1 = self.extractor.get_new_lotto_num_list()
        lotto_num_list_2 = self.extractor.get_new_lotto_num_list()
        self.assertEqual(len(lotto_num_list_1), 7)
        self.assertEqual(len(lotto_num_list_2), 7)

    def test_lotto_nums_all_different(self):
        """
        로또 추출기의 모든 요소들은 서로 다른 값을 가지고 있다.
        :return: None
        """
        lotto_num_list_1 = self.extractor.get_new_lotto_num_list()
        for _ in range(100):
            for i, e1 in enumerate(lotto_num_list_1):
                for j, e2 in enumerate(lotto_num_list_1):
                    if i != j:
                        self.assertNotEqual(e1, e2)

    def test_extractor_takes_only_numbers(self):
        """
        로또 추출기에 넣을 리스트는 숫자만 집어 넣을 수 있다.
        :return: None
        """
        self.assertRaises(Exception, self.extractor.lotto_result, ['a', 1, 2, 3, 4, 5])
        self.assertRaises(Exception, self.extractor.lotto_result, ['a', "b", "c", "d", "e", "f"])
        self.assertRaises(Exception, self.extractor.lotto_result, ['1', "2", "3", "4", "5", "6"])
        # with self.assertRaises(Exception) as context:
        #     self.extractor.lotto_result(['a', 1, 2, 3, 4, 5])

    def test_extractor_raise_when_take_string_list(self):
        """
        숫자가 아닌 것이 들어가면 예외가 발생한다.
        :return: None
        """
        error_message = "숫자가 아닙니다."
        with self.assertRaises(Exception) as assert_error:
            self.extractor.lotto_result("123456")
        self.assertEqual(assert_error.exception.args[0], error_message)
        # self.assertRaises(MyError, self.extractor.lotto_result, "123456")

    def test_extractor_return_one_to_six(self):
        """
        6개 숫자가 아닌 것이 들어가면 예외가 발생한다.
        :return: None
        """
        error_message = "6개의 숫자가 들어와야합니다."
        with self.assertRaises(MyError) as assert_error_1:
            self.extractor.lotto_result([1, 2, 3, 4, 5])
        with self.assertRaises(MyError) as assert_error_2:
            self.extractor.lotto_result([1])
        with self.assertRaises(MyError) as assert_error_3:
            self.extractor.lotto_result([])
        self.assertIn(assert_error_1.exception.args[0], error_message)
        self.assertIn(assert_error_2.exception.args[0], error_message)
        self.assertIn(assert_error_3.exception.args[0], error_message)

    def test_extractor_take_num_range_1_to_45(self):
        """
        범위 밖 숫자가 들어올 경우 에러를 던진다.
        :return: None
        """
        error_message = "1~45 범위의 숫자가 들어와야합니다."
        with self.assertRaises(MyError) as assert_error_1:
            self.extractor.lotto_result([100, 1, 2, 3, 4, 5])
        self.assertEqual(assert_error_1.exception.args[0], error_message)

        with self.assertRaises(MyError) as assert_error_2:
            self.extractor.lotto_result([1, 0, 2, 3, 4, 45])
        self.assertEqual(assert_error_2.exception.args[0], error_message)

        with self.assertRaises(MyError) as assert_error_3:
            self.extractor.lotto_result([-1, 1, 2, 3, 4, 45])
        self.assertEqual(assert_error_3.exception.args[0], error_message)

6개가 되면 some_widget.setEnabled(False)를 줘서 추가로 선택하지 못하게 기능을 추가해보았습니다.

소스코드는 다음과 같습니다.

"""
    fileName : MyLottoLogic.py
    description : 로또 추출기 클래스
"""

import random


class LottoNumExtractor():
    def __init__(self):
        self.to_check_list = []
        self.this_time_extraction_numbers = []

    def __repr__(self):
        return f"now check_list = {self.to_check_list} and now extracted num = {self.this_time_extraction_numbers}"

    def make_new_lotto_num(self):
        self.this_time_extraction_numbers = random.sample([x for x in range(1, 46)], 7)

    def get_extracted_lotto_num(self):
        return self.this_time_extraction_numbers

    def get_lotto_result(self, list_):
        if len(list_) != 6:
            raise "6개 숫자가 들어와야 합니다"
        for n in list_:
            if not 0 <= n <= 45:
                raise f"1~45의 숫자가 들어와야합니다. 문제가 되는 입력 : {n}"

        self.make_new_lotto_num()
        count = 0
        for n in list_:
            if n in self.this_time_extraction_numbers[:6]:
                count += 1

        if count == 6:  # 1등인 경우
            return 1
        elif count == 5:  # 2, 3등인 경우
            if self.this_time_extraction_numbers[6] in list_:
                return 2
            else:
                return 3

        elif count == 4:  # 4등인 경우
            return 4
        elif count == 3:  # 5등인 경우
            return 5

        return 6


if __name__ == '__main__':
    app = LottoNumExtractor()
    for i in range(100):
        print(app.get_lotto_result([1, 2, 3, 4, 5, 6]))

"""
    fileName : lotto_window.py
    description : 로또 번호 고르고, 당첨결과를 조회하는 GUI 화면 클래스
"""

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import SelectionLottoWindow
import MyLottoLogic


class MyLottoWindow(QMainWindow, SelectionLottoWindow.Ui_LottoWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self) # desinger 디자인대로 셋업
        self.make_widget_groups() # 위젯(combobox, checkbox, pushbutton) 그룹을 만들어줌
        self.make_lotto_machine() # 로또 번호 생성하고, 6자리 리스트를 넣으면 당첨결과를 반환하는 객체를 만듦
        self.make_my_lucky_num_list() # 각 라인별로 선택한 번호를 저장할 리스트를 생성함

        #### 시그널 선언 ####
        self.connect_signal_comboboxs() # 콤보박스 시그널 매칭
        self.connect_signal_checkboxs() # 체크박스 시그널 매칭
        self.connect_signal_pushbuttons() # 푸시버튼 시그널 매칭

        # "당첨결과 확인하기" 눌렀을 경우
        self.get_lotto_btn_1.clicked.connect(lambda x: self.check_lotto_result(1)) # 1번 라인 당첨 결과 확인
        self.get_lotto_btn_2.clicked.connect(lambda x: self.check_lotto_result(2)) # 2번 라인 당첨 결과 확인
        self.get_lotto_btn_3.clicked.connect(lambda x: self.check_lotto_result(3)) # 3번 라인 당첨 결과 확인
        # TODO: <기능> <통계> 버튼 눌렀을 경우, 메시지창 띄우기

    # TODO: lineEdit_1 중복 있을 시, result_label_1 에 중복값 있다고 setText
    def make_my_lucky_num_list(self):
        self.my_lucky_num_list_1 = [1, 2, 3, 4, 5, 6]
        self.my_lucky_num_list_2 = []
        self.my_lucky_num_list_3 = []

    def make_lotto_machine(self):
        self.lotto_machine = MyLottoLogic.Lotto_Num_Extractor()

    def make_widget_groups(self):
        ### 변수 그룹 선언 ###
        self.combo_group = []  # combobox
        self.cb_group = []  # checkbox
        self.pb_group = []  # pushbutton
        for i in range(1, 7):
            self.combo_group.append(self.__getattribute__("combo_" + f"{i}"))

        for i in range(1, 46):
            self.cb_group.append(self.__getattribute__("cb_" + f"{i:02}"))

        for i in range(1, 46):
            self.pb_group.append(self.__getattribute__("pb_" + f"{i:02}"))

    def connect_signal_comboboxs(self):
        for i, combobox in enumerate(self.combo_group):
            combobox.currentIndexChanged.connect(lambda x, y=i: self.add_my_lucky_num_list_1(x, y))

    def connect_signal_checkboxs(self):
        for i, checkbox in enumerate(self.cb_group):
            checkbox.toggled.connect(lambda x, y=i: self.add_my_lucky_num_list_2(x, y + 1))

    def connect_signal_pushbuttons(self):
        for i, pushbutton in enumerate(self.pb_group):
            pushbutton.toggled.connect(lambda x, y=i: self.add_my_lucky_num_list_3(x, y + 1))

    def console_print_group_state(self):
        """
        콘솔에 group 찍기
        :return: None
        """
        print('combo_group')
        for i in self.combo_group:
            print(i.objectName())

        print('checkbox_group')
        for i in self.cb_group:
            print(i.objectName())

        print('pushbutton_group')
        for i in self.pb_group:
            print(i.objectName())

    def check_lotto_result(self, btn_index):
        """
        "당첨결과 확인하기" 눌렀을 경우 , 해당 my_lucky_num_list 의 선택번호대로 당첨결과를 메세지박스로 알려줌
        :param btn_index:
        :return: None
        """
        if btn_index == 1:
            result = self.lotto_machine.get_lotto_result(self.my_lucky_num_list_1)
        elif btn_index == 2:
            result = self.lotto_machine.get_lotto_result(self.my_lucky_num_list_2)
        elif btn_index == 3:
            result = self.lotto_machine.get_lotto_result(self.my_lucky_num_list_3)

        if result == 6:
            result = "낙첨"
        else:
            result = str(result) + "등"
        QMessageBox.about(self, "당첨 결과",
                          f"""추첨번호 : {sorted(self.lotto_machine.get_extracted_lotto_num()[:6])}, 보너스 번호 : {self.lotto_machine.get_extracted_lotto_num()[6]} 
    선택 번호 : {sorted(self.__getattribute__(f"my_lucky_num_list_{btn_index}"))}\n당첨 결과는 {result} 입니다.""")

    def add_my_lucky_num_list_1(self, num, list_index):
        """
        combobox의 값을 설정할 때 마다, my_lucky_num_list_1 에 값을 변경 하는 함수
        :param num: 콤보 박스에서 선택한 값
        :param list_index: 몇 번째 콤보박스에서 값을 던지는지 인덱스를 받음
        :return:
        """

        self.my_lucky_num_list_1.pop(list_index)
        self.my_lucky_num_list_1.insert(list_index, num + 1)
        print(self.my_lucky_num_list_1)
        self.show_my_lucky_num_list(1)

    def add_my_lucky_num_list_2(self, toggle_value, num):
        if toggle_value is True:
            self.my_lucky_num_list_2.append(num)
        else:
            self.my_lucky_num_list_2.remove(num)

        if len(self.my_lucky_num_list_2) < 6:
            for i, checkbox in enumerate(self.cb_group):
                checkbox.setEnabled(True)
        else:
            for i, checkbox in enumerate(self.cb_group):
                if (i + 1) not in self.my_lucky_num_list_2:
                    checkbox.setEnabled(False)
        self.show_my_lucky_num_list(2)

    def add_my_lucky_num_list_3(self, toggle_value, num):
        if toggle_value is True:
            self.my_lucky_num_list_3.append(num)
        else:
            self.my_lucky_num_list_3.remove(num)

        if len(self.my_lucky_num_list_3) < 6:
            for i, checkbox in enumerate(self.pb_group):
                checkbox.setEnabled(True)
        else:
            for i, checkbox in enumerate(self.pb_group):
                if (i + 1) not in self.my_lucky_num_list_3:
                    checkbox.setEnabled(False)
        self.show_my_lucky_num_list(3)

    def show_my_lucky_num_list(self, index):
        """
        my_lucky_num_list_1에 따라 label 표시 함수
        :return: None
        """
        sorted_string_list = []

        for i in sorted(self.__getattribute__(f"my_lucky_num_list_{index}")):
            if i != 0:
                sorted_string_list.append(str(i))

        result_string = ", ".join(sorted_string_list)

        self.__getattribute__("result_label_" + str(index)).setText(result_string)

    def list_has_no_repeat(self, list_):
        """
            로또 번호는 중복값이 없음. 뽑은 숫자 리스트를 인자로 받음
            중복값이 있을 경우 False를
            중복값이 없을 경우 True를 반환한다.
        :return: boolean
        """
        list_set = set(list_)
        if len(list_set) != len(list_):
            return False
        else:
            return True


if __name__ == '__main__':
    app = QApplication(sys.argv)
    myWindow = MyLottoWindow()
    myWindow.show()
    app.exec_()​

import sys
import os
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5 import uic


def resource_path(relative_path):
    base_path = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
    return os.path.join(base_path, relative_path)


login_window = resource_path('login_window.ui')
login_window_class = uic.loadUiType(login_window)[0]

login_result_modal = resource_path('login_modal.ui')
login_result_modal_class = uic.loadUiType(login_result_modal)[0]

main_window = resource_path('main_menu.ui')
main_window_class = uic.loadUiType(main_window)[0]


class MainWindowClass(QMainWindow, main_window_class):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowFlags(Qt.FramelessWindowHint)

        # 여기에 시그널, 설정
        self.btn_play.clicked.connect(self.btn_play_clicked)
        self.btn_home.clicked.connect(self.btn_home_clicked)
        self.btn_profile.clicked.connect(self.btn_profile_clicked)
        self.btn_collection.clicked.connect(self.btn_collection_clicked)
        self.btn_TFT.clicked.connect(self.btn_TFT_clicked)
        self.btn_user_box.clicked.connect(self.btn_user_box_clicked)
        self.btn_shop.clicked.connect(self.btn_shop_clicked)
        self.btn_user_logo.clicked.connect(self.btn_user_logo_clicked)
        self.btn_qustion.clicked.connect(self.btn_question_clicked)
        self.btn_minimize.clicked.connect(self.btn_minimize_clicked)
        self.btn_setting.clicked.connect(self.btn_setting_clicked)
        self.btn_close.clicked.connect(self.btn_close_clicked)
        self.btn_online_state.clicked.connect(self.btn_online_state_clicked)
        self.btn_this_week_lotation.clicked.connect(self.btn_this_week_lotation_clicked)

    # 여기에 함수 설정
    def upper_bar_frame(self): # 상단 프레임 드래그앤드롭
        pass

    def btn_play_clicked(self):
        self.main_body_stack.setCurrentIndex(0)

    def btn_home_clicked(self):
        self.main_body_stack.setCurrentIndex(1)

    def btn_profile_clicked(self):
        self.main_body_stack.setCurrentIndex(2)

    def btn_collection_clicked(self):
        self.main_body_stack.setCurrentIndex(3)

    def btn_TFT_clicked(self):
        self.main_body_stack.setCurrentIndex(4)

    def btn_user_box_clicked(self):
        pass

    def btn_shop_clicked(self):
        pass

    def btn_user_logo_clicked(self):
        pass

    def btn_question_clicked(self):
        pass

    def btn_minimize_clicked(self):
        pass

    def btn_setting_clicked(self):
        pass

    def btn_online_state_clicked(self):
        pass

    def btn_this_week_lotation_clicked(self):
        pass

    def btn_close_clicked(self):
        self.close()


class LoginWindowClass(QMainWindow, login_window_class):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowFlags(Qt.FramelessWindowHint)

        # 여기에 시그널, 설정
        self.btn_login.clicked.connect(self.btn_login_clicked)
        self.btn_main.clicked.connect(self.btn_main_menu_clicked)

    # 여기에 함수 설정
    def btn_login_clicked(self):
        self.login_result_window = LoginResultModalClass()
        self.login_result_window.show()

    def btn_main_menu_clicked(self):
        self.main_window = MainWindowClass()
        self.main_window.show()
        self.close()


class LoginResultModalClass(QWidget, login_result_modal_class):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowFlags(Qt.FramelessWindowHint)

        # 여기에 시그널, 설정
        self.btn_confirm.clicked.connect(self.btn_confirm_clicked)

    # 여기에 함수 설정
    def btn_confirm_clicked(self):
        self.close()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    myWindow = LoginWindowClass()
    myWindow.show()
    app.exec_()

import datetime
import sys

from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *


class Main(QDialog):
    def __init__(self):
        super().__init__()
        self.config_ui()

    def config_ui(self):
        main_layout = QFormLayout()
        # 이름 h-box-layout
        name_layout = QHBoxLayout()
        name_edit_line = QLineEdit()
        name_layout.addWidget(name_edit_line)

        # 생일 h-box-layout
        birthday_layout = QHBoxLayout()
        year_combo_box = QComboBox()
        month_combo_box = QComboBox()
        date_combo_box = QComboBox()
        next_year = datetime.datetime.now().year + 1
        year_combo_box.addItems([str(x) for x in range(1900, next_year)])
        month_combo_box.addItems([str(x) for x in range(1, 13)])
        date_combo_box.addItems([str(x) for x in range(1, 32)])
        birthday_layout.addWidget(year_combo_box)
        birthday_layout.addWidget(month_combo_box)
        birthday_layout.addWidget(date_combo_box)

        # 주소 h-box-layout
        address_layout = QVBoxLayout()
        address_box = QComboBox()
        address_box.addItems([
            "서울", "광주", "경기", "울산", "부산", "강원"
        ])
        detail_address_edit_line = QLineEdit()
        address_layout.addWidget(address_box)
        address_layout.addWidget(detail_address_edit_line)

        # 이메일 h-box-layout
        email_layout = QHBoxLayout()
        email_edit_line = QLineEdit()
        email_company_line = QLineEdit()
        email_company_combobox = QComboBox()
        email_company_combobox.addItems([
            "google.com", "naver.com", "daum.net"
        ])
        email_layout.addWidget(email_edit_line)
        email_layout.addWidget(QLabel("@"))
        email_layout.addWidget(email_company_line)
        email_layout.addWidget(email_company_combobox)

        # 전화번호 h-box-layout
        phone_number_layout = QHBoxLayout()
        phone_number_front = QLineEdit()
        phone_number_middle = QLineEdit()
        phone_number_end = QLineEdit()
        phone_number_layout.addWidget(phone_number_front)
        phone_number_layout.addWidget(QLabel("-"))
        phone_number_layout.addWidget(phone_number_middle)
        phone_number_layout.addWidget(QLabel("-"))

        phone_number_layout.addWidget(phone_number_end)

        # 키 h-box-layout
        height_layout = QHBoxLayout()
        height_widget = QSpinBox()
        height_widget.setValue(20)
        height_layout.addWidget(height_widget)

        # 개인정보 제공 h-box-layout
        privacy_information_share_layout = QHBoxLayout()
        privacy_info_share_agree_checkbox = QCheckBox()
        privacy_info_share_agree_checkbox.setChecked(True)
        privacy_information_share_layout.addWidget(privacy_info_share_agree_checkbox)
        privacy_information_share_layout.addWidget(QLabel("동의"))
        privacy_information_share_layout.addStretch()

        # 플레인 텍스트 h-box-layout
        self_introduction_layout = QHBoxLayout()
        self_intro_text = QPlainTextEdit()
        self_introduction_layout.addWidget(self_intro_text)

        # Save or cancel button h-box-layout
        save_cancel_layout = QHBoxLayout()
        save_button = QPushButton()
        save_button.setText("저장")
        cancel_button = QPushButton()
        cancel_button.setText("취소")
        save_cancel_layout.addWidget(save_button)
        save_cancel_layout.addWidget(cancel_button)

        # add row on main layout
        main_layout.addRow("이름: ", name_layout)
        main_layout.addRow("생일: ", birthday_layout)
        main_layout.addRow("주소: ", address_layout)
        main_layout.addRow("E-mail: ", email_layout)
        main_layout.addRow("전화번호: ", phone_number_layout)
        main_layout.addRow("키: ", height_layout)
        main_layout.addRow("개인정보제공 동의: ", privacy_information_share_layout)
        main_layout.addRow("자기소개: ", self_introduction_layout)
        main_layout.addRow("", save_cancel_layout)

        # showing
        self.setFont(QFont("맑은 고딕", 12))
        self.setLayout(main_layout)
        self.resize(300, 400)
        self.show()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    sample_window = Main()
    app.exec()

print(type(True))
print(type(False))

<class 'bool'>
<class 'bool'>

print('a is True ? ', bool('a'))
print('\'\' is True ? ', bool(''))
print('1 is True ? ', bool(1))
print('0 is True ? ', bool(0))
print('[1,2] is True ?', bool([1, 2]))
print('[] is True ?', bool([]))
# print('(1,2) is True ?', bool(tuple(1, 2))) # error!! tuple 내 값이 존재할 경우.
print('() is True ?', bool(tuple()))
print('dict{"a":"1"} is True ?', bool({'a': '1'}))
print('dict{} is True ?', bool(dict()))
print('None is True ?', bool(None))

a is True ?  True
'' is True ?  False
1 is True ?  True
0 is True ?  False
[1,2] is True ? True
[] is True ? False
() is True ? False
dict{"a":"1"} is True ? True
dict{} is True ? False
None is True ? False

print('[True and True] is True?', bool(True and True))
print('[True and False] is True?', bool(True and False))
print('[False and False] is True?', bool(False and False))
print('[True or True] is True?', bool(True or True))
print('[True or False] is True?', bool(True or False))
print('[True ^ True] is True?', bool(True ^ True))
print('[True ^ False] is True?', bool(True ^ False))
print('[True & False] is True?', bool(True & False))  # && 연산자 없음!
print('[True | False] is True?', bool(True | False))  # || 연산자 없음!
list_ = [1, 2, 3]
print('[5 in list_] is True?', bool(5 in list_))
print('[1 in list_] is True?', bool(1 in list_))
print('[5 not in list_] is True?', bool(5 not in list_))
print('[True ^ bool(None)] is True?', bool(True ^ bool(None)))

[True and True] is True? True
[True and False] is True? False
[False and False] is True? False
[True or True] is True? True
[True or False] is True? True
[True ^ True] is True? False
[True ^ False] is True? True
[True & False] is True? False
[True | False] is True? True
[5 in list_] is True? False
[1 in list_] is True? True
[5 not in list_] is True? True
[True ^ bool(None)] is True? True

list_1 = [1.2]
list_2 = [1.2]
print('id(list_1) : ', id(list_1))
print('id(list_2) : ', id(list_2))
print('bool(list_1 == list_2) is True?', bool(list_1 == list_2))

id(list_1) :  1796999509696
id(list_2) :  1797000082240
bool(list_1 == list_2) is True? True

print('str : "abc"')
print('numeric : 0, 2, 3..')
print('bool : True, False')
print('collection : list, dict, tuple,..')
print('special : None')

str : "abc"
numeric : 0, 2, 3..
bool : True, False
collection : list, dict, tuple,..
special : None

my_name = input('이름이 무엇입니까?')
print(type(my_name)) # // "1"를 입력했을 때

<class 'str'>

# 문제1: 다음은 경찰청 부산광역시경찰청 교통사고 발생 현황.csv 의 일부 내용입니다.
"""구분,발생건수,사망자 수,부상자 수
2019,13250,127,18357
2020,12091,112,16664
2021,11550,118,15880
2022,11133,119,15335
"""
# 문제 1-1) 2019 ~ 2022년도 사망자 수와 부상자 수 평균을 구하세요(str함수 사용!)
# 해설:
# ta : traffic_accident
ta_data = """구분,발생건수,사망자 수,부상자 수
2019,13250,127,18357
2020,12091,112,16664
2021,11550,118,15880
2022,11133,119,15335
""".split('\n')

ta_data_2019 = ta_data[1].split(',')
ta_data_2020 = ta_data[2].split(',')
ta_data_2021 = ta_data[3].split(',')
ta_data_2022 = ta_data[4].split(',')

death_sum = 0
death_sum += int(ta_data_2019[2])
death_sum += int(ta_data_2020[2])
death_sum += int(ta_data_2021[2])
death_sum += int(ta_data_2022[2])

injury_sum = 0
injury_sum += int(ta_data_2019[3])
injury_sum += int(ta_data_2020[3])
injury_sum += int(ta_data_2021[3])
injury_sum += int(ta_data_2022[3])
print(f"2019 ~ 2022년도 사망자 수 평균 : {death_sum / 4:10.1f}명")
print(f"2019 ~ 2022년도 부상자 수 평균 : {injury_sum / 4:10.1f}명")

# 문제 1-2) 최근 4년 동안 교통사고 발생건수의 합은 몇 건입니까?
ta_sum = 0
ta_sum += int(ta_data_2019[1])
ta_sum += int(ta_data_2020[1])
ta_sum += int(ta_data_2021[1])
ta_sum += int(ta_data_2022[1])
print(f"2019 ~ 2022년도 교통사고 발생건수 합 : {ta_sum:10d}건")

2019 ~ 2022년도 사망자 수 평균 :      119.0명
2019 ~ 2022년도 부상자 수 평균 :    16559.0명
2019 ~ 2022년도 교통사고 발생건수 합 :      48024건

# 문제 2: 다음은 인천광역시 미추홀구_제설함 현황(도화 1동).csv 의 일부 내용입니다.
prevent_snow_data = """연번,구분,관리부서,전화번호,도로명주소
1,제설함,도화1동,032-728-6281,인천광역시 미추홀구 주안서로33번길 14
2,제설함,도화1동,032-728-6281,인천광역시 미추홀구 주안서로53번길 65
3,제설함,도화1동,032-728-6281,인천광역시 미추홀구 주안서로33번길 52
4,제설함,도화1동,032-728-6281,인천광역시 미추홀구 주안서로33번길 71
5,제설함,도화1동,032-728-6281,인천광역시 미추홀구 경인로265번길 43""".split("\n")

data_title = prevent_snow_data[0].split(',')
data_row_1 = prevent_snow_data[1].split(',')
data_row_2 = prevent_snow_data[2].split(',')
data_row_3 = prevent_snow_data[3].split(',')
data_row_4 = prevent_snow_data[4].split(',')
data_row_5 = prevent_snow_data[5].split(',')

# 문제 2-1) 이 데이터를 하나의 딕셔너리 구조로 만들어보세요.
# 해설 : 여러 방법 존재합니다.
prevent_icing_road_box_type_1 = {
    '구분': '제설함',
    '관리부서': '도화1동',
    '전화번호': '032-728-6281',
    '연번, 주소': [(1, '인천광역시 미추홀구 주안서로33번길 14'),
               (2, '인천광역시 미추홀구 주안서로53번길 65'),
               (3, '인천광역시 미추홀구 주안서로33번길 52'),
               (4, '인천광역시 미추홀구 주안서로33번길 71'),
               (5, '인천광역시 미추홀구 경인로265번길 43')]
}

prevent_icing_road_box_type_2 = {
    data_title[1]: data_row_1[1],
    data_title[2]: data_row_1[2],
    data_title[3]: data_row_1[3],
    data_title[0] + ', ' + data_title[4]: [(data_row_1[0], data_row_1[4]),
                                           (data_row_2[0], data_row_2[4]),
                                           (data_row_3[0], data_row_3[4]),
                                           (data_row_4[0], data_row_4[4]),
                                           (data_row_5[0], data_row_5[4])]
}
print(prevent_icing_road_box_type_1)
print(prevent_icing_road_box_type_2)

{'구분': '제설함', '관리부서': '도화1동', '전화번호': '032-728-6281', '연번, 주소': [(1, '인천광역시 미추홀구 주안서로33번길 14'), (2, '인천광역시 미추홀구 주안서로53번길 65'), (3, '인천광역시 미추홀구 주안서로33번길 52'), (4, '인천광역시 미추홀구 주안서로33번길 71'), (5, '인천광역시 미추홀구 경인로265번길 43')]}
{'구분': '제설함', '관리부서': '도화1동', '전화번호': '032-728-6281', '연번, 도로명주소': [('1', '인천광역시 미추홀구 주안서로33번길 14'), ('2', '인천광역시 미추홀구 주안서로53번길 65'), ('3', '인천광역시 미추홀구 주안서로33번길 52'), ('4', '인천광역시 미추홀구 주안서로33번길 71'), ('5', '인천광역시 미추홀구 경인로265번길 43')]}

# 문제 3: 다음은 대구광역시교육청 대구광역시립달성도서관_인기도서목록.csv 의 일부 내용입니다.
book_table_list = """순위,등록번호,청구기호,서명,저자,발행자,자료실,대출횟수
1,BPG000239319,J 219-그239-30,"그리스 로마 신화. 30, 기나긴 모험 그 끝의 이야기",박시연 글 ; 최우빈 그림,북이십일아울북,[달성]어린이자료실,12
2,BPG000188450,J 475-곰225ㅁ-2,미생물 세계에서 살아남기. 2,곰돌이 co. 글 ; 한현동 그림 ; 연합뉴스 ...[등]사진,미래엔 아이세움,[달성]어린이자료실,11
3,BPG000198559,J 594-조72ㅇ-2,"요리스타 청. 2, 아이스크림 대결",조재호 글 ; 은하수 그림,주니어김영사,[달성]어린이자료실,10
4,BPG000203012,J 813.8-반79-2,반지의 비밀일기. 2,종이 원작 ; 대원키즈 편집부 편,대원씨아이,[달성]어린이자료실,10
5,BPG000201625,J 407-곰225ㄴ-42,"내일은 실험왕 : 본격 대결 과학실험 만화. 42, 중력과 무중력",스토리 a. 글 ; 홍종현 그림,아이세움,[달성]어린이자료실,10
6,BPG000198464,J 508-도839,(도티&잠뜰) 빅데이터 : 빅브라더를 잡아라!,글: 전판교  ; 그림: 최우빈,대원키즈 ,[달성]어린이자료실,10""".split("\n")

table_title = book_table_list[0].split(',')
book_data_row_1 = book_table_list[1].split(',')
book_data_row_2 = book_table_list[2].split(',')
book_data_row_3 = book_table_list[3].split(',')
book_data_row_4 = book_table_list[4].split(',')
book_data_row_5 = book_table_list[5].split(',')
book_data_row_6 = book_table_list[6].split(',')
# 1, 3, 5 는 하나의 셀 안에 ,로 나뉘어져있음, 그럴 경우엔 ""(큰따옴표)로 묶어줄 필요 있음,
# 추후에 조건문과 반복문을 배우게 되면 함수 처리가 가능하지만, 우리가 배운 방식으로도 해결할 수 있습니다.
temp_title = book_data_row_1[3] + book_data_row_1[4]
del book_data_row_1[4] # 뒤쪽 인덱스부터 지워야 의도대로 삭제할 수 있습니다
del book_data_row_1[3]
book_data_row_1.insert(3, temp_title) # 이하는 마찬가지 방식으로..


temp_title = book_data_row_3[3] + book_data_row_3[4]
del book_data_row_3[4]
del book_data_row_3[3]
book_data_row_3.insert(3, temp_title)

temp_title = book_data_row_5[3] + book_data_row_5[4]
del book_data_row_5[4]
del book_data_row_5[3]
book_data_row_5.insert(3, temp_title)



# 문제 3-1) 다음 데이터를 리스트[딕셔너리] 구조로 만드세요
high_rank_rental_book_list = []
book_1 = {
    table_title[1]: book_data_row_1[1],
    table_title[2]: book_data_row_1[2],
    table_title[3]: book_data_row_1[3],
    table_title[4]: book_data_row_1[4],
    table_title[5]: book_data_row_1[5],
    table_title[6]: book_data_row_1[6],
}
book_2 = {
    table_title[1]: book_data_row_2[1],
    table_title[2]: book_data_row_2[2],
    table_title[3]: book_data_row_2[3],
    table_title[4]: book_data_row_2[4],
    table_title[5]: book_data_row_2[5],
    table_title[6]: book_data_row_2[6],
}
book_3 = {
    table_title[1]: book_data_row_3[1],
    table_title[2]: book_data_row_3[2],
    table_title[3]: book_data_row_3[3],
    table_title[4]: book_data_row_3[4],
    table_title[5]: book_data_row_3[5],
    table_title[6]: book_data_row_3[6],
}
book_4 = {
    table_title[1]: book_data_row_4[1],
    table_title[2]: book_data_row_4[2],
    table_title[3]: book_data_row_4[3],
    table_title[4]: book_data_row_4[4],
    table_title[5]: book_data_row_4[5],
    table_title[6]: book_data_row_4[6],
}
book_5 = {
    table_title[1]: book_data_row_5[1],
    table_title[2]: book_data_row_5[2],
    table_title[3]: book_data_row_5[3],
    table_title[4]: book_data_row_5[4],
    table_title[5]: book_data_row_5[5],
    table_title[6]: book_data_row_5[6],
}
book_6 = {
    table_title[1]: book_data_row_6[1],
    table_title[2]: book_data_row_6[2],
    table_title[3]: book_data_row_6[3],
    table_title[4]: book_data_row_6[4],
    table_title[5]: book_data_row_6[5],
    table_title[6]: book_data_row_6[6],
}
high_rank_rental_book_list.append(book_1)
high_rank_rental_book_list.append(book_2)
high_rank_rental_book_list.append(book_3)
high_rank_rental_book_list.append(book_4)
high_rank_rental_book_list.append(book_5)
high_rank_rental_book_list.append(book_6)

print(high_rank_rental_book_list)
# 문제 3-2) 만든 리스트에서 인기 순위 3위 이내의 출판사를 조합으로 만들어 출력하세요.
high_rank_publisher = {high_rank_rental_book_list[0]['발행자'],
                       high_rank_rental_book_list[1]['발행자'],
                       high_rank_rental_book_list[2]['발행자']}
print(high_rank_publisher)

[{'등록번호': 'BPG000239319', '청구기호': 'J 219-그239-30', '서명': '"그리스 로마 신화. 30 기나긴 모험 그 끝의 이야기"', '저자': '박시연 글 ; 최우빈 그림', '발행자': '북이십일아울북', '자료실': '[달성]어린이자료실'}, {'등록번호': 'BPG000188450', '청구기호': 'J 475-곰225ㅁ-2', '서명': '미생물 세계에서 살아남기. 2', '저자': '곰돌이 co. 글 ; 한현동 그림 ; 연합뉴스 ...[등]사진', '발행자': '미래엔 아이세움', '자료실': '[달성]어린이자료실'}, {'등록번호': 'BPG000198559', '청구기호': 'J 594-조72ㅇ-2', '서명': '"요리스타 청. 2 아이스크림 대결"', '저자': '조재호 글 ; 은하수 그림', '발행자': '주니어김영사', '자료실': '[달성]어린이자료실'}, {'등록번호': 'BPG000203012', '청구기호': 'J 813.8-반79-2', '서명': '반지의 비밀일기. 2', '저자': '종이 원작 ; 대원키즈 편집부 편', '발행자': '대원씨아이', '자료실': '[달성]어린이자료실'}, {'등록번호': 'BPG000201625', '청구기호': 'J 407-곰225ㄴ-42', '서명': '"내일은 실험왕 : 본격 대결 과학실험 만화. 42 중력과 무중력"', '저자': '스토리 a. 글 ; 홍종현 그림', '발행자': '아이세움', '자료실': '[달성]어린이자료실'}, {'등록번호': 'BPG000198464', '청구기호': 'J 508-도839', '서명': '(도티&잠뜰) 빅데이터 : 빅브라더를 잡아라!', '저자': '글: 전판교  ; 그림: 최우빈', '발행자': '대원키즈 ', '자료실': '[달성]어린이자료실'}]
{'주니어김영사', '미래엔 아이세움', '북이십일아울북'}

tu = (1, 2, 3) + (4,)
print(id(tu))
tu += (5,)
print(id(tu))

2097661672192
2097661668912

tu_name_1 = (1,)
tu_name_2 = (1,)
print("id(tu_name_1) :", id(tu_name_1))
print("id(tu_name_2) :", id(tu_name_2))  # 같은 주소값을 가진다!
tu = 1, 2  # 이런 식으로도 선언 가능하지만 비추천
print(id(tu))

id(tu_name_1) : 2097659620336
id(tu_name_2) : 2097659620336
2097660591040

tu_2 = (1, 2) * 10
print(tu_2)

(1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2)

tu_3 = tuple(range(1, 11))
print(tu_3)

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

print(tu_3[1])
print(tu_3[0: 5: 2])

2
(1, 3, 5)

tu_4 = (1, 2, (2,), (4, 5))
print(tu_4[3][1])

5

str_tu = ('hi', 'mike',)
str_tu += (1,)
str_tu_2 = ('hi', 1, 2.0)
str_tu_3 = (['hello', 'jason'], 2)
print(str_tu)
print(str_tu_2)
print(str_tu_3)

('hi', 'mike', 1)
('hi', 1, 2.0)
(['hello', 'jason'], 2)

list_tu = (['1', 2, 3, 4], 5, 6, 7)
print('before add "list_tu" id: ', id(list_tu))
list_tu[0].append(0)
print('after add "list_tu" id: ', id(list_tu))
print(list_tu)

before add "list_tu" id:  2097662113520
after add "list_tu" id:  2097662113520
(['1', 2, 3, 4, 0], 5, 6, 7)

str_tu = ('hi', 'mike')
# // str_tu[0] = str_tu[0].replace('hi', 'hello') # error!
print(str_tu)
print(str_tu[0][1])
tu_del = (1, 2, 3,)
# // del tu[1] error!
del tu #는 가능

('hi', 'mike')
i

tu_len = tuple(range(10))
print('len(tu_len): ', len(tu_len))

len(tu_len):  10

dict_ = dict()
dict_another_declare = {} # 이런 선언 방식은 추천하지 않음, 집합과 선언방식이 동일하여 가독성 해침
dict_structure = {'김윤재': 1, '송준혁': 2, '김혜빈': 3}
print(dict_structure)

{'김윤재': 1, '송준혁': 2, '김혜빈': 3}

print(dict_structure['김윤재'])
print(dict_structure.get('김윤재'))
print(dict_structure.get('박광현'))  # None 출력

1
1
None

dict_structure['주혜인'] = 4
dict_structure['김윤재'] = 0
print(dict_structure)

{'김윤재': 0, '송준혁': 2, '김혜빈': 3, '주혜인': 4}

del dict_structure['박광현'] # // error!!
print(dict_structure)

Traceback (most recent call last):
  File "C:\Users\KDT107\Desktop\learn_py\lecture.py", line 87, in <module>
    del dict_structure['박광현']
        ~~~~~~~~~~~~~~^^^^^^^
KeyError: '박광현'

for i in dict_structure:
    print(i)

0
2
3
4

dict_tuple = {(1,): 'hello'}
print(dict_tuple)

{(1,): 'hello'}

student = {
    'name': 'park',
    'age': 31,
    'address': 'gwang-ju',
    'cell-1': '010-',
    'cell-2': 'null',
    'enable': {'1st': 'python',
               '2nd': 'java',
               '3rd': 'C'},
    'tuple_type': (1, 2,),
    'set_type': set(range(10)),
    'subject': ['nursing', 's/w programming'],
    'tryNone': None
}

print(student.keys())
print(student.values())
print(student.items())
print(type(student.keys()))
print(type(student.values()))
print(type(student.items()))
# print(student.keys()[0])  # error!

dict_keys(['name', 'age', 'address', 'cell-1', 'cell-2', 'enable', 'tuple_type', 'set_type', 'subject', 'tryNone'])
dict_values(['park', 31, 'gwang-ju', '010-', 'null', {'1st': 'python', '2nd': 'java', '3rd': 'C'}, (1, 2), {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, ['nursing', 's/w programming'], None])
dict_items([('name', 'park'), ('age', 31), ('address', 'gwang-ju'), ('cell-1', '010-'), ('cell-2', 'null'), ('enable', {'1st': 'python', '2nd': 'java', '3rd': 'C'}), ('tuple_type', (1, 2)), ('set_type', {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), ('subject', ['nursing', 's/w programming']), ('tryNone', None)])
<class 'dict_keys'>
<class 'dict_values'>
<class 'dict_items'>

print('[for test start]')
for k, v in student.items():
    print('key : ', k)
    print('value : ', v)
print('[for test end]')

[for test start]
key :  name
value :  park
key :  age
value :  31
key :  address
value :  gwang-ju
key :  cell-1
value :  010-
key :  cell-2
value :  null
key :  enable
value :  {'1st': 'python', '2nd': 'java', '3rd': 'C'}
...
key :  tryNone
value :  None
[for test end]

student.clear()
print(student)  # {} 로 출력됨
del student
# print(student)  # error!

{}

dict_ = {'sample': 'apple'}
dict_.update({'greeting': 'hello'})
print(dict_)

{'sample': 'apple', 'greeting': 'hello'}

# data = dict_.pop() # error!
# data = dict_.pop(1)  # error!
data = dict_.pop('sample')
print(data)  # value만 리턴!

apple

x = ('key1', 'key2', 'key3')
y = 0
example_dict = dict.fromkeys(x, y)  # 또는
example_dict_2 = dict.fromkeys(x, -1)
print(example_dict)
print(example_dict_2)

{'key1': 0, 'key2': 0, 'key3': 0}
{'key1': -1, 'key2': -1, 'key3': -1}

s_list = [1, 7, 1, 3, 4, 5, 6, 3, 2, 1]
s = set(s_list)
s_direct = {3, 5, 6}
# s_range = {[range(10)],} # error, 중괄호 안에 리스트 사용 불가
s_range = set(range(10))  # 대신 set()함수 안에는 사용 가능함
print('s :', s)
print('s_direct :', s_direct)
print('s_range :', s_range)

s : {1, 2, 3, 4, 5, 6, 7}
s_direct : {3, 5, 6}
s_range : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

s_string = 'Hello! Every body!'
s_str = set(s_string)
print(s_str)

{'b', 'H', 'e', 'r', ' ', 'E', 'y', 'l', 'o', 'v', '!', 'd'}

s_range = set(range(10))
# s_range += {10} # error!  plus 연산자 안됨
# s_range.update(11) # error! update는 iterable만 가능!
s_range.add(10)
s_range.update((10,))
print(s_range)

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

s_range = set(range(10))
another_set = set.copy(s_range)
s_range = s_range | {11, 12,} # 합집합, s_range 정보를 변경함
another_set2 = s_range.copy()  # 둘다 사용 가능
print('s_range:', s_range)
print('another_set:', another_set)
print('another_set2:', another_set2)

s_range: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
another_set: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
another_set2: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

differ_set = set('abcde')
vowel_set = set('aeiou')
differ_vowel_set = differ_set - vowel_set  # 동일
print(differ_set.difference(vowel_set))  # {'c', 'd', 'b'}

{'b', 'd', 'c'}

discard_set = {'a', 'b', 'c'}
discard_set.discard('b')
print(discard_set)

{'a', 'c'}

odd_set = {1, 3, 5, 7, 9}
even_set = {0, 2, 4, 6, 8}
result_set = odd_set.intersection(even_set)
result_set2 = odd_set & even_set  # 동일
print("result_set :", result_set)  # set() 공집합
print("result_set2 :", result_set2)  # set() 공집합

result_set : set()
result_set2 : set()

result_set = odd_set.union(even_set)
result_set2 = odd_set | even_set
print("result_set :", result_set)  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print("result_set2 :", result_set2)

result_set : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
result_set2 : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

print(odd_set.isdisjoint(even_set))  # True

True

alpha_set = set("abcdefghijklmnopqrstuvwxyz")
hello_set = set("hello")
print(alpha_set.issubset(hello_set))  # False
print(hello_set.issubset(alpha_set))  # True

False
True

print(alpha_set.issuperset(hello_set))  # True
print(hello_set.issuperset(alpha_set))  # False

True
False

pop_set = set(range(10))  # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
result_element = pop_set.pop()
print(result_element)  # 0
result_element = pop_set.pop()
print(result_element)  # 1
result_element = pop_set.pop()
print(result_element)  # 2

0
1
2

rm_set = set(range(10))
rm_set.remove(1) # 1개만 인자를 받음
print("rm_set :", rm_set)  # {0, 2, 3, 4, 5, 6, 7, 8, 9}
// # rm_set.remove((4,5,6)) # error! iterable 타입 사용 불가
rm_set = rm_set - {4, 5, 6} # 차집합으로 응용 가능
print("rm_set :", rm_set)  # {0, 2, 3, 7, 8, 9}

rm_set : {0, 2, 3, 4, 5, 6, 7, 8, 9}
rm_set : {0, 2, 3, 7, 8, 9}

list_ = [n ** 2 for n in range(10)]
print(list_)

random_list = [(random.randint(2, 30)) ** 3 for n in range(10)]
print(random_list)

even_set = set(x for x in range(101) if x % 2 == 0)
print(even_set)

subjects = ['english', 'korea', 'science', 'social']
scores = [80, 100, 50, 20]
midterm_score_dict = {key: value for key, value in zip(subjects, scores)}
print(midterm_score_dict)

gen = (math.sqrt(x) for x in range(10, 13))
print(gen)
print(next(gen))
print(next(gen))
print(next(gen))
# print(next(gen)) #error! 3개만 선언했으므로!

alpha_list = ['a', 'b', 'c', 'd']
num_list = [1, 2, 3, 4]
cartesian_multi_list = [[a, n] for a in alpha_list for n in num_list]
print("cartesian_multi_list :", cartesian_multi_list)

matrix_1 = [
    [1, 2, 3],
    [4, 5, 6],
]

flatten = [e for r in matrix_1 for e in r]
print("flatten :", flatten)

[0, 1, 4, 9, 16]
[9261, 64, 512, 64, 27000]
{0, 2, 4}
{'english': 80, 'korea': 100, 'science': 50, 'social': 20}
<generator object <genexpr> at 0x000001B26112ADC0>
3.1622776601683795
3.3166247903554
3.4641016151377544
cartesian_multi_list : [['a', 1], ['a', 2], ['a', 3], ['b', 1], ['b', 2], ['b', 3], ['c', 1], ['c', 2], ['c', 3]]
flatten : [1, 2, 3, 4, 5, 6]

test_list_1 = []
test_list_2 = []
test_list_3 = []
test_list_4 = []
print(id(test_list_1))
print(id(test_list_2))
print(id(test_list_3))
print(id(test_list_4))

test_list_1.append(test_list_2)
test_list_1.append(test_list_2)
test_list_1.append(test_list_2)
test_list_2.append(2) 
print(test_list_1)

1865644838272
1865644838208
1865644838336
1865644838400
[[2], [2], [2]]

• 0열 선택0열 다음에 열 추가
• 1열 선택1열 다음에 열 추가
• 2열 선택2열 다음에 열 추가
• 3열 선택3열 다음에 열 추가
• 4열 선택4열 다음에 열 추가

• 0행 선택0행 다음에 행 추가
• 1행 선택1행 다음에 행 추가
• 2행 선택2행 다음에 행 추가
• 3행 선택3행 다음에 행 추가
• 4행 선택4행 다음에 행 추가

arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])
np.sort(arr)

[1, 2, 3, 4, 5, 6, 7, 8]

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
np.concatenate((a, b))

[1, 2, 3, 4, 5, 6, 7, 8]

array_example = np.array([[[0, 1, 2, 3],
[4, 5, 6, 7]],
[[0, 1, 2, 3],
[4, 5, 6, 7]],
[[0 ,1 ,2, 3],
[4, 5, 6, 7]]])

>> array_example.ndim
3
>> array_example.size
24
>> array_example.shape
(3, 2, 4)

a = np.arange(6)
b = a.reshape(3, 2)

 [[0 1]
 [2 3]
 [4 5]]

a = np.array([1,2,3,4,5,6])
a2 = a[np.newaxis, :] # 행추가
a3 = a[:, np.newaxis] # 열추가
print(a.shape)
print(a2)
print(a2.shape)
print(a3)
print(a3.shape)

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