words = "The quick brown fox jumped over the lazy dog".split()
words = (word for word in words if 'o' in word or 'e' in word) # generator comprehension: not evaluated yet!
words = (word[::-1] for word in words) #same here
print(list(words)) #finally evaluated here

['ehT', 'nworb', 'xof', 'depmuj', 'revo', 'eht', 'god']

words = "The quick brown fox jumped over the lazy dog".split()
words = filter(lambda word: 'o' in word or 'e' in word, words)
words = map(lambda word: word[::-1], words)
print(list(words)) #finally evaluated here

Eela6 fucked around with this message at 06:34 on Jun 6, 2017

Eela6 fucked around with this message at 21:19 on Jun 11, 2017

Eela6 fucked around with this message at 16:14 on Jul 4, 2017

class Fighter(CClass):
     starting_ages = {Human: (15, 1, 4)
                  Dwarf: (40, 5, 20)
                  ...}
     @classmethod
     def starting_age(cls, race):
          base, low, high = cls.starting_ages[race]
          return base+random.randint(low, high)

     def __init__(self, name: str, race: Race):
         self.name = name
         self.race = race
         self.age = self.starting_age(race)

Eela6 fucked around with this message at 21:50 on Jul 5, 2017

nodes = sorted(nodes, key = lambda node: node.chirality)

nodes = sortedcontainers.SortedListWithKey(nodes, key=lambda node: node.chirality)
nodes.add(node) #insert a new node while maintaining the sort

Eela6 fucked around with this message at 01:53 on Jul 7, 2017

def __eq__(self, other):
    # return true if you know how to compare the two and self should == other
    # return false if you know how to compare the two and self should != other
    # return NotImplemented otherwise (this is a fallback that allows for further extension).

def equals_op(a, b):
    try:
        f_result = a.__eq__(b)
        if f_result is not NotImplemented:
            return f_result
    except LookupError: # a does not implement __eq__
        pass

    try:
        b_result = b.__eq__(a)
        if b_result is not NotImplemented:
            return b_result
    except LookupError: # b does not implement __eq__
        pass
    return a is b

class Person:
    def __init__(self, name):
        self.name = name



class Hero:
    def __init__(self, name, secret_identity):
        self.name = name
        self.secret_identity = secret_identity

    def __eq__(self, other):
        if not issubclass(type(other), Person):
            return NotImplemented
        return self.secret_identity == other.name

clark_kent = Person('clark kent')
superman = Hero(name='Superman', secret_identity= 'clark kent')

assert clark_kent == superman
assert superman == superman
assert clark_kent == clark_kent

Eela6 fucked around with this message at 21:03 on Jul 21, 2017

class MyCustomThing:
    def _public_attribs(self):
        return {k:v for k,v in vars(self).items() if not k.startswith('_')}

    def __eq__(self, other):
        """Test equality with same type or dict"""
        if isinstance(other, MyCustomThing): #cleaner handling of subclassing
            return self._public_attribs() == other._public_attribs()
        elif isinstance(other, dict):
            return self._public_attribs() == other
        else:
            return NotImplemented #fall through in case the other thing has a more permissive __eq__

    def __eq__(self, other):
        """Test equality with same type or dict"""
        if hasattr(other, "_public_attribs"): #fufills contract
            return self._public_attribs() == other._public_attribs()
        elif isinstance(other, dict):
            return self._public_attribs() == other
        else: 
            return NotImplemented

class MyCustomThing:
    def __init__(self, a, b):
        self.a, self.b = a, b

    @property 
    def _public_attribs(self):
        return {k:v for k,v in vars(self).items() if not k.startswith('_')}

    def __eq__(self, other):
        """Test equality with dicts or others specifying _public_attribs contract"""
        return self._public_attribs == other

superman = MyCustomThing("foo", "bar")
batman = MyCustomThing("foo", "bar")
aquaman = {"a": "foo", "b": "bar"}
steve = {"a": "steve"}

heroes = {'superman': superman, 'batman':batman, 'aquaman':aquaman, 'steve': steve}
for keya, heroa in heroes.items():
    for keyb, herob in heroes.items():
        print(f'{keya}=={keyb}: {heroa==herob}')

superman==superman: True
superman==batman: True
superman==aquaman: True
superman==steve: False
batman==superman: True
batman==batman: True
batman==aquaman: True
batman==steve: False
aquaman==superman: True
aquaman==batman: True
aquaman==aquaman: True
aquaman==steve: False
steve==superman: False
steve==batman: False
steve==aquaman: False
steve==steve: True

Eela6 fucked around with this message at 22:57 on Jul 21, 2017

Eela6 fucked around with this message at 22:59 on Jul 21, 2017

Eela6 fucked around with this message at 23:40 on Jul 21, 2017

Eela6 fucked around with this message at 20:24 on Aug 14, 2017

Eela6 fucked around with this message at 00:22 on Sep 15, 2017

a = [1, 2, 3]
b = a.reverse()
print(a)
print(b)

[3, 2, 1]
None

a = [1, 2, 3]
b = reversed(a)
print(b)
print(a)
print(list(b))

<list_reverseiterator at 0x2f46d9ef0f0>
[1, 2, 3] 
[3, 2, 1]

a = [1, 2, 3]
b = a[::-1]
print(b)
print(a)

[3, 2, 1]
[1, 2, 3]

Eela6 fucked around with this message at 01:08 on Sep 16, 2017