실 용적 인 Python 프로 그래 밍 0202_Containers

목차 | 이전 절 (2.1 데이터 형식) | 다음 절 (2.3 포맷)
2.2 용기
이 절 토론 목록 (list), 사전 (dict), 집합 (set).
개술
일반적으로 프로그램 은 많은 대상 을 처리 해 야 한다.

주식 의 투자 조합

주식 가격표

여기에 세 가지 주요 선택 (번역: 데이터 구조) 을 사용 할 수 있다.

리스트 입 니 다.질서 있 는 데이터.

사전.무질서 한 데이터.

집합.서로 다 르 고 무질서 한 데이터.

목록 을 용기 로 삼다
데이터 순서 가 중요 할 때 목록 을 사용 하 십시오.목록 은 모든 종류의 대상 을 저장 할 수 있다 는 것 을 기억 하 세 요.예 를 들 어, 원 그룹 을 포함 하 는 목록:

portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]

portfolio[0]            # ('GOOG', 100, 490.1)
portfolio[2]            # ('CAT', 150, 83.44)

목록 구축
0 부터 목록 을 만 듭 니 다.

records = []  # Initial empty list

# Use .append() to add more items
records.append(('GOOG', 100, 490.10))
records.append(('IBM', 50, 91.3))
...

파일 에서 기록 을 읽 는 예제:

records = []  # Initial empty list

with open('Data/portfolio.csv', 'rt') as f:
    next(f) # Skip header
    for line in f:
        row = line.split(',')
        records.append((row[0], int(row[1]), float(row[2])))

사전 을 용기 로 삼다
빠 른 랜 덤 으로 찾 으 려 면 사전 이 유용 합 니 다.예 를 들 어 주식 가격 사전:

prices = {
   'GOOG': 513.25,
   'CAT': 87.22,
   'IBM': 93.37,
   'MSFT': 44.12
}

다음은 간단 한 검색 입 니 다.

>>> prices['IBM']
93.37
>>> prices['GOOG']
513.25
>>>

사전 구축
0 부터 사전 을 구축 하 는 예제:

prices = {} # Initial empty dict

# Insert new items
prices['GOOG'] = 513.25
prices['CAT'] = 87.22
prices['IBM'] = 93.37

파일 내용 에서 사전 을 채 우 는 예제:

prices = {} # Initial empty dict

with open('Data/prices.csv', 'rt') as f:
    for line in f:
        row = line.split(',')
        prices[row[0]] = float(row[1])

메모: Data/prices.csv 파일 에서 이 작업 을 시도 하면 거의 정상적으로 작 동 할 수 있 습 니 다. 그러나 끝 에 빈 줄 이 있어 프로그램 이 무 너 졌 습 니 다.이 문 제 를 해결 하기 위해 코드 를 수정 하 는 방법 을 찾 아야 한다 (연습 2.6 참조).
사전 찾기
테스트 키 존재 여부:

if key in d:
    # YES
else:
    # NO

존재 하지 않 을 수 있 는 값 을 찾 을 수 있 으 며, 값 이 존재 하지 않 을 경우 기본 값 을 제공 할 수 있 습 니 다.

name = d.get(key, default)

예시:

>>> prices.get('IBM', 0.0)
93.37
>>> prices.get('SCOX', 0.0)
0.0
>>>

조합 키
Python 에 서 는 거의 모든 종류의 값 을 사전 키 로 사용 할 수 있 습 니 다.사전 의 키 는 변 하지 않 는 형식 이 어야 합 니 다.예 를 들 어, 모듈:

holidays = {
  (1, 1) : 'New Years',
  (3, 14) : 'Pi day',
  (9, 13) : "Programmer's day",
}

그리고 방문:

>>> holidays[3, 14]
'Pi day'
>>>

목록, 집합 또는 기타 사전 은 사전 의 키 로 사용 할 수 없습니다. 목록 과 사전 (번역 주: 집합 도 해시 기술 로 이 루어 집 니 다) 은 가 변 적 이기 때 문 입 니 다.
집합 하 다.
집합 은 서로 다 르 고 무질서 한 데이터 이다.

tech_stocks = { 'IBM','AAPL','MSFT' }
# Alternative syntax
tech_stocks = set(['IBM', 'AAPL', 'MSFT'])

집합 은 구성원 관계 테스트 에 매우 유용 하 다.

>>> tech_stocks
set(['AAPL', 'IBM', 'MSFT'])
>>> 'IBM' in tech_stocks
True
>>> 'FB' in tech_stocks
False
>>>

집합 은 중복 을 없 애 는 데 도 유용 하 다.

names = ['IBM', 'AAPL', 'GOOG', 'IBM', 'GOOG', 'YHOO']

unique = set(names)
# unique = set(['IBM', 'AAPL','GOOG','YHOO'])

기타 집합 동작:

names.add('CAT')        # Add an item
names.remove('YHOO')    # Remove an item

s1 | s2                 # Set union
s1 & s2                 # Set intersection
s1 - s2                 # Set difference

연습 하 다.
이런 연습 에서 당신 이 구축 하기 시작 한 프로그램 은 본 과정의 나머지 부분 에서 사용 하 는 주요 프로그램 중 하나 입 니 다.Work/report.py 파일 에서 일 하 세 요.
연습 2.4: 원 조 를 포함 하 는 목록Data/portfolio.csv 서 류 는 투자 조합의 주식 목록 을 포함한다.연습 에서 이 파일 을 읽 고 간단 한 계산 을 수행 하 는 portfolio_cost(filename) 함 수 를 작 성 했 습 니 다.
코드 는 아래 처럼 보 여야 합 니 다:

# pcost.py

import csv

def portfolio_cost(filename):
    '''Computes the total cost (shares*price) of a portfolio file'''
    total_cost = 0.0

    with open(filename, 'rt') as f:
        rows = csv.reader(f)
        headers = next(rows)
        for row in rows:
            nshares = int(row[1])
            price = float(row[2])
            total_cost += nshares * price
    return total_cost

이 코드 를 지도 로 새 파일 report.py 을 만 드 십시오.report.py 파일 에서 read_portfolio(filename) 함 수 를 정의 합 니 다. 이 함 수 는 Data/portfolio.csv 파일 을 열 고 원 그룹 을 포함 하 는 목록 에 읽 습 니 다.이 를 위해 서 는 위의 코드 에 대해 약간의 수정 이 필요 하 다.
우선, 정의 total_cost = 0 가 아 닌 빈 목록 으로 설 정 된 변 수 를 만 듭 니 다.예 를 들 면:

portfolio = []

이 어 각 줄 을 원 그룹 에 정확하게 저장 한 뒤 총 비용 이 아 닌 원 그룹 을 목록 에 추가 했다.

for row in rows:
    holding = (row[0], int(row[1]), float(row[2]))
    portfolio.append(holding)

마지막 으로 얻 은 portfolio 목록 을 되 돌려 줍 니 다.
대화 식 시험 함수 (이 작업 을 수행 하려 면 먼저 해석 기 에서 실행 report.py 프로그램 이 필요 합 니 다).
알림: 터미널 에서 파일 을 실행 할 때 -i 인 자 를 사용 하 십시오.

>>> portfolio = read_portfolio('Data/portfolio.csv')
>>> portfolio
[('AA', 100, 32.2), ('IBM', 50, 91.1), ('CAT', 150, 83.44), ('MSFT', 200, 51.23),
    ('GE', 95, 40.37), ('MSFT', 50, 65.1), ('IBM', 100, 70.44)]
>>>
>>> portfolio[0]
('AA', 100, 32.2)
>>> portfolio[1]
('IBM', 50, 91.1)
>>> portfolio[1][1]
50
>>> total = 0.0
>>> for s in portfolio:
        total += s[1] * s[2]

>>> print(total)
44671.15
>>>

원 그룹 을 포함 하 는 목록 을 만 드 는 것 은 2 차원 (2 - D) 배열 과 매우 유사 합 니 다.예 를 들 어 portfolio[row][column] row 와 column 는 정수) 와 같은 검색 을 통 해 특정한 열 과 줄 에 접근 합 니 다.
즉, 아래 와 같은 문 구 를 사용 하여 마지막 for 순환 을 다시 쓸 수 있 습 니 다.

>>> total = 0.0
>>> for name, shares, price in portfolio:
            total += shares*price

>>> print(total)
44671.15
>>>

연습 2.5: 사전 포함 목록
사전 (원본 이 아 닌) 을 사용 하여 연습 2.4 에서 작 성 된 함 수 를 수정 하여 투자 조합의 주식 을 표시 합 니 다.사전 에 서 는 필드 이름 'name', 'shares',' price '를 사용 하여 입력 파일 의 다른 열 을 표시 합 니 다.
연습 2.4 와 같은 방식 으로 이 새로운 함 수 를 시험 하 다.

>>> portfolio = read_portfolio('Data/portfolio.csv')
>>> portfolio
[{'name': 'AA', 'shares': 100, 'price': 32.2}, {'name': 'IBM', 'shares': 50, 'price': 91.1},
    {'name': 'CAT', 'shares': 150, 'price': 83.44}, {'name': 'MSFT', 'shares': 200, 'price': 51.23},
    {'name': 'GE', 'shares': 95, 'price': 40.37}, {'name': 'MSFT', 'shares': 50, 'price': 65.1},
    {'name': 'IBM', 'shares': 100, 'price': 70.44}]
>>> portfolio[0]
{'name': 'AA', 'shares': 100, 'price': 32.2}
>>> portfolio[1]
{'name': 'IBM', 'shares': 50, 'price': 91.1}
>>> portfolio[1]['shares']
50
>>> total = 0.0
>>> for s in portfolio:
        total += s['shares']*s['price']

>>> print(total)
44671.15
>>>

각 항목 의 다른 필드 는 숫자 형식의 열 번호 가 아 닌 키 이름 으로 접근 하 는 것 을 볼 수 있 습 니 다.이것 은 일반적으로 가장 좋 은 방법 이다. 왜냐하면 이렇게 얻 은 코드 는 나중에 쉽게 읽 을 수 있 기 때문이다.
대형 사전 이나 목록 을 보면 혼 란 스 러 울 수 있 습 니 다.디 버 깅 의 출력 을 깨끗하게 하려 면 pprint() 함 수 를 사용 하 는 것 을 고려 할 수 있다.

>>> 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}]
>>>

연습 2.6: 사전 을 용기 로 삼다
숫자 가 아 닌 색인 을 사용 하여 특정한 요 소 를 찾 는 곳 에서 사전 은 요 소 를 추적 하 는 데 유용 한 방식 이다.Python 셸 에서 사전 사용 하기:

>>> prices = { }
>>> prices['IBM'] = 92.45
>>> prices['MSFT'] = 45.12
>>> prices
... look at the result ...
>>> prices['IBM']
92.45
>>> prices['AAPL']
... look at the result ...
>>> 'AAPL' in prices
False
>>>

이 Data/prices.csv 문 서 는 주식 가격 을 가 진 일련의 줄 을 포함 하고 있 는데 아래 와 같이 보인다.

"AA",9.22
"AXP",24.85
"BA",44.85
"BAC",11.27
"C",3.72
...

작성 read_prices(filename) 함 수 는 이러한 가격 집합 을 사전 에 읽 습 니 다. 사전 의 키 는 주식 의 이름 을 대표 하고 사전 의 값 은 주식 의 가격 을 대표 합 니 다.
이 를 위해 빈 사전 부터 시작 하고 위 에서 만 든 것 처럼 값 을 삽입 합 니 다.하지만 파일 에서 값 을 읽 고 있 습 니 다.
우 리 는 이 데이터 구 조 를 이용 하여 주어진 명칭 의 주식 가격 을 신속하게 찾 을 것 이다.
이 부분 은 약간의 기교가 필요 하 다.우선, 이전에 한 것 처럼 csv 모듈 을 사용 하도록 확보 하 세 요. 여기 서 바퀴 를 중복 발명 할 필요 가 없습니다.

>>> import csv
>>> f = open('Data/prices.csv', 'r')
>>> rows = csv.reader(f)
>>> for row in rows:
        print(row)


['AA', '9.22']
['AXP', '24.85']
...
[]
>>>

또 다른 작은 문 제 는 Data/prices.csv 파일 이 빈 줄 이 있 을 수 있다 는 것 이다.위의 데이터 의 마지막 줄 은 빈 목록 입 니 다. 그 줄 에 데이터 가 없다 는 것 을 의미 합 니 다.
이것 은 당신 의 프로그램 이 이상 으로 인해 종 료 될 수 있 습 니 다.상황 을 고려 하여 사용 try 과 except 문 구 를 사용 하여 이러한 이상 을 포착 하 다.사고: if 문 구 를 사용 하여 잘못된 데 이 터 를 예방 하 는 것 이 좋 을 까?read_prices() 함 수 를 작 성 했 습 니 다. 상호작용 적 으로 테스트 하고 정상 적 인 작업 을 확보 하 십시오.

>>> prices = read_prices('Data/prices.csv')
>>> prices['IBM']
106.28
>>> prices['MSFT']
20.89
>>>

은퇴 할 수 있 는 지 없 는 지
손익 을 계산 하 는 문 구 를 추가 하여 report.py 프로그램 에 모든 업 무 를 연결 합 니 다.이런 문 구 는 연습 2.5 에 주식 이름 을 저장 하 는 목록 과 연습 2.6 에 주식 가격 을 저장 하 는 사전 을 사용 하고 투자 조합의 현재 가치 와 손익 을 계산 해 야 한다.
목차 | 이전 절 (2.1 데이터 형식) | 다음 절 (2.3 포맷)
주: 완전 번역 참조 https://github.com/codists/practical-python-zh