Python函数如何给函数传递一个简单参数 Python函数单参数传递的入门操作指南-Python教程-PHP中文网

给python函数传递单参数需两步：定义函数时声明参数，调用时传入值；2. python参数传递是“传对象引用”，不可变对象表现如值传递，可变对象修改内容会影响外部；3. 函数不强制类型，支持鸭子类型，但需注意类型不匹配引发的typeerror；4. 常见错误包括遗漏或多余参数、参数名拼写错误及意外修改可变参数，应通过副本避免副作用。

Python函数如何给函数传递一个简单参数 Python函数单参数传递的入门操作指南

在Python里，给函数传一个简单参数，说白了就是定义一个接收口，然后在调用时把数据塞进去。这事儿，初看起来可能觉得有点绕，但实际上，它构成了我们编写几乎所有有意义代码的基础，是函数间协作最直接的方式。理解它，就像掌握了和函数对话的基本礼仪。

解决方案

要给Python函数传递一个单参数，核心就两步：在定义函数时声明一个参数，然后在调用函数时提供一个值。

当你写下

def my_function(parameter_name):

登录后复制

这行代码时，

parameter_name

登录后复制

就是那个等待接收数据的“占位符”。它告诉函数：“嘿，我需要一个东西才能开始工作。”

立即学习“Python免费学习笔记（深入）”；

接着，当你需要让这个函数跑起来，并且给它提供数据时，你会这样写：

my_function(argument_value)

登录后复制

。这里的

argument_value

登录后复制

就是你实际传递给

parameter_name

登录后复制

的具体数据。

举个例子，我们想写一个函数，它能把任何传给它的名字打印出来：

def greet_person(name): # name 就是我们定义的参数
    print(f"你好，{name}！很高兴见到你。")

# 现在，我们来调用这个函数，并传递一个实际的名字
greet_person("张三") # "张三" 是传递给 name 参数的实际值
greet_person("李四") # "李四" 也是一个实际值

# 你甚至可以传递一个变量
my_name = "王五"
greet_person(my_name)

登录后复制

你看，

name

登录后复制

在函数定义时是个通用标签，而

“张三”

登录后复制

、

“李四”

登录后复制

、

my_name

登录后复制

则是你实际扔进这个标签里的具体内容。Python会很自然地把这些值绑定到函数内部的

name

登录后复制

上，然后执行接下来的操作。就这么简单，一个萝卜一个坑。

Python函数参数传递是值传递还是引用传递？

这大概是初学者最容易感到困惑的地方之一，也是一个经常被拿来讨论的“哲学问题”。Python在参数传递上，既不是严格意义上的“值传递”，也不是纯粹的“引用传递”，它更准确地说是“传对象引用”（pass by object reference）。听起来有点玄乎，但理解了就豁然开朗了。

简单来说，当你把一个变量传递给函数时，实际上是把这个变量所指向的“对象”的引用传递过去了。

对于不可变对象（如数字、字符串、元组）：如果函数内部尝试修改这个参数（比如
```
param = new_value
```
登录后复制
），那么它不会影响到函数外部的原始对象。因为不可变对象一旦创建就不能改变，任何“修改”操作实际上都是在函数内部创建了一个新的对象，并让参数指向了这个新对象，而外部的变量仍然指向原来的对象。这就表现得像“值传递”。
```
def modify_number(num):
    print(f"函数内部修改前：{num} (id: {id(num)})")
    num = num + 10 # 实际上是创建了一个新的整数对象
    print(f"函数内部修改后：{num} (id: {id(num)})")

my_num = 5
print(f"函数外部调用前：{my_num} (id: {id(my_num)})")
modify_number(my_num)
print(f"函数外部调用后：{my_num} (id: {id(my_num)})")
```
登录后复制
你会发现，
```
my_num
```
登录后复制
的值在函数调用后并没有改变。
对于可变对象（如列表、字典、集合）：如果函数内部通过某种操作（比如
```
list.append()
```
登录后复制
、
```
dict['key'] = value
```
登录后复制
）来修改这个参数的“内容”，那么这些修改会直接反映到函数外部的原始对象上。因为参数和外部变量都指向同一个对象，修改的是对象本身。
```
def modify_list(my_list_param):
    print(f"函数内部修改前：{my_list_param} (id: {id(my_list_param)})")
    my_list_param.append(4) # 修改了列表的内容
    print(f"函数内部修改后：{my_list_param} (id: {id(my_list_param)})")

data = [1, 2, 3]
print(f"函数外部调用前：{data} (id: {id(data)})")
modify_list(data)
print(f"函数外部调用后：{data} (id: {id(data)})")
```
登录后复制
这里，
```
data
```
登录后复制
列表在函数调用后确实被修改了。但如果函数内部是
```
my_list_param = [5, 6, 7]
```
登录后复制
这种赋值操作，那么同样会创建一个新列表，外部的
```
data
```
登录后复制
不会受影响。

所以，关键在于你是在“修改对象的内容”还是在“重新给参数赋值”。这个区别，在写代码时得时刻留意，尤其是在处理列表或字典这类可变数据结构时，一不小心就可能踩坑。

Python精要参考 pdf版

这本书给出了一份关于python这门优美语言的精要的参考。作者通过一个完整而清晰的入门指引将你带入python的乐园，随后在语法、类型和对象、运算符与表达式、控制流函数与函数编程、类及面向对象编程、模块和包、输入输出、执行环境等多方面给出了详尽的讲解。如果你想加入 python的世界，David M beazley的这本书可不要错过哦。 (封面是最新英文版的,中文版貌似只译到第二版)

查看详情

传递不同类型参数会有什么影响？

Python是一个动态类型语言，这意味着你在定义函数时不需要明确指定参数的类型（比如C++的

int my_param

登录后复制

）。你可以把任何类型的数据传递给一个参数，只要函数内部对这个参数的操作是合法的就行。这种灵活性是Python的一大优点，但也可能带来一些意想不到的情况。

比如，我们有一个函数，它期望接收一个数字并进行加法：

def add_five(number):
    return number + 5

print(add_five(10)) # 没问题，输出 15
print(add_five(3.14)) # 也没问题，输出 8.14

登录后复制

但如果你不小心传了一个字符串进去：

# print(add_five("hello"))

登录后复制

这行代码会直接抛出一个

TypeError

登录后复制

，告诉你不能将字符串和整数进行加法运算。这就是所谓的“鸭子类型”（Duck Typing）在起作用：如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子。你的函数只关心

number

登录后复制

这个参数是否支持

+ 5

登录后复制

这个操作，而不关心它是不是真的

int

登录后复制

或

float

登录后复制

。

这种机制意味着，你的函数可以非常通用，能处理多种数据类型，只要它们有相同的“行为”或“接口”。但同时，你也需要更小心地进行输入验证，或者依赖于异常处理机制（

try-except

登录后复制

），来应对可能出现的类型不匹配问题。

def process_data(item):
    try:
        # 尝试把它当成数字处理
        result = item * 2
        print(f"处理结果 (数字翻倍): {result}")
    except TypeError:
        # 如果不是数字，尝试把它当成字符串处理
        print(f"处理结果 (字符串重复): {str(item) * 2}")
    except Exception as e:
        print(f"未知错误: {e}")

process_data(7)
process_data("Python")
process_data([1, 2]) # 列表和整数相乘会报错，但列表和字符串相乘是重复列表

登录后复制

这种处理方式给了我们很大的自由度，但也要求我们在设计函数时，要考虑清楚它可能接收哪些类型的数据，以及如何优雅地处理那些“不符合预期”的类型。

函数参数传递的常见错误有哪些？

在给Python函数传递参数时，有些坑是新手甚至老手都可能不小心踩到的。了解这些常见错误，能帮你省下不少调试时间。

遗漏了必需的参数 (
```
TypeError: missing 1 required positional argument
```
登录后复制
) 这是最常见的错误。你定义了一个函数，它明确需要一个参数，但你在调用时忘了给它。
```
def say_hello(name):
    print(f"Hello, {name}!")

# say_hello() # 这样调用就会报错：TypeError: missing 1 required positional argument: 'name'
say_hello("Alice") # 正确的做法
```
登录后复制
函数定义时指定了
```
name
```
登录后复制
，调用时就必须提供一个值。

传递了过多的参数 (

TypeError: takes 0 positional arguments but 1 was given

登录后复制

) 反过来，如果你的函数定义时不需要任何参数，但你在调用时却给了它一个。

def just_say_hi():
    print("Hi there!")

# just_say_hi("Bob") # 这样调用就会报错：TypeError: just_say_hi() takes 0 positional arguments but 1 was given
just_say_hi() # 正确的做法

登录后复制

函数是“无参数”的，你就别硬塞东西给它。

参数名混淆或拼写错误 (
```
NameError
```
登录后复制
) 虽然这不直接是参数传递的错误，但在函数内部处理参数时，如果把参数名写错了，就会导致
```
NameError
```
登录后复制
。
```
def process_data(input_value):
    # print(another_value) # 如果这里写错了 input_value，就会是 NameError
    print(input_value * 2)

process_data(10)
```
登录后复制
这是个基础的变量命名问题，但因为它发生在函数内部，且与参数直接相关，所以也值得提一下。
对可变参数的意外修改 前面提到过“传对象引用”的问题，尤其在处理列表、字典这类可变类型时，要格外小心。如果你不希望函数内部对参数的修改影响到外部，那么在函数内部应该先创建一个副本。
```
def process_list(items):
    # 如果不希望修改原始列表，先复制一份
    # local_items = list(items)
    items.append("new_item") # 这会修改原始列表！
    print(f"函数内部列表: {items}")

my_list = ["apple", "banana"]
process_list(my_list)
print(f"函数外部列表: {my_list}") # my_list 已经被修改了
```
登录后复制
如果想避免这种情况，你可以在函数内部对列表进行切片复制：
```
local_items = items[:]
```
登录后复制
或者
```
local_items = list(items)
```
登录后复制
，然后再操作
```
local_items
```
登录后复制
。