Python class (Python learning memo ⑦)

About scopes and namespaces

Namespace

point

• Namespace is the correspondence between names and objects.
• Attributes associated with namespaces are connected with dots like ʻobj.attribute`

scope

point

• A scope is a range in the program text that can be accessed directly from a namespace with scope.
• The reference order of the scope is as follows
• Scope with local name
• If there is a function surrounding ↑, the scope of that function
• Global scope of current module
• The outermost scope is the scope with the built-in name
• Assignments and deletions are always done in the innermost scope unless the global statement is used.
• Use the global statement to indicate that the variable is in global scope
• nonlocal minutes indicate that the variable is in the scope surrounding the current scope

Scope and namespace examples

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"
    spam = "test spam"
    
    do_local()
    print("After local assignment:", spam)
    # After local assignment: test spam
    
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    # After nonlocal assignment: nonlocal spam
    
    do_global()
    print("After global assignment:", spam)
    # After global assignment: nonlocal spam

scope_test()
print("In global scope:", spam)
# In global scope: global spam

Class definition

Class definition syntax

Class definition

class className:
    <Sentence 1>
    .
    .
    .
    <Sentence N>

point

• When you enter the class definition, a new namespace will be created Used as a local scope (local variables, local functions are in this scope)
• A class object is created when the class definition finishes executing (basically it's just a wrapper that wraps the namespace)

Class object

point

• Class objects support two types of operations: attribute reference and instantiation.
• Attribute reference is done in the form of ʻobj.name`
• Attribute references are all names that exist in the class namespace (MyClass.i and MyClass.f are valid in the following cases)

Attribute reference

class MyClass:
    """A simple example class"""
    i = 12345
    def f(self):
        return 'hello world'

• Class instantiation is called like a function

Class instantiation

x = MyClass()

• At this time, if the __init __ () method is defined, __init () __ will be called automatically for the newly created instance.

__init__()function

    def __init__(self):
        self.data = []

• Arguments can be given to the __init __ () function
• As the argument, the argument given at the time of instantiation of the class is used.

Class instantiation(With arguments)

class Human:
    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

x = Human(165, 55)
print('height:', x.height, 'weight:', x.weight)
# height: 165 weight: 55

Instance object

point

• Instance has two attribute references, "data attribute" and "method"

Data attribute and method references

class MyClass:
    def __init__(self):
        pass
    def f(self, word):
        print(word)
        
x = MyClass()

#Add / reference data attributes
x.counter = 1 #Data attributes do not need to be declared in advance
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter) # 16
del x.counter

#Method reference
x.f("hello kawauso")

Method object

• Methods can be stored in variables
• The feature of the method is that the instance object is passed as the first argument.
• Calls to x.f () are equivalent to MyClass.f (x)

Store method object in variable

xf = x.f
xf('hello kawauso again') #output: hello kawauso again

Class variables and instance variables

point

• There are class variables common to the class and instance variables unique to each instance.
• Do not make class variables that need to be changed for each instance.

Examples of class and instance variables

class Dog:
    
    kind = 'Shiba' #Class variables
    
    def __init__(self, name):
        self.name = name #Instance variables
        
        
taro = Dog('Taro')
jiro = Dog('Jiro')

#Reference to class variables
print(taro.kind) #Shiba
print(jiro.kind) #Shiba

#Instance variable reference
print(taro.name) #Taro
print(jiro.name) #Jiro

Various other

point

• Data attributes will override the method with the same name, so avoid duplicate names with naming conventions, etc.
• Data attributes can be manipulated from anywhere (not hidden by class)
• The first argument of the method is customarily self (not a reserved word, but everyone is used to it)
• The global scope of a method is the module in which the method is defined (the class is never used as a global scope)
• Of course, functions and modules imported into the global scope can also be used.
• The method class itself is also defined in the global scope, so it can be referenced.

Inheritance

Class inheritance

point

• Inheritance passes the base class name as a class argument
• Can be passed from another module

Inheritance sample

class base():
    def a(self):
        print('I base.is a.base.Call b')
        self.b()
    def b(self):
        print('I base.b.der.Overridden with b')

class der(base):
    def b(self):
        print('I der.b.')


b = base()
d = der()

b.a()
#I base.is a.base.Call b
#I base.b.der.Overridden with b

d.a()
#I base.is a.base.Call b
#I der.b.

• Use the built-in function ʻis instance (obj, int)` to check the instance type
• Use ʻissubclass ()` to check class inheritance

Multiple inheritance

point

• Python allows class definition with multiple base classes

• There seems to be volume, so I will summarize this separately

Private variables

point

• Python does not have private instance variables that can only be accessed from inside the object
• By convention, names prefixed with _ are private parts of the API
• For class private members, there is a mechanism called name mandaring to prevent name collisions with subclasses.
• This replaces all identifiers of the form __spam with the form of _classname__spam

Name mandaring example

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable)

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update #↑ update()Private copy of method

class MappingSubclass(Mapping):
    # update()While offering a new signature of
    #Existing__init__()Can be used without destroying
    def update(self, iterable):
        for item in zip(keys, values):
            self.items_list.append(item)

Other things

• It is convenient to use an empty class definition when filling in named data items.

class Employee:
    pass

john = Employee()

john.name = 'Jhon Doe'
john.dept = 'computer lab'
john.salary = 1000

• It's common to pass a class that emulates a method of a particular data type to Python code that assumes that data type. For example, if you define a read () or readline () method in a class that gets data from a string buffer, you can pass it as an argument to a function that receives and formats data from a file object.
• Instance method objects also have attributes. For the method m (), the instance object is m.__self__ and the function object corresponding to the method is m.__ func__.

Exceptions are also classes

point

• User-defined exceptions are also classes, so you can use them to create an extensible hierarchical exception system.

Iterator

point

• The for statement internally calls ʻiter ()` on the container object.
• The iterator object has __next__ (), which throws a StopIteration exception when the elements are exhausted, and the for loop ends in response.
• In order to add iterator behavior to your own class, you can use this mechanism and define it as follows.

__iter__()When__next__()

# __next__()Returns an object with a method__iter__()Define a method
#Already__next()__In the class defined by__iter__()Just return self
class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

rev = Reverse('spam')
iter(rev)

for char in rev:
    print(char)

# m
# a
# p
# s

generator

point

• Generator is a simple tool for creating iterators
• Write like a normal function, but use yield in the part that returns data
• Every time next () is called, the generator will return to where it left off last time.
• The generator automatically generates the __iter__ () and __next__ () methods, so it's easy to generate iterators.
• The generator automatically saves local variables and execution state between calls
• The generator automatically sends a Stop Iteration when finished

Generator example

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]

for char in reverse('golf'):
    print(char)

# f
# l
# o
# g

Generator type

point

• If it is a simple generator, use () to easily apply it.

Generator expression example

sum(i*i for i in range(10)) #Squared total

xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec)) #inner product

from math import pi, sin
#sin table
sine_table = {x: sin(x*pi/180) for x in range(0, 91)}

#Unique words on the page
unique_words = set(word for line in page for word in line.split())

#Alumni president
valedictorian = max((student.gpa, student.name) for student in graduates)

data = 'golf'
list(data[i] for i in rage(len(data)-1, 1, -1))