Understanding In-Class Python Classes

It's working, but it's obvious that you're wasting your memory, and I think there's another better way.
Could you lend me your knowledge? What I want to do is
data.generate.mu_sigma()
Generate and modify parameters as shown in
data.mu
Browse the data as .

The reason is
data.generate_mu_sigma(self)
In such a way, searching by predictive interpolation is difficult.
data.generate.
data.generate2.
Because I want to try other methods of generation by making things like that.

I thought it would be good to use the .py file as a module, but sometimes I wonder if the value is not maintained as an object.

I would be happy if I could create another class that declares only a mold like the structure of c, and a class that mainly deals with processing, but would it be it would be impossible.

I look forward to your kind cooperation.

import numpy as np
class test_data:
    def_init__(self, n_samples, dim):
        class generate:
            def_init__(self, n_samples, dim):
                self.n_samples=n_samples
                self.dim = dim
                self.mu = 0.0
                self.sigma = 0.0

            defmu_sigma(self):
                self.mu=np.random.uniform (low=-2.0, high=2.0, size=self.dim)
                self.sigma=np.random.uniform (low=1.0, high=2.0, size=self.dim)

        self.n_samples=n_samples
        self.dim = dim
        self.generate=generate(n_samples, dim)
        self.generate.mu_sigma()
        self.mu = self.generate.mu
        self.sigma = self.generate.sigma

data=test_data(n_samples=10, dim=2)
print(data.generate.mu)
print(data.mu)

Results
[0.97730724 1.0678634]
[0.97730724 1.0678634]

python python3

2022-09-30 21:23

2 Answers

For your information, how to use a function that returns named table instead of inner class.

import collections
import numpy as np

class test_data:
  def_init__(self, n_samples, dim, generator):
    self.n_samples=n_samples
    self.dim = dim
    self.generate=generator(n_samples, dim)
    self.mu = self.generate.mu
    self.sigma = self.generate.sigma

def generator(n_samples, dim):
  generate=collections.namedtuple('generate', ['mu', 'sigma'])
  US>return generate(
    mu=np.random.uniform (low=-2.0, high=2.0, size=dim),
    sigma=np.random.uniform (low=1.0, high=2.0, size=dim))

data=test_data(n_samples=10, dim=2, generator=generator)

print(data.generate.mu)
print(data.mu)

2022-09-30 21:23

I'm not sure why you want to define classes within a class.Why don't you just define two classes and transfer the processing from the test_data class to the internal generate class?

import numpy as np

class GenerateData:

    def_init__(self, n_samples, dim):
        self.n_samples=n_samples
        self.dim = dim

    @property
    defmu(self):
        return np.random.uniform (low=-2.0, high=2.0, size=self.dim)

    @property
    def sigma(self):
        return np.random.uniform (low=-2.0, high=2.0, size=self.dim)

class TestData:

    def_init__(self, n_samples, dim):
        self.generate_data = GenerateData(n_samples, dim)

    @property
    defmu(self):
        return self.generate_data.mu

    @property
    def sigma(self):
        return self.generate_data.sigma

test=TestData(n_samples=10, dim=2)

print(test.mu)
print(test.sigma)

2022-09-30 21:23

If you have any answers or tips

Popular Tags

python x 4647

android x 1593

java x 1494

javascript x 1427

c x 927

c++ x 878

ruby-on-rails x 696

php x 692

python3 x 685

html x 656