| 1 | # Copyright 2007 Google, Inc. All Rights Reserved.
|
| 2 | # Licensed to PSF under a Contributor Agreement.
|
| 3 |
|
| 4 | """Abstract Base Classes (ABCs) for collections, according to PEP 3119.
|
| 5 |
|
| 6 | DON'T USE THIS MODULE DIRECTLY! The classes here should be imported
|
| 7 | via collections; they are defined here only to alleviate certain
|
| 8 | bootstrapping issues. Unit tests are in test_collections.
|
| 9 | """
|
| 10 |
|
| 11 | from abc import ABCMeta, abstractmethod
|
| 12 | import sys
|
| 13 |
|
| 14 | __all__ = ["Hashable", "Iterable", "Iterator",
|
| 15 | "Sized", "Container", "Callable",
|
| 16 | "Set", "MutableSet",
|
| 17 | "Mapping", "MutableMapping",
|
| 18 | "MappingView", "KeysView", "ItemsView", "ValuesView",
|
| 19 | "Sequence", "MutableSequence",
|
| 20 | ]
|
| 21 |
|
| 22 | ### ONE-TRICK PONIES ###
|
| 23 |
|
| 24 | def _hasattr(C, attr):
|
| 25 | try:
|
| 26 | return any(attr in B.__dict__ for B in C.__mro__)
|
| 27 | except AttributeError:
|
| 28 | # Old-style class
|
| 29 | return hasattr(C, attr)
|
| 30 |
|
| 31 |
|
| 32 | class Hashable:
|
| 33 | __metaclass__ = ABCMeta
|
| 34 |
|
| 35 | @abstractmethod
|
| 36 | def __hash__(self):
|
| 37 | return 0
|
| 38 |
|
| 39 | @classmethod
|
| 40 | def __subclasshook__(cls, C):
|
| 41 | if cls is Hashable:
|
| 42 | try:
|
| 43 | for B in C.__mro__:
|
| 44 | if "__hash__" in B.__dict__:
|
| 45 | if B.__dict__["__hash__"]:
|
| 46 | return True
|
| 47 | break
|
| 48 | except AttributeError:
|
| 49 | # Old-style class
|
| 50 | if getattr(C, "__hash__", None):
|
| 51 | return True
|
| 52 | return NotImplemented
|
| 53 |
|
| 54 |
|
| 55 | class Iterable:
|
| 56 | __metaclass__ = ABCMeta
|
| 57 |
|
| 58 | @abstractmethod
|
| 59 | def __iter__(self):
|
| 60 | while False:
|
| 61 | yield None
|
| 62 |
|
| 63 | @classmethod
|
| 64 | def __subclasshook__(cls, C):
|
| 65 | if cls is Iterable:
|
| 66 | if _hasattr(C, "__iter__"):
|
| 67 | return True
|
| 68 | return NotImplemented
|
| 69 |
|
| 70 | Iterable.register(str)
|
| 71 |
|
| 72 |
|
| 73 | class Iterator(Iterable):
|
| 74 |
|
| 75 | @abstractmethod
|
| 76 | def next(self):
|
| 77 | 'Return the next item from the iterator. When exhausted, raise StopIteration'
|
| 78 | raise StopIteration
|
| 79 |
|
| 80 | def __iter__(self):
|
| 81 | return self
|
| 82 |
|
| 83 | @classmethod
|
| 84 | def __subclasshook__(cls, C):
|
| 85 | if cls is Iterator:
|
| 86 | if _hasattr(C, "next") and _hasattr(C, "__iter__"):
|
| 87 | return True
|
| 88 | return NotImplemented
|
| 89 |
|
| 90 |
|
| 91 | class Sized:
|
| 92 | __metaclass__ = ABCMeta
|
| 93 |
|
| 94 | @abstractmethod
|
| 95 | def __len__(self):
|
| 96 | return 0
|
| 97 |
|
| 98 | @classmethod
|
| 99 | def __subclasshook__(cls, C):
|
| 100 | if cls is Sized:
|
| 101 | if _hasattr(C, "__len__"):
|
| 102 | return True
|
| 103 | return NotImplemented
|
| 104 |
|
| 105 |
|
| 106 | class Container:
|
| 107 | __metaclass__ = ABCMeta
|
| 108 |
|
| 109 | @abstractmethod
|
| 110 | def __contains__(self, x):
|
| 111 | return False
|
| 112 |
|
| 113 | @classmethod
|
| 114 | def __subclasshook__(cls, C):
|
| 115 | if cls is Container:
|
| 116 | if _hasattr(C, "__contains__"):
|
| 117 | return True
|
| 118 | return NotImplemented
|
| 119 |
|
| 120 |
|
| 121 | class Callable:
|
| 122 | __metaclass__ = ABCMeta
|
| 123 |
|
| 124 | @abstractmethod
|
| 125 | def __call__(self, *args, **kwds):
|
| 126 | return False
|
| 127 |
|
| 128 | @classmethod
|
| 129 | def __subclasshook__(cls, C):
|
| 130 | if cls is Callable:
|
| 131 | if _hasattr(C, "__call__"):
|
| 132 | return True
|
| 133 | return NotImplemented
|
| 134 |
|
| 135 |
|
| 136 | ### SETS ###
|
| 137 |
|
| 138 |
|
| 139 | class Set(Sized, Iterable, Container):
|
| 140 | """A set is a finite, iterable container.
|
| 141 |
|
| 142 | This class provides concrete generic implementations of all
|
| 143 | methods except for __contains__, __iter__ and __len__.
|
| 144 |
|
| 145 | To override the comparisons (presumably for speed, as the
|
| 146 | semantics are fixed), redefine __le__ and __ge__,
|
| 147 | then the other operations will automatically follow suit.
|
| 148 | """
|
| 149 |
|
| 150 | def __le__(self, other):
|
| 151 | if not isinstance(other, Set):
|
| 152 | return NotImplemented
|
| 153 | if len(self) > len(other):
|
| 154 | return False
|
| 155 | for elem in self:
|
| 156 | if elem not in other:
|
| 157 | return False
|
| 158 | return True
|
| 159 |
|
| 160 | def __lt__(self, other):
|
| 161 | if not isinstance(other, Set):
|
| 162 | return NotImplemented
|
| 163 | return len(self) < len(other) and self.__le__(other)
|
| 164 |
|
| 165 | def __gt__(self, other):
|
| 166 | if not isinstance(other, Set):
|
| 167 | return NotImplemented
|
| 168 | return len(self) > len(other) and self.__ge__(other)
|
| 169 |
|
| 170 | def __ge__(self, other):
|
| 171 | if not isinstance(other, Set):
|
| 172 | return NotImplemented
|
| 173 | if len(self) < len(other):
|
| 174 | return False
|
| 175 | for elem in other:
|
| 176 | if elem not in self:
|
| 177 | return False
|
| 178 | return True
|
| 179 |
|
| 180 | def __eq__(self, other):
|
| 181 | if not isinstance(other, Set):
|
| 182 | return NotImplemented
|
| 183 | return len(self) == len(other) and self.__le__(other)
|
| 184 |
|
| 185 | def __ne__(self, other):
|
| 186 | return not (self == other)
|
| 187 |
|
| 188 | @classmethod
|
| 189 | def _from_iterable(cls, it):
|
| 190 | '''Construct an instance of the class from any iterable input.
|
| 191 |
|
| 192 | Must override this method if the class constructor signature
|
| 193 | does not accept an iterable for an input.
|
| 194 | '''
|
| 195 | return cls(it)
|
| 196 |
|
| 197 | def __and__(self, other):
|
| 198 | if not isinstance(other, Iterable):
|
| 199 | return NotImplemented
|
| 200 | return self._from_iterable(value for value in other if value in self)
|
| 201 |
|
| 202 | __rand__ = __and__
|
| 203 |
|
| 204 | def isdisjoint(self, other):
|
| 205 | 'Return True if two sets have a null intersection.'
|
| 206 | for value in other:
|
| 207 | if value in self:
|
| 208 | return False
|
| 209 | return True
|
| 210 |
|
| 211 | def __or__(self, other):
|
| 212 | if not isinstance(other, Iterable):
|
| 213 | return NotImplemented
|
| 214 | chain = (e for s in (self, other) for e in s)
|
| 215 | return self._from_iterable(chain)
|
| 216 |
|
| 217 | __ror__ = __or__
|
| 218 |
|
| 219 | def __sub__(self, other):
|
| 220 | if not isinstance(other, Set):
|
| 221 | if not isinstance(other, Iterable):
|
| 222 | return NotImplemented
|
| 223 | other = self._from_iterable(other)
|
| 224 | return self._from_iterable(value for value in self
|
| 225 | if value not in other)
|
| 226 |
|
| 227 | def __rsub__(self, other):
|
| 228 | if not isinstance(other, Set):
|
| 229 | if not isinstance(other, Iterable):
|
| 230 | return NotImplemented
|
| 231 | other = self._from_iterable(other)
|
| 232 | return self._from_iterable(value for value in other
|
| 233 | if value not in self)
|
| 234 |
|
| 235 | def __xor__(self, other):
|
| 236 | if not isinstance(other, Set):
|
| 237 | if not isinstance(other, Iterable):
|
| 238 | return NotImplemented
|
| 239 | other = self._from_iterable(other)
|
| 240 | return (self - other) | (other - self)
|
| 241 |
|
| 242 | __rxor__ = __xor__
|
| 243 |
|
| 244 | # Sets are not hashable by default, but subclasses can change this
|
| 245 | __hash__ = None
|
| 246 |
|
| 247 | def _hash(self):
|
| 248 | """Compute the hash value of a set.
|
| 249 |
|
| 250 | Note that we don't define __hash__: not all sets are hashable.
|
| 251 | But if you define a hashable set type, its __hash__ should
|
| 252 | call this function.
|
| 253 |
|
| 254 | This must be compatible __eq__.
|
| 255 |
|
| 256 | All sets ought to compare equal if they contain the same
|
| 257 | elements, regardless of how they are implemented, and
|
| 258 | regardless of the order of the elements; so there's not much
|
| 259 | freedom for __eq__ or __hash__. We match the algorithm used
|
| 260 | by the built-in frozenset type.
|
| 261 | """
|
| 262 | MAX = sys.maxint
|
| 263 | MASK = 2 * MAX + 1
|
| 264 | n = len(self)
|
| 265 | h = 1927868237 * (n + 1)
|
| 266 | h &= MASK
|
| 267 | for x in self:
|
| 268 | hx = hash(x)
|
| 269 | h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167
|
| 270 | h &= MASK
|
| 271 | h = h * 69069 + 907133923
|
| 272 | h &= MASK
|
| 273 | if h > MAX:
|
| 274 | h -= MASK + 1
|
| 275 | if h == -1:
|
| 276 | h = 590923713
|
| 277 | return h
|
| 278 |
|
| 279 | Set.register(frozenset)
|
| 280 |
|
| 281 |
|
| 282 | class MutableSet(Set):
|
| 283 | """A mutable set is a finite, iterable container.
|
| 284 |
|
| 285 | This class provides concrete generic implementations of all
|
| 286 | methods except for __contains__, __iter__, __len__,
|
| 287 | add(), and discard().
|
| 288 |
|
| 289 | To override the comparisons (presumably for speed, as the
|
| 290 | semantics are fixed), all you have to do is redefine __le__ and
|
| 291 | then the other operations will automatically follow suit.
|
| 292 | """
|
| 293 |
|
| 294 | @abstractmethod
|
| 295 | def add(self, value):
|
| 296 | """Add an element."""
|
| 297 | raise NotImplementedError
|
| 298 |
|
| 299 | @abstractmethod
|
| 300 | def discard(self, value):
|
| 301 | """Remove an element. Do not raise an exception if absent."""
|
| 302 | raise NotImplementedError
|
| 303 |
|
| 304 | def remove(self, value):
|
| 305 | """Remove an element. If not a member, raise a KeyError."""
|
| 306 | if value not in self:
|
| 307 | raise KeyError(value)
|
| 308 | self.discard(value)
|
| 309 |
|
| 310 | def pop(self):
|
| 311 | """Return the popped value. Raise KeyError if empty."""
|
| 312 | it = iter(self)
|
| 313 | try:
|
| 314 | value = next(it)
|
| 315 | except StopIteration:
|
| 316 | raise KeyError
|
| 317 | self.discard(value)
|
| 318 | return value
|
| 319 |
|
| 320 | def clear(self):
|
| 321 | """This is slow (creates N new iterators!) but effective."""
|
| 322 | try:
|
| 323 | while True:
|
| 324 | self.pop()
|
| 325 | except KeyError:
|
| 326 | pass
|
| 327 |
|
| 328 | def __ior__(self, it):
|
| 329 | for value in it:
|
| 330 | self.add(value)
|
| 331 | return self
|
| 332 |
|
| 333 | def __iand__(self, it):
|
| 334 | for value in (self - it):
|
| 335 | self.discard(value)
|
| 336 | return self
|
| 337 |
|
| 338 | def __ixor__(self, it):
|
| 339 | if it is self:
|
| 340 | self.clear()
|
| 341 | else:
|
| 342 | if not isinstance(it, Set):
|
| 343 | it = self._from_iterable(it)
|
| 344 | for value in it:
|
| 345 | if value in self:
|
| 346 | self.discard(value)
|
| 347 | else:
|
| 348 | self.add(value)
|
| 349 | return self
|
| 350 |
|
| 351 | def __isub__(self, it):
|
| 352 | if it is self:
|
| 353 | self.clear()
|
| 354 | else:
|
| 355 | for value in it:
|
| 356 | self.discard(value)
|
| 357 | return self
|
| 358 |
|
| 359 | MutableSet.register(set)
|
| 360 |
|
| 361 |
|
| 362 | ### MAPPINGS ###
|
| 363 |
|
| 364 |
|
| 365 | class Mapping(Sized, Iterable, Container):
|
| 366 |
|
| 367 | """A Mapping is a generic container for associating key/value
|
| 368 | pairs.
|
| 369 |
|
| 370 | This class provides concrete generic implementations of all
|
| 371 | methods except for __getitem__, __iter__, and __len__.
|
| 372 |
|
| 373 | """
|
| 374 |
|
| 375 | @abstractmethod
|
| 376 | def __getitem__(self, key):
|
| 377 | raise KeyError
|
| 378 |
|
| 379 | def get(self, key, default=None):
|
| 380 | 'D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.'
|
| 381 | try:
|
| 382 | return self[key]
|
| 383 | except KeyError:
|
| 384 | return default
|
| 385 |
|
| 386 | def __contains__(self, key):
|
| 387 | try:
|
| 388 | self[key]
|
| 389 | except KeyError:
|
| 390 | return False
|
| 391 | else:
|
| 392 | return True
|
| 393 |
|
| 394 | def iterkeys(self):
|
| 395 | 'D.iterkeys() -> an iterator over the keys of D'
|
| 396 | return iter(self)
|
| 397 |
|
| 398 | def itervalues(self):
|
| 399 | 'D.itervalues() -> an iterator over the values of D'
|
| 400 | for key in self:
|
| 401 | yield self[key]
|
| 402 |
|
| 403 | def iteritems(self):
|
| 404 | 'D.iteritems() -> an iterator over the (key, value) items of D'
|
| 405 | for key in self:
|
| 406 | yield (key, self[key])
|
| 407 |
|
| 408 | def keys(self):
|
| 409 | "D.keys() -> list of D's keys"
|
| 410 | return list(self)
|
| 411 |
|
| 412 | def items(self):
|
| 413 | "D.items() -> list of D's (key, value) pairs, as 2-tuples"
|
| 414 | return [(key, self[key]) for key in self]
|
| 415 |
|
| 416 | def values(self):
|
| 417 | "D.values() -> list of D's values"
|
| 418 | return [self[key] for key in self]
|
| 419 |
|
| 420 | # Mappings are not hashable by default, but subclasses can change this
|
| 421 | __hash__ = None
|
| 422 |
|
| 423 | def __eq__(self, other):
|
| 424 | if not isinstance(other, Mapping):
|
| 425 | return NotImplemented
|
| 426 | return dict(self.items()) == dict(other.items())
|
| 427 |
|
| 428 | def __ne__(self, other):
|
| 429 | return not (self == other)
|
| 430 |
|
| 431 | class MappingView(Sized):
|
| 432 |
|
| 433 | def __init__(self, mapping):
|
| 434 | self._mapping = mapping
|
| 435 |
|
| 436 | def __len__(self):
|
| 437 | return len(self._mapping)
|
| 438 |
|
| 439 | def __repr__(self):
|
| 440 | return '{0.__class__.__name__}({0._mapping!r})'.format(self)
|
| 441 |
|
| 442 |
|
| 443 | class KeysView(MappingView, Set):
|
| 444 |
|
| 445 | @classmethod
|
| 446 | def _from_iterable(self, it):
|
| 447 | return set(it)
|
| 448 |
|
| 449 | def __contains__(self, key):
|
| 450 | return key in self._mapping
|
| 451 |
|
| 452 | def __iter__(self):
|
| 453 | for key in self._mapping:
|
| 454 | yield key
|
| 455 |
|
| 456 | KeysView.register(type({}.viewkeys()))
|
| 457 |
|
| 458 | class ItemsView(MappingView, Set):
|
| 459 |
|
| 460 | @classmethod
|
| 461 | def _from_iterable(self, it):
|
| 462 | return set(it)
|
| 463 |
|
| 464 | def __contains__(self, item):
|
| 465 | key, value = item
|
| 466 | try:
|
| 467 | v = self._mapping[key]
|
| 468 | except KeyError:
|
| 469 | return False
|
| 470 | else:
|
| 471 | return v == value
|
| 472 |
|
| 473 | def __iter__(self):
|
| 474 | for key in self._mapping:
|
| 475 | yield (key, self._mapping[key])
|
| 476 |
|
| 477 | ItemsView.register(type({}.viewitems()))
|
| 478 |
|
| 479 | class ValuesView(MappingView):
|
| 480 |
|
| 481 | def __contains__(self, value):
|
| 482 | for key in self._mapping:
|
| 483 | if value == self._mapping[key]:
|
| 484 | return True
|
| 485 | return False
|
| 486 |
|
| 487 | def __iter__(self):
|
| 488 | for key in self._mapping:
|
| 489 | yield self._mapping[key]
|
| 490 |
|
| 491 | ValuesView.register(type({}.viewvalues()))
|
| 492 |
|
| 493 | class MutableMapping(Mapping):
|
| 494 |
|
| 495 | """A MutableMapping is a generic container for associating
|
| 496 | key/value pairs.
|
| 497 |
|
| 498 | This class provides concrete generic implementations of all
|
| 499 | methods except for __getitem__, __setitem__, __delitem__,
|
| 500 | __iter__, and __len__.
|
| 501 |
|
| 502 | """
|
| 503 |
|
| 504 | @abstractmethod
|
| 505 | def __setitem__(self, key, value):
|
| 506 | raise KeyError
|
| 507 |
|
| 508 | @abstractmethod
|
| 509 | def __delitem__(self, key):
|
| 510 | raise KeyError
|
| 511 |
|
| 512 | __marker = object()
|
| 513 |
|
| 514 | def pop(self, key, default=__marker):
|
| 515 | '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| 516 | If key is not found, d is returned if given, otherwise KeyError is raised.
|
| 517 | '''
|
| 518 | try:
|
| 519 | value = self[key]
|
| 520 | except KeyError:
|
| 521 | if default is self.__marker:
|
| 522 | raise
|
| 523 | return default
|
| 524 | else:
|
| 525 | del self[key]
|
| 526 | return value
|
| 527 |
|
| 528 | def popitem(self):
|
| 529 | '''D.popitem() -> (k, v), remove and return some (key, value) pair
|
| 530 | as a 2-tuple; but raise KeyError if D is empty.
|
| 531 | '''
|
| 532 | try:
|
| 533 | key = next(iter(self))
|
| 534 | except StopIteration:
|
| 535 | raise KeyError
|
| 536 | value = self[key]
|
| 537 | del self[key]
|
| 538 | return key, value
|
| 539 |
|
| 540 | def clear(self):
|
| 541 | 'D.clear() -> None. Remove all items from D.'
|
| 542 | try:
|
| 543 | while True:
|
| 544 | self.popitem()
|
| 545 | except KeyError:
|
| 546 | pass
|
| 547 |
|
| 548 | def update(*args, **kwds):
|
| 549 | ''' D.update([E, ]**F) -> None. Update D from mapping/iterable E and F.
|
| 550 | If E present and has a .keys() method, does: for k in E: D[k] = E[k]
|
| 551 | If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
|
| 552 | In either case, this is followed by: for k, v in F.items(): D[k] = v
|
| 553 | '''
|
| 554 | if not args:
|
| 555 | raise TypeError("descriptor 'update' of 'MutableMapping' object "
|
| 556 | "needs an argument")
|
| 557 | self = args[0]
|
| 558 | args = args[1:]
|
| 559 | if len(args) > 1:
|
| 560 | raise TypeError('update expected at most 1 arguments, got %d' %
|
| 561 | len(args))
|
| 562 | if args:
|
| 563 | other = args[0]
|
| 564 | if isinstance(other, Mapping):
|
| 565 | for key in other:
|
| 566 | self[key] = other[key]
|
| 567 | elif hasattr(other, "keys"):
|
| 568 | for key in other.keys():
|
| 569 | self[key] = other[key]
|
| 570 | else:
|
| 571 | for key, value in other:
|
| 572 | self[key] = value
|
| 573 | for key, value in kwds.items():
|
| 574 | self[key] = value
|
| 575 |
|
| 576 | def setdefault(self, key, default=None):
|
| 577 | 'D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D'
|
| 578 | try:
|
| 579 | return self[key]
|
| 580 | except KeyError:
|
| 581 | self[key] = default
|
| 582 | return default
|
| 583 |
|
| 584 | MutableMapping.register(dict)
|
| 585 |
|
| 586 |
|
| 587 | ### SEQUENCES ###
|
| 588 |
|
| 589 |
|
| 590 | class Sequence(Sized, Iterable, Container):
|
| 591 | """All the operations on a read-only sequence.
|
| 592 |
|
| 593 | Concrete subclasses must override __new__ or __init__,
|
| 594 | __getitem__, and __len__.
|
| 595 | """
|
| 596 |
|
| 597 | @abstractmethod
|
| 598 | def __getitem__(self, index):
|
| 599 | raise IndexError
|
| 600 |
|
| 601 | def __iter__(self):
|
| 602 | i = 0
|
| 603 | try:
|
| 604 | while True:
|
| 605 | v = self[i]
|
| 606 | yield v
|
| 607 | i += 1
|
| 608 | except IndexError:
|
| 609 | return
|
| 610 |
|
| 611 | def __contains__(self, value):
|
| 612 | for v in self:
|
| 613 | if v == value:
|
| 614 | return True
|
| 615 | return False
|
| 616 |
|
| 617 | def __reversed__(self):
|
| 618 | for i in reversed(range(len(self))):
|
| 619 | yield self[i]
|
| 620 |
|
| 621 | def index(self, value):
|
| 622 | '''S.index(value) -> integer -- return first index of value.
|
| 623 | Raises ValueError if the value is not present.
|
| 624 | '''
|
| 625 | for i, v in enumerate(self):
|
| 626 | if v == value:
|
| 627 | return i
|
| 628 | raise ValueError
|
| 629 |
|
| 630 | def count(self, value):
|
| 631 | 'S.count(value) -> integer -- return number of occurrences of value'
|
| 632 | return sum(1 for v in self if v == value)
|
| 633 |
|
| 634 | Sequence.register(tuple)
|
| 635 | Sequence.register(basestring)
|
| 636 | Sequence.register(buffer)
|
| 637 | Sequence.register(xrange)
|
| 638 |
|
| 639 |
|
| 640 | class MutableSequence(Sequence):
|
| 641 |
|
| 642 | """All the operations on a read-only sequence.
|
| 643 |
|
| 644 | Concrete subclasses must provide __new__ or __init__,
|
| 645 | __getitem__, __setitem__, __delitem__, __len__, and insert().
|
| 646 |
|
| 647 | """
|
| 648 |
|
| 649 | @abstractmethod
|
| 650 | def __setitem__(self, index, value):
|
| 651 | raise IndexError
|
| 652 |
|
| 653 | @abstractmethod
|
| 654 | def __delitem__(self, index):
|
| 655 | raise IndexError
|
| 656 |
|
| 657 | @abstractmethod
|
| 658 | def insert(self, index, value):
|
| 659 | 'S.insert(index, object) -- insert object before index'
|
| 660 | raise IndexError
|
| 661 |
|
| 662 | def append(self, value):
|
| 663 | 'S.append(object) -- append object to the end of the sequence'
|
| 664 | self.insert(len(self), value)
|
| 665 |
|
| 666 | def reverse(self):
|
| 667 | 'S.reverse() -- reverse *IN PLACE*'
|
| 668 | n = len(self)
|
| 669 | for i in range(n//2):
|
| 670 | self[i], self[n-i-1] = self[n-i-1], self[i]
|
| 671 |
|
| 672 | def extend(self, values):
|
| 673 | 'S.extend(iterable) -- extend sequence by appending elements from the iterable'
|
| 674 | for v in values:
|
| 675 | self.append(v)
|
| 676 |
|
| 677 | def pop(self, index=-1):
|
| 678 | '''S.pop([index]) -> item -- remove and return item at index (default last).
|
| 679 | Raise IndexError if list is empty or index is out of range.
|
| 680 | '''
|
| 681 | v = self[index]
|
| 682 | del self[index]
|
| 683 | return v
|
| 684 |
|
| 685 | def remove(self, value):
|
| 686 | '''S.remove(value) -- remove first occurrence of value.
|
| 687 | Raise ValueError if the value is not present.
|
| 688 | '''
|
| 689 | del self[self.index(value)]
|
| 690 |
|
| 691 | def __iadd__(self, values):
|
| 692 | self.extend(values)
|
| 693 | return self
|
| 694 |
|
| 695 | MutableSequence.register(list)
|