Get All Instance Variables Declared in Class

Get all instance variables declared in class

You can use instance_variables:

A.instance_variables

but that’s probably not what you want, since that gets the instance variables in the class A, not an instance of that class. So you probably want:

a = A.new
a.instance_variables

But note that just calling attr_accessor doesn’t define any instance variables (it just defines methods), so there won’t be any in the instance until you set them explicitly.

a = A.new
a.instance_variables #=> []
a.ab = 'foo'
a.instance_variables #=> [:@ab]

View all instance variables currently available? (Ruby)

@foo = 3
instance_variables # => [:@foo]

instance variables declared in a python class outside methods with type hinting

It is the normal interplay of class variables and instance variables. It has nothing to do with typing.

class Quux:
    foo = 1
    bar = 2

    def __init__(self):
        self.bar = 3
        self.baz = 4

quux = Quux()
Quux.foo    # => 1   - class variable
Quux.bar    # => 2   - class variable
quux.foo    # => 1   - class variable, because no instance variable
quux.bar    # => 3   - instance variable shadowing the class variable
quux.baz    # => 4   - instance variable

Your error is the wording here:

captain: str = 'Picard'               # instance variable with default

captain is not an instance variable here. This defines a class variable, which acts as a default when a corresponding instance variable is not set. But the class variable and the instance variable are two separate things.

Note that typing is only ever evaluated by static type checkers, never by Python interpreter itself. Thus, there cannot be any runtime semantic difference between these two:

class CheckedQuux:
    foo: Dict[str, int] = {}
    bar: ClassVar[Dict[str, int]] = {}

At runtime, they are both assignments of an empty dictionary to a class variable. If the annotation made it so that one of them defined an instance variable and the other a class variable, it would violate the rule that typing can't have runtime effect. The comment under ClassVar is misleading, though the text gives hints about what is meant: the annotation serves to indicate the intent of how the variable will be used. The type checker is to assume that foo above will be accessed from the instance (checked_quux.foo) and will presumably be shadowed over by an instance variable, while bar should not be accessed on the instance, but only class (CheckedQuux.bar) and should raise a type check error if we tried to access it on an instance (checked_quux.bar)

Are all instance variables declared outside functions?

If you declare a variable inside a method, it's a local variable belonging to that method. It will go out of scope when the method is terminated. The only way to have a variable belong to an instance is to declare it directly under the class - i.e., outside of any method.

EDIT:

Here's a sample, as suggested by @Yeikel:

public class MyClass {

    private static int iAmAStaticMember = 1;

    private int iAmAnInstanceMember;

    public void someMethod() {
        int iAmALocalVariables = 4;
    }
}

Is there a way to get to all variables of a certain type in a class?

Your code "compiles" to this:

var MyClass = (function () {
    function MyClass() {
    }
    return MyClass;
}());

with nothing in there as you can see... however if you initialize your properties it will result some like this:

source TS:

class MyClass {
    myNum1: number = 0;
    myNum2: number = 0;
    myNum3: number = 0;
    myString: string = "";
    myBoolean: boolean = false;
}

result JS:

var MyClass = (function () {
    function MyClass() {
        this.myNum1 = 0;
        this.myNum2 = 0;
        this.myNum3 = 0;
        this.myString = "";
        this.myBoolean = false;
    }
    return MyClass;
}());

then you can check instance properties:

var instance = new MyClass();
Object.keys(instance) //["myNum1", "myNum2", "myNum3", "myString", "myBoolean"]
instance["myNum1"] // 0

with that in mind you can filter the properties that you need:

var numerics = Object.keys(instance).map(k => instance[k]).filter(v => v.constructor === Number)
console.log(numerics) //[0, 0, 0]

How to get instance variables in Python?

Every object has a __dict__ variable containing all the variables and its values in it.

Try this

>>> hi_obj = hi()
>>> hi_obj.__dict__.keys()

Output

dict_keys(['ii', 'kk'])

Why Are the Instance Variables Declared in the Main Method?

Variables defined within a method are local variables, they belong to an invocation of the method, not to an instance of an object.

The intent seems to be to provide an example that is understandable to beginners who haven't been introduced to constructors, instance variables, and methods. They want to teach local variable declaration, some simple calculating and if-statements, and printing to the console before getting into that other stuff.

As an exercise it would be fine for you to change the CarLoan class to give it instance variables, just to see another way to do it. Keep the variable values hard-coded, make an instance method that calculates the monthly payment, and have the main method print the result to the console.

How to print the instance variables of a class with name and value?

Thanks to Divya Sharma, I've found the method I was looking for:

#instance_variable_get

I used in the following way (regarding my question):

support_case.instance_variables.each { |ivar| puts "#{ivar}: #{support_case.instance_variable_get(ivar)}" }

Can Instance variables be declared at the bottom of the Class?

I think they mean that this is legal:

 public class Test {
    private int someValue;

    public int myMethod() {
        return someValue + anotherValue;
    }

    private int anotherValue;
 }

(And it is!)

However, I think it is a mistake for the site to describe this as "[i]nstance variables can be declared in class level before or after use".

1. The phrase "declared in class level" is bad English grammar.

2. The phrase "in class level" is ambiguous. It could mean declared in the body of a class. However, it could also mean declared as "class-level" (i.e. static) variables. (That is contradictory, and incorrect, but ...)

3. The phrase "before or after use" is ambiguous. It could mean before or after in the source code file. It could also mean in before or after in the temporal sense. (That would be incorrect. At runtime, all of an object's instance variables are declared and initialized before the code in a method or constructor body is executed.)

---

While what they are trying to say (I think) in that sentence is correct, they have expressed themselves poorly, and it is clearly causing confusion for some readers.

---

Related Topics