函数+类——call

嵌套函数：

在函数内部定义的函数

def f1():
        print('f1 running...')
        def f2():
                print('f2 running...')
        f2()
f1()

注：须在f1内部调用函数f2，外部无法调用

一般在什么情况下使用嵌套函数？
1. 封装- 数据隐藏
外部无法访问“嵌套函数”。
2. 贯彻DRY(Don’t Repeat Yourself) 原则
嵌套函数，可以让我们在函数内部避免重复代码。
3. 闭包
后面会详细讲解。

#避免重复代码

def Printname(ischinese,name,familyname):
        def inner_print(a,b):
                print(f'{a}  {b}')
        if ischinees:
                inner_print(familyname,name)
        else:
                inner_print(name,familyname)

nonlocal关键字：用来声明嵌套函数外层函数的局部变量（不声明可以用）【修改外层函数的局部变量的值就得用nonlocal，但可变对象除外，修改可变对象时不需要nonlocal声明】
global：用来声明全局变量（不声明可以用，但是无法实际改变全局变量的值，智能在函数内部重新创建一个新的对象）【修改全局变量的值就得用global，但可变对象除外，修改可变对象时不需要global声明】

LEGB 规则

Python 在查找“名称”时，是按照LEGB 规则查找的：
Local-->Enclosed-->Global-->Built in
Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）
Global 指的是模块中的全局变量
Built in 指的是Python 为自己保留的特殊名称。

1. 定义一个函数实现反响输出一个整数。比如：输入3245，输出5432.

def mk():
        say = input('请输入一个整数：')
        m=list(reversed(say))
        l=''
        for i in m:
                l+=i
        a=int(l)
        return a
mk()

def fuc(n):
        l=0
        for i in range(1,n+1):
                l+=i/(i+1)
        return l
fuc(3)

3. 输入三角形三个顶点的坐标，若有效则计算三角形的面积；如坐标无效，则给出提示。

import math
def m():
        while True:
                x1,y1=map(float,input('请输入三角形的第一个坐标：').split())
                x2, y2 = map(float, input('请输入三角形的第二个坐标：').split())
                x3, y3 = map(float, input('请输入三角形的第三个坐标：').split())
                a=math.sqrt((x1-x2)**2+(y1-y2)**2)
                b=math.sqrt((x2-x3)**2+(y2-y3)**2)
                c = math.sqrt((x1 - x3) ** 2 + (y1 - y3) ** 2)
                p=(a+b+c)/2
                if a+b ==c or a+c==b or b+c==a:
                        print('坐标输入有误，请重新输入：')
                        continue
                else:
                        s=round(math.sqrt(p*(p-a)*(p-b)*(p-c)),2)
                        break
        return print(f'该三角形的面积是{s}')
m()

类和对象

定义类的语法格式如下：
class 类名：
        类体

要点如下：
1. 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
2. 类体中我们可以定义属性和方法。
3. 属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

class Student:
        def __init__(self,name,score): #构造方法第一个参数必须为self
                self.name = name #实例属性
                self.score = score
        def say_score(self): #实例方法
                print(self.name,'的分数是：',self.score)

s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()

__init__构造方法和__new__方法
类是抽象的，也称之为“对象的模板”。我们需要通过类这个模板，创建类的实例对象，然后才能使用类定义的功能。
我们前面说过一个Python 对象包含三个部分：id（identity 识别码）、type（对象类型）、value（对象的值）。
现在，我们可以更进一步的说，一个Python 对象包含如下部分：
1. id（identity 识别码）
2. type（对象类型）
3. value（对象的值）
(1) 属性（attribute）
(2) 方法（method）

创建对象，我们需要定义构造函数__init__()方法。构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。

__init__()的要点如下：
1. 名称固定，必须为：__init__()
2. 第一个参数固定，必须为：self。self 指的就是刚刚创建好的实例对象。
3. 构造函数通常用来初始化实例对象的实例属性，如下代码就是初始化实例属性：name和score。

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

4. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。
比如：s1 = Student('张三', 80)
5. __init__()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
6. __new__()方法: 用于创建对象，但我们一般无需重定义该方法。
7. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参的__init__方法，系统不创建默认的__init__方法。

注：。Python 中，self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做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 语句时，就会创建一个类对象。

【注】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. 第一个cls 必须有；cls 指的就是“类对象”本身；
3. 调用类方法格式：“类名.类方法名(参数列表)”。参数列表中，不需要也不能给cls 传值。
4. 类方法中访问实例属性和实例方法会导致错误
5. 子类继承父类方法时，传入cls 是子类对象，而非父类对象

class Student:
        company = "SXT" #类属性
        @classmethod
        def printCompany(cls):
                print(cls.company)
Student.printCompany()

静态方法

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

__call__方法和可调用对象

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

class SalaryAccount:
'''工资计算类'''
        def __call__(self, salary):
                yearSalary = salary*12
                daySalary = salary//30
                hourSalary = daySalary//8
        return
dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)
s = SalaryAccount()
print(s(5000)) #可以像调用函数一样调用对象的__call__方法

类的总结：

1、面向过程找动词，写方法，面向对象找名词，确定类和属性及方法
2、在类里面，方法代码是共享的，属性数据不共享。
3、__init__（构造函数）：用于确定类的实例对象（即实例参数），第一个参数固定，为self
4、实例方法就是要对实际参数进行方法操作
5、类也是对象，可以赋值给任意变量
6、类属性指存在于类里的变量或参数，不在构造函数，也不再实例方法中，独立存在于类中。
7、@classmethod,针对类属性的方法，不可用于实例参数
8、@staticmethod，静态方法仅仅只是放在类里面的一个普通函数，但是必须通过类去调取使用
9、__call__方法可以直接调用类进行使用，无需在对象后加后缀调用