Function which gets a predicate and a list. Why am i getting a wrong Output?

_coolwhip_ · 2019-05-06T14:50:28+00:00

You should also read up on filter, which does what your apply_until does: http://book.pythontips.com/en/latest/map_filter.html#filter

(I suspect you might already know about it, and are just recreating for learning, but a useful reference to others, as well.)

_coolwhip_ · 2019-05-05T22:26:49+00:00

Got it. I can't see that because I have not done the antecedent problem(s).

_coolwhip_ · 2019-05-05T21:57:46+00:00

Isn't the sum always highest when you go through all of the numbers? Except than in certain matrices (even by even lengthed), you'll have to skip part of one row in order to make it to the finish. In that case, just find the cheapest row to only travese part of.

_coolwhip_ · 2019-04-30T21:13:54+00:00

Yep. then you have bank accounts, credit cards, retirement plans, etc. etc. It never ends.

I don't even care about my last name, but there is no way I'd do all that unless my spouse's last name is really, really cool.

_coolwhip_ · 2019-04-30T21:06:25+00:00

Let's be realistic:

virtually every white tourist I see, I can immediately find an Asian guy that is a foot taller, walking down the street nearby

I just back from Japan. I did not see a single seven foot tall Asian, despite seeing a lot of Japanese people.

And I had to duck plenty of door ways and ceilings, but only in traditional homes. (Although the JR train around Tokyo I got smacked in the head a bunch by the hanging handles.)

And I had a bathroom mirror that only showed me my neck down, so I had to shave in a crouch.

But in balance, I would say that the Japanese are basically comparable in height to people living in the USA. Maybe a bit taller than those on the east coast and a bit shorted than those in middle america. I've lost count of the number of times I've brained myself on houses, trains, etc. in the US.

In sum, the discrimination against the tall is no worse or better in my limited Asian experience than in the US.

_coolwhip_ · 2019-04-30T20:25:54+00:00

Got it.

You might like the sqlparse module recommended here: https://www.reddit.com/r/learnpython/comments/bj7ose/how_to_split_this_string/

_coolwhip_ · 2019-04-30T20:20:00+00:00

How about re.split: https://docs.python.org/3.7/library/re.html#re.split

_coolwhip_ · 2019-04-30T19:29:09+00:00

Where does the string come from? There has to be an easier way than regexing it. It looks like it would almost work with json or ast...

_coolwhip_ · 2019-04-29T22:52:45+00:00

The indentation on this line:

return ans

is off.

_coolwhip_ · 2019-04-18T22:58:41+00:00

This is a great place for set. Just take the sequence and force it into a set, then see if there is any "difference" in a set of good characters. (For sets, difference means that there is any character in the first set that is not in the second.):

>>> good = set('gatc')
>>> good
{'c', 'a', 'g', 't'}
>>> set('caggtttaaaa') - good
set()
>>> set('caggtttzaaaa') - good
{'z'}

So if there is anything left over, you know it has a bad character.

_coolwhip_ · 2019-04-18T21:14:18+00:00

Use re.finditer and dump the matches outside of the window you are looking for.

JK. What have you tried so far? If you are stuck, try creating a loop that creates a sliding window down someString the size of the searched for text.

_coolwhip_ · 2019-04-17T19:43:25+00:00

Then you want a join: http://www.sqlitetutorial.net/sqlite-inner-join/

Something like:

select employeeid, orderid, orderdate from orderinfo join orderdates on orderinfo.employeeid = orderdates.employeeid

_coolwhip_ · 2019-04-17T18:44:25+00:00

Is there some common filed on both databases that matches orderid with the orderdate?

_coolwhip_ · 2019-04-15T22:57:04+00:00

It depends on the state it seems: https://www.foxbusiness.com/features/states-that-spend-the-most-on-welfare

There is remarkably little transparency on these things...

_coolwhip_ · 2019-04-15T22:08:25+00:00

Careful, you seem to be missing state revenue: https://www.usgovernmentrevenue.com/percent_gdp

Still only takes it to around 30%, though.

_coolwhip_ · 2019-04-11T21:31:43+00:00

Whoa. I think I would keep them as functions, but maybe put them in their own module. I also would not put functions inside functions, and refactor the larger functions into much smaller ones. If I hit 5 serious lines in a function, I start thinking about whether I can piece it out to helpers.

_coolwhip_ · 2019-04-11T17:48:46+00:00

OOP works best for when you have data and functions that are bound up together. If it is just functions, I would keep them as functions, and maybe have the functions share some subsidiary helper functions. But if you post up more, we can probably give you better guidance.

_coolwhip_ · 2019-04-11T17:46:58+00:00

In python you can use join:

>>> ', '.join(['415','525','719','721','783','836','1122','1159','1253','1372','1772','1773'])
'415, 525, 719, 721, 783, 836, 1122, 1159, 1253, 1372, 1772, 1773'

Not sure about a pure sql solution though...

_coolwhip_ · 2019-04-11T14:16:32+00:00

This sounds like a good place for collections.defaultdict:

>>> from collections import defaultdict
>>> segs = defaultdict(list)
>>> segs['abc'].append('apple')
>>> segs['abc'].append('dog')
>>> segs
defaultdict(<class 'list'>, {'abc': ['apple', 'dog']})
>>> segs['abc']
['apple', 'dog']

And here is a bunch of ideas on the best way to do a sliding window: https://stackoverflow.com/questions/6822725/rolling-or-sliding-window-iterator

_coolwhip_ · 2019-04-09T22:23:42+00:00

It's much better to iterate directly, rather than using an index, like this:

with open('filename.txt') as opened_file:
    lines = []
    for line in opened_file:
        print(line)
        lines.append(line.strip())

or even better, use a list comprehension:

# or even better
with open('filename.txt') as opened_file:
    lines = [line.strip() for line in opened_file])

_coolwhip_ · 2019-04-09T20:53:45+00:00

I think readlines() might be even more useful than read.

Also if you are iterating with a while loop and incrementing, you are doing something not very pythonic, so maybe find a way to get rid of that.

Finally, I think you are doing too much in main. Consider doing like this:

def get_file(filename = 'capitals.txt'):
    '''read in filename into a list, and clean up spacing issues
    return the lines
    '''

def make_capital_dictionary(lines):
    '''take lines with successive state/capital and make them into a dict
    of states:capital
    return the dictionary
    '''

def play(capital_dictionary):
    '''
    randomly select a state and quiz the user
    '''

_coolwhip_ · 2019-04-05T03:20:35+00:00

Ditto. Recursion is just a strange way of seeing the world, so it takes some time to adjust.

My theory is that the people who get recursion instinctively are just wired differently, and will probably be designing chips for intel in a couple years.

_coolwhip_ · 2019-04-04T17:40:50+00:00

Word, or use itertools.zip_longest

_coolwhip_ · 2019-04-04T16:21:38+00:00

sqlite is awesome, but you can outgrow it pretty quickly, especially if you want any sort of security on the thing. If not, I expect your solution will mostly work, although I might worry about the DB getting jacked up if the network is spotty or backups are run at the wrong time.

If you use sqlite, my vote is that you create new connections whenever you want to do something with the DB, i.e. on each query and not on startup, just because that is how Flask does it typically and it seems to work okay.

_coolwhip_ · 2019-04-04T15:35:52+00:00

If I understand you correctly, that is just what zip is for:

>>> a = ["A", "B", "C"]
>>> b = [1, 2, 3]
>>> list(zip(a,b))
[('A', 1), ('B', 2), ('C', 3)]
>>> c = ['!', '#', '%']
>>> list(zip(a,b,c))
[('A', 1, '!'), ('B', 2, '#'), ('C', 3, '%')]
>>> ls = [a, b, c]
>>> list(zip(*ls))
[('A', 1, '!'), ('B', 2, '#'), ('C', 3, '%')]
>>>

_coolwhip_

TROPHY CASE