SurgicalOntologist posted:

Whenever you find yourself wanting to use different variables based on their name, the answer is usually a dictionary.

In this case you'd be best served with something designed for data, like pandas, but as an exercise maybe just start with dictionaries. I'll suggest something like

Python code:

data = {
    'Ronaldo': {
        'appearances':
            [25, 29, 33, 33, 34, 34, 33, 29, 34, 38, 34, 30, 14],
        'goals':
            [3, 4, 5, 9, 17, 31, 18, 26, 40, 46, 34, 31, 25],
    },
    ...
}

From there you should find it relatively easy to choose the data based on the user selection.

Cingulate posted:

Is there a simple explanation (rule) for why (or when) in such contexts, dicts are preferable over objects (ie., dict[key] vs object.attribute)?

tbp posted:

Ah, thank you. This does look like a much more logical way of arranging this, especially because then it becomes far more scale-able. I'll be able to periodically add more "stats" into a player's data set if I want.

I don't have the chance to get into IDLE at the moment but I am assuming then the way I would get the variable I need would be something like

code:

customplayer.add(%playerentry.get['goals'],%playerentry.get[appearances])

Does this seem right?

Thanks again for the help

Cingulate posted:

Is there a simple explanation (rule) for why (or when) in such contexts, dicts are preferable over objects (ie., dict[key] vs object.attribute)?

quote:

************* Module board_tester
E: 8, 0: No name 'test_boards' in module 'setuptools.tests' (no-name-in-module)
F: 8, 0: Unable to import 'tests.test_boards' (import-error)

tbp posted:

So ideally what I'd want to do is use whatever it entered in the playerentry Entry boxes as the name and basically get the right variables based on a shortname.

FoiledAgain posted:

You should learn about "tk variables" (just google it, you probably want the effbot site, it's very good for tk material). You attach a textvariable to your Entry widget so that you can look up the contents of the widget from anywhere. Something like this:

code:

from tkinter import *

root = Tk()
selected_player = StringVar()

main_window = Toplevel(root)
player_frame = LabelFrame(main_window, text='Enter a player name')
player_entry = Entry(player_frame, textvariable=selected_player)
player_entry.grid()
ok = Button(player_frame, text='Select', command=choose_player)
ok.grid()
player_frame.grid()

root.mainloop()

def choose_player():
    player_name = selected_player.get() #this is where tk variables come in handy
    #add code to display player stats here
    if player_name == 'famous_guy_1':
        #do some stuff
    elif player_name == 'famous_guy_2':
        #do some stuff
    

Master_Odin posted:

SurgicalOntologist posted:

Not sure if this is the issue, but you could try putting a blank __init.py__ file in tests/.

baka kaba posted:

Hi I'm an idiot, can someone tell me how in the hell you add a local library to a project in PyCharm? Explain it like half my brain is missing, because it feels like it is after the past hour (for some reason this is an amazing fertile ground for spam websites scraping Stack Exchange)

I've installed the PyCrypto binaries since I don't have a C compiler installed, so that's living in Python34\Lib\site-packages right now. My project is set up with a VirtualEnv. I can install packages from the Project Interpreter screen, which is nice and all since they come from the internet, but I need to add this local package instead, and I can't see any way to do that.

Closest I've got from randomly clicking on things (which is where I'm at now) is adding site-packages as a Content Root which at least makes it appear under External Libraries. Is this the right way to do things? Code completion isn't working at all, is that a separate issue or have I done this wrong?

reading posted:

I'm going through the libtcod tutorial for making a roguelike at http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_13_code and I'm really confused about this stuff:

code:

class Object:
    #this is a generic object: the player, a monster, an item, the stairs...
    #it's always represented by a character on screen.
    def __init__(self, x, y, char, name, color, blocks=False, always_visible=False, fighter=None, ai=None, item=None, equipment=None):
        self.x = x
        self.y = y
        self.char = char
        self.name = name
        self.color = color
        self.blocks = blocks
        self.always_visible = always_visible
        self.fighter = fighter
        if self.fighter:  #let the fighter component know who owns it
            self.fighter.owner = self
 
        self.ai = ai
        if self.ai:  #let the AI component know who owns it
            self.ai.owner = self
 
        self.item = item
        if self.item:  #let the Item component know who owns it
            self.item.owner = self
 
        self.equipment = equipment
        if self.equipment:  #let the Equipment component know who owns it
            self.equipment.owner = self
 
            #there must be an Item component for the Equipment component to work properly
            self.item = Item()
            self.item.owner = self

class Fighter, class Item, class Equipment, and several AI classes are defined elsewhere.

I understand "self" in python, and I'm slowly comprehending the ability to assign objects to other objects which is done frequently in this tutorial, but there are two things I need help understanding:

"self.equipment.owner = self" what exactly is this about? Who owns what?

"self.item = item" versus "self.item = Item()" what's the difference here? What does it mean to invoke a class like a function with "()" ?

Finally, I do not understand the whole self.equipment section. I understand that logically an Equipment must also be an Item, but the three lines of code

code:

self.equipment.owner = self
 
#there must be an Item component for the Equipment component to work properly
self.item = Item()
self.item.owner = self

are really confusing to me. I would appreciate any help from object oriented gurus, I'm mostly an embedded C programmer.

reading posted:

I'm going through the libtcod tutorial for making a roguelike at http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_13_code and I'm really confused about this stuff:

"self.equipment.owner = self" what exactly is this about? Who owns what?

quote:

"self.item = item" versus "self.item = Item()" what's the difference here? What does it mean to invoke a class like a function with "()" ?

reading posted:

I'm going through the libtcod tutorial for making a roguelike at http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_13_code

henn and potion posted:

PyQt and their model-view framework may be an option. One approach is to load your data in one of Qt's model classes and then use one of the view classes to point to the model and automagically view your data.

You could possibly derive from QAbstractItemModel to load your data and QTreeView to display it with expandable/collapsible options, sorting, etc.

Symbolic Butt posted:

It may just be me but self.equipment.owner = self looks kind of goofy.

BeefofAges posted:

Yeah I've never seen that sort of thing before.

Symbolic Butt posted:

It may just be me but self.equipment.owner = self looks kind of goofy.

Heavy_D posted:

Here we have a chain of properties, each of which is talking about an object:

• self is the current entity
  
• self.equipment is a property of the current object, which stores the equipment object
  
• self.equipment.owner is defining a property on the equipment object
  
• self.equipment.owner = self is setting the property on the equipment object to point at the original object
  

The result is a small loop. The self object can find the equipment object by looking at the "equipment" property, and the equipment object can locate the self object by looking at the "owner" propertry.


In reverse order: Item() makes a new object of the Item class. The lowercase item is a parameter to the _init_ function, so the person calling our code may have a pre-made Item they would like to send for us to use.

Hopefully that should clarify the self.equipment section, as it's just these two tricks happening twice in a row.

Symbolic Butt posted:

It may just be me but self.equipment.owner = self looks kind of goofy.

ShadowHawk posted:

I believe it's a symptom of not fully separating what each class does, or having the wrong ownership of methods that interact between them.

FoiledAgain posted:

Just for the sake of discussion, let's imagine that party members can lend each other equipment, but items have special properties when equipped on the original owner. In this case, wouldn't it be useful to keep track which Object instance is the owner? And supposing the answer is 'yes', would there be a better way?

good jovi posted:

This smells like someone trying to build a class structure that directly mirrors their database relationships.

quote:

Internally, lex.py uses the re module to do its patten matching. When building the master regular expression, rules are added in the following order:

All tokens defined by functions are added in the same order as they appear in the lexer file.
Tokens defined by strings are added next by sorting them in order of decreasing regular expression length (longer expressions are added first).

Cingulate posted:

My main python installation is Python3 from anaconda, and python calls the anaconda Py3k. I want to install a package that is Python 2.x only, and asks for python to call a Python 2.x. What's the best way for going about this?

Aaronicon posted:

Speaking of that terrible libtcodpy tutorial, is there any practical difference between going

Python code:

ClassName(BaseClass):

    def __init__(self):
        super(ClassName, self).__init__()

vs

Python code:

ClassName(BaseClass):

    def __init__(self):
        BaseClass.__init__(self)

I believe they both accomplish the same thing but the latter seems a lot cleaner and 'pythonic' to me. The super() syntax doesn't feel nice to me, for lack of any other actual reason. I mean arguably the second method means that you have to change the name of the function should you ever change the name of the BaseClass, but we live in the year 2014 and if you don't have an IDE with find/replace I don't know what to tell you.

Hammerite posted:

I'm coming back to a personal project that I set aside a while ago. The project involves using PLY to create a parser for a domain specific language. There is a long and detailed help file, which is great, but one thing that strikes me as weird is this:


This business of treating functions based on the order they were defined - is that something that is used by other Python projects? Is it something that is guaranteed to not be broken by future versions of Python? It seems like a funny thing to rely on.

The way you create a lexer (by calling a function in the module rather than by calling Lexer()) is awkward too, as I want to subclass the Lexer class to tweak its behaviour but it's set up in such a way that it's hard to know how to do that. Just having a wrapper class that contains a Lexer is not a perfect solution, as the token parameters to so-called "rule" functions/methods contain a reference to the Lexer object.

Cingulate posted:

My main python installation is Python3 from anaconda, and python calls the anaconda Py3k. I want to install a package that is Python 2.x only, and asks for python to call a Python 2.x. What's the best way for going about this?

Also, it seems readthedocs.org is down right now?

Edit: I'm on a Mac, if this matters.