{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 14. 복잡한 기준을 사용해 정렬할 때는 key 파라미터를 사용하라"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"list는 sort 메서드가 있다."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[11, 68, 70, 86, 93]\n"
]
}
],
"source": [
"numbers = [93, 86, 11, 68, 70]\n",
"numbers.sort()\n",
"print(numbers)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"sort가 객체를 처리하는 방법에 대해 알아보자"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"class Tool:\n",
" def __init__(self, name, weight):\n",
" self.name = name\n",
" self.weight = weight\n",
"\n",
" def __repr__(self):\n",
" return f'Tool({self.name!r}, {self.weight})'"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"tools = [\n",
" Tool('수준계', 3.5),\n",
" Tool('해머', 1.25),\n",
" Tool('스크류드라이버', 0.5),\n",
" Tool('끌', 0.25),\n",
"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"sort 메서드가 호출하는 객체 비교 특별 메서드가 정의돼 있지 않으므로 이런 타입의 객체를 정렬할 수 없다."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'<' not supported between instances of 'Tool' and 'Tool'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-16-934c749d7824>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtools\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'Tool' and 'Tool'"
]
}
],
"source": [
"tools.sort()"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Tool('수준계', 3.5)"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tools[0]"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[Tool('수준계', 3.5), Tool('해머', 1.25), Tool('스크류드라이버', 0.5), Tool('끌', 0.25)]"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tools"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tool('수준계', 3.5)\n"
]
}
],
"source": [
"print(tools[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"정렬에 사용하고 싶은 애트리뷰트가 객체에 들어 있는 경우가 많다.\n",
"\n",
"sort 에는 key라는 파라미터가 존재하는데 함수를 사용해야 한다."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"미정렬: [Tool('수준계', 3.5), Tool('해머', 1.25), Tool('스크류드라이버', 0.5), Tool('끌', 0.25)]\n",
"\n",
"정렬: [Tool('끌', 0.25), Tool('수준계', 3.5), Tool('스크류드라이버', 0.5), Tool('해머', 1.25)]\n"
]
}
],
"source": [
"print('미정렬:', repr(tools))\n",
"tools.sort(key=lambda x: x.name)\n",
"print('\\n정렬: ', tools)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"무게순 정렬: [Tool('끌', 0.25), Tool('스크류드라이버', 0.5), Tool('해머', 1.25), Tool('수준계', 3.5)]\n"
]
}
],
"source": [
"tools.sort(key=lambda x: x.weight)\n",
"print('무게순 정렬:', tools)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"다음 예제는 lower 메서드를 사용해 리스트에 들어 있는 장소 이름을 소문자로 변환함으로써 첫 글자가 대문자든 소문자든 구분하지 않고 알파벳 순으로 비교한다."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"대소문자 구분: ['New York', 'Paris', 'home', 'work']\n",
"대소문자 무시: ['home', 'New York', 'Paris', 'work']\n"
]
}
],
"source": [
"places = ['home', 'work', 'New York', 'Paris']\n",
"places.sort()\n",
"print('대소문자 구분:', places)\n",
"places.sort(key=lambda x: x.lower())\n",
"print('대소문자 무시:', places)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"여러 기준을 사용하고 싶을때, 즉, 리스트가 있는데 weight로 먼저 정렬한 다음에 name으로 정렬하는 방법"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"power_tools = [\n",
" Tool('드릴', 4),\n",
" Tool('원형 톱', 5),\n",
" Tool('착암기', 40),\n",
" Tool('연마기', 4),\n",
"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"기본적으로 튜플을 사용하는것, 튜플은 비교 가능하며 순서가 있음. sort에 필요한 __lt__ 정의가 들어있음."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"saw = (5, '원형 톱')\n",
"jackhammer = (40, '착암기')\n",
"assert not (jackhammer < saw)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"jackhammer < saw"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"두 튜플의 첫 번째 위치에 있는 값이 서로 같으면 튜플의 비교 메서드는 두 번째 위치에 있는 값을 비교하고.. 반복.."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"drill = (4, '드릴')\n",
"sander = (4, '연마기')\n",
"assert drill[0] == sander[0] # 무게가 같다\n",
"assert drill[1] < sander[1] # 알파벳순으로 볼 때 더 작다\n",
"assert drill < sander # 그러므로 드릴이 더 먼저다"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"두 애트리뷰트를 우선순위에 따라 튜플에 넣어 반환하는 key 함수 정의"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('드릴', 4), Tool('연마기', 4), Tool('원형 톱', 5), Tool('착암기', 40)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: (x.weight, x.name))\n",
"print(power_tools)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"튜플을 반환하는 key 함수의 한 가지 제약 사항은 모든 비교 기준의 정렬 순서가 같아야함"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('착암기', 40), Tool('원형 톱', 5), Tool('연마기', 4), Tool('드릴', 4)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: (x.weight, x.name),\n",
" reverse=True) # 모든 비교 기준을 내림차순으로 만든다\n",
"print(power_tools)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"숫자 값의 경우 - 연산자를 사용해 정렬 방향을 혼합 할 수 있다."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('착암기', 40), Tool('원형 톱', 5), Tool('드릴', 4), Tool('연마기', 4)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: (-x.weight, x.name))\n",
"print(power_tools)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "bad operand type for unary -: 'str'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-30-41e1c1504b5b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m power_tools.sort(key=lambda x: (x.weight, -x.name),\n\u001b[0m\u001b[1;32m 2\u001b[0m reverse=True)\n",
"\u001b[0;32m<ipython-input-30-41e1c1504b5b>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m power_tools.sort(key=lambda x: (x.weight, -x.name),\n\u001b[0m\u001b[1;32m 2\u001b[0m reverse=True)\n",
"\u001b[0;31mTypeError\u001b[0m: bad operand type for unary -: 'str'"
]
}
],
"source": [
"power_tools.sort(key=lambda x: (x.weight, -x.name),\n",
" reverse=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"다른 타입은 이런식으로 사용이 불가 하기 때문에 안정적인 정렬 알고리즘을 제공한다.\n",
"\n",
"리스트 타입의 sort 메서드는 key 함수가 반환하는 값이 서로 같은 경우 리스트에 들어 있던 원래 순서를 그대로 유지한다.\n",
"\n",
"따라서 다른 기준으로 sort를 여러번 호출해도 된다."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('착암기', 40), Tool('원형 톱', 5), Tool('드릴', 4), Tool('연마기', 4)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: x.name) # name 기준 오름차순\n",
"power_tools.sort(key=lambda x: x.weight, # weight 기준 내림차순\n",
" reverse=True)\n",
"print(power_tools)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('드릴', 4), Tool('연마기', 4), Tool('원형 톱', 5), Tool('착암기', 40)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: x.name)\n",
"print(power_tools)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[Tool('착암기', 40), Tool('원형 톱', 5), Tool('드릴', 4), Tool('연마기', 4)]\n"
]
}
],
"source": [
"power_tools.sort(key=lambda x: x.weight,\n",
" reverse=True)\n",
"print(power_tools)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 기억해야 할 내용\n",
"- 리스트 타입에 들어 있는 sort 메서드를 사용하면 원소 타입이 문자열, 정수, 튜플 등과 같은 내장 타입인 경우 자연스러운 순서로 리스트의 원소를 정렬할 수 있다.\n",
"- 원소 타입에 특별 메서드를 통해 자연스러운 순서가 정의돼 있지 않으면 sort 메서드를 쓸 수 없다. 하지만 원소 타입에 순서 특별 메서드를 정의하는 경우는 드물다.\n",
"- sort 메서드의 key 파라미터를 사용하면 리스트의 각 원소 대신 비교에 사용할 객체를 반환하는 도우미 함수를 제공할 수 있다.\n",
"- key 함수에서 튜플을 반환하면 여러 정렬 기준을 하나로 엮을 수 있다. 단한 부호 반전 연산자를 사용하면 부호를 바꿀 수 있는 타입이 정렬 기준인 경우 정렬 순서를 반대로 바꿀 수 있다.\n",
"- 부호를 바꿀 수 없는 타입의 경우 여러 정렬 기준을 조합하려면 각 정렬 기준마다 reverse 값으로 정렬 순서를 지정하면서 sort 메서드를 여러 번 사용해야한다. 이때 정렬 기준의 우선순위가 점점 높아지는 순서로 sort를 호출해야 한다."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.2"
}
},
"nbformat": 4,
"nbformat_minor": 4
}