Core syntax Python – Class 02

Instance variables and class variables

There are two types of variables related to Python classes: instance variables and class variables. In addition, some intermediate variables may be used in the instance method. These intermediate variables can only be used in an instance method. They are ordinary variables. Global variables can be used in all instances.

1. Instance variable
The non ordinary variable defined in the instance method is the instance ratio, also known as "instance attribute". The instance variable can be called by the method that defines it or by other methods in the class. The calling form is: self. Variable
Instance variables cannot only be__ init__ () defined by the method.
For example, in the Gamer class, four instance variables are defined: the variable name representing the name, the variable number representing the number, the variable sex representing the gender, and the variable score representing the score. They are all constructed by the constructor
(initialization method) defined by init(). Of course, in other instance methods, instance variables can also be defined.
As follows:

class Mm(object):
    def __init__(self,name):
        self.name = name

    def setmm(self,age):
        self.age = age
    def show(self):
        print(self.name,self.age)
a1 = Mm('shh')
a1.setmm(34)
a1.show()
print(a1.name,a1.age)

In the above example, two instance variables - name and age are defined in two different ways. Instance variables can be referenced by instances within or outside a class. There are two methods to reference instance variables:
The first method refers to the instance variable in the class. Its syntax form is: self. Instance variable
For example: self.name = "Zhang Junying"
The second method refers to the instance variable outside the class. Its syntax form is: instance. Instance variable
For example, a1 = Gamer('101 ',' Junying ', 20)
a1.score += 10
2. Class variable
The so-called "class variable" refers to the variable defined separately in the class, but not in any method of the class. It is also called "class attribute", which is different from the instance attribute. For example, the two variables top defined in the Gamer class_ Score and games are class variables.
Class variables can be shared by all instances of a class.
Class variables are often not referenced as frequently as instance variables.
Class variables can be referenced by classes inside or outside the class, but class variables can only be referenced by classes. The method of referencing class variables is as follows:
(1) Intra class reference intra class variable syntax: cls. Class variable
cls.gamers +=1
(2) Syntax for referencing class variables outside a class: class. Class variables
a1 = Gamer('101','Junying',20)
Gamer.gamers += 1

3. Relationship between instance variables and class variables
The relationship between instance variables and class variables is as follows:
(1) Instance variables are owned by each instance, and the instance variables of each instance are independent of each other; Class variables can only be owned by classes.
(2) If the instance variable has the same name as the class variable, the instance variable takes precedence over the class variable. Therefore, instance variables mask class variables. In other words, instance variables are used first.

Private properties and private methods
1. Private properties and methods
If a property or method name begins with a double underscore "_", the property or method cannot be accessed outside the class. They are called private properties and private methods
2. Built in properties and methods
If a property or method is defined in the form of "xxx", that is, there are double underscores before and after, the property or method can be accessed outside the class. In Python classes, attributes and methods defined in the form of "xxx" are special attributes and special methods,
They are called built-in properties and built-in methods.
In general, do not define common attributes in the form of "xxx",
Python has ordered several special properties and methods. All Python classes have the following built-in properties and can be accessed like any other property.
dict: dictionary containing the namespace of the class
doc: dictionary containing the namespace of the class
Name: class name
mmodule: defines the module name of the class. Under this attribute, the value in interactive mode is "main"
__ bases: a tuple containing a base class. Tuple elements are arranged in the order in which they appear in the base class list.

Private property case
A property that begins with a double underscore is private, so it cannot be used or accessed directly outside the class.

class Mytester(object):
    def __init__(self,dat1,dat2):
        self.__dat1 = dat1   #Private property
        self.dat2 = dat2
    def get_dat1(self):
        return self.__dat1

if __name__ == '__main__':
    test1 = Mytester(10,18)
    print(test1.dat2)
    """
    print(test1.__dat1)
      File "D:\Python\pycharm\pycharm_code\Class_Python02.py", line 120, in <module>
    print(test1.__dat1)
AttributeError: 'Mytester' object has no attribute '__dat1'
    """
    print(test1._Mytester__dat1)
    print(test1.get_dat1())
    print(test1.__dict__)

There are two ways to access private properties outside the class:

1,
Change print (test1. _dat1) to print (test1. _mytester_dat1)
2,
Change print (test1. _dat1) to print(test1.get_dat1())

Private properties cannot be inherited
How to view all properties

print(test1.__dict__)

Although private properties can be accessed outside the class, do not access them. It can be considered that private properties cannot be accessed directly outside the class. Just remember!

Private method

class Person(object):
    def __init__(self):
        self.__name ='Zhang San'    #Private property
        self.age = 22
    def __get_name(self):      #Private method
        return self.__name

    def get_age(self):          #public Method 
        return self.age
if __name__ == '__main__':
    p1 =Person()
    print(p1.get_age())
 
 """
    print(p1.__get_name())
    Traceback (most recent call last):
  File "D:\Python\pycharm\pycharm_code\Class_Python02.py", line 154, in <module>
    print(p1.__get_name())
AttributeError: 'Person' object has no attribute '__get_name'
"""

It is recommended that you do not use private properties and private methods outside your class

Use of classes

Classes without default properties and their use
Create a class:
Object 1 = class (parameter 1, parameter 2,...)

Access the properties of the instance or class and call the methods of the instance or class in the following forms.
(1) The form of accessing instance properties is: object. Instance properties
(2) The form of accessing class attributes is: class. Class attribute
(3) The form of calling instance method is: object. Instance method
(4) The form of calling class method: class. Class method or class. Class static method

#case
class Gamer(object):
    """
    Gamer
    So and so
    """
    top_score = 0   #Class variable
    gamers = 0

    #Static method
    @staticmethod
    def show_help():   #Methods that do not require class variables and instance variables
        print("This is a guessing game (1)-100 Integer)")
        print("You can have three players at the same time")
        print("Who is closest and who scores the highest")
        print("If it is exactly the same, 10 points will be given, with an error of 10 points%Within 8 points, 20 points%6 points")
        print("The error is 30%Within 5 points, otherwise no point will be given")

    #Class method
    @classmethod
    def show_top_score(cls):
        print("The highest score of the game is:%d"%cls.top_score)
    @classmethod
    def show_gamers(cls):
        print("Total gamers:%d"%cls.gamers)

    def test():
        print("kkkk")

    #Constructor (initializing an instance of a class)
    def __init__(self,number,name,sex):
        self.name = name
        self.number = number
        self.sex = sex
        self.score = 0
        Gamer.gamers += 1

    #How to start the game
    def start_game(self):
        self.age = 16
        print("{}Start the game".format(self.name))

    #Case scoring method
    def add_score(self,score):
        self.score += score

    #Get instance score method
    def get_score(self):
        # self.add_score(s)
        return self.score

Gamer.show_help()  #Call class method
a1 = Gamer("101",'Junying',18)   #Create instance a1
a1.start_game()                         #Call instance method
a1.add_score(10)
print(a1.get_score())
print(a1.add_score(10))
print(a1.get_score())
print(Gamer.gamers)
a2 = Gamer('102','Yd',19)
Gamer.show_top_score()
Gamer.show_gamers()
a1.age          #Access instance properties

print(Gamer.__dict__)
print(Gamer.__doc__)
print(Gamer.__module__)
print(Gamer.top_score)

Classes with default properties and their use
When defining a class, you can set default values for instance properties. If the actual parameters are omitted when the method is called, the corresponding instance properties are set to the default values.

class Food(object):
    """
    Takeout
    #Attributes: customer, address, mobile phone number, number of copies, discount

    """
    def __init__(self,name,address,moblile,discount=1):  #No discount by default
        self.name = name
        self.address = address
        self.mobile = moblile
        self.discount = discount

    #Cost calculation method
    def cacl_all(self,servings=1):  #The number of copies is 1 by default
        return servings*10*self.discount
if __name__ == '__main__':
    #Customer 1
    name = input("Welcome Junying Dumpling restaurant! Hello, your name:")
    mobile = input("May I have your mobile number")
    address =input("May I have your address")
    servings = int(input("How many copies:"))

    c1 = Food(name,address,mobile) #Create instance
    print("Number of copies:{}cost:{}".format(servings,c1.cacl_all(servings)))

    #Customer 2
    name = input("Welcome Junying Dumpling restaurant! Hello, your name:")
    mobile = input("May I have your mobile number")
    address = input("May I have your address")
    servings = int(input("Number of copies:"))

    c2 = Food(name,address,mobile,0.95)  #5% off
    print("Number of copies:{}cost:{}".format(servings,c2.cacl_all(servings)))

Combination of classes

#Combination of classes
class Food2(object):
    """
    Food category
    Attribute: product name, discount, unit price, copies
    """
    def __init__(self,name,discount,price,servings):
        self.name = name
        self.discount = discount
        self.price = price
        self.servings = servings

class Customers(object):
    """
    Customer class
    Attribute: name, address, mobile number
    """
    def __init__(self,name,adress,mobile):
        self.name = name
        self.adress =  adress
        self.mobile = mobile

    #How to order food
    def order_food(self,fname,servings,fprice,discount):
        return Food2(fname,servings,fprice,discount)

    #Method of calculating total customer cost
    def cacl_all(self,flist):     #flist is the customer order
        money = 0
        for dd in flist:
            money += dd.price*dd.servings*dd.discount
        return money

if __name__ == '__main__':
    #Customer 1
    name = input("Welcome Junying Dumpling restaurant! Hello, your name:")
    mobile = input("May I have your mobile number")
    adress = input("May I have your address")

    c1 = Customers(name,mobile,adress)

    flist = []
    while True:
        fname = input("What do you need")
        servings = int(input("How many copies do you have"))
        price = eval(input("Price:"))
        discount = eval(input("Discount?"))

        flist.append(c1.order_food(fname,servings,price,discount))  #Add order

        answer = input("Do you need any more? ( y/n)")
        if answer != 'y' and answer != 'Y':
            break
    print("Thank you for your patronage!")
    print("What is your total cost%f"%(c1.cacl_all(flist))) #Call the method to calculate the total amount