python-构造函数中的另一个类

Question

I'm new to Python and I'm having a hard time understanding how I can do the following in Python (eg how I would do in Java)

class Person{ 
 private String name;
 private Address address; 
 public Person(String xyz, Address a) {
    this.name = xyz;
    this.address = a;
}

 .... 
}

Answer 1

I don't know why you think there is another class inside the constructor, but above Java could would look like this in Python:

class Person (object):
    def __init__ (self, xyz, a):
        self.name = xyz
        self.address = a

As a dynamically typed language, Python does not need to know what types look like when the code compiles. Instead, it dynamically creates objects, and adds properties whenever needed. This allows you not only to add instance fields in the initializer that were not declared before, but also allows you to add things after an object was created:

x = Person("poke", "My address")
x.phoneNumber = "012345679"

Answer 2

Like @poke mentioned, you can do:

class Person (object):
    def __init__ (self, xyz, a):
       self.name = xyz
       self.address = a

If you mean also having the default constructor, then you can have something like:

class Person (object):
    def __init__ (self, xyz=None, a=None):
       self.name = xyz
       self.address = a

Which will allow you to call the constructor with no arguments.

You can use the constructor as:

p = Person("yadda","bla")

or

p = Person()

Answer 3

something like this:

class Person(object):
    def __init__(self, xyz, a):
        self.name = xyz
        self.address = a
    # ...

now, of course you can define a new class inside the constructor:

class Person(object):
    def __init__(self, xyz, a):
        self.name = xyz
        self.address = a
        class Glass(object):
            def __init__(self):
                self.glass_name = xyz
                #... whatever - but what purpose would this serve?
    # ...

Answer 4

Python doesn't really have private variables, everyone is treated like adults in regards to member access however you would probably end up implementing getter / setter methods anyway. Note the _ variable name prefix is just a PEP-8 naming convention for "private" variables although it doesn't actually stop access to them.

class Person(object): # subclass object for a new-style class
    def __init__(self, name, address):
        self._name = name
        self._address = address

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

    @property
    def address(self):
        return self._address

    @address.setter
    def address(self, address):
        self._address = address