languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-10-14 11:31:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged revisions 56125-56153 via svnmerge from

Browse source 
svn+ssh://pythondev@svn.python.org/python/branches/p3yk

........
  r56127 | georg.brandl | 2007-06-30 09:32:49 +0200 (Sat, 30 Jun 2007) | 2 lines

  Fix a place where floor division would be in order.
........
  r56135 | guido.van.rossum | 2007-07-01 06:13:54 +0200 (Sun, 01 Jul 2007) | 28 lines

  Make map() and filter() identical to itertools.imap() and .ifilter(),
  respectively.

  I fixed two bootstrap issues, due to the dynamic import of itertools:

  1. Starting python requires that map() and filter() are not used until
     site.py has added build/lib.<arch> to sys.path.
  2. Building python requires that setup.py and distutils and everything
     they use is free of map() and filter() calls.

  Beyond this, I only fixed the tests in test_builtin.py.
  Others, please help fixing the remaining tests that are now broken!
  The fixes are usually simple:
  a. map(None, X) -> list(X)
  b. map(F, X) -> list(map(F, X))
  c. map(lambda x: F(x), X) -> [F(x) for x in X]
  d. filter(F, X) -> list(filter(F, X))
  e. filter(lambda x: P(x), X) -> [x for x in X if P(x)]

  Someone, please also contribute a fixer for 2to3 to do this.
  It can leave map()/filter() calls alone that are already
  inside a list() or sorted() call or for-loop.

  Only in rare cases have I seen code that depends on map() of lists
  of different lengths going to the end of the longest, or on filter()
  of a string or tuple returning an object of the same type; these
  will need more thought to fix.
........
  r56136 | guido.van.rossum | 2007-07-01 06:22:01 +0200 (Sun, 01 Jul 2007) | 3 lines

  Make it so that test_decimal fails instead of hangs, to help automated
  test runners.
........
  r56139 | georg.brandl | 2007-07-01 18:20:58 +0200 (Sun, 01 Jul 2007) | 2 lines

  Fix a few test cases after the map->imap change.
........
  r56142 | neal.norwitz | 2007-07-02 06:38:12 +0200 (Mon, 02 Jul 2007) | 1 line

  Get a bunch more tests passing after converting map/filter to return iterators.
........
  r56147 | guido.van.rossum | 2007-07-02 15:32:02 +0200 (Mon, 02 Jul 2007) | 4 lines

  Fix the remaining failing unit tests (at least on OSX).
  Also tweaked urllib2 so it doesn't raise socket.gaierror when
  all network interfaces are turned off.
........
This commit is contained in:
Guido van Rossum 2007-07-03 08:25:58 +00:00
parent d09413012c
commit c1f779cb01
45 changed files with 231 additions and 760 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Lib/cgi.py
View file

@ -572,7 +572,7 @@ def getvalue(self, key, default=None):
if key in self:
value = self[key]
if type(value) is type([]):
return map(attrgetter('value'), value)
return [x.value for x in value]
else:
return value.value
else:
@ -594,7 +594,7 @@ def getlist(self, key):
if key in self:
value = self[key]
if type(value) is type([]):
return map(attrgetter('value'), value)
return [x.value for x in value]
else:
return [value.value]
else:

2
Lib/csv.py
View file

@ -253,7 +253,7 @@ def _guess_delimiter(self, data, delimiters):
additional chunks as necessary.
"""
data = filter(None, data.split('\n'))
data = list(filter(None, data.split('\n')))
ascii = [chr(c) for c in range(127)] # 7-bit ASCII

8
Lib/decimal.py
View file

@ -841,7 +841,7 @@ def __str__(self, eng = 0, context=None):
if context is None:
context = getcontext()
tmp = map(str, self._int)
tmp = list(map(str, self._int))
numdigits = len(self._int)
leftdigits = self._exp + numdigits
if eng and not self: # self = 0eX wants 0[.0[0]]eY, not [[0]0]0eY
@ -1193,7 +1193,9 @@ def __mul__(self, other, context=None):
op1 = _WorkRep(self)
op2 = _WorkRep(other)
ans = Decimal((resultsign, map(int, str(op1.int * op2.int)), resultexp))
ans = Decimal((resultsign,
tuple(map(int, str(op1.int * op2.int))),
resultexp))
if shouldround:
ans = ans._fix(context)
@ -3145,7 +3147,7 @@ def _string2exact(s):
exp -= len(fracpart)
mantissa = intpart + fracpart
tmp = map(int, mantissa)
tmp = list(map(int, mantissa))
backup = tmp
while tmp and tmp[0] == 0:
del tmp[0]

2
Lib/difflib.py
View file

@ -587,7 +587,7 @@ def get_grouped_opcodes(self, n=3):
Each group is in the same format as returned by get_opcodes().
>>> from pprint import pprint
>>> a = map(str, range(1,40))
>>> a = list(map(str, range(1,40)))
>>> b = a[:]
>>> b[8:8] = ['i'] # Make an insertion
>>> b[20] += 'x' # Make a replacement

5
Lib/distutils/dist.py
View file

@ -112,8 +112,7 @@ class Distribution:
('obsoletes', None,
"print the list of packages/modules made obsolete")
]
display_option_names = map(lambda x: translate_longopt(x[0]),
display_options)
display_option_names = [translate_longopt(x[0]) for x in display_options]
# negative options are options that exclude other options
negative_opt = {'quiet': 'verbose'}
@ -805,7 +804,7 @@ def get_command_packages (self):
pkgs = (pkgs or "").split(",")
for i in range(len(pkgs)):
pkgs[i] = pkgs[i].strip()
pkgs = filter(None, pkgs)
pkgs = [p for p in pkgs if p]
if "distutils.command" not in pkgs:
pkgs.insert(0, "distutils.command")
self.command_packages = pkgs

2
Lib/distutils/sysconfig.py
View file

@ -372,7 +372,7 @@ def _init_posix():
if cur_target == '':
cur_target = cfg_target
os.putenv('MACOSX_DEPLOYMENT_TARGET', cfg_target)
elif map(int, cfg_target.split('.')) > map(int, cur_target.split('.')):
elif [int(x) for x in cfg_target.split('.')] > [int(x) for x in cur_target.split('.')]:
my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configure'
% (cur_target, cfg_target))
raise DistutilsPlatformError(my_msg)

2
Lib/distutils/version.py
View file

@ -148,7 +148,7 @@ def parse (self, vstring):
if patch:
self.version = tuple(map(int, [major, minor, patch]))
else:
self.version = tuple(map(int, [major, minor]) + [0])
self.version = tuple(map(int, [major, minor])) + (0,)
if prerelease:
self.prerelease = (prerelease[0], int(prerelease_num))

4
Lib/encodings/idna.py
View file

@ -38,7 +38,7 @@ def nameprep(label):
raise UnicodeError("Invalid character %r" % c)
# Check bidi
RandAL = map(stringprep.in_table_d1, label)
RandAL = [stringprep.in_table_d1(x) for x in label]
for c in RandAL:
if c:
# There is a RandAL char in the string. Must perform further
@ -47,7 +47,7 @@ def nameprep(label):
# This is table C.8, which was already checked
# 2) If a string contains any RandALCat character, the string
# MUST NOT contain any LCat character.
if filter(stringprep.in_table_d2, label):
if any(stringprep.in_table_d2(x) for x in label):
raise UnicodeError("Violation of BIDI requirement 2")
# 3) If a string contains any RandALCat character, a

6
Lib/filecmp.py
View file

@ -132,9 +132,9 @@ def phase0(self): # Compare everything except common subdirectories
def phase1(self): # Compute common names
a = dict(izip(imap(os.path.normcase, self.left_list), self.left_list))
b = dict(izip(imap(os.path.normcase, self.right_list), self.right_list))
self.common = map(a.__getitem__, ifilter(b.__contains__, a))
self.left_only = map(a.__getitem__, ifilterfalse(b.__contains__, a))
self.right_only = map(b.__getitem__, ifilterfalse(a.__contains__, b))
self.common = list(map(a.__getitem__, ifilter(b.__contains__, a)))
self.left_only = list(map(a.__getitem__, ifilterfalse(b.__contains__, a)))
self.right_only = list(map(b.__getitem__, ifilterfalse(a.__contains__, b)))
def phase2(self): # Distinguish files, directories, funnies
self.common_dirs = []

12
Lib/heapq.py
View file

@ -129,7 +129,7 @@
__all__ = ['heappush', 'heappop', 'heapify', 'heapreplace', 'merge',
'nlargest', 'nsmallest']
from itertools import islice, repeat, count, imap, izip, tee
from itertools import islice, repeat, count, izip, tee
from operator import itemgetter, neg
import bisect
@ -225,7 +225,7 @@ def nsmallest(n, iterable):
# O(m) + O(n log m) comparisons.
h = list(iterable)
heapify(h)
return map(heappop, repeat(h, min(n, len(h))))
return list(map(heappop, repeat(h, min(n, len(h)))))
# 'heap' is a heap at all indices >= startpos, except possibly for pos. pos
# is the index of a leaf with a possibly out-of-order value. Restore the
@ -351,9 +351,9 @@ def nsmallest(n, iterable, key=None):
Equivalent to: sorted(iterable, key=key)[:n]
"""
in1, in2 = tee(iterable)
it = izip(imap(key, in1), count(), in2) # decorate
it = izip(map(key, in1), count(), in2) # decorate
result = _nsmallest(n, it)
return map(itemgetter(2), result) # undecorate
return list(map(itemgetter(2), result)) # undecorate
_nlargest = nlargest
def nlargest(n, iterable, key=None):
@ -362,9 +362,9 @@ def nlargest(n, iterable, key=None):
Equivalent to: sorted(iterable, key=key, reverse=True)[:n]
"""
in1, in2 = tee(iterable)
it = izip(imap(key, in1), imap(neg, count()), in2) # decorate
it = izip(map(key, in1), map(neg, count()), in2) # decorate
result = _nlargest(n, it)
return map(itemgetter(2), result) # undecorate
return list(map(itemgetter(2), result)) # undecorate
if __name__ == "__main__":
# Simple sanity test

2
Lib/logging/config.py
View file

@ -176,7 +176,7 @@ def _install_loggers(cp, handlers):
# configure the root first
llist = cp.get("loggers", "keys")
llist = llist.split(",")
llist = map(lambda x: x.strip(), llist)
llist = list(map(lambda x: x.strip(), llist))
llist.remove("root")
sectname = "logger_root"
root = logging.root

3
Lib/mhlib.py
View file

@ -282,8 +282,7 @@ def listmessages(self):
for name in os.listdir(self.getfullname()):
if match(name):
append(name)
messages = map(int, messages)
messages.sort()
messages = sorted(map(int, messages))
if messages:
self.last = messages[-1]
else:

2
Lib/optparse.py
View file

@ -573,7 +573,7 @@ def _check_opt_strings(self, opts):
# Filter out None because early versions of Optik had exactly
# one short option and one long option, either of which
# could be None.
opts = filter(None, opts)
opts = [opt for opt in opts if opt]
if not opts:
raise TypeError("at least one option string must be supplied")
return opts

4
Lib/pydoc.py
View file

@ -468,9 +468,9 @@ def preformat(self, text):
def multicolumn(self, list, format, cols=4):
"""Format a list of items into a multi-column list."""
result = ''
rows = (len(list)+cols-1)/cols
rows = (len(list)+cols-1)//cols
for col in range(cols):
result = result + '<td width="%d%%" valign=top>' % (100/cols)
result = result + '<td width="%d%%" valign=top>' % (100//cols)
for i in range(rows*col, rows*col+rows):
if i < len(list):
result = result + format(list[i]) + '<br>\n'

11
Lib/string.py
View file

@ -30,9 +30,7 @@
# Case conversion helpers
# Use str to convert Unicode literal in case of -U
l = map(chr, range(256))
_idmap = str('').join(l)
del l
_idmap = str('').join(chr(c) for c in range(256))
# Functions which aren't available as string methods.
@ -63,11 +61,10 @@ def maketrans(fromstr, tostr):
raise ValueError, "maketrans arguments must have same length"
global _idmapL
if not _idmapL:
_idmapL = map(None, _idmap)
_idmapL = list(_idmap)
L = _idmapL[:]
fromstr = map(ord, fromstr)
for i in range(len(fromstr)):
L[fromstr[i]] = tostr[i]
for i, c in enumerate(fromstr):
L[ord(c)] = tostr[i]
return ''.join(L)

2
Lib/test/test_bisect.py
View file

@ -223,7 +223,7 @@ def test_arg_parsing(self):
...
>>> grade(66)
'C'
>>> map(grade, [33, 99, 77, 44, 12, 88])
>>> list(map(grade, [33, 99, 77, 44, 12, 88]))
['E', 'A', 'B', 'D', 'F', 'A']
"""

123
Lib/test/test_builtin.py
View file

@ -466,11 +466,11 @@ def test_exec(self):
self.assertEqual((g, l), ({'a': 1}, {'b': 2}))
def test_filter(self):
self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')
self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])
self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])
self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])
self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])
self.assertEqual(list(filter(lambda c: 'a' <= c <= 'z', 'Hello World')), list('elloorld'))
self.assertEqual(list(filter(None, [1, 'hello', [], [3], '', None, 9, 0])), [1, 'hello', [3], 9])
self.assertEqual(list(filter(lambda x: x > 0, [1, -3, 9, 0, 2])), [1, 9, 2])
self.assertEqual(list(filter(None, Squares(10))), [1, 4, 9, 16, 25, 36, 49, 64, 81])
self.assertEqual(list(filter(lambda x: x%2, Squares(10))), [1, 9, 25, 49, 81])
def identity(item):
return 1
filter(identity, Squares(5))
@ -480,67 +480,15 @@ def __getitem__(self, index):
if index<4:
return 42
raise ValueError
self.assertRaises(ValueError, filter, lambda x: x, BadSeq())
self.assertRaises(ValueError, list, filter(lambda x: x, BadSeq()))
def badfunc():
pass
self.assertRaises(TypeError, filter, badfunc, range(5))
self.assertRaises(TypeError, list, filter(badfunc, range(5)))
# test bltinmodule.c::filtertuple()
self.assertEqual(filter(None, (1, 2)), (1, 2))
self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))
self.assertRaises(TypeError, filter, 42, (1, 2))
# test bltinmodule.c::filterunicode()
self.assertEqual(filter(None, "12"), "12")
self.assertEqual(filter(lambda x: x>="3", "1234"), "34")
self.assertRaises(TypeError, filter, 42, "12")
class badstr(str):
def __getitem__(self, index):
raise ValueError
self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))
class badstr2(str):
def __getitem__(self, index):
return 42
self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))
class weirdstr(str):
def __getitem__(self, index):
return weirdstr(2*str.__getitem__(self, index))
self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")
class shiftstr(str):
def __getitem__(self, index):
return chr(ord(str.__getitem__(self, index))+1)
self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")
def test_filter_subclasses(self):
# test that filter() never returns tuple or str subclasses
# and that the result always goes through __getitem__
funcs = (None, bool, lambda x: True)
class tuple2(tuple):
def __getitem__(self, index):
return 2*tuple.__getitem__(self, index)
class str2(str):
def __getitem__(self, index):
return 2*str.__getitem__(self, index)
inputs = {
tuple2: {(): (), (1, 2, 3): (2, 4, 6)},
str2: {"": "", "123": "112233"}
}
for (cls, inps) in inputs.items():
for (inp, exp) in inps.items():
# make sure the output goes through __getitem__
# even if func is None
self.assertEqual(
filter(funcs[0], cls(inp)),
filter(funcs[1], cls(inp))
)
for func in funcs:
outp = filter(func, cls(inp))
self.assertEqual(outp, exp)
self.assert_(not isinstance(outp, cls))
self.assertEqual(list(filter(None, (1, 2))), [1, 2])
self.assertEqual(list(filter(lambda x: x>=3, (1, 2, 3, 4))), [3, 4])
self.assertRaises(TypeError, list, filter(42, (1, 2)))
def test_float(self):
self.assertEqual(float(3.14), 3.14)
@ -1102,19 +1050,19 @@ def __long__(self):
def test_map(self):
self.assertEqual(
map(None, 'hello world'),
['h','e','l','l','o',' ','w','o','r','l','d']
list(map(None, 'hello')),
[('h',), ('e',), ('l',), ('l',), ('o',)]
)
self.assertEqual(
map(None, 'abcd', 'efg'),
[('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', None)]
list(map(None, 'abcd', 'efg')),
[('a', 'e'), ('b', 'f'), ('c', 'g')]
)
self.assertEqual(
map(None, range(10)),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list(map(None, range(3))),
[(0,), (1,), (2,)]
)
self.assertEqual(
map(lambda x: x*x, range(1,4)),
list(map(lambda x: x*x, range(1,4))),
[1, 4, 9]
)
try:
@ -1123,11 +1071,11 @@ def test_map(self):
def sqrt(x):
return pow(x, 0.5)
self.assertEqual(
map(lambda x: map(sqrt,x), [[16, 4], [81, 9]]),
list(map(lambda x: list(map(sqrt, x)), [[16, 4], [81, 9]])),
[[4.0, 2.0], [9.0, 3.0]]
)
self.assertEqual(
map(lambda x, y: x+y, [1,3,2], [9,1,4]),
list(map(lambda x, y: x+y, [1,3,2], [9,1,4])),
[10, 4, 6]
)
@ -1136,28 +1084,28 @@ def plus(*v):
for i in v: accu = accu + i
return accu
self.assertEqual(
map(plus, [1, 3, 7]),
list(map(plus, [1, 3, 7])),
[1, 3, 7]
)
self.assertEqual(
map(plus, [1, 3, 7], [4, 9, 2]),
list(map(plus, [1, 3, 7], [4, 9, 2])),
[1+4, 3+9, 7+2]
)
self.assertEqual(
map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0]),
list(map(plus, [1, 3, 7], [4, 9, 2], [1, 1, 0])),
[1+4+1, 3+9+1, 7+2+0]
)
self.assertEqual(
map(None, Squares(10)),
list(map(None, Squares(10))),
[(0,), (1,), (4,), (9,), (16,), (25,), (36,), (49,), (64,), (81,)]
)
self.assertEqual(
list(map(int, Squares(10))),
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
)
self.assertEqual(
map(int, Squares(10)),
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
)
self.assertEqual(
map(None, Squares(3), Squares(2)),
[(0,0), (1,1), (4,None)]
list(map(None, Squares(3), Squares(2))),
[(0,0), (1,1)]
)
def Max(a, b):
if a is None:
@ -1166,19 +1114,20 @@ def Max(a, b):
return a
return max(a, b)
self.assertEqual(
map(Max, Squares(3), Squares(2)),
[0, 1, 4]
list(map(Max, Squares(3), Squares(2))),
[0, 1]
)
self.assertRaises(TypeError, map)
self.assertRaises(TypeError, map, lambda x: x, 42)
self.assertEqual(map(None, [42]), [42])
self.assertEqual(list(map(None, [42])), [(42,)])
class BadSeq:
def __getitem__(self, index):
def __iter__(self):
raise ValueError
self.assertRaises(ValueError, map, lambda x: x, BadSeq())
yield None
self.assertRaises(ValueError, list, map(lambda x: x, BadSeq()))
def badfunc(x):
raise RuntimeError
self.assertRaises(RuntimeError, map, badfunc, range(5))
self.assertRaises(RuntimeError, list, map(badfunc, range(5)))
def test_max(self):
self.assertEqual(max('123123'), '3')

6
Lib/test/test_bytes.py
View file

@ -158,7 +158,7 @@ def test_buffer_api(self):
b = b"x"*20
n = f.readinto(b)
self.assertEqual(n, len(short_sample))
self.assertEqual(b, sample)
self.assertEqual(list(b), list(sample))
# Test writing in binary mode
with open(tfn, "wb") as f:
f.write(b)
@ -172,7 +172,7 @@ def test_buffer_api(self):
pass
def test_reversed(self):
input = map(ord, "Hello")
input = list(map(ord, "Hello"))
b = bytes(input)
output = list(reversed(b))
input.reverse()
@ -469,7 +469,7 @@ def test_join(self):
self.assertEqual(b"".join([]), bytes())
self.assertEqual(b"".join([bytes()]), bytes())
for part in [("abc",), ("a", "bc"), ("ab", "c"), ("a", "b", "c")]:
lst = map(bytes, part)
lst = list(map(bytes, part))
self.assertEqual(b"".join(lst), bytes("abc"))
self.assertEqual(b"".join(tuple(lst)), bytes("abc"))
self.assertEqual(b"".join(iter(lst)), bytes("abc"))

5
Lib/test/test_cgi.py
View file

@ -121,10 +121,11 @@ def norm(seq):
return sorted(seq, key=repr)
def first_elts(list):
return map(lambda x:x[0], list)
return [p[0] for p in list]
def first_second_elts(list):
return map(lambda p:(p[0], p[1][0]), list)
return [(p[0], p[1][0]) for p in list]
class CgiTests(unittest.TestCase):

3
Lib/test/test_datetime.py
View file

@ -830,8 +830,7 @@ def test_iso_long_years(self):
320 348 376
325 353 381
"""
iso_long_years = map(int, ISO_LONG_YEARS_TABLE.split())
iso_long_years.sort()
iso_long_years = sorted(map(int, ISO_LONG_YEARS_TABLE.split()))
L = []
for i in range(400):
d = self.theclass(2000+i, 12, 31)

6
Lib/test/test_decimal.py
View file

@ -39,7 +39,7 @@
threading = None
# Useful Test Constant
Signals = getcontext().flags.keys()
Signals = tuple(getcontext().flags.keys())
# Tests are built around these assumed context defaults.
# test_main() restores the original context.
@ -171,7 +171,7 @@ def eval_line(self, s):
return self.eval_equation(s)
def eval_directive(self, s):
funct, value = map(lambda x: x.strip().lower(), s.split(':'))
funct, value = (x.strip().lower() for x in s.split(':'))
if funct == 'rounding':
value = RoundingDict[value]
else:
@ -842,7 +842,7 @@ def test_comparison_operators(self):
self.assertNotEqual(da, object)
# sortable
a = map(Decimal, range(100))
a = list(map(Decimal, range(100)))
b = a[:]
random.shuffle(a)
a.sort()

3
Lib/test/test_extcall.py
View file

@ -263,8 +263,7 @@ def method(self, arg1, arg2):
for vararg in ['', 'v']:
for kwarg in ['', 'k']:
name = 'z' + args + defargs + vararg + kwarg
arglist = list(args) + map(
lambda x: '%s="%s"' % (x, x), defargs)
arglist = list(args) + ['%s="%s"' % (x, x) for x in defargs]
if vararg: arglist.append('*' + vararg)
if kwarg: arglist.append('**' + kwarg)
decl = (('def %s(%s): print("ok %s", a, b, d, e, v, ' +

5
Lib/test/test_functools.py
View file

@ -19,6 +19,7 @@ def capture(*args, **kw):
"""capture all positional and keyword arguments"""
return args, kw
class TestPartial(unittest.TestCase):
thetype = functools.partial
@ -28,7 +29,7 @@ def test_basic_examples(self):
self.assertEqual(p(3, 4, b=30, c=40),
((1, 2, 3, 4), dict(a=10, b=30, c=40)))
p = self.thetype(map, lambda x: x*10)
self.assertEqual(p([1,2,3,4]), [10, 20, 30, 40])
self.assertEqual(list(p([1,2,3,4])), [10, 20, 30, 40])
def test_attributes(self):
p = self.thetype(capture, 1, 2, a=10, b=20)
@ -134,7 +135,7 @@ def test_weakref(self):
self.assertRaises(ReferenceError, getattr, p, 'func')
def test_with_bound_and_unbound_methods(self):
data = map(str, range(10))
data = list(map(str, range(10)))
join = self.thetype(str.join, '')
self.assertEqual(join(data), '0123456789')
join = self.thetype(''.join)

2
Lib/test/test_genexps.py
View file

@ -128,7 +128,7 @@
Verify re-use of tuples (a side benefit of using genexps over listcomps)
>>> tupleids = map(id, ((i,i) for i in range(10)))
>>> tupleids = list(map(id, ((i,i) for i in range(10))))
>>> int(max(tupleids) - min(tupleids))
0

4
Lib/test/test_grp.py
View file

@ -54,7 +54,7 @@ def test_errors(self):
namei = 0
fakename = allnames[namei]
while fakename in bynames:
chars = map(None, fakename)
chars = list(fakename)
for i in range(len(chars)):
if chars[i] == 'z':
chars[i] = 'A'
@ -71,7 +71,7 @@ def test_errors(self):
except IndexError:
# should never happen... if so, just forget it
break
fakename = ''.join(map(None, chars))
fakename = ''.join(chars)
self.assertRaises(KeyError, grp.getgrnam, fakename)

2
Lib/test/test_hash.py
View file

@ -11,7 +11,7 @@ class HashEqualityTestCase(unittest.TestCase):
def same_hash(self, *objlist):
# Hash each object given and fail if
# the hash values are not all the same.
hashed = map(hash, objlist)
hashed = list(map(hash, objlist))
for h in hashed[1:]:
if h != hashed[0]:
self.fail("hashed values differ: %r" % (objlist,))

13
Lib/test/test_heapq.py
View file

@ -130,16 +130,17 @@ def test_nsmallest(self):
data = [(random.randrange(2000), i) for i in range(1000)]
for f in (None, lambda x: x[0] * 547 % 2000):
for n in (0, 1, 2, 10, 100, 400, 999, 1000, 1100):
self.assertEqual(nsmallest(n, data), sorted(data)[:n])
self.assertEqual(nsmallest(n, data, key=f),
self.assertEqual(list(nsmallest(n, data)), sorted(data)[:n])
self.assertEqual(list(nsmallest(n, data, key=f)),
sorted(data, key=f)[:n])
def test_nlargest(self):
data = [(random.randrange(2000), i) for i in range(1000)]
for f in (None, lambda x: x[0] * 547 % 2000):
for n in (0, 1, 2, 10, 100, 400, 999, 1000, 1100):
self.assertEqual(nlargest(n, data), sorted(data, reverse=True)[:n])
self.assertEqual(nlargest(n, data, key=f),
self.assertEqual(list(nlargest(n, data)),
sorted(data, reverse=True)[:n])
self.assertEqual(list(nlargest(n, data, key=f)),
sorted(data, key=f, reverse=True)[:n])
@ -279,8 +280,8 @@ def test_iterable_args(self):
for f in (nlargest, nsmallest):
for s in ("123", "", range(1000), (1, 1.2), range(2000,2200,5)):
for g in (G, I, Ig, L, R):
self.assertEqual(f(2, g(s)), f(2,s))
self.assertEqual(f(2, S(s)), [])
self.assertEqual(list(f(2, g(s))), list(f(2,s)))
self.assertEqual(list(f(2, S(s))), [])
self.assertRaises(TypeError, f, 2, X(s))
self.assertRaises(TypeError, f, 2, N(s))
self.assertRaises(ZeroDivisionError, f, 2, E(s))

2
Lib/test/test_inspect.py
View file

@ -44,7 +44,7 @@ def istest(self, predicate, exp):
class TestPredicates(IsTestBase):
def test_thirteen(self):
count = len(filter(lambda x:x.startswith('is'), dir(inspect)))
count = len([x for x in dir(inspect) if x.startswith('is')])
# Doc/lib/libinspect.tex claims there are 13 such functions
expected = 13
err_msg = "There are %d (not %d) is* functions" % (count, expected)

37
Lib/test/test_iter.py
View file

@ -305,13 +305,14 @@ def test_builtin_tuple(self):
# Test filter()'s use of iterators.
def test_builtin_filter(self):
self.assertEqual(filter(None, SequenceClass(5)), list(range(1, 5)))
self.assertEqual(filter(None, SequenceClass(0)), [])
self.assertEqual(filter(None, ()), ())
self.assertEqual(filter(None, "abc"), "abc")
self.assertEqual(list(filter(None, SequenceClass(5))),
list(range(1, 5)))
self.assertEqual(list(filter(None, SequenceClass(0))), [])
self.assertEqual(list(filter(None, ())), [])
self.assertEqual(list(filter(None, "abc")), ["a", "b", "c"])
d = {"one": 1, "two": 2, "three": 3}
self.assertEqual(filter(None, d), list(d.keys()))
self.assertEqual(list(filter(None, d)), list(d.keys()))
self.assertRaises(TypeError, filter, None, list)
self.assertRaises(TypeError, filter, None, 42)
@ -344,8 +345,8 @@ def __next__(self):
return SeqIter(self.vals)
seq = Seq(*([bTrue, bFalse] * 25))
self.assertEqual(filter(lambda x: not x, seq), [bFalse]*25)
self.assertEqual(filter(lambda x: not x, iter(seq)), [bFalse]*25)
self.assertEqual(list(filter(lambda x: not x, seq)), [bFalse]*25)
self.assertEqual(list(filter(lambda x: not x, iter(seq))), [bFalse]*25)
# Test max() and min()'s use of iterators.
def test_builtin_max_min(self):
@ -381,20 +382,24 @@ def test_builtin_max_min(self):
# Test map()'s use of iterators.
def test_builtin_map(self):
self.assertEqual(map(None, SequenceClass(5)), list(range(5)))
self.assertEqual(map(lambda x: x+1, SequenceClass(5)), list(range(1, 6)))
self.assertEqual(list(map(None, SequenceClass(5))),
[(0,), (1,), (2,), (3,), (4,)])
self.assertEqual(list(map(lambda x: x+1, SequenceClass(5))),
list(range(1, 6)))
d = {"one": 1, "two": 2, "three": 3}
self.assertEqual(map(None, d), list(d.keys()))
self.assertEqual(map(lambda k, d=d: (k, d[k]), d), list(d.items()))
self.assertEqual(list(map(None, d)), [(k,) for k in d])
self.assertEqual(list(map(lambda k, d=d: (k, d[k]), d)),
list(d.items()))
dkeys = list(d.keys())
expected = [(i < len(d) and dkeys[i] or None,
i,
i < len(d) and dkeys[i] or None)
for i in range(5)]
self.assertEqual(map(None, d,
SequenceClass(5),
iter(d.keys())),
for i in range(3)]
self.assertEqual(list(map(None,
d,
SequenceClass(5),
iter(d.keys()))),
expected)
f = open(TESTFN, "w")
@ -405,7 +410,7 @@ def test_builtin_map(self):
f.close()
f = open(TESTFN, "r")
try:
self.assertEqual(map(len, f), list(range(1, 21, 2)))
self.assertEqual(list(map(len, f)), list(range(1, 21, 2)))
finally:
f.close()
try:

35
Lib/test/test_itertools.py
View file

@ -199,9 +199,9 @@ def test_izip(self):
lzip('abc', 'def'))
self.assertEqual([pair for pair in izip('abc', 'def')],
lzip('abc', 'def'))
ids = map(id, izip('abc', 'def'))
ids = list(map(id, izip('abc', 'def')))
self.assertEqual(min(ids), max(ids))
ids = map(id, list(izip('abc', 'def')))
ids = list(map(id, list(izip('abc', 'def'))))
self.assertEqual(len(dict.fromkeys(ids)), len(ids))
def test_iziplongest(self):
@ -212,7 +212,8 @@ def test_iziplongest(self):
[range(1000), range(0), range(3000,3050), range(1200), range(1500)],
[range(1000), range(0), range(3000,3050), range(1200), range(1500), range(0)],
]:
target = map(None, *args)
target = [tuple([arg[i] if i < len(arg) else None for arg in args])
for i in range(max(map(len, args)))]
self.assertEqual(list(izip_longest(*args)), target)
self.assertEqual(list(izip_longest(*args, **{})), target)
target = [tuple((e is None and 'X' or e) for e in t) for t in target] # Replace None fills with 'X'
@ -224,7 +225,8 @@ def test_iziplongest(self):
self.assertEqual(list(izip_longest([])), list(zip([])))
self.assertEqual(list(izip_longest('abcdef')), list(zip('abcdef')))
self.assertEqual(list(izip_longest('abc', 'defg', **{})), map(None, 'abc', 'defg')) # empty keyword dict
self.assertEqual(list(izip_longest('abc', 'defg', **{})),
list(map(None, list('abc')+[None], 'defg'))) # empty keyword dict
self.assertRaises(TypeError, izip_longest, 3)
self.assertRaises(TypeError, izip_longest, range(3), 3)
@ -244,9 +246,9 @@ def test_iziplongest(self):
list(zip('abc', 'def')))
self.assertEqual([pair for pair in izip_longest('abc', 'def')],
list(zip('abc', 'def')))
ids = map(id, izip_longest('abc', 'def'))
ids = list(map(id, izip_longest('abc', 'def')))
self.assertEqual(min(ids), max(ids))
ids = map(id, list(izip_longest('abc', 'def')))
ids = list(map(id, list(izip_longest('abc', 'def'))))
self.assertEqual(len(dict.fromkeys(ids)), len(ids))
def test_repeat(self):
@ -432,7 +434,7 @@ def irange(n):
result = tee('abc', n)
self.assertEqual(type(result), tuple)
self.assertEqual(len(result), n)
self.assertEqual(map(list, result), [list('abc')]*n)
self.assertEqual([list(x) for x in result], [list('abc')]*n)
# tee pass-through to copyable iterator
a, b = tee('abc')
@ -642,7 +644,8 @@ def test_groupby(self):
def test_ifilter(self):
for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
for g in (G, I, Ig, S, L, R):
self.assertEqual(list(ifilter(isEven, g(s))), filter(isEven, g(s)))
self.assertEqual(list(ifilter(isEven, g(s))),
[x for x in g(s) if isEven(x)])
self.assertRaises(TypeError, ifilter, isEven, X(s))
self.assertRaises(TypeError, ifilter, isEven, N(s))
self.assertRaises(ZeroDivisionError, list, ifilter(isEven, E(s)))
@ -650,7 +653,8 @@ def test_ifilter(self):
def test_ifilterfalse(self):
for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
for g in (G, I, Ig, S, L, R):
self.assertEqual(list(ifilterfalse(isEven, g(s))), filter(isOdd, g(s)))
self.assertEqual(list(ifilterfalse(isEven, g(s))),
[x for x in g(s) if isOdd(x)])
self.assertRaises(TypeError, ifilterfalse, isEven, X(s))
self.assertRaises(TypeError, ifilterfalse, isEven, N(s))
self.assertRaises(ZeroDivisionError, list, ifilterfalse(isEven, E(s)))
@ -676,8 +680,10 @@ def test_iziplongest(self):
def test_imap(self):
for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
for g in (G, I, Ig, S, L, R):
self.assertEqual(list(imap(onearg, g(s))), map(onearg, g(s)))
self.assertEqual(list(imap(operator.pow, g(s), g(s))), map(operator.pow, g(s), g(s)))
self.assertEqual(list(imap(onearg, g(s))),
[onearg(x) for x in g(s)])
self.assertEqual(list(imap(operator.pow, g(s), g(s))),
[x**x for x in g(s)])
self.assertRaises(TypeError, imap, onearg, X(s))
self.assertRaises(TypeError, imap, onearg, N(s))
self.assertRaises(ZeroDivisionError, list, imap(onearg, E(s)))
@ -694,7 +700,8 @@ def test_starmap(self):
for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
for g in (G, I, Ig, S, L, R):
ss = lzip(s, s)
self.assertEqual(list(starmap(operator.pow, g(ss))), map(operator.pow, g(s), g(s)))
self.assertEqual(list(starmap(operator.pow, g(ss))),
[x**x for x in g(s)])
self.assertRaises(TypeError, starmap, operator.pow, X(ss))
self.assertRaises(TypeError, starmap, operator.pow, N(ss))
self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
@ -849,7 +856,7 @@ def __init__(self, newarg=None, *args):
>>> d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)
>>> di = sorted(sorted(d.items()), key=itemgetter(1))
>>> for k, g in groupby(di, itemgetter(1)):
... print(k, map(itemgetter(0), g))
... print(k, list(map(itemgetter(0), g)))
...
1 ['a', 'c', 'e']
2 ['b', 'd', 'f']
@ -860,7 +867,7 @@ def __init__(self, newarg=None, *args):
# same group.
>>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
>>> for k, g in groupby(enumerate(data), lambda t:t[0]-t[1]):
... print(map(operator.itemgetter(1), g))
... print(list(map(operator.itemgetter(1), g)))
...
[1]
[4, 5, 6]

7
Lib/test/test_long.py
View file

@ -23,9 +23,7 @@ def __str__(self):
MAXDIGITS = 15
# build some special values
special = map(int, [0, 1, 2, BASE, BASE >> 1])
special.append(0x5555555555555555)
special.append(0xaaaaaaaaaaaaaaaa)
special = [0, 1, 2, BASE, BASE >> 1, 0x5555555555555555, 0xaaaaaaaaaaaaaaaa]
# some solid strings of one bits
p2 = 4 # 0 and 1 already added
for i in range(2*SHIFT):
@ -33,8 +31,7 @@ def __str__(self):
p2 = p2 << 1
del p2
# add complements & negations
special = special + map(lambda x: ~x, special) + \
map(lambda x: -x, special)
special += [~x for x in special] + [-x for x in special]
class LongTest(unittest.TestCase):

2
Lib/test/test_mailbox.py
View file

@ -1669,7 +1669,7 @@ def setUp(self):
self._msgfiles = []
def tearDown(self):
map(os.unlink, self._msgfiles)
list(map(os.unlink, self._msgfiles))
os.rmdir(os.path.join(self._dir, "cur"))
os.rmdir(os.path.join(self._dir, "tmp"))
os.rmdir(os.path.join(self._dir, "new"))

9
Lib/test/test_mhlib.py
View file

@ -179,18 +179,17 @@ def test_listfolders(self):
folders = mh.listallfolders()
folders.sort()
tfolders = map(normF, ['deep', 'deep/f1', 'deep/f2', 'deep/f2/f3',
'inbox', 'wide'])
tfolders.sort()
tfolders = sorted(map(normF, ['deep', 'deep/f1', 'deep/f2',
'deep/f2/f3', 'inbox', 'wide']))
eq(folders, tfolders)
folders = mh.listsubfolders('deep')
folders.sort()
eq(folders, map(normF, ['deep/f1', 'deep/f2']))
eq(folders, list(map(normF, ['deep/f1', 'deep/f2'])))
folders = mh.listallsubfolders('deep')
folders.sort()
eq(folders, map(normF, ['deep/f1', 'deep/f2', 'deep/f2/f3']))
eq(folders, list(map(normF, ['deep/f1', 'deep/f2', 'deep/f2/f3'])))
eq(mh.listsubfolders(normF('deep/f2')), [normF('deep/f2/f3')])
eq(mh.listsubfolders('inbox'), [])

2
Lib/test/test_old_mailbox.py
View file

@ -35,7 +35,7 @@ def setUp(self):
self._msgfiles = []
def tearDown(self):
map(os.unlink, self._msgfiles)
list(map(os.unlink, self._msgfiles))
os.rmdir(os.path.join(self._dir, "cur"))
os.rmdir(os.path.join(self._dir, "tmp"))
os.rmdir(os.path.join(self._dir, "new"))

4
Lib/test/test_operator.py
View file

@ -393,12 +393,12 @@ def __getitem(self, name):
# example used in the docs
inventory = [('apple', 3), ('banana', 2), ('pear', 5), ('orange', 1)]
getcount = operator.itemgetter(1)
self.assertEqual(map(getcount, inventory), [3, 2, 5, 1])
self.assertEqual(list(map(getcount, inventory)), [3, 2, 5, 1])
self.assertEqual(sorted(inventory, key=getcount),
[('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)])
# multiple gets
data = map(str, range(20))
data = list(map(str, range(20)))
self.assertEqual(operator.itemgetter(2,10,5)(data), ('2', '10', '5'))
self.assertRaises(TypeError, operator.itemgetter(2, 'x', 5), data)

4
Lib/test/test_pwd.py
View file

@ -59,7 +59,7 @@ def test_errors(self):
namei = 0
fakename = allnames[namei]
while fakename in bynames:
chars = map(None, fakename)
chars = list(fakename)
for i in range(len(chars)):
if chars[i] == 'z':
chars[i] = 'A'
@ -76,7 +76,7 @@ def test_errors(self):
except IndexError:
# should never happen... if so, just forget it
break
fakename = ''.join(map(None, chars))
fakename = ''.join(chars)
self.assertRaises(KeyError, pwd.getpwnam, fakename)

12
Lib/test/test_weakref.py
View file

@ -740,15 +740,15 @@ def test_weak_values(self):
items2 = dict.copy().items()
items1.sort()
items2.sort()
self.assert_(items1 == items2,
self.assertEqual(items1, items2,
"cloning of weak-valued dictionary did not work!")
del items1, items2
self.assert_(len(dict) == self.COUNT)
self.assertEqual(len(dict), self.COUNT)
del objects[0]
self.assert_(len(dict) == (self.COUNT - 1),
self.assertEqual(len(dict), self.COUNT - 1,
"deleting object did not cause dictionary update")
del objects, o
self.assert_(len(dict) == 0,
self.assertEqual(len(dict), 0,
"deleting the values did not clear the dictionary")
# regression on SF bug #447152:
dict = weakref.WeakValueDictionary()
@ -875,14 +875,14 @@ def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
def make_weak_keyed_dict(self):
dict = weakref.WeakKeyDictionary()
objects = map(Object, range(self.COUNT))
objects = list(map(Object, range(self.COUNT)))
for o in objects:
dict[o] = o.arg
return dict, objects
def make_weak_valued_dict(self):
dict = weakref.WeakValueDictionary()
objects = map(Object, range(self.COUNT))
objects = list(map(Object, range(self.COUNT)))
for o in objects:
dict[o.arg] = o
return dict, objects

2
Lib/test/test_xml_etree.py
View file

@ -53,7 +53,7 @@ def summarize(elem):
return elem.tag
def summarize_list(seq):
return map(summarize, seq)
return list(map(summarize, seq))
def interface():
"""

2
Lib/test/test_xml_etree_c.py
View file

@ -51,7 +51,7 @@ def summarize(elem):
return elem.tag
def summarize_list(seq):
return map(summarize, seq)
return list(map(summarize, seq))
def interface():
"""

6
Lib/textwrap.py
View file

@ -63,8 +63,8 @@ class TextWrapper:
unicode_whitespace_trans = {}
uspace = ord(' ')
for x in map(ord, _whitespace):
unicode_whitespace_trans[x] = uspace
for x in _whitespace:
unicode_whitespace_trans[ord(x)] = uspace
# This funky little regex is just the trick for splitting
# text up into word-wrappable chunks. E.g.
@ -136,7 +136,7 @@ def _split(self, text):
'use', ' ', 'the', ' ', '-b', ' ', 'option!'
"""
chunks = self.wordsep_re.split(text)
chunks = filter(None, chunks) # remove empty chunks
chunks = [c for c in chunks if c]
return chunks
def _fix_sentence_endings(self, chunks):

4
Lib/unittest.py
View file

@ -586,7 +586,7 @@ def getTestCaseNames(self, testCaseClass):
"""
def isTestMethod(attrname, testCaseClass=testCaseClass, prefix=self.testMethodPrefix):
return attrname.startswith(prefix) and hasattr(getattr(testCaseClass, attrname), '__call__')
testFnNames = filter(isTestMethod, dir(testCaseClass))
testFnNames = list(filter(isTestMethod, dir(testCaseClass)))
if self.sortTestMethodsUsing:
testFnNames.sort(self.sortTestMethodsUsing)
return testFnNames
@ -725,7 +725,7 @@ def run(self, test):
self.stream.writeln()
if not result.wasSuccessful():
self.stream.write("FAILED (")
failed, errored = map(len, (result.failures, result.errors))
failed, errored = len(result.failures), len(result.errors)
if failed:
self.stream.write("failures=%d" % failed)
if errored:

10
Lib/urllib2.py
View file

@ -1222,7 +1222,7 @@ def open_local_file(self, req):
if host:
host, port = splitport(host)
if not host or \
(not port and socket.gethostbyname(host) in self.get_names()):
(not port and _safe_gethostbyname(host) in self.get_names()):
return addinfourl(open(localfile, 'rb'),
headers, 'file:'+file)
except OSError as msg:
@ -1230,6 +1230,12 @@ def open_local_file(self, req):
raise URLError(msg)
raise URLError('file not on local host')
def _safe_gethostbyname(host):
try:
return socket.gethostbyname(host)
except socket.gaierror:
return None
class FTPHandler(BaseHandler):
def ftp_open(self, req):
import ftplib
@ -1259,7 +1265,7 @@ def ftp_open(self, req):
raise URLError(msg)
path, attrs = splitattr(req.get_selector())
dirs = path.split('/')
dirs = map(unquote, dirs)
dirs = list(map(unquote, dirs))
dirs, file = dirs[:-1], dirs[-1]
if dirs and not dirs[0]:
dirs = dirs[1:]

2
Lib/zipfile.py
View file

@ -793,7 +793,7 @@ def open(self, name, mode="r", pwd=None):
# completely random, while the 12th contains the MSB of the CRC,
# and is used to check the correctness of the password.
bytes = zef_file.read(12)
h = map(zd, bytes[0:12])
h = list(map(zd, bytes[0:12]))
if h[11] != ((zinfo.CRC>>24) & 255):
raise RuntimeError, "Bad password for file %s" % name

604
Python/bltinmodule.c
View file

@ -23,11 +23,6 @@ const char *Py_FileSystemDefaultEncoding = "utf-8";
const char *Py_FileSystemDefaultEncoding = NULL; /* use default */
#endif
/* Forward */
static PyObject *filterstring(PyObject *, PyObject *);
static PyObject *filterunicode(PyObject *, PyObject *);
static PyObject *filtertuple (PyObject *, PyObject *);
static PyObject *
builtin___build_class__(PyObject *self, PyObject *args, PyObject *kwds)
{
@ -263,121 +258,26 @@ Return the binary representation of an integer or long integer.");
static PyObject *
builtin_filter(PyObject *self, PyObject *args)
{
PyObject *func, *seq, *result, *it, *arg;
Py_ssize_t len; /* guess for result list size */
register Py_ssize_t j;
if (!PyArg_UnpackTuple(args, "filter", 2, 2, &func, &seq))
PyObject *itertools, *ifilter, *result;
itertools = PyImport_ImportModule("itertools");
if (itertools == NULL)
return NULL;
/* Strings and tuples return a result of the same type. */
if (PyString_Check(seq))
return filterstring(func, seq);
if (PyUnicode_Check(seq))
return filterunicode(func, seq);
if (PyTuple_Check(seq))
return filtertuple(func, seq);
/* Pre-allocate argument list tuple. */
arg = PyTuple_New(1);
if (arg == NULL)
ifilter = PyObject_GetAttrString(itertools, "ifilter");
Py_DECREF(itertools);
if (ifilter == NULL)
return NULL;
/* Get iterator. */
it = PyObject_GetIter(seq);
if (it == NULL)
goto Fail_arg;
/* Guess a result list size. */
len = _PyObject_LengthHint(seq);
if (len < 0) {
if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
!PyErr_ExceptionMatches(PyExc_AttributeError)) {
goto Fail_it;
}
PyErr_Clear();
len = 8; /* arbitrary */
}
/* Get a result list. */
if (PyList_Check(seq) && seq->ob_refcnt == 1) {
/* Eww - can modify the list in-place. */
Py_INCREF(seq);
result = seq;
}
else {
result = PyList_New(len);
if (result == NULL)
goto Fail_it;
}
/* Build the result list. */
j = 0;
for (;;) {
PyObject *item;
int ok;
item = PyIter_Next(it);
if (item == NULL) {
if (PyErr_Occurred())
goto Fail_result_it;
break;
}
if (func == (PyObject *)&PyBool_Type || func == Py_None) {
ok = PyObject_IsTrue(item);
}
else {
PyObject *good;
PyTuple_SET_ITEM(arg, 0, item);
good = PyObject_Call(func, arg, NULL);
PyTuple_SET_ITEM(arg, 0, NULL);
if (good == NULL) {
Py_DECREF(item);
goto Fail_result_it;
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
}
if (ok) {
if (j < len)
PyList_SET_ITEM(result, j, item);
else {
int status = PyList_Append(result, item);
Py_DECREF(item);
if (status < 0)
goto Fail_result_it;
}
++j;
}
else
Py_DECREF(item);
}
/* Cut back result list if len is too big. */
if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)
goto Fail_result_it;
Py_DECREF(it);
Py_DECREF(arg);
result = PyObject_Call(ifilter, args, NULL);
Py_DECREF(ifilter);
return result;
Fail_result_it:
Py_DECREF(result);
Fail_it:
Py_DECREF(it);
Fail_arg:
Py_DECREF(arg);
return NULL;
}
PyDoc_STRVAR(filter_doc,
"filter(function or None, sequence) -> list, tuple, or string\n"
"\n"
"Return those items of sequence for which function(item) is true. If\n"
"function is None, return the items that are true. If sequence is a tuple\n"
"or string, return the same type, else return a list.");
"filter(predicate, iterable) -> iterator\n\
\n\
Return an iterator yielding only those elements of the input iterable\n\
for which the predicate (a Boolean function) returns true.\n\
If the predicate is None, 'lambda x: bool(x)' is assumed.\n\
(This is identical to itertools.ifilter().)");
static PyObject *
@ -940,168 +840,28 @@ simultaneously existing objects. (Hint: it's the object's memory address.)");
static PyObject *
builtin_map(PyObject *self, PyObject *args)
{
typedef struct {
PyObject *it; /* the iterator object */
int saw_StopIteration; /* bool: did the iterator end? */
} sequence;
PyObject *func, *result;
sequence *seqs = NULL, *sqp;
Py_ssize_t n, len;
register int i, j;
n = PyTuple_Size(args);
if (n < 2) {
PyErr_SetString(PyExc_TypeError,
"map() requires at least two args");
PyObject *itertools, *imap, *result;
itertools = PyImport_ImportModule("itertools");
if (itertools == NULL)
return NULL;
}
func = PyTuple_GetItem(args, 0);
n--;
if (func == Py_None && n == 1) {
/* map(None, S) is the same as list(S). */
return PySequence_List(PyTuple_GetItem(args, 1));
}
/* Get space for sequence descriptors. Must NULL out the iterator
* pointers so that jumping to Fail_2 later doesn't see trash.
*/
if ((seqs = PyMem_NEW(sequence, n)) == NULL) {
PyErr_NoMemory();
imap = PyObject_GetAttrString(itertools, "imap");
Py_DECREF(itertools);
if (imap == NULL)
return NULL;
}
for (i = 0; i < n; ++i) {
seqs[i].it = (PyObject*)NULL;
seqs[i].saw_StopIteration = 0;
}
/* Do a first pass to obtain iterators for the arguments, and set len
* to the largest of their lengths.
*/
len = 0;
for (i = 0, sqp = seqs; i < n; ++i, ++sqp) {
PyObject *curseq;
Py_ssize_t curlen;
/* Get iterator. */
curseq = PyTuple_GetItem(args, i+1);
sqp->it = PyObject_GetIter(curseq);
if (sqp->it == NULL) {
static char errmsg[] =
"argument %d to map() must support iteration";
char errbuf[sizeof(errmsg) + 25];
PyOS_snprintf(errbuf, sizeof(errbuf), errmsg, i+2);
PyErr_SetString(PyExc_TypeError, errbuf);
goto Fail_2;
}
/* Update len. */
curlen = _PyObject_LengthHint(curseq);
if (curlen < 0) {
if (!PyErr_ExceptionMatches(PyExc_TypeError) &&
!PyErr_ExceptionMatches(PyExc_AttributeError)) {
goto Fail_2;
}
PyErr_Clear();
curlen = 8; /* arbitrary */
}
if (curlen > len)
len = curlen;
}
/* Get space for the result list. */
if ((result = (PyObject *) PyList_New(len)) == NULL)
goto Fail_2;
/* Iterate over the sequences until all have stopped. */
for (i = 0; ; ++i) {
PyObject *alist, *item=NULL, *value;
int numactive = 0;
if (func == Py_None && n == 1)
alist = NULL;
else if ((alist = PyTuple_New(n)) == NULL)
goto Fail_1;
for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {
if (sqp->saw_StopIteration) {
Py_INCREF(Py_None);
item = Py_None;
}
else {
item = PyIter_Next(sqp->it);
if (item)
++numactive;
else {
if (PyErr_Occurred()) {
Py_XDECREF(alist);
goto Fail_1;
}
Py_INCREF(Py_None);
item = Py_None;
sqp->saw_StopIteration = 1;
}
}
if (alist)
PyTuple_SET_ITEM(alist, j, item);
else
break;
}
if (!alist)
alist = item;
if (numactive == 0) {
Py_DECREF(alist);
break;
}
if (func == Py_None)
value = alist;
else {
value = PyEval_CallObject(func, alist);
Py_DECREF(alist);
if (value == NULL)
goto Fail_1;
}
if (i >= len) {
int status = PyList_Append(result, value);
Py_DECREF(value);
if (status < 0)
goto Fail_1;
}
else if (PyList_SetItem(result, i, value) < 0)
goto Fail_1;
}
if (i < len && PyList_SetSlice(result, i, len, NULL) < 0)
goto Fail_1;
goto Succeed;
Fail_1:
Py_DECREF(result);
Fail_2:
result = NULL;
Succeed:
assert(seqs);
for (i = 0; i < n; ++i)
Py_XDECREF(seqs[i].it);
PyMem_DEL(seqs);
result = PyObject_Call(imap, args, NULL);
Py_DECREF(imap);
return result;
}
PyDoc_STRVAR(map_doc,
"map(function, sequence[, sequence, ...]) -> list\n\
"map(function, iterable[, iterable, ...]) -> iterator\n\
\n\
Return a list of the results of applying the function to the items of\n\
the argument sequence(s). If more than one sequence is given, the\n\
function is called with an argument list consisting of the corresponding\n\
item of each sequence, substituting None for missing values when not all\n\
sequences have the same length. If the function is None, return a list of\n\
the items of the sequence (or a list of tuples if more than one sequence).");
Return an iterator yielding the results of applying the function to the\n\
items of the argument iterables(s). If more than one iterable is given,\n\
the function is called with an argument list consisting of the\n\
corresponding item of each iterable, until an iterable is exhausted.\n\
If the function is None, 'lambda *a: a' is assumed.\n\
(This is identical to itertools.imap().)");
static PyObject *
@ -1570,29 +1330,36 @@ builtin_input(PyObject *self, PyObject *args)
/* First of all, flush stderr */
tmp = PyObject_CallMethod(ferr, "flush", "");
if (tmp == NULL)
return NULL;
Py_DECREF(tmp);
PyErr_Clear();
else
Py_DECREF(tmp);
/* We should only use (GNU) readline if Python's sys.stdin and
sys.stdout are the same as C's stdin and stdout, because we
need to pass it those. */
tmp = PyObject_CallMethod(fin, "fileno", "");
if (tmp == NULL)
return NULL;
fd = PyInt_AsLong(tmp);
if (fd < 0 && PyErr_Occurred())
return NULL;
Py_DECREF(tmp);
tty = fd == fileno(stdin) && isatty(fd);
if (tty) {
tmp = PyObject_CallMethod(fout, "fileno", "");
if (tmp == NULL)
return NULL;
if (tmp == NULL) {
PyErr_Clear();
tty = 0;
}
else {
fd = PyInt_AsLong(tmp);
Py_DECREF(tmp);
if (fd < 0 && PyErr_Occurred())
return NULL;
tty = fd == fileno(stdout) && isatty(fd);
tty = fd == fileno(stdin) && isatty(fd);
}
if (tty) {
tmp = PyObject_CallMethod(fout, "fileno", "");
if (tmp == NULL)
PyErr_Clear();
else {
fd = PyInt_AsLong(tmp);
Py_DECREF(tmp);
if (fd < 0 && PyErr_Occurred())
return NULL;
tty = fd == fileno(stdout) && isatty(fd);
}
}
/* If we're interactive, use (GNU) readline */
@ -1603,8 +1370,9 @@ builtin_input(PyObject *self, PyObject *args)
PyObject *result;
tmp = PyObject_CallMethod(fout, "flush", "");
if (tmp == NULL)
return NULL;
Py_DECREF(tmp);
PyErr_Clear();
else
Py_DECREF(tmp);
if (promptarg != NULL) {
po = PyObject_Str(promptarg);
if (po == NULL)
@ -1652,8 +1420,9 @@ builtin_input(PyObject *self, PyObject *args)
}
tmp = PyObject_CallMethod(fout, "flush", "");
if (tmp == NULL)
return NULL;
Py_DECREF(tmp);
PyErr_Clear();
else
Py_DECREF(tmp);
return PyFile_GetLine(fin, -1);
}
@ -1921,7 +1690,7 @@ PyDoc_STRVAR(zip_doc,
Return an iterator yielding tuples, where each tuple contains the\n\
corresponding element from each of the argument iterables.\n\
The returned iterator ends when the shortest argument iterable is exhausted.\n\
NOTE: This is implemented using itertools.izip().");
(This is identical to itertools.izip().)");
static PyMethodDef builtin_methods[] = {
@ -2048,262 +1817,3 @@ _PyBuiltin_Init(void)
#undef ADD_TO_ALL
#undef SETBUILTIN
}
/* Helper for filter(): filter a tuple through a function */
static PyObject *
filtertuple(PyObject *func, PyObject *tuple)
{
PyObject *result;
Py_ssize_t i, j;
Py_ssize_t len = PyTuple_Size(tuple);
if (len == 0) {
if (PyTuple_CheckExact(tuple))
Py_INCREF(tuple);
else
tuple = PyTuple_New(0);
return tuple;
}
if ((result = PyTuple_New(len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item, *good;
int ok;
if (tuple->ob_type->tp_as_sequence &&
tuple->ob_type->tp_as_sequence->sq_item) {
item = tuple->ob_type->tp_as_sequence->sq_item(tuple, i);
if (item == NULL)
goto Fail_1;
} else {
PyErr_SetString(PyExc_TypeError, "filter(): unsubscriptable tuple");
goto Fail_1;
}
if (func == Py_None) {
Py_INCREF(item);
good = item;
}
else {
PyObject *arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
if (ok) {
if (PyTuple_SetItem(result, j++, item) < 0)
goto Fail_1;
}
else
Py_DECREF(item);
}
if (_PyTuple_Resize(&result, j) < 0)
return NULL;
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}
/* Helper for filter(): filter a string through a function */
static PyObject *
filterstring(PyObject *func, PyObject *strobj)
{
PyObject *result;
Py_ssize_t i, j;
Py_ssize_t len = PyString_Size(strobj);
Py_ssize_t outlen = len;
if (func == Py_None) {
/* If it's a real string we can return the original,
* as no character is ever false and __getitem__
* does return this character. If it's a subclass
* we must go through the __getitem__ loop */
if (PyString_CheckExact(strobj)) {
Py_INCREF(strobj);
return strobj;
}
}
if ((result = PyString_FromStringAndSize(NULL, len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item;
int ok;
item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
if (item == NULL)
goto Fail_1;
if (func==Py_None) {
ok = 1;
} else {
PyObject *arg, *good;
arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
}
if (ok) {
Py_ssize_t reslen;
if (!PyString_Check(item)) {
PyErr_SetString(PyExc_TypeError, "can't filter str to str:"
" __getitem__ returned different type");
Py_DECREF(item);
goto Fail_1;
}
reslen = PyString_GET_SIZE(item);
if (reslen == 1) {
PyString_AS_STRING(result)[j++] =
PyString_AS_STRING(item)[0];
} else {
/* do we need more space? */
Py_ssize_t need = j + reslen + len-i-1;
if (need > outlen) {
/* overallocate, to avoid reallocations */
if (need<2*outlen)
need = 2*outlen;
if (_PyString_Resize(&result, need)) {
Py_DECREF(item);
return NULL;
}
outlen = need;
}
memcpy(
PyString_AS_STRING(result) + j,
PyString_AS_STRING(item),
reslen
);
j += reslen;
}
}
Py_DECREF(item);
}
if (j < outlen)
_PyString_Resize(&result, j);
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}
/* Helper for filter(): filter a Unicode object through a function */
static PyObject *
filterunicode(PyObject *func, PyObject *strobj)
{
PyObject *result;
register Py_ssize_t i, j;
Py_ssize_t len = PyUnicode_GetSize(strobj);
Py_ssize_t outlen = len;
if (func == Py_None) {
/* If it's a real string we can return the original,
* as no character is ever false and __getitem__
* does return this character. If it's a subclass
* we must go through the __getitem__ loop */
if (PyUnicode_CheckExact(strobj)) {
Py_INCREF(strobj);
return strobj;
}
}
if ((result = PyUnicode_FromUnicode(NULL, len)) == NULL)
return NULL;
for (i = j = 0; i < len; ++i) {
PyObject *item, *arg, *good;
int ok;
item = (*strobj->ob_type->tp_as_sequence->sq_item)(strobj, i);
if (item == NULL)
goto Fail_1;
if (func == Py_None) {
ok = 1;
} else {
arg = PyTuple_Pack(1, item);
if (arg == NULL) {
Py_DECREF(item);
goto Fail_1;
}
good = PyEval_CallObject(func, arg);
Py_DECREF(arg);
if (good == NULL) {
Py_DECREF(item);
goto Fail_1;
}
ok = PyObject_IsTrue(good);
Py_DECREF(good);
}
if (ok) {
Py_ssize_t reslen;
if (!PyUnicode_Check(item)) {
PyErr_SetString(PyExc_TypeError,
"can't filter unicode to unicode:"
" __getitem__ returned different type");
Py_DECREF(item);
goto Fail_1;
}
reslen = PyUnicode_GET_SIZE(item);
if (reslen == 1)
PyUnicode_AS_UNICODE(result)[j++] =
PyUnicode_AS_UNICODE(item)[0];
else {
/* do we need more space? */
Py_ssize_t need = j + reslen + len - i - 1;
if (need > outlen) {
/* overallocate,
to avoid reallocations */
if (need < 2 * outlen)
need = 2 * outlen;
if (PyUnicode_Resize(
&result, need) < 0) {
Py_DECREF(item);
goto Fail_1;
}
outlen = need;
}
memcpy(PyUnicode_AS_UNICODE(result) + j,
PyUnicode_AS_UNICODE(item),
reslen*sizeof(Py_UNICODE));
j += reslen;
}
}
Py_DECREF(item);
}
if (j < outlen)
PyUnicode_Resize(&result, j);
return result;
Fail_1:
Py_DECREF(result);
return NULL;
}

4
setup.py
View file

@ -728,7 +728,7 @@ class db_found(Exception): pass
db_incdir.replace("include", 'lib64'),
db_incdir.replace("include", 'lib'),
]
db_dirs_to_check = filter(os.path.isdir, db_dirs_to_check)
db_dirs_to_check = [x for x in db_dirs_to_check if os.path.isdir(x)]
# Look for a version specific db-X.Y before an ambiguoius dbX
# XXX should we -ever- look for a dbX name? Do any
@ -1555,7 +1555,7 @@ def main():
description = "A high-level object-oriented programming language",
long_description = SUMMARY.strip(),
license = "PSF license",
classifiers = filter(None, CLASSIFIERS.split("\n")),
classifiers = [x for x in CLASSIFIERS.split("\n") if x],
platforms = ["Many"],
# Build info