一、嵌套函数在函数内部定义的函数
def f1():
print("1")
def f2():
print("2")
f2()
#f1()
def ChineseName(name,famliyName):
print("{0} {1}".format(famliyName,name))
def EnglishName(name,famliyName):
print("{0} {1}".format(name,famliyName))
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(False,"xuan","li")
二、nonlocol关键字
1、概念
nonlocal用来声明外层的局部变量
global 用来声明全局变量
2、测试
def outer():
b=10
a=1000
def inner():
nonlocal b
print("inner:",b)
b=20
global a
a=1000
inner()
print("outer:",b)
outer()
print("a:",a)
三、LEGB规则
1、概念：在查重名称时，按照local enclosed global built in 顺序查找
local：方法内部
enclosed：嵌套函数
global：全局变量
built in：特殊名称
其实就是由里到外查找
str="global"
def outer():
#str="outer"
def inner():
#str="inner"
print(str)
inner()
outer()
1、面向对象和面向过程的区别
1）面向过程更加关注的是程序逻辑流程
2）面向对象关注的是软件中对象之间的关系，适合大规模的程序
2、面向对象思考方式：
遇到复杂问题，先从问题中找名词，确立类，根据需求确定类的属性和方法，确定类之间的关系。
五、对象的进化
1、说明：随着编程面临的问题越来越复杂，语言也在进化。从主要处理简单数据开始，随着数据变多进化“数组”，数据类型变复杂，进化出了结构体，处理数据的方式和逻辑变复杂，进化出了对象。
数据：1，2，3
数组：（1，2，3）
结构体：包含了类别
对象
六、类的定义
1、类的结构：属性+方法
属性：数据对应的状态
方法：函数行为对应了行为
2、定义类示例
class Student:
def __init__(self,name,age):
#构造方法
self.name=name
self.age=age
def score(self):
print("{0}的分数是：{1}".format(self.name,self.age))
s=Student("lixuan",24)
s.score()
七、构造函数
1、对象的组成：id，type，value
2、构造函数用于执行实例对象的初始化工作，即对象创建后，初始化当前对象的属性。
八、实例属性
1、概念：实例属性是属于实例对象的属性，也成为实例变量。
2、实例方法
class Student:
def __init__(self,name,age):
#构造方法
self.name=name
self.age=age
def score(self):
print("{0}的分数是：{1}".format(self.name,self.age))
s=Student("lixuan",24)
s.score()
s.age=32
s.salary=3000
print(s.salary)
s1=Student("JAMES",36)
print(s1.name,s1.age)
九、实例方法
1、要定义一个实例方法，第一个参数必须为self，self指当前实例对象
2、调用实例方法时，不需要也不能给self传参，self由解释器自动传参
3、函数和方法的区别：
1）都是用用来完成一个功能的语句块，本质一样
2）方法调用时，通过对象来调用，函数没有这个特点。
3）方法需要传递self，函数不需要
4、dir（object）可以获得对象的所有属性，方法
5、obj.__dict__对象的属性字典。
6、pass语句
class Student:
def __init__(self,name,age):
#构造方法
self.name=name
self.age=age
def score(self):
print("{0}的分数是：{1}".format(self.name,self.age))
s=Student("lixuan",24)
s.score()
s.age=32
s.salary=3000
print(s.salary)
s1=Student("JAMES",36)
print(s1.name,s1.age)
print(dir(s1))
print(s1.__dict__)
十、类对象
1、class 类名：会创造一个类对象
class student:
pass
print(id(student))
print(type(student))
十一、类属性
1、概念：从属于类对象的属性，也成为类变量。可以被所有实例对象共享。实例在__init__构造函数中，类属性在class下直接添加，无需定义在函数下。
2、示例：
class student:
company="tencent"
#类属性
def __init__(self,name,age):
self.name=name
self.age=age
#实例属性
十二、类方法
1、格式：
@classmethod
def 类方法名（cls）:
函数体
2、要点：
1）classmethod必须位于方法上面一行
2）第一个cls必须有，指的是类对象本身
3）调用方法通过类名.类方法名调用
3、测试：
class student:
company="tencent"
#类属性
def __init__(self,name,age):
self.name=name
self.age=age
#实例属性
@classmethod
def printCompany(cls):
print(cls.company)
student.printCompany()
类方法和静态方法中不能调用实例变量
十三、静态方法
1、允许定义与类对象无关的方法，成为静态方法。
2、与普通函数没有区别
3、格式
@staticmethod
def 静态方法名（形参列表）
函数体
十四、__del__析构函数
1、作用：销毁对象
2、也可以通过del语句删除对象。
3、python会自动提供__del__方法，不需要自定义析构方法。
4、示例：
class Person:
def __del__(self):
print("销毁对象：{0}".format(self))
p1=Person()
p2=Person()
del p2
print("程序结束")
15、call()方法
1、功能：定义了方法的对象，成为可调用对象，可以像调用函数一样被调用
2、测试
#测试可调用方法__call__()
class SalaryAccount:
'''计算工资'''
def __call__(self, salary):
print("算工资了")
yearSalary=salary*12
daySalary=salary//22.5
hourSalary=daySalary//8
return dict(yearSalary=yearSalary,monthsalary=salary,daySalary=daySalary,hourSalary=hourSalary)
s=SalaryAccount()
print(s(30000))
本文地址：https://blog.csdn.net/weixin_51182518/article/details/109641474
