This is just a way to declare a and b as equal to c.

>>> c=2
>>> a=b=c
>>> a
2
>>> b
2
>>> c
2

So you can use as much as you want:

>>> i=7
>>> a=b=c=d=e=f=g=h=i

You can read more in Multiple Assignment from this Python tutorial.

Python allows you to assign a single value to several variables simultaneously. For example:

a = b = c = 1

Here, an integer object is created with the value 1, and all three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables. For example:

a, b, c = 1, 2, "john"

Here, two integer objects with values 1 and 2 are assigned to variables a and b, and one string object with the value "john" is assigned to the variable c.

There is also another fancy thing! You can swap values like this: a,b=b,a:

>>> a=2
>>> b=5
>>> a,b=b,a
>>> a
5
>>> b
2

s.accept() returns a tuple of two values : (host, port).

Therefore,

conn, address = s.accept()

is (apart that accept() is called twice) the same as

conn, address = s.accept()[0], s.accept()[1]

In many languages some values evaluate to False. In Python this is False, None, 0, 0.0, [], (), {}, '' and every object, that has a special method which evaluates to False.

In your description you only want to fill a list up to 3 elements. This can be done with:

a, b, c = s + [0,9,1][len(s):]

SubQuery is an abstract base class (per the abc module) with one or more abstract methods that you did not override. By adding ABC to the list of base classes, you defined ValueSum itself to be an abstract base class. That means you aren't forced to override the methods, but it also means you cannot instantiate ValueSum itself.

PyCharm is warning you ahead of time that you need to implement the abstract methods inherited from SubQuery; if you don't, you would get an error from Python when you actually tried to instantiate ValueSum.

As to what inheriting from ABC does, the answer is... not much. It's a convenience for setting the metaclass. The following are equivalent:

class Foo(metaclass=abc.ABCMeta):
    ...

and

class Foo(abc.ABC):
    ...

The metaclass modifies __new__ so that every attempt to create an instance of your class checks that the class has implemented all methods decorated with @abstractmethod in a parent class.

You want the zip function to make a generator of tuples of values from each of a number of inputs:

mydict = {}
for key, value in zip(listKeys, listValues):
     mydict[key] = value

That said, you could skip the rigmarole of writing your own loop and let the dict constructor do the work; it can take an iterable of key/value pairs to initialize itself, and avoid the Python level loop entirely:

mydict = dict(zip(listKeys, listValues))

or if mydict is an existing non-empty dict, use the update method, which accepts the same arguments as the constructor:

mydict.update(zip(listKeys, listValues))

Side-note: I renamed your variable to mydict, because shadowing built-in names like dict is a terrible, terrible idea.

In a, b = b, a + b, the expressions on the right hand side are evaluated before being assigned to the left hand side. So it is equivalent to:

c = a + b
a = b
b = c

In the second example, the value of a has already been changed by the time b = a + b is run. Hence, the result is different.

First, this does not work...

a = [john jr 0, Akbar AK 1001, doctor rd 9999, Mohammedans med 1000, pat mat 200, cajole Jul 21]

because it is not python valid syntax. So I assume you mean

a = "[john jr 0, Akbar AK 1001, doctor rd 9999, Mohammedans med 1000, pat mat 200, cajole Jul 21]"

We can split it into parts on a separator... The default seperator is space " " now our code is

s = "[john jr 0, Akbar AK 1001, doctor rd 9999, Mohammedans med 1000, pat mat 200, cajole Jul 21]"
s = s.replace("[", "").replace("]", "")
s = s.replace(",", " ")
a = s.split()
print(s)
print(a)

and we get printed

[john jr 0, Akbar AK 1001, doctor rd 9999, Mohammedans med 1000, pat mat 200, cajole Jul 21]
['[john', 'jr', '0,', 'Akbar', 'AK', '1001,', 'doctor', 'rd', '9999,', 'Mohammedans', 'med', '1000,', 'pat', 'mat', '200,', 'cajole', 'Jul', '21]']

A bit hard to read and you probably don't want the leading and trailing brackets so we strip those. the commas are going to cause number parsing errors so we replace those with spaces. Since spaces are the separator and we want any parts like 12,hi with no space to become 12 hi

Next lets find all the numbers and add those up. We have to simply try to parse each string as a number see if it succeeds.

s = "[john jr 0, Akbar AK 1001, doctor rd 9999, Mohammedans med 1000, pat mat 200, cajole Jul 21]"
s = s.replace("[", "").replace("]", "")
s = s.replace(",", " ")
a = s.split()
print(s)
print(a)
mysum = 0.0
for w in a:
    print("Word is %s" % (w,))
    try:
        n = float(w)
        print("Found number %f" % (n,))
        mysum += n
    except:
        # Ignore any exceptions
        pass
print("Sum is %f" %(mysum,))
pass

And we get

john jr 0  Akbar AK 1001  doctor rd 9999  Mohammedans med 1000  pat mat 200  cajole Jul 21
['john', 'jr', '0', 'Akbar', 'AK', '1001', 'doctor', 'rd', '9999', 'Mohammedans', 'med', '1000', 'pat', 'mat', '200', 'cajole', 'Jul', '21']
Word is john
Word is jr
Word is 0
Found number 0.000000
Word is Akbar
Word is AK
Word is 1001
Found number 1001.000000
Word is doctor
Word is rd
Word is 9999
Found number 9999.000000
Word is Mohammedans
Word is med
Word is 1000
Found number 1000.000000
Word is pat
Word is mat
Word is 200
Found number 200.000000
Word is cajole
Word is Jul
Word is 21
Found number 21.000000
Sum is 12221.000000

So now we have working code that meets what you stated, it finds the numbers and adds them. But is this maintainable and efficient and functional etc. When I have the above problem I use some methods I made that make it easier. Here they are.

def tryParseInt(value=None, default_value=0):
    """
    Try to parse a string value to an int.  Returns the value and True
    e.g.  tryParseInt("42", 7) returns (42, True)
    tryParseInt("abcdef", 7) returns (7, False)
    See twit_test.py
    """
    try:
        return int(value), True
    except (ValueError, TypeError):
        return default_value, False


def tryParseFloat(value=None, default_value=0.0):
    """
    Try to parse a string value to an float.  Returns the value and True
    e.g.  tryParseInt("42.42", 7.3) returns (42.42, True)
    tryParseInt("abcdef", 7.3) returns (7.3, False)
    See twit_test.py
    """
    try:
        return float(value), True
    except (ValueError, TypeError):
        return default_value, False


def split_strip(s: str, sep=' '):
    """ 
    Split s into parts on delimiter, then strip the sub strings and remove any blanks.
    Never returns None.
    Returns an array of the sub strings.  The returned array my be empty.
    See twit_test.py for examples.
    """
    if s is None:
        return []
    parts = s.split(sep=sep)
    ret = []
    if parts is not None:
        for ss in parts:
            sss = ss.strip()
            if len(sss) > 0:
                ret.append(sss)
    return ret

The above helpers are available on GitHib project https://github.com/RMKeene/twit

@Oddthinking's answer is not wrong, but I think it misses the real, practical reason Python has ABCs in a world of duck-typing.

Abstract methods are neat, but in my opinion they don't really fill any use-cases not already covered by duck typing. Abstract base classes' real power lies in the way they allow you to customise the behaviour of isinstance and issubclass. (__subclasshook__ is basically a friendlier API on top of Python's __instancecheck__ and __subclasscheck__ hooks.) Adapting built-in constructs to work on custom types is very much part of Python's philosophy.

Python's source code is exemplary. Here is how collections.Container is defined in the standard library (at time of writing):

class Container(metaclass=ABCMeta):
    __slots__ = ()

    @abstractmethod
    def __contains__(self, x):
        return False

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Container:
            if any("__contains__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

This definition of __subclasshook__ says that any class with a __contains__ attribute is considered to be a subclass of Container, even if it doesn't subclass it directly. So I can write this:

class ContainAllTheThings(object):
    def __contains__(self, item):
        return True

>>> issubclass(ContainAllTheThings, collections.Container)
True
>>> isinstance(ContainAllTheThings(), collections.Container)
True

In other words, if you implement the right interface, you're a subclass! ABCs provide a formal way to define interfaces in Python, while staying true to the spirit of duck-typing. Besides, this works in a way that honours the Open-Closed Principle.

Python's object model looks superficially similar to that of a more "traditional" OO system (by which I mean Java*) - we got yer classes, yer objects, yer methods - but when you scratch the surface you'll find something far richer and more flexible. Likewise, Python's notion of abstract base classes may be recognisable to a Java developer, but in practice they are intended for a very different purpose.

I sometimes find myself writing polymorphic functions that can act on a single item or a collection of items, and I find isinstance(x, collections.Iterable) to be much more readable than hasattr(x, '__iter__') or an equivalent try...except block. (If you didn't know Python, which of those three would make the intention of the code clearest?)

That said, I find that I rarely need to write my own ABC and I typically discover the need for one through refactoring. If I see a polymorphic function making a lot of attribute checks, or lots of functions making the same attribute checks, that smell suggests the existence of an ABC waiting to be extracted.

*without getting into the debate over whether Java is a "traditional" OO system...

Addendum: Even though an abstract base class can override the behaviour of isinstance and issubclass, it still doesn't enter the MRO of the virtual subclass. This is a potential pitfall for clients: not every object for which isinstance(x, MyABC) == True has the methods defined on MyABC.

class MyABC(metaclass=abc.ABCMeta):
    def abc_method(self):
        pass
    @classmethod
    def __subclasshook__(cls, C):
        return True

class C(object):
    pass

# typical client code
c = C()
if isinstance(c, MyABC):  # will be true
    c.abc_method()  # raises AttributeError

Unfortunately this one of those "just don't do that" traps (of which Python has relatively few!): avoid defining ABCs with both a __subclasshook__ and non-abstract methods. Moreover, you should make your definition of __subclasshook__ consistent with the set of abstract methods your ABC defines.

In Python 2.5, you can use ternary conditionals like this:

a if b else c

There is more discussion here: Does Python have a ternary conditional operator?

You can cause a stack overflow quite easily in python, as in any other language, by building an infinately recursive funcion. This is easier in python as it doesn't actually have to do anything at all other than be recursive.

>>> def foo():
...     return foo()
... 

>>> foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  .......
  File "<stdin>", line 2, in foo
RuntimeError: maximum recursion depth exceeded
>>> 

As for the heap, that is managed by a garbage collector. You can allocate lots of objects and eventually run out of heap space and Python will raise a MemoryError, but it's going to take a fair amount of time. You actually did that with your 'stack overflow' example in the question. You stored a reference to a string on the stack, this string took up all the free memory available to the process. As a rule of thumb, Python stores a reference to a heap structure on the stack for any value that it can't guarantee the size of.

As for how it all works, from the fist example you can see that python has a built-in limit to the depth of the call stack that it will not exceed. The amount of memory available for heap space is defined by the OS however and will depend upon many factors.

These are should be the appropriate parts of the python docs for infomation on the errors themselves:

• http://docs.python.org/release/3.2.3/library/exceptions.html#RuntimeError
• http://docs.python.org/release/3.2.3/library/exceptions.html#MemoryError

Python 3.x makes a clear distinction between the types:

• str = '...' literals = a sequence of characters. A “character” is a basic unit of text: a letter, digit, punctuation mark, symbol, space, or “control character” (like tab or backspace). The Unicode standard assigns each character to an integer code point between 0 and 0x10FFFF. (Well, more or less. Unicode includes ligatures and combining characters, so a string might not have the same number of code points as user-perceived characters.) Internally, str uses a flexible string representation that can use either 1, 2, or 4 bytes per code point.
• bytes = b'...' literals = a sequence of bytes. A “byte” is the smallest integer type addressable on a computer, which is nearly universally an octet, or 8-bit unit, thus allowing numbers between 0 and 255.

If you're familiar with:

• Java or C#, think of str as String and bytes as byte[];
• SQL, think of str as NVARCHAR and bytes as BINARY or BLOB;
• Windows registry, think of str as REG_SZ and bytes as REG_BINARY.

If you're familiar with C(++), then forget everything you've learned about char and strings, because a character is not a byte. That idea is long obsolete.

You use str when you want to represent text.

print('שלום עולם')

You use bytes when you want to represent low-level binary data like structs.

NaN = struct.unpack('>d', b'\xff\xf8\x00\x00\x00\x00\x00\x00')[0]

You can encode a str to a bytes object.

>>> '\uFEFF'.encode('UTF-8')
b'\xef\xbb\xbf'

And you can decode a bytes into a str.

>>> b'\xE2\x82\xAC'.decode('UTF-8')
'€'

But you can't freely mix the two types.

>>> b'\xEF\xBB\xBF' + 'Text with a UTF-8 BOM'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't concat bytes to str

The b'...' notation is somewhat confusing in that it allows the printable range of ASCII characters i.e. character code 32 - 126 (space " " up to tilde "~") to be used as a shorthand directly instead of their hex values (0x20 up to 0x7E)

>>> b'A' == b'\x41'
True

But I must emphasize, a character is not a byte.

>>> 'A' == b'A'
False

In Python 2.x

Pre-3.0 versions of Python lacked this kind of distinction between text and binary data. Instead, there was:

• unicode = u'...' literals = sequence of Unicode characters = 3.x str
• str = '...' literals = sequences of confounded bytes/characters
  • Usually text, encoded in some unspecified encoding.
  • But also used to represent binary data like struct.pack output.

In order to ease the 2.x-to-3.x transition, the b'...' literal syntax was backported to Python 2.6, in order to allow distinguishing binary strings (which should be bytes in 3.x) from text strings (which should be str in 3.x). The b prefix does nothing in 2.x, but tells the 2to3 script not to convert it to a Unicode string in 3.x.

So yes, b'...' literals in Python have the same purpose that they do in PHP.

Also, just out of curiosity, are there more symbols than the b and u that do other things?

The r prefix creates a raw string (e.g., r'\t' is a backslash + t instead of a tab), and triple quotes '''...''' or """...""" allow multi-line string literals.

The f prefix (introduced in Python 3.6) creates a “formatted string literal” which can reference Python variables. For example, f'My name is {name}.' is shorthand for 'My name is {0}.'.format(name).