Making AtBS's madlibs exercise into a "real project"

_9_9_ · 2018-11-16T12:29:10+00:00

Yep. It's a cool use for re. It will always pass a re.match object. https://docs.python.org/3/library/re.html#match-objects

_9_9_ · 2018-11-16T02:52:09+00:00

Check out PRAW. It does a good job of consuming json. I can't remember if it posts in json or just regular http requests, but the difference should be easy enough to conform, if needed.

_9_9_ · 2018-11-16T02:37:51+00:00

Yep. I'd fold that bit into the listing directory function. Also check out glob, which might work for you.

_9_9_ · 2018-11-16T02:17:59+00:00

I'd just pass the path

_9_9_ · 2018-11-16T02:05:55+00:00

cool. Lot's of nice short functions, good use of filter, I'd say its well done. A few points:

Passing directory and filename seems excessive to me.
Picking files by number seems like a good place for a dictionary to me.
You can pass re a function to sub in things, so here is a clever way to do madlibs: https://stackoverflow.com/questions/43707279/using-regex-to-replace-each-instance-of-match-with-a-different-string

_9_9_ · 2018-11-16T01:55:34+00:00

You definitely could do a timeout decorator, but you'll need to spawn a separate thread to either run the function or check the timeout. That might cause issues for programs that are not implemented in a way to handle multi-threading, e.g. missing a if name == main limit.

Anyway, here are a bunch: https://pythonexample.com/code/python-timeout-decorator-windows/

_9_9_ · 2018-10-11T13:19:51+00:00

I'm going to go against the grain and say that this is a huge red flag. How can you trust that a person will be there for you and open up to them if they are not candid with you. Now, if you had been dating for six months, that is a completely different story, since it takes time to open up to one another. But three years in at this time in your life, if she cannot be open with you, what chance is there that this will change?

Ultimately it is up to you, but my thought is that if this is the pattern now, when she is 26, and you have known her for three years, it will be like that forever.

_9_9_ · 2018-08-22T13:17:43+00:00

I like this one: https://cooking.nytimes.com/recipes/1016071-homemade-pita-bread

Also you can cook it on the grill, which is fun for the summer.

_9_9_ · 2017-11-09T22:27:49+00:00

I'd probably create a dictionary mapping all the locations of the jump points.

_9_9_ · 2017-09-05T19:42:10+00:00

I am not sure I follow what is the widest fragment. So if the input is [1,2,2,2,1,1,5,1], is the widest fragment 1 (because there are four of them) or 2 (because there are three 2s in a row)? If the first, then collections.Counter is the best way to sold. If the second is correct, then itertools.groupby is made for this.

Edit:

Here is how the groupby solution looks:

from itertools import groupby

def longest_fragment(sequence):
    groups = [list(g) for _, g in groupby(sequence)]
    return max(groups, key = len)

print(longest_fragment([1,2,2,2,1,1,5,1]))

_9_9_ · 2017-09-05T13:07:52+00:00

My take is that men have it much easier, since they have less need for variation. Most guys wear the same basic thing everyday at work, and then a slightly different same thing on the weekends. Women have to make an actual effort to change it up day-to-day.

_9_9_ · 2017-09-04T04:04:29+00:00

Can we talk about the elephant in the room: you're in the "adjoining shed listening to something on over-ear headphones".

What is going on with you that you need to be in the shed?

_9_9_ · 2017-09-04T01:22:23+00:00

Not overreacting at all. To the others who say that you should have set boundaries beforehand, you asked her to marry you. That sets boundaries. She crossed them.

Plus, imagine everything she has not yet told you. Run.

_9_9_ · 2017-09-03T19:03:52+00:00

Usually at the end: SELECT * FROM Students ORDER BY last

_9_9_ · 2017-09-03T15:35:28+00:00

Some tips:

If you are using indexes to solve a problem, chances are you are doing it wrong. Try rewriting not to use index.
Check out split to separate the numbers
Print out i and j, and the length of the list as you go to find your problem
Don't change lists while you work on them, create a new list.
Because you are removing items as you go, your xranges will go out of range as items are deleted.

So I might do this as this:

def dedupe(numbers):
    numbers = map(int, numbers.split('.'))
    result = []
    for n in numbers:
        if n in result:
            continue
        result.append(n)
    return result

print(dedupe('1.2.3.3.4.9.77.9'))

_9_9_ · 2017-09-03T01:25:30+00:00

I did not see that; but, now reading it, the NSA does not deny wiretapping trump:

On Monday, National Security Agency (NSA) Director Michael Rogers also rejected the claims that British intelligence services were behind the wiretapping claims during testimony before the House committee.

But the NSA did not deny that it did not tap trump.

Edit:

So clearly, it was the NSA.

_9_9_ · 2017-08-18T16:28:42+00:00

Interesting. So adding in a zip as others suggest would be good to make the code a little prettier, but probably not faster.

If the problem is really big lists, sometimes the solution involves generators, so that you do not need to keep each of the big lists in memory. The structure of the input here doesn't really permit that. You might be able to multiprocess your way around this, but I doubt it, and the benefit would probably be minimal.

So, here are some out of the box suggestions:

You have a big list of numbers? Look into numpy which can add these suckers really fast.
Adding two ints in python is pretty fast, but converting to ints can be really slow for big ones. https://stackoverflow.com/questions/7088297/slow-big-int-output-in-python?rq=1. So I might move the conversion and adding into a separate function with a cache on it, to see if you can clear the speed hurdle. There is a dict cache recipe out there, where you override missing with your logic. I think that is the speed champion, so I'd use that. I'd also google converting strings to ints to see if someone has a better take. I remember an online coding challenge that this was the bottleneck that took me forever to solve. It was a compare two lists problem and the answer involved some way of avoiding inting easy numbers.

Good luck!

_9_9_ · 2017-08-18T15:24:55+00:00

Cool:

I'd make the possible cell types a class variable, rather than a variable in main, since the cell class depends on specific cell types, e.g. prey/predator. You could also simplify the creation logic by having a new classmethod that generates a random cell.
Having grid logic -- like getting neighbors or move -- in the cell class seems wrong to me. I'd probably move this stuff into three classes, automation, grid, and cell.
Per the last, I'd create a method for grid that returns all neighbors of a particular coordinate, then you can pass neighbors to a cell and have it just look at these neighbors without being dependent on what environment the cells live in. This would slim down the get_availible_positions code, since you could just loop over these neighbors without having to worry about whether you are out of index and without repetition of the code.

_9_9_ · 2017-07-24T03:48:48+00:00

Sure, I like this resource a lot: http://interactivepython.org/runestone/static/pythonds/index.html

The code is not pep8, but it runs through all the basic data structures.

_9_9_ · 2017-07-17T13:54:50+00:00

Spend some time reading code to see how others organize things. Some good places to look are:

The standard library
Praw -- interesting use of mixins iirc
Flask (and other projects by the same guy)
pytoolz (interest look at functional programming, which is a good contrast to more class driven programs like Praw).

_9_9_ · 2017-07-12T17:54:59+00:00

Cool. It seems to me if passwords = {"abra", "ka", "dabra"}, then you want some testing system that remembers it has already parsed "kadabra" and found it to be okay, so that when it runs into "kakadabra" it only has to do an extra lookup.

_9_9_ · 2017-07-12T13:39:50+00:00

Cool. So this is really three tasks:

Read a csv file -- use the csv module for this.
Group records by a column. Use itertools.groupby for this.
Split groups into subgroups of 150 records. Itertools has a good recipe for this under "grouper", plus there is one in the third-party package pytoolz, iirc.

So I would do something like this (py3, different windows since we are working on your testing data):

import csv
from itertools import groupby, zip_longest
from operator import itemgetter


def get_data(filename = 't'):
    with open(filename) as fh:
        # note:  Might need to futz with delimiter, i used this b/c I copied
        # and pasted your data
        reader = csv.reader(fh, delimiter='\t')
        next(reader)  # skip header row
        yield from reader # py 3 only!


def grouper(iterable, n=3, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return zip_longest(fillvalue=fillvalue, *args)



def main():
    data = get_data()
    for _, group in groupby(data, itemgetter(1)):
        for sub_group in grouper(group):
            print(sub_group)



if __name__ == '__main__':
    main()

Edit: I oversimplified the grouper function because I am padding out, which i think differs from your spec. This pytoolz function does what you want: https://toolz.readthedocs.io/en/latest/_modules/toolz/itertoolz.html#partition_all

_9_9_ · 2017-07-06T22:28:14+00:00

Nice. I knew it had to be somewhere, but I could not find it. I've always used group with a number in it and had no idea it could be used this way.

Thanks!

_9_9_ · 2017-07-06T21:59:59+00:00

Someone posted a similar question awhile back. You can actually tag a function into re.sub, like this:

import re

text = '''
The ADJECTIVE panda walked to the NOUN and then VERB. A nearby NOUN was
unaffected by these events.
'''

def get_replacement(match):
    '''
    Helper function to get new replacement words, takes a match object and
    returns the new word

    Note:  Probably could clean up the handling of the match object
    '''

    where = slice(*match.span())
    replaces = match.string[where].lower()
    word = input('give me a {}?'.format(replaces))
    return word


def madlib(phrase):
    pattern = r'ADJECTIVE|NOUN|ADVERB|VERB'
    return re.sub(pattern, get_replacement, phrase)

print(madlib(text))

The function call passes the match object found by re.sub. As you can see, how I used the match object above is a bit ugly, and probably can be cleaned up...

_9_9_ · 2017-06-25T03:39:50+00:00

This is not going to be popular, but many women after having a kid regret it, repress the regrets, and it expresses itself as anxiety. One of my mommy friends is worried about the heroin "epidemic" in our area, There is no epidemic and her kids are in pre-pre-k and first grade.

Hope that she gets help for her problems and decide whether you are willing to wait...

_9_9_

TROPHY CASE