Python 学习笔记函数

最新推荐文章于 2024-05-08 08:46:48 发布

奔跑的灰灰

最新推荐文章于 2024-05-08 08:46:48 发布

阅读量131

点赞数

文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/qq_53086801/article/details/125955361

版权

1.嵌套函数

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

def f1(): 
	print('f1 running...') 
	def f2(): 
		print('f2 running...') 
	f2() 
f1()
# 执行结果： 
f1 running... 
f2 running...

f2()就是定义在 f1 函数内部的函数。f2()的定义和调用都在 f1()函数内部。
使用嵌套函数场景：
1.封装 - 数据隐藏
外部无法访问“嵌套函数”。
2.贯彻 DRY(Don’t Repeat Yourself) 原则
嵌套函数，可以让我们在函数内部避免重复代码。
3.闭包

# 测试嵌套函数
#打印中文名和英文名
'''
不用嵌套需要分别定义两个函数，代码量大
def printChineseName(name,familyName):
    print(f'{familyName} {name}')
def printEnglishName(familyName,name):
    print(f'{name} {familyName}')
'''
# 嵌套实现
def printName(isChinese,name,familyName):
    def in_def(a,b):
        print(f'{a} {b}')
    if isChinese:
        in_def(familyName,name)
    else:
        in_def(name,familyName)
printName(True,'小明','李')
printName(False,'Leonardo','DiCaprio')
# 执行结果
李 小明
Leonardo DiCaprio

1.2nonlocal 关键字

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

# 测试 nonlocal、global 关键字的用法
a = 100
def out_def():
    b = 10
    def in_def():
        nonlocal b    #声明外部函数的局部变量
        print('in_def b:',b)
        b = 20
    in_def()
    print('out_def b:',b)
    global a    #声明全局变量
    a = 1000
out_def()
print('a:',a)
# 执行结果
in_def b: 10
out_def b: 20
a: 1000

1.3LEGB 规则

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

str = "global"
def outer():
    str = "outer"
    def inner():
        str = "inner"
        print(str)
    inner()
outer()
# 执行结果
inner
*********
str = "global"
def outer():
    str = "outer"
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()
# 执行结果
outer
*********
str = "global"
def outer():
    #str = "outer"
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()
# 执行结果
global
*********
#str = "global"
def outer():
    #str = "outer"
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()
# 执行结果
<class 'str'>

2.面向对象

Python 完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。
Python 中，一切皆对象。我们在前面学习的数据类型、函数等，都是对象。
对象：将不同类型的数据、方法（即函数）放到一起，就是对象。

2.1类

通过类定义数据类型的属性（数据）和方法（行为）
对象是类的具体实体，一般称为“类的实例”。Python 中，“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。
从一个类创建对象时，方法代码是共享的，属性数据不共享
在这里插入图片描述

定义类的语法格式：

class 类名： 
	类体

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

class Student:
    def __init__(self,name,age):  # 构造方法第一个参数必须为 self
        self.name = name   #实例属性
        self.age = age

    def sey_age(self):     #实例方法
        print(f'名字是{self.name},年龄是{self.age}')


s1 = Student('Tom',18)    #s1 是实例对象，自动调用__init__()方法
s1.sey_age()

2.1.1init构造方法和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.构造函数通常用来初始化实例对象的实例属性。
请添加图片描述
4. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。比如：s1 = Student(‘Tom’,18)
5.init()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
6. new()方法: 用于创建对象，但我们一般无需重定义该方法。
7. 如果我们不定义__init__方法，系统会提供一个默认的__init__方法。如果我们定义了带参的__init__方法，系统不创建默认的__init__方法。

2.1.2实例属性和实例方法

实例属性
实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：
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（对象,类型）判断“对象”是不是“指定类型”

2.1.3类对象、类属性、类方法、静态方法

类对象

类定义格式中，“class 类名：”。实际上，当解释器执行 class 语句时，就会创建一个类对象。
请添加图片描述

类属性

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。

类属性的定义方式：

class 类名： 
	类变量名= 初始值

在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。

在这里插入图片描述

类方法

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod 
def 类方法名(cls [，形参列表]) ： 
	函数体

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

静态方法

Python 中允许定义与“类对象”无关的方法，称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。
静态方法通过装饰器@staticmethod 来定义，格式如下：

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

要点：
1.@staticmethod 必须位于方法上面一行
2.调用静态方法格式：“类名.静态方法名(参数列表)”。
3.静态方法中访问实例属性和实例方法会导致错误

在这里插入图片描述

2.1.4内存分析实例对象和类对象创建过程

class Student:
    school = "**小学"    #类属性
    count = 0         #类属性
    def __init__(self,name,score):
        self.name = name     #实例属性
        self.score = score
        Student.count = Student.count + 1
    def say_score(self):  # 实例方法
        print("我的学校是：",Student.school)
        print(self.name,'的分数是：',self.score)
s1 = Student('小明',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score()
print(f'一共创建{Student.count}个 Student 对象')

在这里插入图片描述

2.1.5del方法(析构函数)和垃圾回收机制

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。
Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器调用__del__方法。
我们也可以通过 del 语句删除对象，从而保证调用__del__方法。
系统会自动提供__del__方法，一般不需要自定义析构方法。
在这里插入图片描述

2.1.6call方法和可调用对象

定义了__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)) #通过s(5000)调用__call__方法

# 执行结果
{'monthSalary': 5000, 'yearSalary': 60000, 'daySalary': 166, 'hourSalary': 20}