[ 측정소 정보 추출하기 ]

   📌  대구에 있는 측정소의 측정소 명, 측정소 주소, 위도, 경도, 설치년도를 csv 파일로 저장

import requests
import json

# 1. 초기값 설정
# 1) 서비스 키: requests 사용시 자동으로 인코딩되어 decoding된 키를 사용
service_key:str = 'uAhO32pV0qa7BDOmkJLhw2ZyOB9i5bGj7cMN8cuuHmKIwyyf29lHLjym8hBXdIaXyvAI1IyLvQZopk5HW233qQ=='

# 2) url 설정
url = 'http://apis.data.go.kr/B552584/MsrstnInfoInqireSvc/getMsrstnList'
parameter = f'?serviceKey={service_key}&returnType=json&numOfRows=100&pageNo=1&addr=대구'
print(url+parameter)

# 2. 서버에서 요청값을 받은 후 파싱(parsing)(= 구문 분석)
# 딕셔너리 데이터를 분석해서 원하는 값을 추출
response = requests.get(url + parameter)
# requests.get() 메서드를 사용하여 url 주소로 GET 요청을 보내고, 응답을 response 변수에 저장
json_data = response.text
# head 값 외 text 값만 들고오기 위함
dict_data = json.loads(json_data)
# JSON 형식의 데이터를 파이썬 객체로 변환하여 data 변수에 저장

print(dict_data)

'''
실행결과)
{'response': {'body': {'totalCount': 28, 'items': 
[{'dmX': '35.859', 'item': 'SO2, CO, O3, NO2, PM10, PM2.5', 'mangName': '도시대기', 
'year': '2020', 'addr': '대구광역시 서구 서대구로3길 46 내당4동 행정복지센터 3층 옥상 (
... 생략...

'''

# 3. 필요 정보 추출

count_datas = dict_data['response']['body']['items']
#print(count_datas)

for k in range(len(count_datas)):
    count_data = count_datas[k]
    if count_data['addr'][0:2] == "대구":
        print(f'측정소 명 : {count_data["stationName"]}')
        print(f'측정소 주소 : {count_data["addr"]}')
        print(f'위도 : {count_data["dmX"]}')
        print(f'경도 : {count_data["dmY"]}')
        print(f'설치년도 : {count_data["year"]}')
        print('=' * 20)

'''
실행결과)
측정소 명 : 내당동
측정소 주소 : 대구광역시 서구 서대구로3길 46 내당4동 행정복지센터 3층 옥상 (내당동)
위도 : 35.859
경도 : 128.55183
설치년도 : 2020
====================
측정소 명 : 침산동
측정소 주소 : 대구광역시 북구 옥산로17길 21 대구일중학교 (침산동)
위도 : 35.88761
경도 : 128.58434
설치년도 : 2020

... 생략...

'''

# 4. csv 파일 저장
import csv

data_list: list[str] = ['측정소 명', '측정소 주소', '위도', '경도', '설치년도']
daegu_list:list[dict] = list()

for k in range(len(count_datas)):
    count_data = count_datas[k]
    if count_data['addr'][0:2] == "대구":
        new_data: dict = dict()
        new_data[data_list[0]] = count_data["stationName"]
        new_data[data_list[1]] = count_data["addr"]
        new_data[data_list[2]] = count_data["dmX"]
        new_data[data_list[3]] = count_data["dmY"]
        new_data[data_list[4]] = count_data["year"]

        daegu_list.append(new_data)

with open('../output_02/daegu_air_list.csv', 'w', newline='', encoding='UTF-8') as csvfile:
    csv_writer = csv.DictWriter(csvfile, data_list)
    csv_writer.writeheader()
    for data in daegu_list:
        data:dict
        csv_writer.writerow(data)

print(f'파일이 생성되었습니다.')

[ 내용 참고 : IT 학원 강의 ]

1.  API 통해 위치 정보 얻기

import urllib.request as request
import json
import datetime

# API 이용하기
# openweathermap.org

api_key: str = 'd1569da48f0b4251e9ec538982a29548'

# 대구 위치 정보 얻기
# https://openweathermap.org/api/geocoding-api

city: str = 'Taegu'
url: str = f'http://api.openweathermap.org/geo/1.0/direct?q={city}&limit=5&appid={api_key}'
print(url)

json_data = request.urlopen(url).read()
dict_data = json.loads(json_data)
lat = dict_data[0]['lat']
lon = dict_data[0]['lon']
print(f'{lat} / {lon}')

# 현재 날씨
# https://openweathermap.org/current
# lang=kr : 한국어 사용
# units=metric : 섭씨온도

url = (f'https://api.openweathermap.org/data/2.5/weather?lat={lat}&'  #위도
       f'lon={lon}&'  #경도
       f'appid={api_key}&'
       f'lang=kr&'
       f'units=metric')
print(url)
json_data = request.urlopen(url).read()
dict_data = json.loads(json_data)
json_data = json.dumps(dict_data, indent=4)
# print(json_data)

print(f'도시 : {dict_data["name"]}')
print(f'현재날씨 : {dict_data["weather"][0]["description"]}')
print(f'최고기온 : {dict_data["main"]["temp_max"]}')
print(f'최저기온 : {dict_data["main"]["temp_min"]}')
print(f'일출시간 : {datetime.datetime.fromtimestamp(dict_data["sys"]["sunrise"])}')
print(f'일몰시간 : {datetime.datetime.fromtimestamp(dict_data["sys"]["sunset"])}')

# 날씨 예보 : 5days / 3 hours
# https://openweathermap.org/forecast5

url: str = (f'https://api.openweathermap.org/data/2.5/forecast?lat={lat}&lon={lon}&appid={api_key}&lang=kr&'
       f'units=metric')
print(url)

json_data = request.urlopen(url).read()
dict_data = json.loads(json_data)
json_data = json.dumps(dict_data, indent=4)
print(json_data)

weather_list = dict_data['list']  #json 데이터 중에서 list key에 해당하는 목록 가져오기.
#print(weather_list)

for item in weather_list:
       print(f'시간: {datetime.datetime.fromtimestamp(item["dt"])}', end=', ')
       print(f'최고기온: {item["main"]["temp_max"]}', end=', ')
       print(f'날씨: {item["weather"][0]["main"]}', end=', ')
       print(f'날씨: {item["weather"][0]["description"]}')
       print()

2. 공공데이터를 JSON 타입으로 받아 필요한 내용 출력하고  CSV 타입으로 저장

# 공공데이터 포탈에서 '대구광역시_맛집' 검색 (키사용이 없음)
# https://www.data.go.kr/data/15057236/openapi.do
# 중구의 맛집 목록을 json 타입으로 받아서 처리

# 1. 음식카테고리 출력
# {'한식', '일식', '세계요리', '중식', '전통차/커피전문점', '특별한 술집', '디저트/베이커리', '양식'}

# 2. 일식의 음식점명, 연락처, 메뉴 출력
# --------------------
# 음식점명: 종로초밥
# 연락처: 053-252-0321
# 메뉴: 광어회 50,000원 <br />모둠회 40,000원 <br />무침회 20,000원<br />
# --------------------
# 음식점명: 삼삼구이초밥
# 연락처: 053-425-3392
# 메뉴: 회덮밥 9,000원 <br />미주구리 30,000원 <br />점심특선 6,000원<br />
# --------------------
import json
import urllib.request as request


url: str = "https://www.daegufood.go.kr/kor/api/tasty.html?mode=json&addr=%EC%A4%91%EA%B5%AC"

json_data = request.urlopen(url).read()
dict_data: dict = json.loads(json_data)
# print(dict_data)

# 문제 1)
food_kind = set()  # 중복 값 걸러주는 set 활용
for row in dict_data['data']:
    food_kind.add(row['FD_CS'])
print(food_kind)


# 문제 2)
for item in dict_data['data']:
    kind = item['FD_CS']
    if kind == "일식":
        print(f'음식점명: {item["BZ_NM"]}')
        print(f'연락처: {item["TLNO"]}')
        print(f'메뉴: {item["MNU"]}')
        print("-" * 20)

# 3. csv 파일 저장
# 파일명 : daegu_food_jonggu_list.csv
# 인코딩 : utf-8
# 헤더 : '음식 카테고리', '음식점명', '연락처', '메뉴'
import csv

food_list: list[dict] = list()
name_list: list[str] = ['음식 카테고리', '음식점명', '연락처', '메뉴']  
# csv 헤더 및 딕셔너리의 key값으로 사용.

for data in dict_data['data']:
    if data['FD_CS'] == '일식':
        new_data: dict = dict()
        new_data[name_list[0]] = data['FD_CS']
        new_data[name_list[1]] = row["BZ_NM"]
        new_data[name_list[2]] = row["TLNO"]
        new_data[name_list[3]] = row["MNU"]

        food_list.append(new_data)

file_name = 'daegu_food_jonggu_list.csv'
with open(f'../output_02/{file_name}', 'w', newline='', encoding='UTF-8') as csvfile:
    writer = csv.DictWriter(csvfile, name_list)
    writer.writeheader()
    for data in food_list:
        data: dict
        writer.writerow(data)

print(f'{file_name} 파일이 생성되었습니다.')

[ 내용 참고 : IT 학원 강의 자료 ]

1. 서버에서 데이터 받기

1) 아이디와 이름 순서대로 데이터를 전달
 

    🚀  test, tom  ➡️ 인덱스를 사용하는 것처럼 위치값으로 파악
    🚀  빈값이나, 값에 구분자가 들어가는 경우 어려움등의 문제로 사용 빈도 낮음

2) xml 방식

    🚀  <id>test</id>
          <name>tom</name>
           ➡️  마크업 방식, 속성값이 반복되어서 상대적으로 데이터의 크기가 커짐

3) json 방식

    🚀  'id': 'test',
           'name': 'tom'
            ➡️  객체 속성 표현 방식. 상대적으로 간결한 표현

2.  JSON 파일 입출력

 1) JSON 파일이란?

    👾  JavaScript Object Notation의 약자로 JavaScript의 객체 표현 방법이라는 뜻

    👾  데이터를 전달할 때 사람이 읽고 쓰기 쉽도록 텍스트 형식을 정해 놓은 개방형 데이터 표준 형식
    👾  많은 양의 데이터를 처리할 때는 속도가 느린 단점이 있으므로 경량의 데이터를 주고 받을 때 주로 사용
 

 2) JSON 데이터 형식

    👾  속성 attribute - 값 value 쌍으로 구성된 데이터들이 순서없이 모여 있는 구조
          ⚡️ 중괄호를 이용해서 전체 JSON 데이터를 묶어 주고 속성과 값 사이에 콜론(:)을 붙여 줌
          ⚡️ 속성과 값으로 구성된 각 데이터의 구분은 쉼표(,)를 이용
                ∴  즉, 파이썬의 딕셔너리와 같은 모습

3) JSON 파일 생성

    👾  JSON 데이터 처리를 위해서 json 모듈 제공
         ⚡️  json 모듈을 import 하면 리스트나 딕셔너리와 같은 파이썬 객체를 JSON 데이터로 변환하거나,
              JSON 데이터를 다시 파이썬 객체로 변환할 수 있음

    👾  JSON 인코딩 encoding : 파이썬 객체를 JSON 문자열로 변환하는 것
         ⚡️ 변환된 문자열을 파일에 기록하면 확장자가 json인 JSON 파일 (*.json)을 만들 수 있음
         ⚡️ json.dumps() 메소드를 이용해서 JSON 인코딩을 처리할 수 있음

# json 모듈 import
import json

dict_list = [
    {
        'name': 'james',
        'age': 20,
        'spec': [
            175.5,
            70.5
        ]
    },
    {
        'name': 'alice',
        'age': 21,
        'spec': [
            168.5,
            60.5
        ]
    }
]

# 인코딩 메소드를 이용해 json 문자열로 변환
json_string: str = json.dumps(dict_list)
print(json_string)
'''
실행결과)
[{"name": "james", "age": 20, "spec": [175.5, 70.5]}, 
 {"name": "alice", "age": 21, "spec": [168.5, 60.5]}]
'''

# output_02 디렉토리에 json 파일 생성
with open('../output_02/dict_list_01.json', 'w') as file:
    file.write(json_string)

print('dict_list_01.json 파일이 생성되었습니다.')

(1) indent 옵션

📌  JSON 데이터는 네트워크를 주고받는 데이터의 표준 형식
📌  파일의 크기를 줄이기 위해서 의도적으로 불필요한 공백 문자 white space가 제거된 상태로 만들어 지기 때문에 

      사람들이 직접 그 내용을 해석하기에는 불편

    ⚡️ 보기 좋은 형식으로 만들기 위해서 json.dump() 메소드에 indent 옵션을 추가 할 수 있음
           ➡️  indent 옵션을 추가하면 JSON 데이터에 들여쓰기와 줄 바꿈이 추가되면서 보기 좋은 형식으로 만들어짐

json_string = json.dumps(dict_list, indent=4)  # indent 옵션 사용

with open('../output_02/dict_list_02.json', 'w') as file:
    file.write(json_string)

print('dict_list_02.json 파일이 생성되었습니다.')

📁  indent = 4는 들여쓰기로 공백문자 4개로 처리 한다는 의미
📁  하지만 indent 옵션을 사용하면 파일의 크기가 커지기 때문에 네트워크 전송이 목적이라면 사용하지 않는 것이 좋음
📁 JSON 데이터는 문자열을 큰따옴표로 묶어서 처리

 4) JSON 파일 읽기

    👾  JSON 디코딩 decording : 인코딩된 JSON 데이터를 다시 파이썬 객체로 변경하는 것
    👾  디코딩을 처리하는 메소드는 json.loads()

with open('../output_02/dict_list_02.json', 'r') as file:
    json_reader = file.read()
    dict_list = json.loads(json_reader)
    print(dict_list)
    # [{'name': 'james', 'age': 20, 'spec': [175.5, 70.5]}, 
    # {'name': 'alice', 'age': 21, 'spec': [168.5, 60.5]}]
    print(type(dict_list))  # <class 'list'>

    📁  json 파일을 read() 메소드로 한 번에 전체를 읽어 들여 json_reader에 저장
    📁  json.loads(json_reader)를 통해서 디코딩이 이뤄지면 파이썬 객체인 dict_list가 생성
    📁  dict_list는 리스트 내부에 2개의 딕셔너리가 저장된 구조이기 때문에 for 문을 이용해서 그 내용을 모두 처리 가능

3. JSON과 API

🚀  JSON은 데이터를 사람이 읽을 수 있는 문자열(바이너리가 아니라 텍스트)로 나타내는 방식 
🚀  많은 웹 사이트에서 프로그램이 웹 사이트와 상호 작용하는 데 JSON 형식의 내용을 제공
        ➡️  이를 API 제공이라고 하고, API로 접근하는 것은 URL을 통해 일반 웹 페이지에 접근하는 것과 동일
        ➡️  차이점은 API가 반환하는 값은 기계를 위한 JSON 형식으로 되어 있음

🚀  원하는 데이터를 얻으려면 프로그램이 요청해야 할 URL 뿐만 아니라 반환되는 JSON 데이터 구조의 일반적인 형식에 대한 문서도 찾아 봐야 되는데, API를 제공하는 모든 사이트는 이 문서를 제공

1) JSON 모듈

👾  JSON 모듈은 json.loads(), json.dumps() 함수로 JSON 데이터와 파이썬 값을 서로 변환하는 모든 세부 사항을 처리
👾  JSON은 문자열, 정수, 부동 소수점 수, 불, 리스트(배열) '[]', 딕셔너리(객체) '{}', NoneType 자료형 값만 저장 가능

import json

2) loads() 함수를 사용하여 JSON 읽기

👾  JSON 데이터가 들어 있는 문자열을 파이썬 값으로 변환하려면, 이를 json.loads() 함수에 전달
👾  JSON 문자열은 큰 따옴표를 사용

string_json_data: str = '{"name": "Zopgie", "isCat": true, "miceCaught": 0, "felineIQ": null}'
json_data_as_python_value = json.loads(string_json_data)
print(type(json_data_as_python_value))  # <class 'dict'>
print(json_data_as_python_value)
# {'name': 'Zopgie', 'isCat': True, 'miceCaught': 0, 'felineIQ': None}

# 온라인에서 JSON 파일 열기
import urllib.request as request

# urlopen() 함수 사용하여 소스 가져옴
json_data = request.urlopen("https://jsonplaceholder.typicode.com/todos/1").read()
print(type(json_data))  # <class 'bytes'>

# loads() 함수로 파이썬 객체로 변환
python_data = json.loads(json_data)
print(type(python_data))  # <class 'dict'>
print(python_data)  
#{'userId': 1, 'id': 1, 'title': 'delectus aut autem', 'completed': False}

    📌  urllib.request : 내부모듈(url 라이브러리). 기본적인 기능만 제공
    📌  requests : 외부모듈. 다양한 기능을 제공. 실작업에 많이 사용

3) dupms() 함수를 이용하여 JSON 작성하기

👾  파이썬 값을 JSON 형식 데이터 문자열로 변환

python_data: dict = {'name': 'Zopgie', 'isCat': True, 'miceCaught': 0, 'felineIQ': None}
json_data: str = json.dumps(python_data)
print(type(json_data))  # <class 'str'>
print(json_data)  
# {"name": "Zopgie", "isCat": true, "miceCaught": 0, "felineIQ": null}

    📌  JSON 에서는 True ▶️ true,  None ▶️ null 로 표현

[ 내용 참고 : IT 학원 강의 자료 ]

1. 클래스 변수

🚀  클래스를 구현할 때 인스턴스마다 서로 다른 값을 가지는 경우에는 인스턴스 변수를 사용
🚀  모든 인스턴스 변수들은 self 키워드를 붙여서 사용
🚀  모든 인스턴스가 동일한 값을 사용할 때는 클래스 변수로 처리해서 모든 인스턴스들이 공유하도록 처리하는 것이 좋음
        ➡️  하나의 값을 모든 인스턴스가 공유하기 때문에 메모리 공간의 낭비를 막을 수 있음

     ⚡️  self
         - 관례적으로 모든 메서드의 첫 번째 매개변수 이름을 self로 지정.
         - self라는 명칭은 관례적으로 사용하는 단어.

# 클래스 변수 만들기
class 클래스 이름:
    클래스 변수 = 값
# 클래스 변수 접근
클래스 이름.변수 이름

class Korean:
    country = '한국'  # 클래스 변수 country

    def __init__(self, name, age, address):
        self.name = name  # 인스턴스 변수
        self.age = age
        self.address = address

print(Korean.country)  # 객체 생성전에도 사용 가능.

man = Korean('홍길동', 35, '서울')
print(man.name)
# print(Korean.name)  # AttributeError: type object 'Korean' has no attribute 'name'

print(man.country)  # 인스턴스 man을 통한 클래스 변수 접근
print(Korean.country)  # 클래스 Korean을 통한 클래스 변수 접근

print('객체 property 생성과 동일한 이름의 클래스 변수')
man.country = '중국'  # 객체의 인스턴스 변수 생성
print(man.country)  # 중국. 
# 클래스 변수가 아니라 인스턴스 변수를 불러옴. 
# man 객체의 country 라는 인스턴스 변수와 country 클래스 변수
print(man.__class__.country)  # 한국. 객체를 사용해서 클래스 변수 불러오기.
print(Korean.country)  # 한국.

print('객체를 이용해서 클래스 변수 값 변경')
man.__class__.country = '영국'
print(Korean.country)  # 영국

print('클래스를 이용해서 클래스 변수 값 변경')
Korean.country = '미국'  # 클래스 변수를 변경
print(Korean.country)  # 미국

man2 = Korean('홍길동2', 35, '서울')
print(man2.country)  # 미국
print(Korean.country)  # 미국

# 클래스 변수는 클래스를 통해서 접근하는 것이 권장사항

2. 클래스 메소드

🚀  클래스 변수를 사용하는 메소드를 의미
 

   ⚡️ 주요 특징
         a. 인스턴스 혹은 클래스로 호출
         b. 생성된 인스턴스가 없어도 호출할 수 있음
         c. @classmethod 데코레이터 decorator를 표시하고 작성
         d. 매개변수 self를 사용하지 않고 cls를 사용
         e. 클래스 메소드는 self를 사용하지 않기 때문에 인스턴스 변수에 접근할 수 없지만 cls를 통해서 클래스 변수에 접근할 수 있음

class Korean:
    country = '한국'  # 클래스 변수 country

    @classmethod
    def trip(cls, country):
        if cls.country == country:
            print('국내여행입니다.')
        else:
            print('해외여행입니다.')

Korean.trip('한국')  # 국내여행입니다.
Korean.trip('미국')  # 해외여행입니다.

3. 정적 메소드

🚀  인스턴스 또는 클래스로 호출
🚀  생성된 인스턴스가 없어도 호출 가능
🚀  @staticmethod 데코레이터 decorator를 표시하고 작성
🚀  반드시 작성해야 할 매개변수가  없음

    ⚡️  self와 cls를 모두 사용하지 않기 때문에 인스턴스 변수와 클래스 변수를 모두 사용하지 않는 메소드를 정의하는 경우에 적절
    ⚡️  정적 메소드는 클래스에 소속이 되어 있지만, 인스턴스에는 영향을 주지 않고 또 인스턴스로부터 영향을 받지도 않음

class Korean:
    country = '한국'  # 클래스 변수 country

    @staticmethod
    def slogan():
        print('Imagine your Korea')

Korean.slogan()  # Imagine your Korea

4. 상속  inheritance

1) 상속이란?

👾  어떤 클래스가 가지고 있는 기능을 그대로 물려받아서 사용할 수 있는 클래스를 만들 수 있다.
👾  다른 클래스의 기능을 물려받을 때 상속받는다는 표현을 사용
👾  상속 관계에 있는 클래스를 표현할 때 '부모 클래스와 자식 클래스'라는 말을 사용

    ⚡️ 부모 클래스 : 상속해 주는 클래스 / 슈퍼 클래스 super class , 기반 클래스 base class
    ⚡️ 자식 클래스 : 상속 받는 클래스 / 서브 클래스 sub class, 파생 클래스 derived class

2) 상속 관계 구현

👾  기본적으로 두 클래스가 상속 관계에 놓이려면 IS-A 관계가 성립해야 한다
👾  IS-A 관계란 '~은 ~ 이다'로 해설할 수 있는 관계를 의미
        ex. '학생은 사람이다 Student is a Person'처럼 해석되는 것이 IS-A 관계
                이때 Student 는 서브 클래스가 되고, Person은 슈퍼 클래스가 됨

👾  has-a 관계는  '그릇이 스쿱을 갖는다 Bowl has-a Scoop'
👾  has-a 관계는 상속이 아니라 구성 Composition으로 구현함

# 상속의 기본적인 형식
class 슈퍼 클래스:
    본문

class 서브 클래스(슈퍼 클래스):
    본문

  ⚡️  서브 클래스를 구현할 때는 괄호 안에 어떤 슈퍼 클래스를 상속 받는지 명시
  ⚡️  상속 관계에 놓인 서브 클래스는 마치 자신의 것처럼 슈퍼 클래스의 기능을 사용할 수 있음

class Person:  # 슈퍼 클래스
    def __init__(self, name):
        self.name = name

    def eat(self, food: str) -> None:
        print(f'{self.name}가 {food}를 먹습니다.')

class Student(Person):  # 서브 클래스
    def __init__(self, name: str, school: str) -> None:
        super().__init__(name)  # 슈퍼 클래스의 생성자 실행
        self.school = school

    def study(self) -> None:
        print(f'{self.name}는 {self.school}에서 공부를 합니다.')

potter = Student('해리포터', '호그와트')
potter.eat('감자')  # 해리포터가 감자를 먹습니다.
potter.study()  # 해리포터는 호그와트에서 공부를 합니다.

3) 서브 클래스의  __init__()

👾  서브 클래스의 생성자를 구현할 때는 반드시 슈퍼 클래스의 생성자를 먼저 호출하는 코드를 작성해야 함
👾  super라는 키워드는 슈퍼 클래스를 의미

class Computer:  # 슈퍼 클래스
    def __init__(self):
        print('슈퍼 클래스의 생성자가 실행되었습니다.')

class NoteBook(Computer):  # 서브 클래스
    def __init__(self):
        super().__init__()
        print('서브 클래스의 생성자가 실행되었습니다.')

4) 서브 클래스의 인스턴스 자료형

👾  슈퍼 클래스 객체는 슈퍼 클래스의 인스턴스
👾  그에 비해 서브 클래스 객체는 서브 클래스의 인스턴스이면서 동시에 수퍼 클래스의 인스턴스

    ⚡️ 서브 클래스 Student의 객체는 서브 클래스 Student의 인스턴스 이면서 동시에 슈퍼 클래스 Person의 인스턴스

👾  어떤 객체가 어떤 클래스의 인스턴스인지 확인하기 위해서 isinstance() 함수를 사용
        ➡️  객체가 인스턴스일 경우에는 True 아니면 False 반환

# isinstance(객체, 클래스)
print(isinstance(potter, Student))  # True
print(isinstance(potter, Person))  # True

[ 내용 참고 : IT 학원 강의 ]

1. 모듈 만들기

# test_module.py 파일
PI = 3.141592

def number_input():
    output = input("숫자 입력 >>> ")
    return float(output)

def get_circumference(radius):
    return 2 * PI * radius

def get_circle_area(radius):
    return PI * radius * radius

# test.py 파일
import test_module as test

radius = test.number_input()
print(test.get_circumference(radius))
print(test.get_circle_area(radius))

2.  __name__ =="__main__"

📁  프로그램의 진입점을 엔트리 포인트 entry point 또는 메인 main 이라고 부른다

      ➡️  엔트리 포인트 또는 메인 내부에서의 __name__ 은 "__main__"

📁  모듈 내부에서 __name__ 을 출력하면 모듈의 이름을 나타낸다.

# 엔트리 포인트 확인하는 모듈
PI = 3.141592

def number_input():
    output = input("숫자 입력 >>> ")
    return float(output)

def get_circumference(radius):
    return 2 * PI * radius

def get_circle_area(radius):
    return PI * radius * radius

# 현재 파일이 엔트리 포인트인지 확인하고, 엔트리 포인트일 때만 실행
if __name__ == '__main__':
    print('get_circumference(10):', get_circumference(10))
    print('get_circle_area(10)', get_circle_area(10))

3. __init__.py 파일

📁  해당 폴더가 패키지임을 알려주고, 패키지와 관련된 초기화 처리를 하는 파일

       ➡️  패키지 폴더 내부에 __init__.py 파일을 생성

📁  __all__ 이라는 이름의 리스트를 파일안에 만드는데, 이 리스트에 지정한 모듈들이 from<패키지이름> import * 를 할 때 전부 읽어 들여진다.

# "from <모듈이름> import *"로
# 모듈을 읽어 들일 때 가져올 모듈
__all__ = [사용시 읽어 들일 모듈의 목록]

[ 내용 참고 : 책 '혼자 공부하는 파이썬' ]