嵌套函数（nonlocal，LEGB规则），面向对象编程，类和实例

嵌套函数（内部函数）

嵌套函数：在函数内部定义的函数！

def outer():
    print("outer runnung")

    def inner01():
        print("inner01  running")

    inner01()

outer()

结果如下：

outer runnung
inner01  running

使用嵌套函数的几种情况
1、封装-数据隐藏
外部无法访问“嵌套函数”
2、贯彻DRY（Don’t Repeat Yourself）原则
嵌套函数，可以让我们在函数内部避免重复代码
3、闭包

使用嵌套函数避免重复代码

def printChineseName(name,familyName):
    print("{0}  {1}".format(familyName,name))

def printEnglishName(name,familyName):
    print("{0}  {1}".format(name,familyName))

def printName(isChinese,name,familyName):
    def inner_print(a,b):
        print("{0}  {1}".format(a,b))

    if isChinese:
        inner_print(familyName,name)
    else:
        inner_print(name,familyName)
        
printName(True,"小闪","李")
printName(False,"Naxisha","xindelu")

结果如下：

李  小闪
Naxisha  xindelu

nonlocal关键字

nonligal 用来声明外层的局部变量。
global 用来声明全局变量。

使用nonlocal声明外层局部变量

a = 100

def outer():
    b = 10

    def inner():
        nonlocal b #声明外部函数的局部变量
        print("inner b:",b)
        b = 20

        global a #声明全局变量
        a=1000
    inner()
    print("outer b:",b)

outer()
print("a:",a)

结果如下：

inner b: 10
outer b: 20
a: 1000

LEGB规则

Python 在查找“名称”时，是按照LEGB规则查找的：Local–>Enclosed–>Global–>Built in .

Local 指函数或类的方法内部
Enclosed 指嵌套函数（一个函数包裹着另一个函数，闭包）
Global 指的是模块中的全局变量
Built in 指的是Python为自己保留的特殊名称。

如果某个name映射在局部（local）命名空间中没有找到，接下来就会到闭包作用域（enclosed）进行搜索，如果闭包作用域也没有找到，Python就会到全局（global）命名空间中进行查找，最后会在内建（built-in）命名空间搜索（如果一个名称在所有命名空间中都没有找到，就会产生一个NameError）

测试LEGB规则

print(type(str))
#str = "glocal str"
def outer():

    #str = "outer"
    def inner():
        #str = "inner"
        print(str)
    inner()
    
outer()

结果如下：

<class 'type'>
<class 'str'>

面向对象编程

面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型软件设计而来的。面向对象编程使用程序的扩展性更强，可读性更好。
面对对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。
Python完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承，多态，封装等。
Python中，一切皆对象，我们在前面学习的数据类型、函数等，都是对象。
Python支持面向过程、面向对象、函数式编程等多种编程范式。

面向对象和面向过程的区别

面向过程（Procedure Oriented）思维
面向过程编程更加关注的是“程序的逻辑过程”，是一种“执行者”思维，适合编写小规模的程序。面向过程适合简单，不需要协作的事务。

面向对象（Object Oriented）思维
面向对象更加关注的是“软件中对象之间的关系”，面向对象（object）的思想更契合人的思维方式。

面向对象思考方式
遇到复杂问题，先从问题中找名词（面向过程更多的是找动词），然后确立这些名词哪些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

面向对象和面向过程的总结
1、都是解决问题的思维方式，都是代码组织的方式。
2、解决简单问题可以使用面向过程。
3、解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

对象的进化

1、简单数据
像30,40,50等这些数字，可以看做事简单的数据。最初的计算机编程，都是像这样的数字。
2、数组
将同类型的数据放到一起。比如：整数数组[20,30,40],浮点数数组[10.2,11.3,12.4],字符串数组:[“aa”,“bb”,“cc”]
3、结构体
将不同的类型的数据放到一起，是C语言中的数据结构。比如：

struct resume{
    int age；
    char namr[10];
    double salary;
    };

4、对象
将不同类型的数据、方法（即函数）放到一起，就是对象。

类的定义

1、通过类定义数据类型的属性（数据）和方法（行为），对象是类的具体实体，一般称为“类的实例”。从一个类创建对象时，每个对象会共享类的行为（类中定义的方法），但会有自己的属性值（不共享状态）。更具体一点：方法代码是共享的，属性数据不共享。
2、python中，一切皆对象，类也称类对象，类的实例也称为“实例对象”
定义类的语法格式如下：
calss 类名：
类体
要点如下：
1、类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”
2、类体中，我们可以定义属性和方法。
3、属性用来描述数据，方法（即函数）用来描述这些数据的相关操作。

class Student:  #类名一般首字母大写，多个单词采用驼峰原则
    def __init__(self,name,score): #self必须位于第一个参数
        self.name = name  #实例属性
        self.score = score

    def say__score(self):  #self必须位于第一个参数
        print("{0}的分数是：{1}".format(self.name,self.score))

s1= Student("张涵",110)  #通过类名（）调用构造函数
s1.say__score()

结果如下：

张涵的分数是：110

构造函数_init_()

1、创建对象，我们需要定义构造函数_init_()方法，构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
2、init()要点如下
1.名称固定，必须为：init()
2.第一个参数固定，必须为：self self指的就是刚刚创建好的实例对象。
3.构造函数通常用来初始化实例对象的实例属性。
4.通过“类名（参数列表）”来调用构造函数。调用后，将创建好的对象返回给相应的变量。
5.init()方法：初始化创建好的对象，初始化是指：“实例属性赋值”
6.new()方法：用于创建对象，但我们一般无需重定义该方法。
7.self必须为构造函数的第一个参数。

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。
使用要点
1、实例属性一般在_init_()方法中通过如下代码定义：
self.实例属性名 = 初始值
2、在本类的其他属性方法中，也是通过self进行访问：
self实例属性名
3、创建实例对象后，通过实例对象访问：
obj01=类名（）#创建对象，调用_init_()初始化属性
obj01.实例属性名 = 值#可以给已有的属性赋值，也可以新加属性

实例方法

实例方法是从属实例对象的方法。定义格式如下：
def 方法名（self，[形参列表]）:
函数体
方法的调用格式如下：
对象.方法名（[实参列表]）
要点
1.定义实例方法时，第一个参数必须为self。self指当前的实例对象。
2.调用实例方法时，不需要也不能给self传参，self由解释器自动传参。

函数和方法的区别
1、都是用来完成一个功能语句块，本质一样。
2、方法调用时，通过对象来调用，方法从属于特定实例对象，普通函数没有这个特点。
3、直观上看，方法定义时需要传递self，函数不需要

其他操作
1、dir(obj)可以获得对象的所有属性，方法
2、obj.dict 对象的属性字典
3、pass 空语句
4、isinstance（对象，类型） 判断“对象”是不是“指定类型”

类对象

当解释器执行class语句时，就会创建一个类对象。
测试类对象的生成

class Student:
    pass  #空语句

print(type(Student))
print((Student))

Stu2 = Student
s1 =Stu2()
print(s1)

结果如下：

<class 'type'>
<class '__main__.Student'>
<__main__.Student object at 0x000001A9FEBC1668>

实际上就是生成了一个变量名就是类名“Student ”的对象。我们通过赋值给新变量Stu2，也能实现相关调用，说明，确实创建了“类对象”
注 pass为空语句，就是表示什么都不做，只是作为一个占位符存在。当暂时不知道往方法或类中加入什么时，可以先用pass占位，后期再补上。

类属性和类方法

类属性
类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属类对象，可以被所有实例对象共享。
类属性的定义方式：
class 类名：
类变量名 = 初始值
在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。

类属性的使用测试

class Student:
    company = "SXT" #类属性
    count = 0 #类属性

    def __init__(self,name,score):
        self.name = name #实例属性
        self.score = score
        Student.count = Student.count+1

    def say_score(self):   #实例方法
        print('我的公司是：',Student.company)
        print(self.name,'的分数是：',self.score)

s1 = Student('张三',80)  #s1是实例对象，自动调用__init__()方法
s1.say_score()
print('一共创建{0}个Student对象'.format(Student.count))

结果如下：

我的公司是： SXT
张三 的分数是： 80
一共创建1个Student对象

类方法和静态方法

类方法
类方法是从属于“类对象”的方法，类方法通过装饰器@classmethod来定义，格式如下：
@classmethod
def 类方法名（cls,[形参列表]）：
函数体

要点如下：
1、@classmethod必须位于方法上面一行
2、第一个cl必须有‘cls指的就是“类对象”本身
3、调用类方法的格式：“类名.类方法名（参数列表）”。参数列表中，不需要也不能给cls传值。
4、类方法中访问实例属性和实例方法会导致错误。
5、子类继承父类方法时，传入cls是子类对象，而非父类对象。

类方法使用测试

class Student:
    company ="SXT" #类属性

    @classmethod
    def printCompany(cls):
        print(cls.company)

Student.printCompany()

结果如下：

SXT

静态方法
Python中允许定义与“类对象”无关的方法，称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。
静态方法通过装饰器@staticmethod来定义，格式如下：
@staticmethod
def 静态方法名（[形参列表]）：
函数体
要点如下：
1、@staticmethod 必须位于方法上面一行
2、调用静态方法格式：“类名.静态方法名（参数列表）”
3、静态方法中实现实例属性和实例方法会导致错误。
静态方法的测试

class Student:
    company = "SXT" #类属性

    @staticmethod
    def add(a,b): #静态方法
        print("{0}+{1}={2}".format(a,b,(a+b)))
        return a+b

Student.add(20,30)

结果如下：

20+30=50

_del_方法（析构函数）和垃圾回收机制

_del_方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源，例如：打开文件资源，网络连接等。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为0），由垃圾回收器调用_del_方法。
我们也可以通过del语句找对象，从而保证调用的_del_方法。
系统会自动提供_del_方法，一般不需要自定义析构方法。

#析构函数
class Person:
    def __del__(self):
        print("销毁对象{0}".format(self))

p1 = Person()
p2 = Person()
del p2
print("程序结束")

结果如下：

销毁对象<__main__.Person object at 0x0000021B9A7BCBA8>
程序结束
销毁对象<__main__.Person object at 0x0000021B9A591668>

_call_方法和可调用对象

定义了_call_方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。

class SalaryAccount:
    '''工资计算类'''
    def __call__(self,salary):
        print("算工资啦...")
        yearSalary = salary*12
        daySalary = salary//12
        hourSalary = daySalary//8

        return dict(yearSalary = yearSalary,monthSalary = salary,daySalary=daySalary,hourSalary=hourSalary)
s = SalaryAccount()
print(s(30000))

结果如下：

算工资啦...
{'yearSalary': 360000, 'monthSalary': 30000, 'daySalary': 2500, 'hourSalary': 312}