이 랩에서는 다양한 Python 데이터 컨테이너를 사용하고 리스트, 세트, 딕셔너리 컴프리헨션을 활용하는 방법을 배우게 됩니다. 또한 데이터 처리에 유용한 도구를 제공하는 collections 모듈도 탐구할 것입니다.
Python 은 데이터 조작 및 분석을 위한 강력한 도구를 제공합니다. 이 랩에서는 Python 의 내장 데이터 구조와 특수 도구를 사용하여 다양한 데이터 세트를 분석하는 연습을 할 것입니다. 간단한 포트폴리오 데이터 세트로 시작하여 Chicago Transit Authority 버스 데이터를 분석하여 의미 있는 통찰력을 추출하는 방식으로 진행할 것입니다.
주식 보유에 대한 간단한 데이터 세트를 검토하는 것으로 시작해 보겠습니다. 이 단계에서는 CSV 파일에서 데이터를 읽고 딕셔너리를 사용하여 구조화된 형식으로 저장하는 방법을 배우게 됩니다.
CSV (Comma-Separated Values, 쉼표로 구분된 값) 파일은 각 줄이 행을 나타내고 값이 쉼표로 구분되는 표 형식 데이터를 저장하는 일반적인 방법입니다. Python 의 딕셔너리는 키 - 값 쌍을 저장할 수 있는 강력한 데이터 구조입니다. 딕셔너리를 사용하면 CSV 파일의 데이터를 더 의미 있는 방식으로 구성할 수 있습니다.
먼저 다음 단계를 따라 WebIDE 에서 새 Python 파일을 만듭니다.
readport.py로 지정합니다.## readport.py
import csv
## A function that reads a file into a list of dictionaries
def read_portfolio(filename):
portfolio = []
with open(filename) as f:
rows = csv.reader(f)
headers = next(rows) ## Skip the header row
for row in rows:
record = {
'name': row[0],
'shares': int(row[1]),
'price': float(row[2])
}
portfolio.append(record)
return portfolio이 코드는 몇 가지 중요한 작업을 수행하는 read_portfolio 함수를 정의합니다.
filename 매개변수로 지정된 CSV 파일을 엽니다. open 함수는 파일에 액세스하는 데 사용되며, with 문은 읽기를 완료한 후 파일이 제대로 닫히도록 합니다.next(rows)를 사용하여 반복자를 다음 행으로 이동하여 헤더를 효과적으로 건너뜁니다.portfolio라는 목록에 추가합니다. 이 목록에는 CSV 파일의 모든 레코드가 포함됩니다.이제 교통 데이터를 위한 파일을 만들어 보겠습니다. 다음 내용으로 readrides.py라는 새 파일을 만듭니다.
## readrides.py
import csv
def read_rides_as_dicts(filename):
"""
Read the CTA bus data as a list of dictionaries
"""
records = []
with open(filename) as f:
rows = csv.reader(f)
headers = next(rows) ## Skip header
for row in rows:
route = row[0]
date = row[1]
daytype = row[2]
rides = int(row[3])
record = {
'route': route,
'date': date,
'daytype': daytype,
'rides': rides
}
records.append(record)
return records이 read_rides_as_dicts 함수는 read_portfolio 함수와 유사하게 작동합니다. CTA 버스 데이터와 관련된 CSV 파일을 읽고, 헤더 행을 건너뛰고, 각 데이터 행에 대한 딕셔너리를 만들고, 이러한 딕셔너리를 목록에 저장합니다.
이제 WebIDE 에서 터미널을 열어 read_portfolio 함수를 테스트해 보겠습니다.
python3를 입력하여 Python 인터프리터를 시작합니다.>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')
>>> from pprint import pprint
>>> pprint(portfolio)
[{'name': 'AA', 'price': 32.2, 'shares': 100},
{'name': 'IBM', 'price': 91.1, 'shares': 50},
{'name': 'CAT', 'price': 83.44, 'shares': 150},
{'name': 'MSFT', 'price': 51.23, 'shares': 200},
{'name': 'GE', 'price': 40.37, 'shares': 95},
{'name': 'MSFT', 'price': 65.1, 'shares': 50},
{'name': 'IBM', 'price': 70.44, 'shares': 100}]여기서는 pprint 함수 (pretty print) 를 사용하여 데이터를 더 읽기 쉬운 형식으로 표시합니다. 목록의 각 항목은 하나의 주식 보유를 나타내는 딕셔너리입니다. 딕셔너리에는 다음과 같은 키가 있습니다.
name): 주식을 식별하는 데 사용되는 약어입니다.shares): 주식의 보유 주식 수를 나타냅니다.price): 각 주식을 구매한 가격입니다.'MSFT' 및 'IBM'과 같은 일부 주식이 여러 번 나타나는 것을 알 수 있습니다. 이는 동일한 주식의 서로 다른 구매를 나타내며, 서로 다른 시기와 가격으로 이루어졌을 수 있습니다.
Python 컴프리헨션은 기존 컬렉션을 기반으로 새로운 컬렉션을 만드는 매우 유용하고 간결한 방법입니다. Python 의 컬렉션은 리스트, 세트 또는 딕셔너리가 될 수 있으며, 이는 다양한 유형의 데이터를 담는 컨테이너와 같습니다. 컴프리헨션을 사용하면 특정 데이터를 필터링하고, 데이터를 어떤 방식으로 변환하고, 보다 효율적으로 구성할 수 있습니다. 이 부분에서는 포트폴리오 데이터를 사용하여 이러한 컴프리헨션이 어떻게 작동하는지 살펴보겠습니다.
먼저 이전 단계에서 했던 것처럼 Python 터미널을 열어야 합니다. 터미널이 열리면 다음 예제를 하나씩 입력합니다. 이러한 실습 방식은 컴프리헨션이 실제로 어떻게 작동하는지 이해하는 데 도움이 됩니다.
리스트 컴프리헨션은 Python 에서 새로운 리스트를 만드는 특수한 구문입니다. 기존 컬렉션의 각 항목에 표현식을 적용하여 수행합니다.
예시부터 시작해 보겠습니다. 먼저 포트폴리오 데이터를 읽는 함수를 가져오겠습니다. 그런 다음 리스트 컴프리헨션을 사용하여 포트폴리오에서 특정 보유 자산을 필터링합니다.
>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')
## Find all holdings with more than 100 shares
>>> large_holdings = [s for s in portfolio if s['shares'] > 100]
>>> print(large_holdings)
[{'name': 'CAT', 'shares': 150, 'price': 83.44}, {'name': 'MSFT', 'shares': 200, 'price': 51.23}]이 코드에서 먼저 read_portfolio 함수를 가져와 CSV 파일에서 포트폴리오 데이터를 읽는 데 사용합니다. 그런 다음 리스트 컴프리헨션 [s for s in portfolio if s['shares'] > 100]은 portfolio 컬렉션의 각 항목 s를 거칩니다. 해당 보유 자산의 주식 수가 100 보다 큰 경우에만 새 리스트 large_holdings에 항목 s를 포함합니다.
리스트 컴프리헨션은 계산을 수행하는 데에도 사용할 수 있습니다. 다음은 몇 가지 예입니다.
## Calculate the total cost of each holding (shares * price)
>>> holding_costs = [s['shares'] * s['price'] for s in portfolio]
>>> print(holding_costs)
[3220.0, 4555.0, 12516.0, 10246.0, 3835.15, 3255.0, 7044.0]
## Calculate the total cost of the entire portfolio
>>> total_portfolio_cost = sum([s['shares'] * s['price'] for s in portfolio])
>>> print(total_portfolio_cost)
44671.15첫 번째 예에서 리스트 컴프리헨션 [s['shares'] * s['price'] for s in portfolio]는 portfolio의 각 항목에 대해 주식 수에 가격을 곱하여 각 보유 자산의 총 비용을 계산합니다. 두 번째 예에서는 sum 함수를 리스트 컴프리헨션과 함께 사용하여 전체 포트폴리오의 총 비용을 계산합니다.
세트 컴프리헨션은 기존 컬렉션에서 세트를 만드는 데 사용됩니다. 세트는 고유한 값만 포함하는 컬렉션입니다.
포트폴리오 데이터로 어떻게 작동하는지 살펴보겠습니다.
## Find all unique stock names
>>> unique_stocks = {s['name'] for s in portfolio}
>>> print(unique_stocks)
{'MSFT', 'IBM', 'AA', 'GE', 'CAT'}이 코드에서 세트 컴프리헨션 {s['name'] for s in portfolio}는 portfolio의 각 항목 s를 거쳐 주식 이름 (s['name']) 을 세트 unique_stocks에 추가합니다. 세트는 고유한 값만 저장하므로 중복 없이 포트폴리오의 모든 다른 주식 목록이 생성됩니다.
딕셔너리 컴프리헨션은 표현식을 적용하여 키 - 값 쌍을 생성하여 새로운 딕셔너리를 만듭니다.
다음은 딕셔너리 컴프리헨션을 사용하여 포트폴리오의 각 주식에 대한 총 주식 수를 계산하는 예입니다.
## Create a dictionary to count total shares for each stock
>>> totals = {s['name']: 0 for s in portfolio}
>>> for s in portfolio:
... totals[s['name']] += s['shares']
...
>>> print(totals)
{'AA': 100, 'IBM': 150, 'CAT': 150, 'MSFT': 250, 'GE': 95}첫 번째 줄에서 딕셔너리 컴프리헨션 {s['name']: 0 for s in portfolio}는 각 주식 이름 (s['name']) 이 키이고 각 키의 초기 값이 0 인 딕셔너리를 만듭니다. 그런 다음 for 루프를 사용하여 portfolio의 각 항목을 거칩니다. 각 항목에 대해 주식 수 (s['shares']) 를 totals 딕셔너리의 해당 값에 추가합니다.
이러한 컴프리헨션은 단 몇 줄의 코드로 데이터를 변환하고 분석할 수 있으므로 매우 강력합니다. Python 프로그래밍 도구 상자에 포함할 수 있는 훌륭한 도구입니다.
Python 에서 리스트, 딕셔너리, 세트와 같은 내장 컨테이너는 매우 유용합니다. 그러나 Python 의 collections 모듈은 이러한 내장 컨테이너의 기능을 확장하는 특수 컨테이너 데이터 유형을 제공하여 한 단계 더 나아갑니다. 이러한 유용한 데이터 유형 중 일부를 자세히 살펴보겠습니다.
Python 터미널에서 계속 작업하고 아래 예제를 따라 진행합니다.
Counter 클래스는 딕셔너리의 하위 클래스입니다. 주요 목적은 해시 가능한 객체를 계산하는 것입니다. 항목을 계산하는 편리한 방법을 제공하며 다양한 작업을 지원합니다.
먼저 Counter 클래스와 포트폴리오를 읽는 함수를 가져와야 합니다. 그런 다음 CSV 파일에서 포트폴리오를 읽습니다.
>>> from collections import Counter
>>> from readport import read_portfolio
>>> portfolio = read_portfolio('/home/labex/project/portfolio.csv')이제 각 주식의 주식 수를 이름별로 계산하기 위해 Counter 객체를 만들겠습니다.
## Create a counter to count shares by stock name
>>> totals = Counter()
>>> for s in portfolio:
... totals[s['name']] += s['shares']
...
>>> print(totals)
Counter({'MSFT': 250, 'IBM': 150, 'CAT': 150, 'AA': 100, 'GE': 95})Counter 객체의 훌륭한 기능 중 하나는 새 키를 자동으로 0 으로 초기화한다는 것입니다. 즉, 카운트를 증가시키기 전에 키가 있는지 확인할 필요가 없으므로 카운트를 누적하는 코드가 단순화됩니다.
Counter 에는 특수 메서드도 함께 제공됩니다. 예를 들어, most_common() 메서드는 데이터 분석에 매우 유용합니다.
## Get the two stocks with the most shares
>>> most_common_stocks = totals.most_common(2)
>>> print(most_common_stocks)
[('MSFT', 250), ('IBM', 150)]또한 산술 연산을 사용하여 카운터를 결합할 수 있습니다.
## Create another counter
>>> more = Counter()
>>> more['IBM'] = 75
>>> more['AA'] = 200
>>> more['ACME'] = 30
>>> print(more)
Counter({'AA': 200, 'IBM': 75, 'ACME': 30})
## Add two counters together
>>> combined = totals + more
>>> print(combined)
Counter({'AA': 300, 'MSFT': 250, 'IBM': 225, 'CAT': 150, 'GE': 95, 'ACME': 30})defaultdict는 일반 딕셔너리와 유사하지만 고유한 기능이 있습니다. 아직 존재하지 않는 키에 대한 기본값을 제공합니다. 이렇게 하면 키를 사용하기 전에 키가 있는지 확인할 필요가 없으므로 코드를 단순화할 수 있습니다.
>>> from collections import defaultdict
## Group portfolio entries by stock name
>>> byname = defaultdict(list)
>>> for s in portfolio:
... byname[s['name']].append(s)
...
>>> print(byname['IBM'])
[{'name': 'IBM', 'shares': 50, 'price': 91.1}, {'name': 'IBM', 'shares': 100, 'price': 70.44}]
>>> print(byname['AA'])
[{'name': 'AA', 'shares': 100, 'price': 32.2}]defaultdict(list)를 만들면 각 새 키에 대해 자동으로 새 빈 리스트가 생성됩니다. 따라서 키가 이전에 존재하지 않더라도 키의 값에 직접 추가할 수 있습니다. 이렇게 하면 키가 있는지 확인하고 빈 리스트를 수동으로 만들 필요가 없습니다.
다른 기본 팩토리 함수도 사용할 수 있습니다. 예를 들어 int, float 또는 사용자 정의 함수를 사용할 수 있습니다.
## Use defaultdict with int to count items
>>> word_counts = defaultdict(int)
>>> words = ['apple', 'orange', 'banana', 'apple', 'orange', 'apple']
>>> for word in words:
... word_counts[word] += 1
...
>>> print(word_counts)
defaultdict(<class 'int'>, {'apple': 3, 'orange': 2, 'banana': 1})collections 모듈의 이러한 특수 컨테이너 유형은 데이터를 사용할 때 코드를 더 간결하고 효율적으로 만들 수 있습니다.
이제 다양한 Python 데이터 구조와 collections 모듈을 사용하는 연습을 했으므로 이러한 기술을 실제 데이터 분석 작업에 적용할 때입니다. 이 실험에서는 시카고 교통국 (CTA) 의 버스 승차 데이터에 대한 분석을 수행합니다. 이 실용적인 응용 프로그램은 실제 데이터 세트에서 의미 있는 정보를 추출하기 위해 Python 을 사용하는 방법을 이해하는 데 도움이 됩니다.
먼저, 작업할 교통 데이터를 살펴보겠습니다. Python 터미널에서 데이터를 로드하고 기본 구조를 이해하기 위해 일부 코드를 실행합니다.
>>> import readrides
>>> rows = readrides.read_rides_as_dicts('/home/labex/project/ctabus.csv')
>>> print(len(rows))
## This will show the number of records in the dataset
>>> ## Let's look at the first record to understand the structure
>>> import pprint
>>> pprint.pprint(rows[0])import readrides 문은 CSV 파일에서 데이터를 읽는 함수가 있는 사용자 지정 모듈을 가져옵니다. readrides.read_rides_as_dicts 함수는 지정된 CSV 파일에서 데이터를 읽고 각 행을 딕셔너리로 변환합니다. len(rows)는 데이터 세트의 총 레코드 수를 제공합니다. pprint.pprint(rows[0])을 사용하여 첫 번째 레코드를 인쇄하면 각 레코드의 구조를 명확하게 볼 수 있습니다.
데이터에는 다양한 버스 노선에 대한 일일 승차 기록이 포함되어 있습니다. 각 레코드에는 다음이 포함됩니다.
route: 버스 노선 번호date: "YYYY-MM-DD" 형식의 날짜daytype: 평일의 경우 "W", 토요일의 경우 "A", 일요일/공휴일의 경우 "U"rides: 해당 날짜의 승차 횟수각 챌린지 질문을 하나씩 해결해 보겠습니다.
이 질문에 답하려면 데이터 세트에서 고유한 모든 노선 번호를 찾아야 합니다. 이 작업에 세트 컴프리헨션을 사용합니다.
>>> ## Get all unique route numbers using a set comprehension
>>> unique_routes = {row['route'] for row in rows}
>>> print(len(unique_routes))세트 컴프리헨션은 세트를 만드는 간결한 방법입니다. 이 경우 rows 목록의 각 행을 반복하고 route 값을 추출합니다. 세트는 고유한 요소만 저장하므로 모든 고유한 노선 번호의 세트가 생성됩니다. 이 세트의 길이를 인쇄하면 고유한 버스 노선의 총 수를 얻을 수 있습니다.
이러한 노선 중 일부가 무엇인지 확인할 수도 있습니다.
>>> ## Print a few of the route numbers
>>> print(list(unique_routes)[:10])여기서는 고유한 노선의 세트를 목록으로 변환한 다음 해당 목록의 처음 10 개 요소를 인쇄합니다.
이 질문의 경우, 주어진 노선과 날짜와 일치하는 특정 레코드를 찾기 위해 데이터를 필터링해야 합니다.
>>> ## Find rides on route 22 on February 2, 2011
>>> target_date = "2011-02-02"
>>> target_route = "22"
>>>
>>> for row in rows:
... if row['route'] == target_route and row['date'] == target_date:
... print(f"Rides on route {target_route} on {target_date}: {row['rides']}")
... break먼저 target_date 및 target_route 변수를 정의합니다. 그런 다음 rows 목록의 각 행을 반복합니다. 각 행에 대해 route 및 date가 대상 값과 일치하는지 확인합니다. 일치하는 항목이 발견되면 승차 횟수를 인쇄하고 찾고 있는 레코드를 찾았으므로 루프를 종료합니다.
target_date 및 target_route 변수를 변경하여 모든 날짜의 모든 노선을 확인할 수 있도록 수정할 수 있습니다.
Counter 를 사용하여 노선별 총 승차 횟수를 계산해 보겠습니다. Counter 는 collections 모듈의 딕셔너리 하위 클래스로, 해시 가능한 객체를 계산하는 데 사용됩니다.
>>> from collections import Counter
>>>
>>> ## Initialize a counter
>>> total_rides_by_route = Counter()
>>>
>>> ## Sum up rides for each route
>>> for row in rows:
... total_rides_by_route[row['route']] += row['rides']
...
>>> ## View the top 5 routes by total ridership
>>> for route, rides in total_rides_by_route.most_common(5):
... print(f"Route {route}: {rides:,} total rides")먼저 collections 모듈에서 Counter 클래스를 가져옵니다. 그런 다음 total_rides_by_route라는 빈 카운터를 초기화합니다. rows 목록의 각 행을 반복하면서 각 노선의 승차 횟수를 카운터에 추가합니다. 마지막으로 most_common(5) 메서드를 사용하여 총 승차 횟수가 가장 많은 상위 5 개 노선을 가져와 결과를 인쇄합니다.
이것은 더 복잡한 작업입니다. 각 노선에 대해 2001 년의 승차 횟수를 2011 년의 승차 횟수와 비교해야 합니다.
>>> ## Create dictionaries to store total annual rides by route
>>> rides_2001 = Counter()
>>> rides_2011 = Counter()
>>>
>>> ## Collect data for each year
>>> for row in rows:
... if row['date'].startswith('2001-'):
... rides_2001[row['route']] += row['rides']
... elif row['date'].startswith('2011-'):
... rides_2011[row['route']] += row['rides']
...
>>> ## Calculate increases
>>> increases = {}
>>> for route in unique_routes:
... if route in rides_2001 and route in rides_2011:
... increase = rides_2011[route] - rides_2001[route]
... increases[route] = increase
...
>>> ## Find the top 5 routes with the biggest increases
>>> import heapq
>>> top_5_increases = heapq.nlargest(5, increases.items(), key=lambda x: x[1])
>>>
>>> ## Display the results
>>> print("Top 5 routes with the greatest ridership increase from 2001 to 2011:")
>>> for route, increase in top_5_increases:
... print(f"Route {route}: increased by {increase:,} rides")
... print(f" 2001 rides: {rides_2001[route]:,}")
... print(f" 2011 rides: {rides_2011[route]:,}")
... print()먼저 2001 년과 2011 년의 각 노선에 대한 총 승차 횟수를 저장하기 위해 rides_2001 및 rides_2011의 두 개의 Counter 객체를 만듭니다. rows 목록의 각 행을 반복하면서 날짜가 '2001-' 또는 '2011-'로 시작하는지 확인하고 승차 횟수를 해당 카운터에 추가합니다.
그런 다음 각 노선의 승차 횟수 증가를 저장하기 위해 빈 딕셔너리 increases를 만듭니다. 고유한 노선을 반복하고 각 노선에 대해 2001 년 승차 횟수에서 2011 년 승차 횟수를 빼서 증가를 계산합니다.
가장 큰 증가를 보인 상위 5 개 노선을 찾기 위해 heapq.nlargest 함수를 사용합니다. 이 함수는 반환할 요소 수 (이 경우 5), 반복 가능한 객체 (increases.items()) 및 요소를 비교하는 방법을 지정하는 키 함수 (lambda x: x[1]) 를 사용합니다.
마지막으로 결과를 인쇄하여 노선 번호, 승차 횟수 증가 및 2001 년과 2011 년의 승차 횟수를 표시합니다.
이 분석은 10 년 동안 승차 횟수가 가장 많이 증가한 버스 노선을 식별하며, 이는 인구 패턴 변화, 서비스 개선 또는 기타 흥미로운 추세를 나타낼 수 있습니다.
이러한 분석을 여러 가지 방법으로 확장할 수 있습니다. 예를 들어 다음을 수행할 수 있습니다.
이 랩에서 배운 기술은 이러한 종류의 데이터 탐색 및 분석을 위한 견고한 기반을 제공합니다.
이 랩에서는 몇 가지 중요한 Python 데이터 조작 기술을 배웠습니다. 여기에는 CSV 데이터를 딕셔너리로 읽고 처리하는 것, 데이터 변환을 위해 리스트, 세트 및 딕셔너리 컴프리헨션을 사용하는 것, 그리고 collections 모듈의 특수 컨테이너 유형을 활용하는 것이 포함됩니다. 또한 이러한 기술을 적용하여 의미 있는 데이터 분석을 수행했습니다.
이러한 기술은 Python 데이터 분석의 기본이며 다양한 실제 시나리오에서 유용합니다. 데이터를 처리, 변환하고 통찰력을 추출하는 능력은 Python 프로그래머에게 매우 중요합니다. Python 데이터 분석 전문 지식을 향상시키기 위해 자신만의 데이터 세트로 계속 연습하십시오.