Dominoes fucked around with this message at 20:55 on Feb 27, 2017

Thermopyle fucked around with this message at 22:16 on Feb 27, 2017

a witch fucked around with this message at 17:43 on Mar 1, 2017

"""awfulerrors.py is a stand-in 
for the function that contains 
your troublesome error"""

class AwfulError(Exception):
    pass

def fake_upload():
    raise AwfulError

"""main.py"""
import awfulerrors
from awfulerrors import AwfulError
def main():
    try:
        awfulerrors.fake_upload()
    except AwfulError:
        print('caught correctly')
        return False
    except Exception:
        print('this line should never be reached')
        raise
    else: # No Error at All
        return True
    
if __name__ == '__main__':
    result = main()
    assert result is False
    print('we did it!')

this line should never be reached
Traceback (most recent call last):
<<< some ommitted>>
    line 11, in fake_upload
    raise AwfulError

# during your imports:
from awfulerrors import AwfulError 
#(this pushes it into the local namespace where it is
#defined; normally at the #module level)

#replacing your except block
except awfulerrors.AwfulError:
# this tells the interpreter that the error lives in 
# the awfulerrors package, which you have imported before

caught correctly
we did it!

Eela6 fucked around with this message at 21:16 on Mar 1, 2017

Eela6 fucked around with this message at 21:09 on Mar 1, 2017

Boris Galerkin fucked around with this message at 16:01 on Mar 4, 2017

Boris Galerkin fucked around with this message at 15:34 on Mar 5, 2017

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

Dominoes fucked around with this message at 23:27 on Mar 5, 2017

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

• Requests - for making web requests with easy syntax
  
• Pytest - unit tests; cleaner than the built-in module.
  
• SQLalchemy - for working with databases.
  
• BeautifulSoup - for parsing HTML and XML. Recommended over a built-in alternative
  
• Websockets – Live communication betweeen browser and server.
  
• PyQt5 Lets you use the C++ GUI library Qt with Python
  . Steep learning curve, but QT is a powerful, well-documented way to make desktop and mobile GUIs. Used by Ipython Qtconsole, and Spyder.
  
• Toolz - functional programming tools like currying, accumulate, take, compose, and pipe. Some of this functionality's included in the built-in itertools and functools libraries, or is easily created from them. You should check those libraries out too!
  

f(x) = 2x^2

f = lambda x: 2 * x**2

Dominoes fucked around with this message at 15:03 on Mar 6, 2017

Dominoes fucked around with this message at 00:38 on Mar 6, 2017

new_features = [r'await/async',
 'better dictionaries', 
'formatted string literals'
'@ operator for matrix multiplication'
'type hints']
print(f"new in python: {new_features}")

Eela6 fucked around with this message at 00:59 on Mar 6, 2017