# Basic python learning - week 5

## closure

### 1. Closure

```# def outer(m):  # External function, m is the formal parameter
#     def inner(n):  # Internal function, n is a formal parameter
#         Print ('value in inner function: ', m+n)
#
#     # The return value of an external function is a reference to an internal function
#     return inner
# Call external functions
# print(outer(20))  # Print out the address of the internal function < function outer. < locals >. Inner at 0x0000018fdc2d6828 >

# The first way to write:
# ot = outer(20)
# ot(30)

# The second way to write:
# outer(10)(90)
```

### 2. Function reference

```# a = 10  # The address of the integer 10 is saved in a
# print(a)

def test():
print('This is test function')

# print(test)  # < function test at 0x0000021328ba6828 > function address
# Call function
# test()

# Reference function
# te = test
# print(te)

# Calling functions by reference
# te()
```

### 3. Each time the inner function is opened, the same closure variable is used

```def outer(m):       # External function
print('out Value in function:', m)

def inner(n):   # Inner function
print('inner Value in function:', n)
return m+n  # Return the value of m+n in the inner function

return inner

# Call the external function and pass the value of 10 to the outer function
ot = outer(10)
# Call the inner function for the first time and pass the value of 20 to the inner function
print(ot(20))
# Call the inner function for the second time and pass the value of 30 to the inner function
print(ot(30))

# In the process of using closures, once the outer function is called, the reference of the inner function is returned
# Although the inner function is called every time. A function will be opened and die after execution, but there is only one closure variable. Each time the function is opened, the same closure variable is used
# Second:
# outer(10)(20)
```

## Decorator

```# def wrapper(func, fn):     # For external functions, func is a formal parameter, but the value passed in is the decorated function name: test
#     def inner():    # Inner function
#         func()       # func is actually test. func() is equivalent to calling test()
#         fn()
#
#     return inner

# # Decorated function
# def test():
#     print('comment: like ~ ')
#
# def test3():
#     print('tweet: I learned about decorators today, and I feel very Naisi ~ ')

# First:
# Decorating functions with decorators
# wr = wrapper(test, test3)
# # Call the inner function in the decorator
# wr()

# Second: use the form of grammar sugar
# Write directly: @ decorator name and put it on the head of the function to be decorated

# @wrapper
# # Decorated function
# def test2():
#     print('forward: This is fun ')

# @wrapper
# def test3():
#     print('tweet: I learned about decorators today, and I feel very Naisi ~ ')
#
# test2()
# test3()
```

### 2. The decorated function has parameters

```# def outer(fn):
#     def inner(c, d):  # c. D is the parameter in the inner function
#         print(f'{c}, {d} is the value' in the inner function)
#         fn(c, d)  # fn() is exam()
#     return inner

# @outer
# # Decorated function
# def exam(a, b):
#     print('nine songs one meter eight ')
#     print(f'{a}, {b} is the value' in the exam function)

# exam(1, 2)

# ot = outer(exam)
# ot(1, 2)
```

### 3. The decorated function has variable parameters * args **kwargs

```# def funa(hanshu):
#     def inner(*args, **kwargs):
#         print('Start executing decorated function! ')
#         hanshu(*args, **kwargs)
#         print('execution completed ')
#
#     return inner
#
# # Decorated function
# def test(*args, **kwargs):
#     print(args)
#     print(kwargs)
#
# fa = funa(test)
#
# fa('Life like water ',' Pumpkin Baby ',' Xiaobai ', name =' cappuccino ')
```

### 4. Multiple trimmers

#### First decorator

```def maketest1(fn):
def inner():
return 'I am a great fairy ' + fn() + ' Heart less'
return inner
```

#### Second decorator

```def maketest2(fn):
def inner2():
return 'Take Le home ' + fn() + ' small amount'

return inner2
```

#### Decorated function 1:

```@maketest1
def test1():
return 'Stay and make up lessons'
```

#### Decorated function 2:

```@maketest2
def test2():
return 'I'm going to change my name'
```

#### Decorated function 3:

```@maketest1   # 'I am a great immortal' + fn() + 'Xinshao' - 'I am a great immortal' + 'Bring Music Home' + 'there are no legends in the Jianghu' + 'small amount' + 'Xinshao'
@maketest2   # 'Take Le home '+ fn() +' small amount '-' take Le home '+' there are no legends in the Jianghu '+' small amount '
def test3():
return 'There are no legends in the Jianghu'
# print(test1())
# print(test2())

print(test3())
```

## object-oriented

### 2. Class - class

#### 2.1 writing method of definition class: class name hump naming method, initial capital

```# class name:
#     pass
```

#### 2.2 three elements

##### Class name: human attributes: blonde hair, wearing glasses method: eating and speaking
```# class Human:
#     hair = 'gold'   # Class properties

# Add, delete, modify and query a single attribute in a class, and operate through universal points
# print(Human.hair)        # see
# Human.hair = 'black'     # modify
# # print(Human.hair)
# Human.name = 'Bill Gates'   # increase
# del Human.hair           # delete
# print(Human.hair)
```

### 3. Add () to the object class name. This is an instantiation process, and an object will be instantiated

```# Format of instantiated object: object name = class name ()
# Instance method: called by object, with at least one self parameter; When the instance method is executed, the object calling the method is automatically assigned to self

class Person:
name = 'jiuge'  # Class properties

def speak(self):    # Example method
print('In the instance method self: ', self)  # self represents the object of the current calling method.
print('Nine songs are talking')

# Instantiated object object name = class name ()
p1 = Person()
# Print the instantiated object and display the address of the object in memory
print('First instantiated object:', p1)
# Object calls methods / properties in a class
p1.speak()
# print(p1.name)

p2 = Person()
print('Second instantiated object:', p2)
p2.speak()
```

## init and del

### 1. Instance attribute - self. Attribute name

```# class A:
#     name = 'jiuge'  # Class properties
#
#     def work(self):  # The instance method self represents the instance object itself
#         print('This is the instance method ')
#         print(f'What is the age of Jiuge{self.age}')  # self.age instance properties
```

### Instantiate object

```# Object operates on a single attribute in an object
# a = A()
# a.age = 18         # Modify instance properties
# a.job = 'python'   # Add instance properties
# print(a.job)
# a.work()
```

### 2. Construction method

#### __ init__ Method: usually used for attribute initialization or assignment; It will be called automatically when instantiating

```# class Test
#     def __init__(self):
#         print('This is init ')
#
# te = Test()
```
```# Version 1:
# class Hero:   # Hero class
#     def __init__(self):
#         self.name = 'Li Bai'         # Instance properties
#         self.hp = 500  # Life value
#         self.at = 280  # aggressivity
#
#
#     def move(self):   # Example method
#         print(f'{self.name} is moving')
#
#     def attcak(self):
#         Print (the health value of F '{self. Name} is {self.hp}, which sends out a green lotus sword song {self.at}')
#
# # Instantiate object
# hero = Hero()

# hero.move()
# hero.attcak()

# Version 2:
# class Hero:   # Hero class
#     def __init__(self, name, hp, at):
#         self.name = name         # Instance properties
#         self.hp = hp  # Life value
#         self.at = at  # aggressivity
#
#
#     def move(self):   # Example method
#         print(f'{self.name} is moving')
#
#     def attcak(self):
#         Print (the health value of F '{self. Name} is {self.hp}, which sends out a move {self.at}')
#
# # Instantiate object
# hero = Hero('li Bai ', 200, 100)
#
# hero.move()
# hero.attcak()
#
# hero2 = Hero('pig man ', 100, 50)
# hero2.move()
# hero2.attcak()
```

### Summary:

##### Class attribute, instance attribute
###### 3. Class attribute, which can be accessed by class and instance object; Instance property, class cannot be accessed, instance object can be accessed
```# class A:
#     num = 10  # Class properties
#     def __init__(self, name):
#         self.name = name   # Instance properties
#
#     def test(self):  # Example method
#         print(f 'I am {self.name}')
#
#
# print('first instantiation object ----- ')
# a = A('so love will disappear, right ')
# a.test()
# print(A.num)  # View class properties by class name
# # print(a.num)  # Viewing class properties through objects
#
# # print(A.name)   # View instance properties by class name (error report)
# # print(a.name)   # Viewing instance properties through objects
#
# print('second instantiation object ----- ')
# a1 = A('nine songs')
# a1.test()
# print(A.num)
```

### 3. Deconstruction method – del

#### When an object is deleted, the interpreter calls the del method by default

```# class Person:
#     def __init__(self):
#         print('I am the init method ')
#
#     def __del__(self):
#         print('destroyed ')
#
# p = Person()
# print('This is the last sentence ')
# During normal operation, the del method will not be called, and "this is the last sentence" will be printed. After the object execution is completed, the system will automatically execute the del method
```

class Person:
def init(self):
print('I am the init method ')

```def __del__(self):
print('Destroyed')
```

p = Person()
del p # delete objects
print('This is the last sentence ')

### 1. Object oriented review

```# class Test:
#     thing = 'attend class;class begins'  # Class properties
#
#     def __init__(self, name):   # init initialization
#         print('This is init')  # When creating an object, the init method will be called automatically
#         self.name = name  # Instance properties
#
#     def speak(self):      # Example method
#         print(f'{self.name} is lecturing')
```
```# Instantiated object object name = class name ()
# te = Test('small ')
# te.speak()

# print(te.thing)
# print(Test.thing)

# print(te.name)  # Access instance properties through objects
# print(Test.name)  # Cannot access
```

### 2. Packaging

#### 2.2 private is defined in the class, which is only used inside the class and cannot be accessed outside

##### Private permissions: precede the property name and method name with two underscores_
```# class Person:
#     name = 'jiuge'  # Class properties
#     __age = 18      # Private property
#
#     def funa(self):  # Example method
#         print('Access class attribute in instance method ', Person.name)
#         print('Access private property in instance method ', person. _age)
#
#
# pe = Person()
# print(pe.name)
# # Private attribute: external cannot be accessed directly
# # The first: understand, but it's best not to do so
# # _ Class name__ Private property name
# # print(pe._Person__age)
#
# # Second: access inside the class
# pe.funa()
```

#### 2.3 private attributes and methods

```# _ xx: start with a single underscore, declare private properties / methods, and class objects and subclasses can be accessed
# __ xx: it starts with a double underscore, private permission, and cannot be accessed directly from the outside

# class Person:
#     name = 'jiuge'  # Class properties
#     _sex = 'female'      # Private attribute (single underline)
#     __age = 18      # Private attribute (double underline)
#
# pn = Person()
# print(pn._sex)
```

# Private method

```class Human:
def __play(self):  # Private method
print('play with the smarthphone')

def funb(self):  # Example method
print('This is the instance method')
# Human.__play(self)  # Calling private methods in instance methods
self.__play()
ha = Human()
ha.funb()
```

## 1.1 single inheritance

```# class Animal:   # Animals - parent
#     def eat(self):
#         print('--- eat --')
#
#     def sleep(self):
#         print('--- sleep --')
#
#
# class Pig(Animal):  # Pigs - subclasses
#     pass   # placeholder
#
# class Dog(Animal):  # Dogs - subclasses
#     pass
#
# dog = Dog()
# dog.eat()
# dog.sleep()
```

### 1.2 transitivity of inheritance

```# Class A/B/C Class C (subclass) inherits from class B (parent class), class B (subclass) inherits from Class A (parent class), and class C has the properties and methods of class A/B
# A subclass has all the properties and methods in the parent class and the parent class of the parent class
# class A:      #  Parent class of parent class --- grandpa
#     def eat(self):
#         print('--- eat --')
#
#     def sleep(self):
#         print('--- sleep --')
#
#
# class B(A):   #  Parent - Dad
#     def study(self):
#         print('--- learn -')
#
#
# class C(B):   # Subclass - son
#     pass
#
# c = C()
# c.study()
# c.eat()
```

### 2. Rewrite

#### 2.1 override parent class method: define a method with the same name as the parent class in the subclass, which will call the method overridden by the subclass

```# class Person:   # Parent class
#     def work(self):
#         print('accept the test of society ')
#
#
# class Son(Person):  # Subclass
#     def work(self):
#         print('accept the beating of society ')
#
# son = Son()
# son.work()
```

# 1. Parent class name. Method name (self)

```# class Person:   # Parent class
#     def work(self):
#         print('accept the test of society ')
#
#
# class Son(Person):  # Subclass
#     def work(self):
#         Person.work(self)
#         print('but it was later found that he was beaten by the society ')
#         print(123)
#
# son = Son()
# son.work()
```

### 2.super(). Parent class method name ()

#### Super in python is a special class. super() is an object created with super class. You can call the methods in the parent class

```# class Animal():    # Parent class
#     def __init__(self, name):
#         self.name = name
#
#     def bark(self):
#         print(f'{self.name} is calling')
#
#     def paly(self):
#         print('can play ')
#
# class Dog(Animal): # Subclass
#     def bark(self):
#         # super().bark()
#         super().paly()   # You can call other methods in the parent class
#         print(f'{self.name} barking')
#
# dog = Dog('husky ')
# dog.bark()

# 3. New class writing method: there is no difference between the three writing methods. class A(object) is recommended:
# class A:
# class A():
# class A(object):
```

### object is the base class provided for all objects in python and provides some built-in properties and methods

Tags: Python crawler

Posted on Fri, 19 Nov 2021 09:08:28 -0500 by kwilameiya