嵌套函数和类_嵌套类或函数-CSDN博客

本文探讨了嵌套函数的作用、nonlocal关键字在Python中的应用，以及面向对象编程中的类定义、构造函数、属性和方法。深入解析了LEGB作用域规则，并介绍了对象的发展和面向过程与面向对象的区别。

嵌套函数

嵌套函数
nonlocal关键字
LEGB规则
面向对象编程
- 面向过程和面向对象
- 对象的发展
类的定义

嵌套函数

在函数内部定义的函数
使用：

封装-数据隐藏
避免重复原则-在函数内部避免代码重复
闭包

def outer():
    print('outer running')

    def inner01():
        print('inner01 running')
    inner01()

outer()

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

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


printChineseName('美丽','刘')
printEnglishName('Ivanka','Trump')

print('------使用一个函数代替上面的两个函数------')
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,'Ivanka','Trump')

nonlocal关键字

nonlocal：声明外层局部变量
global：声明全局变量

a = 100
def outer():
    b = 10

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

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

outer()
print('a:',a)

LEGB规则

查找变量名，按照LEGB规则进行查找：
Local-Enclosed-Global-Built in
Local：函数或者类的方法内部
Enclosed:嵌套函数
Global：模块中的全局变量
Built in：Python为自己保留的特殊名称

str = 'global str'  #Global
def outer():

    str = 'outer' #Enclosed
    def inner():
        str = 'inner' #Local
        print(str)

    inner()

outer()

面向对象编程

面向对象编程：将数据和操作数据相关的方封装到对象中。
python支持面向对象的基本功能：继承，多态，封装

面向过程和面向对象

面向过程更加注重 “ 程序的逻辑流程 ”，执行者思维
面向对象更加关注 “ 软件中对象之间的关系 ”，，设计者思维，在面向对象的底层，仍然是面向过程的思维

遇到相对复杂的问题时，先使用面向对象的思维来考虑问题，找名词，分解各部件，再确定名词（各部件）之间的关系。

对象的发展

编程语言从处理简单数据发展到处理多类型的复杂数据，对复杂数据，需要将同类型的数据放到一起
1.简单数据
2.数组：多个数据放在一起
3.结构体：不同类型的数据放在一起
4.对象：不同类型的数据、方法（函数，即处理数据的方法）放在一起

类的定义

通过类定义数据类型的
属性（变量）
和
方法（函数）

class Student: #类名首字母大写，多个单词采用驼峰原则

    def __init__(self,name,score): #self必须位于第一个参数
        self.name = name
        self.score = score

    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))


s1 = Student('刘美丽',18)
s1.say_score()

构造函数 init()

init()：初始化对象
new()：创造新对象，一般无需重新定义该方法
一个python对象包含：

id
type
value(1属性，2方法）

init():
1.名称固定，
2.第一个参数必须为self（类中所有的方法，第一个参数都是self，即指刚创建好的实例对象）
3.构造函数常用语初始化实例对象的实例属性
初始化实例属性

def __init__(self,name,score)
	self.name = name
	slef.score = score

4.通过类名调用构造函数

实例属性

实例属性属于对象，

在__init__()中语法：
self.实例属性名 = 初始值
本类其它实例方法中，可以通过self进行访问，
创建实例对象后，通过实例对象访问，语法：
obj01 = 类名()
obj01.实例属性名 = 值

class Student: #类名首字母大写，多个单词采用驼峰原则

    def __init__(self,name,score): #self必须位于第一个参数
        self.name = name
        self.score = score

    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))


s1 = Student('刘美丽',18) #通过类名调用构造函数
s1.say_score()

s1.age = 32
s1.salary = 3000

print(s1.salary)

实例方法

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

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

class Student: #类名首字母大写，多个单词采用驼峰原则

    def __init__(self,name,score): #self必须位于第一个参数
        self.name = name
        self.score = score

    def say_score(self):
        print('{0}的分数是{1}'.format(self.name,self.score))


s1 = Student('刘美丽',18) #通过类名调用构造函数
print('--------看看------')
s1.say_score()

s1.age = 32
s1.salary = 3000

print(s1.salary)

print('--------调用实例方法----------')
s1.say_score()
Student.say_score(s1)

print(dir(s1))#获得属性

print(s1.__dict__)

print(isinstance(s1,Student))

class Man:
    pass #空的类

类对象

创建类，语法：
class 类名：
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.say_score()

s2 = Student('刘美丽',80)
s3 = Student('于美丽',100)

print('一共创建了{0}个Student对象'.format(Student.count))

类方法

类方法是从属于 “ 类对象 ” 的方法，通过@classmethod来定义，语法：
@classmethod
def 类方法名称 (cls [, 参数列表])

class Student:
    company = 'STX'

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

Student.printCompany()

静态方法

与类对象无关的方法称为静态方法
与模块中定义的函数没有区别
但静态方法放到了类名的空间中，需要通过类调用

语法：
@staticmethod
def 静态方法名([形参列表])：
函数体

class Student:
    company = 'STX'

    def __init__(self,name,age):
        self.name = name
        self.age = age


    @classmethod
    def printCompany(cls):
        print(cls.company)
        #print(self.name)
        #类方法和静态方法中不能调用实例对象（实例方法和实例属性）

    @staticmethod
    def add(a,b):
        print('{0}+{1}={2}'.format(a,b,a+b))
        return a+b

Student.printCompany()

Student.add(20,30)

析构函数del()方法

垃圾回收器调用析构方法，
关闭打开的文件，网络连接，释放系统资源。

class Person:

    def __del__(self):
        print('销毁对象{0}'.format(self))


p1 = Person()
p2 = Person()
del p2
print('程序结束')
#print(p2)#报错，p2已被销毁

call()方法

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

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

        return dict(yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)

s = SalaryAccount()
print(s(30000))