Python 函数和类

好先生FX

已于 2023-11-12 21:11:50 修改

阅读量348

点赞数

文章标签： python 开发语言

于 2023-11-12 21:08:02 首次发布

本文链接：https://blog.csdn.net/weixin_36114953/article/details/134215631

版权

一、函数

（一）Python定义一个函数

使用def保留字。
语法：

# def <函数名>(<参数列表>):
# 	'''注释'''
# 	<函数体>
# 	return <返回值列表>
def my_calc(num1, num2):
	'''计算两数之和'''
	return num1 + num2

# 调用
# <函数名>(<参数列表>)
print(my_calc(1, 2)) # 运行结果是3

（二）lambda函数

lambda函数即匿名函数，是一种将函数名作为返回值的特殊函数。

# 语法：
# <函数名> = lambda <参数列表>: <表达式>

# 与上面函数等价的lambda函数写法
my_calc_func = lambda num1,num2 : num1 + num2
num1 = 1
num2 = 2 
print(my_calc_func(1, 2))

（三）可选参数和可变数量参数

1.可选参数

可选参数（默认值参数）必须出现在函数参数列表的最右端。

# 创建一个eat()函数，传入姓名和食物名两个参数
# 现在我们给食物名一个默认值“米饭”
# 因为给了默认值所以只能放到参数列表的最后面（即最右端）
def eat(name, food='米饭'):
	print("{}吃的食物是{}".format(name,food))

eat("张三")
eat("李四", "牛肉干")

# 我们还可以通过指定形参名称进行传参
eat(food="干锅土豆片", name="王五")

# ====== 输出结果如下 ====== #
张三吃的食物是米饭
李四吃的食物是牛肉干
王五吃的食物是干锅土豆片

2.可变数量参数

通过在参数前写星号*可将参数设置为可变数量的参数，即可以传入多个元素给一个参数。

# 我们现在对eat()函数改造一下，传入姓名和吃的食物
# 考虑到吃多种食物的情况，将食物参数设置为一个可变参数
def eat(name, *foods):
	print("{}吃的食物有{}".format(name,"、".join(foods)))

eat("张三", "米饭", "牛肉干")

# ====== 输出结果如下 ====== #
张三吃的食物有米饭、牛肉干

3.参数的位置

def eat(name, food='米饭'):
	print("{}吃的食物是{}".format(name,food))
	
# 我们还可以通过指定形参名称进行传参
eat(food="干锅土豆片", name="王五")

# ====== 输出结果如下 ====== #
王五吃的食物是干锅土豆片

4.返回值

使用return返回值。
未进行转换的情况下一次返回多个值，会默认转换为元组类型进行返回。

# 改造一下eat()函数
# 现在返回一个字典：主键是姓名，值是食物名
def eat(name, food='米饭'):
	return {name:food} # 以字典形式返回
	
# 我们还可以通过指定形参名称进行传参
print(eat(food="干锅土豆片", name="王五"))
# ====== 输出结果如下 ====== #
{'王五': '干锅土豆片'}

二、类

（一）定义一个类

使用class关键字。
同时还可以使用关键字pass为还没有实现具体功能的类或函数来“占位”。

class Person:
	pass

（二）成员

类数据成员分两种：类属性、实例属性：

实例属性：一般是指在构造函数__init__()（__xxx__是系统定义的特殊成员）中定义的，定义和使用时必须以self作为前缀。实例属性属于实例（对象），只能通过对象名访问。
类属性：是在类中所有方法之外定义的数据成员。类属性属于类，即可以通过类名也可以通过对象名访问。

在定义类成员时还需注意有三种修饰符分别是公有、私有和保护：

私有属性（Python中不存在严格意义上的私有）以两个下划线__开头，否则是公有属性。私有属性外部和子类都不能直接访问，需要通过特殊方式来访问类名/对象名._类名__xxx（不推荐）。
保护成员指在类定义中使用一个下划线_开头的成员。保护成员可以在类内部和子类中访问，但是不能在类外部访问。此变量不能通过from XXX import xxx 导入。

class Person:
	_city = "" # 类保护属性
    __country = "" # 创建一个类私有属性
    areaP = "" # 类公开属性
    def __init__(self, name): # __init__是构造函数，实例化时默认调用
        self.name = name # 实例公开属性
p = Person("")
Person.__country = "中国" # 因为是私有变量，所以这种方式无法修改__country这个属性
Person.areaP = "南方人" # 通过类去访问类属性
p.name = "张三" # 只能通过类实例去访问实例属性
Person.age = 30 # 给类动态增加类属性

（三）方法

类的方法分三种：实例方法、类方法、静态方法。
两个下划线__开头是私有方法。

1.实例方法

类的所有实例方法必须有一个形参代表将来要创建的对象本身，一般默认使用self。如使用实例对象调用则可以忽略这个参数，但在类内部调用和使用类直接调用时则要显示传入这个参数。

2.类方法

类方法定义时需要使用装饰器@classmethod，同时至少有cls这个参数。调用时，使用实例对象和类调用结果都一样，都会向第一个参数传入类的名称。

3.静态方法

静态方法定义时需要使用@staticmethod，静态方法没有固定要求的参数。调用时，使用实例对象和类调用结果都一样。

class Person:
    __country = "" # 创建一个私有变量
    areaP = "" # 类属性
    def __init__(self, name): # __init__是构造函数，实例化时默认调用
        self.name = name # 实例属性
        # self.city = city # 实例属性
    @property
    def city(self): #只读，无法修改和删除
        return self.city
    def eat(self, *foods):
        print("{}{}{}吃的食物是{}".format(Person.__country, Person.areaP, self.name,"、".join(foods)))
    @classmethod
    def sleep(cls):
        print("睡觉")
    @staticmethod
    def run():
        print("跑步")
    def __del__(self): #是析构函数，用于在对象被销毁时自动调用
        print("Person Instance deleted")
p = Person("")
Person.__country = "中国" # 这种方式无法修改私有变量
Person.areaP = "南方人" # 通过类去访问类属性
p.name = "张三" # 只能通过类实例去访问实例属性
# p.city = "台州" # 因为通过@property(描述符)将city()转换为属性，所以无法访问
Person.age = 30 # 给类动态增加类属性
p.eat("米饭", "牛肉干")
print("{}今年{}岁".format(p.name, Person.age))
Person.areaP = "北方人"
p.name = "李四" # 通过类实例去访问类属性
p.eat("面条", "馒头")
p.height = 1.85 # 给类实例动态增加类属性
print("{}现在身高有{}米".format(p.name, p.height)) 
Person.sleep()
Person.run()

# ====== 输出结果如下 ====== #	
南方人张三吃的食物是米饭、牛肉干
张三今年30岁
北方人李四吃的食物是面条、馒头
李四现在身高有1.85米
睡觉
跑步

@property装饰器是一个语法糖，实际上他本身是类。定义如下：

class property:
    fget: Callable[[Any], Any] | None
    fset: Callable[[Any, Any], None] | None
    fdel: Callable[[Any], None] | None
    __isabstractmethod__: bool
    def __init__(
        self,
        fget: Callable[[Any], Any] | None = ...,
        fset: Callable[[Any, Any], None] | None = ...,
        fdel: Callable[[Any], None] | None = ...,
        doc: str | None = ...,
    ) -> None: ...
    def getter(self, __fget: Callable[[Any], Any]) -> property: ...
    def setter(self, __fset: Callable[[Any, Any], None]) -> property: ...
    def deleter(self, __fdel: Callable[[Any], None]) -> property: ...
    def __get__(self, __instance: Any, __owner: type | None = None) -> Any: ...
    def __set__(self, __instance: Any, __value: Any) -> None: ...
    def __delete__(self, __instance: Any) -> None: ...