I want to create new variable in def,
but that is not recommended.
https://stackoverflow.com/questions/30517398/creating-a-new-variable-using-the-def-command-in-python\
My code that I want to run is below,
# I imported some libraries,
from bindsnet.network.nodes import Input
import bindsnet
network = Network()
# then I create new variable "input_layer"
input_layer = Input(n=100)
network.add_layer(layer=input_layer, name="A")
Now, I need to create many of input layer.
So, I want to make it as a def that works exactly the same as the above, for ease of repetition.
like this
def test_add_network(layer_name, node_type, n, node_name):
layer_name = node_type(n)
network.add_layer(layer = node_type, name = node_name)
# then run,
test_add_network(input_layer_test, Input, 100, "A")
I got Error,
NameError: name 'input_layer_test' is not defined
I understand what this error wants to say.
Here I face same problem,(pasted earlier)
creating a new variable using the def command in python
how do I solve this
You don't need to pass in the name of the variable you want created. Instead, return the new value from your function and assign it to the variable name in the calling scope:
def test_add_network(node_type, n, node_name):
layer_name = node_type(n)
network.add_layer(layer = node_type, name = node_name)
return layer_name
# then run,
input_layer_test = test_add_network(Input, 100, "A")
Remove 'layer_name' from the parameters. It's not an input, it's an output. Just make your function return layer_name at the end, call it and assign the result to input_layer_test
def test_add_network(node_type, n, node_name):
layer_name = node_type(n)
network.add_layer(layer = node_type, name = node_name)
return layer_name
# then run,
input_layer_test = test_add_network(Input, 100, "A")
Related
I've made a class as follow:
class Plugins:
def __init__(self):
pass
def voter_rep(self, loc, start_header, end_header):
self.loc = loc
ocr_xml = AbbyyXML(loc)
xml_doc = XMLDoc(ocr_xml, CONSTANTS)
xml_doc.split_words("", False)
self.start_header = start_header
self.end_header = end_header
header_pages = xml_doc.se_page(start_header, end_header)
## and stuff
voter_dict = {'Voter':[], 'Record_Key':[], 'Comments':[]}
## and stuff
return voter_dict, rep_dict
if I run the method function on its own and outside of the class it works totally fine, namely if I write the function as:
def voter_rep(loc, start_header, end_header):
ocr_xml = AbbyyXML(loc)
xml_doc = XMLDoc(ocr_xml, CONSTANTS)
xml_doc.split_words("", False)
header_pages = xml_doc.se_page(start_header, end_header)
## and stuff
voter_dict = {'Voter':[], 'Record_Key':[], 'Comments':[]}
## and stuff
return voter_dict, rep_dict
in the function alone I get rid of self and will just have voter_rep(loc, start_header, end_header) but when I want to call it from the class I do plugins.voter_rep(loc, start_header, end_header) which does not work, and it returns:
NameError: name 'plugins' is not defined
I wonder why is it that my function works on its own but not callable from the class?
You can do
plugins = Plugins()
loc = #some val
start_header = #some val
end_header = #some val
plugins.voter_rep(loc, start_header, end_header)
As the error message shows, you are using small 'p' instead of capital. Also since it is not a static function, so it is not good to call it via class name.
Plugins.voter_rep(loc, start_header, end_header)
Take note of the capital letter.
I have a code as follows:
class SifFile():
setting = {}
interesting_param = ['Temp', 'Pressure']
def __init__(self, get_param):
self.File_Type = "Andor Technology Multi-Channel File"
for k, v in get_param.items():
if SifFile.interesting_param in k:
SifFile.setting[k] = v
return SifFile.setting
get_parameter = {'Temp':75, 'Pressure':50, 'Helium':90, 'Exp':96}
sif = SifFile(get_parameter)
There is a big dict named get_parameter that has a few parameters and their values.
There is also a list named interesting_param that contains 2 elements.
What I want to do is to check which parameters from interesting_param list are present in the get_parameter dictionary and I want to save those parameters in an empty dict named setting
I tried running the above code, but it gives me the following error:
Traceback (most recent call last):
File "", line 16, in
sif = SifFile(get_parameter)
File "", line 8, in init
if SifFile.interesting_param in k:
TypeError: 'in ' requires string as left operand, not list
Expected output:
setting = {'Temp':75, 'Pressure':50}
Here is the code that will give you the expected answer:
class SifFile():
setting = {}
interesting_param = ['Temp', 'Pressure']
def __init__(self):
self.File_Type = "Andor Technology Multi-Channel File"
return
def func(self, get_param):
for k, v in get_param.items():
if k in SifFile.interesting_param:
SifFile.setting[k] = v
return SifFile.setting
get_parameter = {'Temp':75, 'Pressure':50, 'Helium':90, 'Exp':96}
sif = SifFile()
x=sif.func(get_parameter)
print(x)
I have created anothter funcion called "func" because "init()" cannot return a dictionary. It should only return "None".
Besides that, the condition statement within the for loop is changed.
The error is telling you what's wrong: you are trying to check if a key exists in a dict but the key that you're checking for isn't a string. Let's look at the line in question:
if SifFile.interesting_param in k:
The error thinks that SifFile.interesting_param is a list, so let's have a look at where you define that:
interesting_param = ['Temp', 'Pressure']
Oh yeah, that is a list. Since a list can't be a dict key it throws an error.
You need to loop through your items in interesting_param one by one to check whether they're in the dict. I've implemented that here, along with a range of other issues in your code, mainly surrounding how you'd implemented the class:
class SifFile():
"""
Class for holding and processing sif files.
"""
def __init__(self, params):
"""
Define the variables you want to use in your class
"""
self.file_type = "Andor Technology Multi-Channel File"
self.interesting_params = ['Temp', 'Pressure']
self.given_params = params
self.setting = {}
def get_settings(self):
"""
Return list of settings of interest
"""
# Look at every parameter of interest in turn
for param in self.interesting_params:
# Check to see if it is in the dict of given parameters
if param in self.given_params:
# If it is then add it to the setting dict
self.setting[param] = self.given_params[param]
# Return the setting dict once the loop is done
return self.setting
parameters = {'Temp':75, 'Pressure':50, 'Helium':90, 'Exp':96}
sif = SifFile(parameters)
print(sif.get_settings())
Note that your variables are now all instance variables rather than class variables (they start with self) because you're changing them, so they are unlikely to be the same for every class.
I am trying to add new objects to a class(emne) but the new instances of the class needs to be created using user input. So i need a way to be able to chose the name for the object and set some of the values of the objects with user input.
I have already tried to create a function that passes the value of the user input into a x = emner(x) to create it but it only returns:
AttributeError: 'str' object has no attribute 'fagKode'
so i think my issue is that the value of the input is created as a string so that it is not understood as a way to create the function
emne=[]
class Emne:
def __init__(self,fagKode):
self.fagKode = fagKode
self.karakter = ""
emne.append(self)
def leggTilEmne():
nyttEmne = input("test:")
nyttEmne=Emne(nyttEmne)
expected result is that the code creates a new instance of the class.
If by choosing a name you mean your fagKode attribute, what you need is:
fagKode = input('Enter code: ')
Emne(fagKode)
You're adding the instances of Enme to the list in the constructor, so you don't need to save them to a variable.
Alternatively, you can handle that in the function:
emne=[]
class Emne:
def __init__(self,fagKode):
self.fagKode = fagKode
self.karakter = ""
def leggTilEmne():
nyttEmne = input("test:")
enme.append(Emne(nyttEmne))
I'm not sure what exactly you are asking, since you haven't responded to the comments. So,
emne=[]
class Emne:
def __init__(self,fagKode):
self.fagKode = fagKode
self.karakter = ""
emne.append(self)
def leggTilEmne(self, value): # <--- is this what you want
self.nyttEmne= Emne(value)
This is an example of when to use a class method. __init__ should not be appending to a global variable, though. Either 1) have the class method append to a class attribute, or 2) have it return the object and let the caller maintain a global list.
emne = []
class Emne:
emne = []
def __init__(self, fag_kode):
self.fag_kode = fag_kode
self.karakter = ""
#classmethod
def legg_til_emne_1(cls):
nytt_emne = input("test:")
cls.emne.append(cls(nytt_emne))
#classmethod
def legg_til_emne_2(cls):
nyttEmne = input("test:")
return cls(nyttEmne)
Emne.legg_til_emne_1() # Add to Emne.emne
e = Emne.legg_til_emne_2()
emne.append(e)
I am trying to use the "setx" function of a Property in a Class to do some processing of date information that I get from excel. I have a few of my own functions that do the data processing which I tested outside the class, and they worked just fine. But when I move them into the class they suddenly become invisible unless I use the self. instance first. When I use the self.My_xldate_as_tuple() method I get an error:
My_xldate_as_tuple() takes 1 positional argument but 2 were given
Even though the code is EXACTLY what i used outside the class before and it worked.
Before moving into the Property Set block, I was doing the processing of date data outside of the class and setting the variables from outside of the class. That gets clunky when I have about 15 different operations that are all based on when the NumDates Property change. I'm showing shortened versions of both the working set of code and the non-working set of code. What is going on with the self. call that changes how the function takes inputs?
Broken Code:
class XLDataClass(object):
_NumDates = []
TupDates = []
def getNumDates(self): return self._NumDates
def setNumDates(self, value):
self._NumDates = value
self.TupDates = list(map(self.My_xldate_as_tuple,value)) #Error here
#This version doesn't work either, since it can't find My_xldate_as_tuple anymore
self.TupDates = list(map(My_xldate_as_tuple,value))
def delNumDates(self):del self._NumDates
NumDates = property(getNumDates,setNumDates,delNumDates,"Ordinal Dates")
#exact copy of the My_xldate_as_tuple function that works outside the class
def My_xldate_as_tuple(Date):
return xlrd.xldate_as_tuple(Date,1)
#Other code and functions here
#end XlDataClass
def GetExcelData(filename,rowNum,titleCol):
csv = np.genfromtxt(filename, delimiter= ",")
NumDates = deque(csv[rowNum,:])
if titleCol == True:
NumDates.popleft()
return NumDates
#Setup
filedir = "C:/Users/blahblahblah"
filename = filedir + "/SamplePandL.csv"
xlData = XLDataClass()
#Put csv data into xlData object
xlData.NumDates= GetExcelData(filename,0,1)
Working Code:
class XLDataClass(object):
NumDates = []
TupDates = []
#Other code and functions here
#end XlDataClass
#exact copy of the same function outside of the class, which works here
def My_xldate_as_tuple(Date):
return xlrd.xldate_as_tuple(Date,1)
def GetExcelData(filename,rowNum,titleCol):
csv = np.genfromtxt(filename, delimiter= ",")
NumDates = deque(csv[rowNum,:])
if titleCol == True:
NumDates.popleft()
return NumDates
#Setup
filedir = "C:/Users/blahblahblah"
filename = filedir + "/SamplePandL.csv"
xlData = XLDataClass()
#Put csv data into xlData object
xlData.NumDates = GetExcelData(filename,0,1)
#same call to the function that was inside the Setx Property of the class, but it works here.
xlData.TupDates = list(map(self.My_xldate_as_tuple,value))
Instance methods in Python require an explicit self in the argument list. Inside the class, you need to write your method definition like:
def My_xldate_as_tuple(self, Date):
I am writing a code for a project in particle physics (using pyroot).
In my first draft, I use the following line
for i in MyTree:
pion.SetXYZM(K_plus_PX, K_plus_PY, K_plus_PZ,K_plus_MM)
This basically assigns to the pion the values of variables in the parenthesis, ie momenta and inv. mass of the kaon.
Physics aside, I would like to write a function "of the form":
def myfunc(particle):
return %s_PX % particle
I know this is wrong. What I would like to achieve is to write a function that allows, for a given particle, to set particle_PX, particle_PY etc to be the arguments of SetXYZM.
Thank you for your help,
B
To access class attributes from string variables you can use python's getattr:
import ROOT
inputfile = ROOT.TFile.Open("somefile.root","read")
inputtree = inputfile.Get("NameOfTTree")
inputtree.Print()
# observe that there are branches
# K_plus_PX
# K_plus_PY
# K_plus_PZ
# K_plus_MM
# K_minus_PX
# K_minus_PY
# K_minus_PZ
# K_minus_MM
# pi_minus_PX
# pi_minus_PY
# pi_minus_PZ
# pi_minus_MM
def getx(ttree,particlename):
return getattr(ttree,particlename+"_PX")
def gety(ttree,particlename):
return getattr(ttree,particlename+"_PY")
def getz(ttree,particlename):
return getattr(ttree,particlename+"_PZ")
def getm(ttree,particlename):
return getattr(ttree,particlename+"_MM")
def getallfour(ttree,particlename):
x = getattr(ttree,particlename+"_PX")
y = getattr(ttree,particlename+"_PY")
z = getattr(ttree,particlename+"_PZ")
m = getattr(ttree,particlename+"_MM")
return x,y,z,m
for entry in xrange(inputtree.GetEntries()):
inputtree.GetEntry(entry)
pion1 = ROOT.TLorentzVector()
x = getx(inputtree,"K_plus")
y = gety(inputtree,"K_plus")
z = getz(inputtree,"K_plus")
m = getm(inputtree,"K_plus")
pion2.SetXYZM(x,y,z,m)
x,y,z,m = getallfour(inputtree,"pi_minus")
pion2 = ROOT.TLorentzVector()
pion2.SetXYZM(x,y,z,m)
As linked by Josh Caswell, you can similarly access variable names:
def getx(particlename):
x = globals()[partilcename+"_PX"]
though that might get nasty quickly as of whether your variables are global or local and for local, in which context.