3
3
# This file is distributed under the same license as the Python package.
4
4
# FIRST AUTHOR <EMAIL@ADDRESS>, 2017.
5
5
#
6
- #, fuzzy
7
6
msgid ""
8
7
msgstr ""
9
8
"Project-Id-Version : Python 3.6\n "
10
9
"Report-Msgid-Bugs-To : \n "
11
10
"POT-Creation-Date : 2017-11-26 18:49+0900\n "
12
11
"PO-Revision-Date : YEAR-MO-DA HO:MI+ZONE\n "
13
- "Last-Translator : FULL NAME <EMAIL@ADDRESS >\n "
14
- "Language-Team : LANGUAGE <LL@li.org> \n "
12
+ "Last-Translator : Dong-gweon Oh <flowdas@gmail.com >\n "
13
+ "Language-Team : Korean (https://python.flowdas.com) \n "
15
14
"MIME-Version : 1.0\n "
16
15
"Content-Type : text/plain; charset=utf-8\n "
17
16
"Content-Transfer-Encoding : 8bit\n "
18
- "Generated-By : Babel 2.5.1 \n "
17
+ "Generated-By : Babel 2.6.0 \n "
19
18
20
19
#: ../Doc/howto/sorting.rst:4
21
20
msgid "Sorting HOW TO"
22
- msgstr ""
21
+ msgstr "정렬 HOW TO "
23
22
24
23
#: ../Doc/howto/sorting.rst
25
24
msgid "Author"
26
- msgstr ""
25
+ msgstr "저자 "
27
26
28
27
#: ../Doc/howto/sorting.rst:6
29
28
msgid "Andrew Dalke and Raymond Hettinger"
30
- msgstr ""
29
+ msgstr "Andrew Dalke와 Raymond Hettinger "
31
30
32
31
#: ../Doc/howto/sorting.rst
33
32
msgid "Release"
34
- msgstr ""
33
+ msgstr "배포 "
35
34
36
35
#: ../Doc/howto/sorting.rst:7
37
36
msgid "0.1"
38
- msgstr ""
37
+ msgstr "0.1 "
39
38
40
39
#: ../Doc/howto/sorting.rst:10
41
40
msgid ""
42
41
"Python lists have a built-in :meth:`list.sort` method that modifies the "
43
42
"list in-place. There is also a :func:`sorted` built-in function that "
44
43
"builds a new sorted list from an iterable."
45
44
msgstr ""
45
+ "파이썬 리스트에는 리스트를 제자리에서(in-place) 수정하는 내장 :meth:`list.sort` 메서드가 있습니다. 또한, "
46
+ "이터러블로부터 새로운 정렬된 리스트를 만드는 :func:`sorted` 내장 함수가 있습니다."
46
47
47
48
#: ../Doc/howto/sorting.rst:14
48
49
msgid ""
49
50
"In this document, we explore the various techniques for sorting data "
50
51
"using Python."
51
- msgstr ""
52
+ msgstr "이 문서에서는, 파이썬을 사용하여 데이터를 정렬하는 다양한 기술을 살펴봅니다. "
52
53
53
54
#: ../Doc/howto/sorting.rst:18
54
55
msgid "Sorting Basics"
55
- msgstr ""
56
+ msgstr "정렬 기초 "
56
57
57
58
#: ../Doc/howto/sorting.rst:20
58
59
msgid ""
59
60
"A simple ascending sort is very easy: just call the :func:`sorted` "
60
61
"function. It returns a new sorted list::"
61
- msgstr ""
62
+ msgstr "간단한 오름차순 정렬은 매우 쉽습니다; 그저 :func:`sorted` 함수를 호출하면 됩니다. 새로운 정렬된 리스트를 반환합니다:: "
62
63
63
64
#: ../Doc/howto/sorting.rst:26
64
65
msgid ""
@@ -67,27 +68,34 @@ msgid ""
67
68
"convenient than :func:`sorted` - but if you don't need the original list,"
68
69
" it's slightly more efficient."
69
70
msgstr ""
71
+ ":meth:`list.sort` 메서드를 사용할 수도 있습니다. 리스트를 제자리에서 수정합니다 (그리고 혼동을 피하고자 "
72
+ "``None``\\ 을 반환합니다). 일반적으로 :func:`sorted`\\ 보다 덜 편리합니다 - 하지만 원래 목록이 필요하지 "
73
+ "않다면, 이것이 약간 더 효율적입니다."
70
74
71
75
#: ../Doc/howto/sorting.rst:36
72
76
msgid ""
73
77
"Another difference is that the :meth:`list.sort` method is only defined "
74
78
"for lists. In contrast, the :func:`sorted` function accepts any iterable."
75
79
msgstr ""
80
+ "또 다른 점은 :meth:`list.sort` 메서드가 리스트에게만 정의된다는 것입니다. 이와 달리, :func:`sorted` "
81
+ "함수는 모든 이터러블을 받아들입니다."
76
82
77
83
#: ../Doc/howto/sorting.rst:43
78
84
msgid "Key Functions"
79
- msgstr ""
85
+ msgstr "키 함수 "
80
86
81
87
#: ../Doc/howto/sorting.rst:45
82
88
msgid ""
83
89
"Both :meth:`list.sort` and :func:`sorted` have a *key* parameter to "
84
90
"specify a function to be called on each list element prior to making "
85
91
"comparisons."
86
92
msgstr ""
93
+ ":meth:`list.sort`\\ 와 :func:`sorted`\\ 는 모두 비교하기 전에 각 리스트 요소에 대해 호출할 함수를 "
94
+ "지정하는 *key* 매개 변수를 가지고 있습니다."
87
95
88
96
#: ../Doc/howto/sorting.rst:48
89
97
msgid "For example, here's a case-insensitive string comparison:"
90
- msgstr ""
98
+ msgstr "예를 들어, 다음은 대소 문자를 구분하지 않는 문자열 비교입니다: "
91
99
92
100
#: ../Doc/howto/sorting.rst:53
93
101
msgid ""
@@ -96,20 +104,22 @@ msgid ""
96
104
"is fast because the key function is called exactly once for each input "
97
105
"record."
98
106
msgstr ""
107
+ "*key* 매개 변수의 값은 단일 인자를 취하고 정렬 목적으로 사용할 키를 반환하는 함수여야 합니다. 키 함수가 각 입력 레코드에 "
108
+ "대해 정확히 한 번 호출되기 때문에 이 기법은 빠릅니다."
99
109
100
110
#: ../Doc/howto/sorting.rst:57
101
111
msgid ""
102
112
"A common pattern is to sort complex objects using some of the object's "
103
113
"indices as keys. For example:"
104
- msgstr ""
114
+ msgstr "일반적인 패턴은 객체의 인덱스 중 일부를 키로 사용하여 복잡한 객체를 정렬하는 것입니다. 예를 들어: "
105
115
106
116
#: ../Doc/howto/sorting.rst:68
107
117
msgid "The same technique works for objects with named attributes. For example:"
108
- msgstr ""
118
+ msgstr "같은 기법이 이름있는 어트리뷰트를 갖는 객체에서도 작동합니다. 예를 들어: "
109
119
110
120
#: ../Doc/howto/sorting.rst:87
111
121
msgid "Operator Module Functions"
112
- msgstr ""
122
+ msgstr "operator 모듈 함수 "
113
123
114
124
#: ../Doc/howto/sorting.rst:89
115
125
msgid ""
@@ -119,31 +129,38 @@ msgid ""
119
129
":func:`~operator.attrgetter`, and a :func:`~operator.methodcaller` "
120
130
"function."
121
131
msgstr ""
132
+ "위에서 보여준 키 함수 패턴은 매우 일반적이므로, 파이썬은 액세스 함수를 더 쉽고 빠르게 만드는 편리 함수를 제공합니다. "
133
+ ":mod:`operator` 모듈에는 :func:`~operator.itemgetter`, "
134
+ ":func:`~operator.attrgetter` 및 :func:`~operator.methodcaller` 함수가 있습니다."
122
135
123
136
#: ../Doc/howto/sorting.rst:94
124
137
msgid "Using those functions, the above examples become simpler and faster:"
125
- msgstr ""
138
+ msgstr "이러한 함수를 사용하면, 위의 예제가 더 간단 해지고 빨라집니다: "
126
139
127
140
#: ../Doc/howto/sorting.rst:104
128
141
msgid ""
129
142
"The operator module functions allow multiple levels of sorting. For "
130
143
"example, to sort by *grade* then by *age*:"
131
144
msgstr ""
145
+ "operator 모듈 함수는 다중 수준의 정렬을 허용합니다. 예를 들어, 먼저 *grade*\\ 로 정렬한 다음 *age*\\ 로 "
146
+ "정렬하려면, 이렇게 합니다:"
132
147
133
148
#: ../Doc/howto/sorting.rst:114
134
149
msgid "Ascending and Descending"
135
- msgstr ""
150
+ msgstr "오름차순과 내림차순 "
136
151
137
152
#: ../Doc/howto/sorting.rst:116
138
153
msgid ""
139
154
"Both :meth:`list.sort` and :func:`sorted` accept a *reverse* parameter "
140
155
"with a boolean value. This is used to flag descending sorts. For example,"
141
156
" to get the student data in reverse *age* order:"
142
157
msgstr ""
158
+ ":meth:`list.sort`\\ 와 :func:`sorted`\\ 는 모두 불리언 값을 갖는 *reverse* 매개 변수를 "
159
+ "받아들입니다. 내림차순 정렬을 지정하는 데 사용됩니다. 예를 들어, 학생 데이터를 역 *age* 순서로 얻으려면, 이렇게 합니다:"
143
160
144
161
#: ../Doc/howto/sorting.rst:127
145
162
msgid "Sort Stability and Complex Sorts"
146
- msgstr ""
163
+ msgstr "정렬 안정성과 복잡한 정렬 "
147
164
148
165
#: ../Doc/howto/sorting.rst:129
149
166
msgid ""
@@ -152,12 +169,17 @@ msgid ""
152
169
"means that when multiple records have the same key, their original order "
153
170
"is preserved."
154
171
msgstr ""
172
+ "정렬은 `안정적 "
173
+ "<https://en.wikipedia.org/wiki/Sorting_algorithm#Stability>`_\\ 임이 보장됩니다. "
174
+ "즉, 여러 레코드가 같은 키를 가질 때, 원래의 순서가 유지됩니다."
155
175
156
176
#: ../Doc/howto/sorting.rst:137
157
177
msgid ""
158
178
"Notice how the two records for *blue* retain their original order so that"
159
179
" ``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."
160
180
msgstr ""
181
+ "*blue*\\ 에 대한 두 레코드가 원래 순서를 유지해서 ``('blue', 1)``\\ 이 ``('blue', 2)``\\ 보다 앞에"
182
+ " 나옴이 보장됨에 유의하십시오."
161
183
162
184
#: ../Doc/howto/sorting.rst:140
163
185
msgid ""
@@ -166,60 +188,67 @@ msgid ""
166
188
"*grade* and then ascending *age*, do the *age* sort first and then sort "
167
189
"again using *grade*:"
168
190
msgstr ""
191
+ "이 멋진 속성은 일련의 정렬 단계로 복잡한 정렬을 만들 수 있도록 합니다. 예를 들어, 학생 데이터를 *grade*\\ 의 "
192
+ "내림차순으로 정렬한 다음, *age*\\ 의 오름차순으로 정렬하려면, 먼저 *age* 정렬을 수행한 다음 *grade*\\ 를 사용하여"
193
+ " 다시 정렬합니다:"
169
194
170
195
#: ../Doc/howto/sorting.rst:148
171
196
msgid ""
172
197
"The `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ algorithm used in "
173
198
"Python does multiple sorts efficiently because it can take advantage of "
174
199
"any ordering already present in a dataset."
175
200
msgstr ""
201
+ "파이썬에서 사용된 `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ 알고리즘은 데이터 "
202
+ "집합에 이미 존재하는 순서를 활용할 수 있으므로 효율적으로 여러 번의 정렬을 수행합니다."
176
203
177
204
#: ../Doc/howto/sorting.rst:153
178
205
msgid "The Old Way Using Decorate-Sort-Undecorate"
179
- msgstr ""
206
+ msgstr "장식-정렬-복원을 사용하는 낡은 방법 "
180
207
181
208
#: ../Doc/howto/sorting.rst:155
182
209
msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"
183
- msgstr ""
210
+ msgstr "이 관용구는 그것의 세 단계를 따라 장식-정렬-복원(Decorate-Sort-Undecorate)이라고 합니다: "
184
211
185
212
#: ../Doc/howto/sorting.rst:157
186
213
msgid ""
187
214
"First, the initial list is decorated with new values that control the "
188
215
"sort order."
189
- msgstr ""
216
+ msgstr "첫째, 초기 리스트가 정렬 순서를 제어하는 새로운 값으로 장식됩니다. "
190
217
191
218
#: ../Doc/howto/sorting.rst:159
192
219
msgid "Second, the decorated list is sorted."
193
- msgstr ""
220
+ msgstr "둘째, 장식된 리스트를 정렬합니다. "
194
221
195
222
#: ../Doc/howto/sorting.rst:161
196
223
msgid ""
197
224
"Finally, the decorations are removed, creating a list that contains only "
198
225
"the initial values in the new order."
199
- msgstr ""
226
+ msgstr "마지막으로, 장식을 제거하여, 새 순서로 초깃값만 포함하는 리스트를 만듭니다. "
200
227
201
228
#: ../Doc/howto/sorting.rst:164
202
229
msgid "For example, to sort the student data by *grade* using the DSU approach:"
203
- msgstr ""
230
+ msgstr "예를 들어, DSU 방식을 사용하여 *grade* \\ 로 학생 데이터를 정렬하려면 다음과 같이 합니다: "
204
231
205
232
#: ../Doc/howto/sorting.rst:171
206
233
msgid ""
207
234
"This idiom works because tuples are compared lexicographically; the first"
208
235
" items are compared; if they are the same then the second items are "
209
236
"compared, and so on."
210
237
msgstr ""
238
+ "이 관용구는 튜플이 사전식으로 비교되기 때문에 작동합니다; 첫 번째 항목이 비교됩니다; 그들이 같으면 두 번째 항목이 비교되고, "
239
+ "이런 식으로 계속됩니다."
211
240
212
241
#: ../Doc/howto/sorting.rst:175
213
242
msgid ""
214
243
"It is not strictly necessary in all cases to include the index *i* in the"
215
244
" decorated list, but including it gives two benefits:"
216
- msgstr ""
245
+ msgstr "모든 경우에 장식된 리스트에 인덱스 *i* \\ 를 포함할 필요는 없지만, 두 가지 이점이 있습니다: "
217
246
218
247
#: ../Doc/howto/sorting.rst:178
219
248
msgid ""
220
249
"The sort is stable -- if two items have the same key, their order will be"
221
250
" preserved in the sorted list."
222
- msgstr ""
251
+ msgstr "정렬이 안정적입니다 -- 두 항목이 같은 키를 가지면, 그 들의 순서가 정렬된 리스트에 유지됩니다. "
223
252
224
253
#: ../Doc/howto/sorting.rst:181
225
254
msgid ""
@@ -228,23 +257,28 @@ msgid ""
228
257
"So for example the original list could contain complex numbers which "
229
258
"cannot be sorted directly."
230
259
msgstr ""
260
+ "장식된 튜플의 순서는 최대 처음 두 항목에 의해 결정되므로 원래 항목은 비교 가능할 필요가 없습니다. 그래서 예를 들어, 원래 "
261
+ "리스트에는 직접 정렬될 수 없는 복소수가 포함될 수 있습니다."
231
262
232
263
#: ../Doc/howto/sorting.rst:186
233
264
msgid ""
234
265
"Another name for this idiom is `Schwartzian transform "
235
266
"<https://en.wikipedia.org/wiki/Schwartzian_transform>`_\\ , after Randal "
236
267
"L. Schwartz, who popularized it among Perl programmers."
237
268
msgstr ""
269
+ "이 관용구의 또 다른 이름은 펄 프로그래머들 사이에서 이것을 대중화한 Randal L. Schwartz의 이름을 딴 "
270
+ "`Schwartzian 변환 "
271
+ "<https://en.wikipedia.org/wiki/Schwartzian_transform>`_\\ 입니다."
238
272
239
273
#: ../Doc/howto/sorting.rst:190
240
274
msgid ""
241
275
"Now that Python sorting provides key-functions, this technique is not "
242
276
"often needed."
243
- msgstr ""
277
+ msgstr "이제 파이썬 정렬이 키 함수를 제공하기 때문에, 이 기법은 자주 필요하지 않습니다. "
244
278
245
279
#: ../Doc/howto/sorting.rst:194
246
280
msgid "The Old Way Using the *cmp* Parameter"
247
- msgstr ""
281
+ msgstr "*cmp* 매개 변수를 사용하는 낡은 방법 "
248
282
249
283
#: ../Doc/howto/sorting.rst:196
250
284
msgid ""
@@ -253,13 +287,18 @@ msgid ""
253
287
"keyword arguments. Instead, all of the Py2.x versions supported a *cmp* "
254
288
"parameter to handle user specified comparison functions."
255
289
msgstr ""
290
+ "이 HOWTO에서 제공하는 많은 구문은 파이썬 2.4 이상을 가정합니다. 그전에는, :func:`sorted` 내장 함수가 없었으며"
291
+ " :meth:`list.sort`\\ 는 키워드 인자를 취하지 않았습니다. 대신, 모든 Py2.x 버전은 사용자 지정 비교 함수를 "
292
+ "처리하기 위해 *cmp* 매개 변수를 지원했습니다."
256
293
257
294
#: ../Doc/howto/sorting.rst:201
258
295
msgid ""
259
296
"In Py3.0, the *cmp* parameter was removed entirely (as part of a larger "
260
297
"effort to simplify and unify the language, eliminating the conflict "
261
298
"between rich comparisons and the :meth:`__cmp__` magic method)."
262
299
msgstr ""
300
+ "Py3.0에서는, *cmp* 매개 변수가 완전히 제거되었습니다 (언어를 단순화하고 통합하기 위한 노력의 일환으로, 풍부한 "
301
+ "비교(rich comparisons)와 :meth:`__cmp__` 매직 메서드 간의 충돌을 제거했습니다)."
263
302
264
303
#: ../Doc/howto/sorting.rst:205
265
304
msgid ""
@@ -269,37 +308,46 @@ msgid ""
269
308
"equal, or return a positive value for greater-than. For example, we can "
270
309
"do:"
271
310
msgstr ""
311
+ "Py2.x에서, sort는 비교 작업을 위해 호출할 수 있는 선택적 함수를 허용했습니다. 이 함수는 비교할 두 개의 인자를 취한 "
312
+ "다음, 첫 번째가 두 번째보다 작으면(less-than) 음수 값을 반환하고, 같으면 0을 반환하고, 크면(greater-than)"
313
+ " 양수 값을 반환해야 합니다. 예를 들어, 다음과 같이 할 수 있습니다:"
272
314
273
315
#: ../Doc/howto/sorting.rst:215
274
316
msgid "Or you can reverse the order of comparison with:"
275
- msgstr ""
317
+ msgstr "또는 비교 순서를 다음과 같이 뒤집을 수 있습니다: "
276
318
277
319
#: ../Doc/howto/sorting.rst:222
278
320
msgid ""
279
321
"When porting code from Python 2.x to 3.x, the situation can arise when "
280
322
"you have the user supplying a comparison function and you need to convert"
281
323
" that to a key function. The following wrapper makes that easy to do::"
282
324
msgstr ""
325
+ "파이썬 2.x에서 3.x로 코드를 이식할 때, 사용자가 비교 함수를 제공하고 이를 키 함수로 변환해야 하는 상황이 발생할 수 "
326
+ "있습니다. 다음 래퍼를 사용하면 쉽게 할 수 있습니다::"
283
327
284
328
#: ../Doc/howto/sorting.rst:245
285
329
msgid "To convert to a key function, just wrap the old comparison function:"
286
- msgstr ""
330
+ msgstr "키 함수로 변환하려면, 단지 이전 비교 함수를 감싸면 됩니다: "
287
331
288
332
#: ../Doc/howto/sorting.rst:256
289
333
msgid ""
290
334
"In Python 3.2, the :func:`functools.cmp_to_key` function was added to the"
291
335
" :mod:`functools` module in the standard library."
292
336
msgstr ""
337
+ "파이썬 3.2에서, :func:`functools.cmp_to_key` 함수가 표준 라이브러리의 :mod:`functools` "
338
+ "모듈에 추가되었습니다."
293
339
294
340
#: ../Doc/howto/sorting.rst:260
295
341
msgid "Odd and Ends"
296
- msgstr ""
342
+ msgstr "잡동사니 "
297
343
298
344
#: ../Doc/howto/sorting.rst:262
299
345
msgid ""
300
346
"For locale aware sorting, use :func:`locale.strxfrm` for a key function "
301
347
"or :func:`locale.strcoll` for a comparison function."
302
348
msgstr ""
349
+ "로케일 인식 정렬의 경우, 키 함수로는 :func:`locale.strxfrm`\\ 를, 비교 함수로는 "
350
+ ":func:`locale.strcoll`\\ 을 사용하십시오."
303
351
304
352
#: ../Doc/howto/sorting.rst:265
305
353
msgid ""
@@ -308,13 +356,17 @@ msgid ""
308
356
"can be simulated without the parameter by using the builtin "
309
357
":func:`reversed` function twice:"
310
358
msgstr ""
359
+ "*reverse* 매개 변수는 여전히 정렬 안정성을 유지합니다 (그래서 같은 키를 갖는 레코드는 원래 순서를 유지합니다). "
360
+ "흥미롭게도, 그 효과는 내장 :func:`reversed` 함수를 두 번 사용하여 매개 변수 없이 흉내 낼 수 있습니다:"
311
361
312
362
#: ../Doc/howto/sorting.rst:277
313
363
msgid ""
314
364
"The sort routines are guaranteed to use :meth:`__lt__` when making "
315
365
"comparisons between two objects. So, it is easy to add a standard sort "
316
366
"order to a class by defining an :meth:`__lt__` method::"
317
367
msgstr ""
368
+ "정렬 루틴은 두 객체를 비교할 때 :meth:`__lt__`\\ 를 사용하도록 보장됩니다. 따라서 :meth:`__lt__` 메서드를"
369
+ " 정의하여, 표준 정렬 순서를 클래스에 추가하기는 쉽습니다::"
318
370
319
371
#: ../Doc/howto/sorting.rst:285
320
372
msgid ""
@@ -323,4 +375,6 @@ msgid ""
323
375
"student grades are stored in a dictionary, they can be used to sort a "
324
376
"separate list of student names:"
325
377
msgstr ""
378
+ "키 함수는 정렬되는 객체에 직접 의존할 필요가 없습니다. 키 함수는 외부 자원에 액세스할 수도 있습니다. 예를 들어, 학생 성적이 "
379
+ "딕셔너리에 저장되어 있다면, 학생 이름의 별도 리스트를 정렬하는 데 사용할 수 있습니다:"
326
380
0 commit comments