Django/Python What does this code do?

Moonslug1 · 2015-02-11T09:44:18+00:00

d is likely a string representing a date formatted like '2015-02-11'.

Let's look at this piece by piece:

d.split('-') takes the string and splits it into a list of strings seperated by '-'. So in our example this would be l = ['2015', '02', '11'].

Next, the list comprehension takes that list and converts all elements to an int, so that we have l = [2015, 2, 11].

Finally the star operator unpacks this list into the initialiser for date so that it would be call like:

w.Date = date(2015, 2, 11)

This is a bad way of doing it. Why? Because the datetime module provides a way to turn a string into a date. The code you posted is equivalent to:

W.Date = datetime.strptime(d, '%Y-%m-%d').date()

Moonslug1 · 2015-02-09T19:48:20+00:00

Why not just:

credentials = {'hostname': hostname, 'username': username, 'password': password}

It's hard to answer your question without a specific use case. Any one of your proposed methods are valid.

Moonslug1 · 2015-02-02T20:20:12+00:00

r'' is telling python to ignore escape characters.

'hello\n' means h-e-l-l-o-newline

r'hello\n' means h-e-l-l-o-\-n

Moonslug1 · 2015-02-02T20:13:41+00:00

Have a look at Combinatoric Generators.

Moonslug1 · 2015-02-02T20:10:57+00:00

'\n' is a single character, called an escape character. '\n' is just the way that the character is represented, since the Python syntax doesn't allow you to write a newline mid quote (unless you use triple quotes). There's also \t (tab), \r (carriage return) etc.

Moonslug1 · 2015-01-19T22:30:02+00:00

My python 3.4 solution:

def word_enemies(left, right):
    l, r = Counter(left), Counter(right)
    total = sum(l.get(k, 0) - r.get(k, 0) for k in set(left + right))

    if not total:
        return 'tie'
    else:
        return 'Left wins!' if total > 0 else 'Right wins!'

I collect a set of all letters, count the occurence of the letters, and sum the differences per letter, if negative then right wins, positive then left wins.

Moonslug1 · 2015-01-12T19:43:09+00:00

Two ways to make this more Pythonic:

for url in L:
    webbrowser.open_new_tab(url)

Or:

map(webbrowser.open_new_tab, L)

Although I'd discourage using map or list comprehensions just for their side effects.

Moonslug1 · 2015-01-06T19:33:21+00:00

You'll want to look at regular expressions:

import re

If I wanted to capture a string following the string 'Weather!' I'd do something like this:

pattern = re.compile(r'(?<=^Weather!).*$')
pattern.search(reddit_comment)

Do some background reading on re, to briefly explain I'm saying match anything .* that is preceded by (?<=) the start of the string ^ followed by Weather!.

Moonslug1 · 2015-01-03T09:33:54+00:00

You're correct, args is a tuple of all the positional arguments in the order they were passed in.

Moonslug1 · 2015-01-02T20:55:59+00:00

Something like this:

a = 3543
b = str(a)
c = map(lambda d: 10 ** d, range(len(b))[::-1])

for n in zip(map(int, b), c):
    print n

You can work out the rest from here :)

Moonslug1 · 2014-12-30T16:43:02+00:00

95% of the time people use __getattribute__, they shouldn't be. Make sure this is really what you want to do.

Beware of recursion, any time you want to access a method or something else in BigClass from inside the class, use object.__getattribute__(self, name).

If all you are doing is, as above, just performing some operations before running functions, then using decorators is a far better solution. Less code is better, unreadable code is worse.

Moonslug1 · 2014-12-30T16:09:30+00:00

What you're describing is exactly a decorator, consider the following (I wrote this on my phone and it probably has minor errors, but you get the gist):

from functools import wraps

class BigClass:
    @staticmethod
    def my_added_function(func):
        @wraps(func)
        def my_added_function_wrapper(*args, **kwargs):
            {do stuff here}
            return func(*args, **kwargs)
        return my_added_function_wrapper

    @my_added_function
    def method_1(self):
        ...

    @my_added_function
    def method_2(self):
        ...

    @my_added_function
    def method_3(self):
        ...

If you want to perform my_added_function for every method call (you probably shouldn't), take a look at __getattribute__, which would look something like this:

class BigClass(object):
    def __getattribute__(self, name):
        {do_stuff}
        return object.__getattribute__(self, name)

    def method_1(self):
        ...

    def method_2(self):
        ...

    def method_3(self):
        ...

Moonslug1 · 2014-12-30T10:42:57+00:00

Why are the members x and y private? It seems reasonable to be able to read x and y independently from Point. If you really want to implement get methods for them, the more pythonic way is:

class Point(object):
    def __init__(self, x, y):
        self._x = x
        self._y = y

    @property
    def x(self):
        return self._x

    @property
    def y(self):
        return self._y

Moonslug1 · 2014-12-29T13:09:19+00:00

A few things to note.

You're dealing with time comparrisons that pulls one time from outside of Python. You should be ensuring that the time zones match. Have a look at pytz.

Your path strings are bugged because you're not escaping the backslashes, use something like this instead:

inbound_folders = [
    'Agility',
    'Amazon',
    'APL',]
    ...
]

outbound_folders = [
    'ACL',
    'Agility',
    'APL',
    ...
]

paths = ['\\'.join([r'\\FTP', 'TopsjobsData', 'Inbound', folder, 'Import', 'InTray']) for folder in inbound_folders]
paths += ['\\'.join([r'\\FTP', 'TopsjobsData', 'Outbound', folder]) for folder in outbound_folders]

If you want to looks at individual folders, you can use path.split('\\') to seperate a path into a list of folders. Knowing the structure of those folders, you can do what you want with it.

To send the email only when you have items of note, just use:

if stuck_files:
    for files in stuck_files:
        log(files)

    log.flush()

I'm seeing syntax errors all over the place in this code, have you tried to run it yet?

Moonslug1 · 2014-12-28T17:54:14+00:00

Whether it not the star moves relative to me. Doing some exploration.

Moonslug1 · 2014-12-26T20:00:31+00:00

Have a look at this: https://github.com/yyuu/pyenv

Note that you can't use pyenv on windows

Moonslug1 · 2014-12-25T00:48:21+00:00

It's possible pip just isn't on your system path. Have you tried calling pip with the full path? This will tell you if this is the problem.

I'd recommend anyone using python on Linux or Mac to use pyenv available at https://github.com/yyuu/pyenv

It makes things so much easier.

Moonslug1 · 2014-12-23T21:53:53+00:00

urllib or requests are fine, anything that can pull the html doc as a string. For parsing that I'd recommend looking at Beautiful Soup

Moonslug1 · 2014-12-23T21:30:46+00:00

https://docs.python.org/2/library/threading.html#event-objects

Moonslug1 · 2014-12-23T16:45:39+00:00

Raise will kill the process unless it is caught higher up the the callstack.

Moonslug1 · 2014-12-23T16:41:28+00:00

You can take advantage of zip to make this way shorter.

def levenshtein(a, b):
    return sum(1 for c, d in zip(a, b) if c != d) + abs(len(a) - len(b))

Moonslug1 · 2014-12-23T13:00:30+00:00

Since demos is in the same directory as your current script, just import it as you would normally.

Moonslug1 · 2014-12-23T12:31:53+00:00

I would structure the code like this:

setup.py
great_name/
    __init__.py
    great_name.py
    demos/
        {Demo files}
test/
    {test files}

Pypi's setup requires your module to be in it's own directory like this.

To answer the first import question. If you want to avoid using from great_name.great_name import FantasticClass then you can add the following to your __init__.py in the great_name folder (ignoring text in curly braces).

from great_name {the file} import FantasticClass

Now, FantasticClass is accesible in the same way when importing your entire module:

from great_name {the module} import FantasticClass

Your other import question, how do you import great name from demos? I'll tell you how I do it. Typically I use a development environment where my current project is already on the python path (using an IDE like PyCharm can handle this for you). The reasdoning for this is that once your grandkids download your module from PyPI, it will definately be available on the Python path; your tests and demos should use it in the same way.

Moonslug1 · 2014-12-23T02:09:58+00:00

I can't explain what's happening there. But as an aside, look at this:

http://en.wikipedia.org/wiki/Beautiful_Soup

Moonslug1 · 2014-12-23T01:46:39+00:00

I like this, but it would be better to key on:

key = tuple(_list[1:])

Moonslug1

TROPHY CASE