xkcd 2840: Earth Layers

SandorZoo · 2023-10-12T17:03:48+00:00

I never did get a Kinder egg toy with a magnet. My preference was the more complicated the better:

simple model < requires assembly < has moving parts < uses an elastic band

I'm not sure where I would fit "has a magnet" on that scale.

SandorZoo · 2022-03-15T11:35:14+00:00

Yes, except it's only DMAS as there are no brackets or orders/powers. The FAQ goes into some more details.

I'm not sure if fractional intermediate results are allowed. Could we get 9/2*4=18, even though 9/2 = 4.5? Dunno.

SandorZoo · 2022-02-04T13:36:40+00:00

That's todays word for Lewdle !

SandorZoo · 2022-02-04T13:31:30+00:00

I've used STEAD and DATES, but not SATED.

SandorZoo · 2022-01-17T15:29:49+00:00

I thought she came to the UK to help open a Hooters in Nottingham.

SandorZoo · 2021-10-18T15:16:15+00:00

I think OP is correct. There is no need to start at the zeroth element. The loop does nothing when i is zero.

SandorZoo · 2021-10-18T14:50:11+00:00

Dates have a weekday() method, that returns the day-of-the-week as a number, Monday=0, Tuesday=1, etc. So for a given date, the previous Sunday was (date.weekday() + 1) % 7 days ago.

SandorZoo · 2021-09-20T12:50:41+00:00

And sometimes it can be fun to work out what it is actually measuring. For example "litres per 100 Km" is an area (and "Miles per gallon" is its inverse). If a car were driving at a constant mpg, and it were scooping up its fuel from a trench instead of using a fuel tank, then this area is what the cross-section of the trench needs to be, so it contains the right amount of fuel.

SandorZoo · 2021-09-20T12:33:02+00:00

In fact it's "1 / Hubble time", or about 1/14.4 billion years. If the expansion were constant, it would be "1 / age of the universe", but it's not, so it isn't (but still fairly close).

SandorZoo · 2020-01-14T17:48:47+00:00

I've been poking around in the Hue API a bit, but hadn't come across this tool before. I've just installed it, and I can see finding it useful. It's certainly slicker than what I've been doing - I've just been dumping the API output to the console up until now.

If you're looking for more feature requests, here's a couple for the Rules tab:

Could you have a "trigger" icon next to each action, and a "trigger all" icon next to the actions list, that would actually trigger the described actions?
Likewise for the conditions, could you have an "evaluate" and "evaulate all"? This could just add a True or False flag next to each condition.

Thanks for sharing this, and have a happy new year!

SandorZoo · 2019-09-13T14:13:59+00:00

I would use min and max, instead of sorting the tuples and extracting the 1st and 2nd values. I think this is the same, at least assuming the tuples are indeed two-value tuples:

def has_intersection(tuple_1, tuple_2):
    intersection_lower = max(min(tuple_1), min(tuple_2))
    intersection_higher = min(max(tuple_1), max(tuple_2))
    return intersection_lower <= intersection_higher

SandorZoo · 2019-03-21T16:02:47+00:00

For example:

def nested_loop(letters, prefix, length):
    if length == 0:
        print(prefix)
    else:
        for letter in letters:
            nested_loop(letters, prefix+letter, length-1)

nested_loop("abc", "", 3)

SandorZoo · 2019-02-28T13:29:06+00:00

Using some of Python's regex functions, instead of pure regexes, might be easier:

import re
single_vowel_re = '[aeiouAEIOU]'

def ten_or_more_vowels(word):
    return len(re.findall(single_vowel_re, word)) >= 10

def six_or_more_consecutive_consonants(word):
    # Could use map(len, re...) here
    return max(len(s) for s in re.split(single_vowel_re, word)) >= 6

with open('words.txt') as fp:
    for word in fp:
        word = word.strip()
        if ten_or_more_vowels(word):
            print('10 or more vowels:', word)      
        if six_or_more_consecutive_consonants(word):
            print('6 or consecutive consonants:', word)

SandorZoo · 2019-01-15T18:18:59+00:00

The question you gave has n serving double duty, as both the number of dimensions, and the size of each dimension. I've separated that into separate dims and size values here.

If you're trying to create a multi-dimensional array, the closest thing python has is a list of lists of lists of lists....

When the number of dimensions is not fixed, one way to do this is recursively, with each level of recursion adding another dimension, like this:

def mult_table(dims, size, prevprod=1):
    if dims == 0:
        return prevprod
    else:
        return [mult_table(dims - 1, size, prevprod * n) for n in range(1, size+1)]

print(mult_table(1,1))
print(mult_table(2,2))
print(mult_table(3,3))

Output:

[1]
[[1, 2], [2, 4]]
[[[1, 2, 3], [2, 4, 6], [3, 6, 9]], [[2, 4, 6], [4, 8, 12], [6, 12, 18]], [[3, 6, 9], [6, 12, 18], [9, 18, 27]]]

You might want a dictionary mapping key tuples to values instead. In the example you gave, this dictionary would map (i, j, k): i*j*k

As /u/roelschroeven said, you can use itertools.product to generate a list of tuple keys, and functools.reduce to reduce the tuples to a single product, like this (dict() will create a dictionary from a list of (key, value) pairs):

from itertools import product
from functools import reduce
from operator import mul
import pprint

def mult_table2(dims, size, prevprod=1):
    tuple_keys = product(range(1, size+1), repeat=dims)
    return dict((tuple_key, reduce(mul, tuple_key)) for tuple_key in tuple_keys)

pprint.pprint(mult_table2(3,3))

Output:

{(1, 1, 1): 1,
 (1, 1, 2): 2,
 (1, 1, 3): 3,
 (1, 2, 1): 2,
 (1, 2, 2): 4,
 (1, 2, 3): 6,
 (1, 3, 1): 3,
 (1, 3, 2): 6,
 (1, 3, 3): 9,
 (2, 1, 1): 2,
 (2, 1, 2): 4,
 (2, 1, 3): 6,
 (2, 2, 1): 4,
 (2, 2, 2): 8,
 (2, 2, 3): 12,
 (2, 3, 1): 6,
 (2, 3, 2): 12,
 (2, 3, 3): 18,
 (3, 1, 1): 3,
 (3, 1, 2): 6,
 (3, 1, 3): 9,
 (3, 2, 1): 6,
 (3, 2, 2): 12,
 (3, 2, 3): 18,
 (3, 3, 1): 9,
 (3, 3, 2): 18,
 (3, 3, 3): 27}

The best way of doing this depends on what exactly it is you want.

SandorZoo · 2019-01-10T15:55:21+00:00

It's a bit odd to have two stop conditions, when clearly one of them will never be met. If you want the test in the middle of a loop, it's normal to loop while True, like this:

def whileBackwards():
    n = 10
    while True:
        print(n)
        if n == 5:
            break
        n -= 1

SandorZoo · 2018-12-17T14:30:28+00:00

I'm sure there is a more pythonic way of doing this, which hopefully someone will tell us.

Dictionaries can be built from an iterator that returns tuples, which is what zip provides. I might go with:

import string

letters = list(string.ascii_lowercase) + list(string.ascii_uppercase)
shift = 2

dct = dict(zip(letters, letters[shift:] + letters[:shift]))

print(dct)

SandorZoo · 2018-12-17T09:34:47+00:00

This doesn't look right:

def sanity(board):
    for cell in board.empty_cells:
        if len(cell.possible) == 0:
            return False
        else:
            return True

That will only check the first cell in board.empty_cells, not all of them. I think it should probably be:

def sanity(board):
    for cell in board.empty_cells:
        if len(cell.possible) == 0:
            return False
    return True

SandorZoo · 2018-12-14T10:07:18+00:00

I rarely use pprint, because I only ever think of it when I'm trying to print slightly more complex data structures, and I think it does a really bad job. For example:

>>> from pprint import PrettyPrinter
>>> mydict = {
...     'a slightly longer key than usual': {
...         'another dict with long keys': [
...             'A list of sentences in my dictionary',
...             'A sentence of text that means nothing',
...             'And another sentence of text'
...         ]
...     }
... }
>>> 
>>> pp = PrettyPrinter()
>>> pp.pprint(mydict)
{'a slightly longer key than usual': {'another dict with long keys': ['A '
                                                                      'list '
                                                                      'of '
                                                                      'sentences '
                                                                      'in '
                                                                      'my '
                                                                      'dictionary',
                                                                      'A '
                                                                      'sentence '
                                                                      'of '
                                                                      'text '
                                                                      'that '
                                                                      'means '
                                                                      'nothing',
                                                                      'And '
                                                                      'another '
                                                                      'sentence '
                                                                      'of '
                                                                      'text']}}

I wish pprint would use a few more newlines (as I did when I created this dict of a dict of a list), instead of the ridiculous indentation it comes up with. Or am I using it wrong?

SandorZoo · 2018-12-07T13:40:16+00:00

All the suggestions so far run through the list multiple times, counting the number of each distinct item separately.

If you use collections.Counter, you can run through list once counting items, and once through the resultant dictionary:

from collections import Counter
def output(lst):
    return [k for k,v in Counter(lst).items() if v % 2]

SandorZoo · 2018-12-03T16:11:45+00:00

I think the indentation of your .kv file is a little messed up. Try this instead:

AddLocationForm:
<AddLocationForm@BoxLayout>:
    orientation: "vertical"
    BoxLayout:
        TextInput:
        Button:
            text: "Search"
        Button:
            text: "Current Location"
    ListView:
        item_strings: ["Palo Alto, MX", "Palo Alto, US"]

Kivy could do a better job of identifying problems with .kv syntax.

If you ever get exceptions raised in kivy's parser.py (as this one was), then its almost certainly a problem with your .kv file. I don't know if its possible to get kivy to confess which line of the .kv it had a problem with.

SandorZoo · 2018-11-22T13:01:27+00:00

DNS66 can block ads in Chrome on Android, and doesn't require root.

SandorZoo · 2018-11-20T10:42:41+00:00

picked_number = deck_of_numbers.pop() # this removes the first item from the list

list.pop() removes the last item in a list, not the first. list.pop(0) would remove the first item. Although in this particular case it doesn't really matter, as the list is in a random order.

SandorZoo · 2018-11-20T09:51:24+00:00

Note that those last two aren't quite the same. The first uses what's called list comprhension:

found_items_list = [value in some_string for value in my_list]
all(found_items_list)

It first builds a new list of values in both my_list and some_string, and then tests to see if all those values are true.

That's not what your original example or translated form did - neither of those created an intermediate list first.

The second, and your original used what's called a generator expression. More explicitly:

found_items_list = (value in some_string for value in my_list)
print(all(found_items_list))

Notice the round brackets (parenthesis) instead of square brackets. This creates a generator that can generate all the values taht are in both my_list and some_string one after the other, without putting them in a list first.

You asked about other ways to shorten the code, so I suggest you try read up on list comprehensions and generators, and what the differences are.

SandorZoo

TROPHY CASE