GVKun编程网logo

Python 函数 参数传递（Python函数参数传递机制(超级详细)）

1

如果您想了解Python函数参数传递的相关知识，那么本文是一篇不可错过的文章，我们将对Python函数参数传递机制(超级详细)进行全面详尽的解释，并且为您提供关于14.Java基础_函数/函数重载/参

如果您想了解Python 函数 参数传递的相关知识，那么本文是一篇不可错过的文章，我们将对Python函数参数传递机制(超级详细)进行全面详尽的解释，并且为您提供关于14.Java基础_函数/函数重载/参数传递、3. 参数传递、 类 方法 参数传递 返回值类、android internet 参数传递的有价值的信息。

本文目录一览：

Python 函数 参数传递（Python函数参数传递机制(超级详细)）

Python 函数 参数传递（Python函数参数传递机制(超级详细)）

参数传递
    在 python 中，类型属于对象，变量是没有类型的：
        a=[1,2,3]
        a="Runoob"
    以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象
    在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
        不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
        可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
    python 函数的参数传递：
        不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
        可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
    python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例
        #!/usr/bin/python3
        
        def ChangeInt( a ):
            a = 10

        b = 2
        ChangeInt(b)
        print( b ) # 结果是 2
    实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例
    可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
        #!/usr/bin/python3
        
        # 可写函数说明
        def changeme( mylist ):
           "修改传入的列表"
           mylist.append([1,2,3,4])
           print ("函数内取值: ", mylist)
           return
        # 调用changeme函数
        mylist = [10,20,30]
        changeme( mylist )
        print ("函数外取值: ", mylist)
    传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
        函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
        函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数
    以下是调用函数时可使用的正式参数类型：
        必需参数
        关键字参数
        默认参数
        不定长参数

必需参数
    必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

    调用printme()函数，你必须传入一个参数，不然会出现语法错误：
        #!/usr/bin/python3
        
        #可写函数说明
        def printme( str ):
           "打印任何传入的字符串"
           print (str)
           return
        
        #调用printme函数
        printme()
    以上实例输出结果：
        Traceback (most recent call last):
          File "test.py", line 10, in <module>
            printme()
        TypeError: printme() missing 1 required positional argument: ''str''

关键字参数
    关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
    使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
    以下实例在函数 printme() 调用时使用参数名：

#coding=utf-8
def jiao(pet1,pet2):
    print(''喵的叫声'',pet1)
    print(''汪的叫声'',pet2)
# jiao(''2ha'',''bosi'')
jiao(pet1=''bosi'',pet2=''2哈'')

 


    以下实例中演示了函数参数的使用不需要使用指定顺序：
        #!/usr/bin/python3
        
        #可写函数说明
        def printinfo( name, age ):
           "打印任何传入的字符串"
           print ("名字: ", name)
           print ("年龄: ", age)
           return
        
        #调用printinfo函数
        printinfo( age=50, name="runoob" )
    以上实例输出结果
        名字:  runoob
        年龄:  50

默认参数
    调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
        #!/usr/bin/python3
        
        #可写函数说明
        def printinfo( name, age = 35 ):
           "打印任何传入的字符串"
           print ("名字: ", name)
           print ("年龄: ", age)
           return
        
        #调用printinfo函数
        printinfo( age=50, name="runoob" )
        print ("------------------------")
        printinfo( name="runoob" )
    以上实例输出结果：
        名字:  runoob
        年龄:  50
        ------------------------
        名字:  runoob
        年龄:  35

...

#coding=utf-8
def jiao(pet1,pet2=''2ha''):
    print(''喵是%s的叫声''%pet1)
    print(''汪是%s的叫声''%pet2)

# jiao(''波斯'')
jiao(''波斯'',''阿拉'')


不定长参数
    你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
        def functionname([formal_args,] *var_args_tuple ):
           "函数_文档字符串"
           function_suite
           return [expression]
    加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

如下实例：
        #!/usr/bin/python3
        # 可写函数说明
        def printinfo( arg1, *vartuple ):
           "打印任何传入的参数"
           print ("输出: ")
           print (arg1)
           for var in vartuple:
              print (var)
           return
        # 调用printinfo 函数
        printinfo( 10 )
        printinfo( 70, 60, 50 )
    以上实例输出结果：
        输出:
        10
        输出:
        70
        60
        50

    声明函数时，参数中星号(*)可以单独出现，例如:
        def f(a,b,*,c):
            return a+b+c
    用法：星号（*）后的参数必须用关键字传入。
        >>> def f(a,b,*,c):
        ...     return a+b+c
        ...
        >>> f(1,2,3)   # 报错
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        TypeError: f() takes 2 positional arguments but 3 were given
        >>> f(1,2,c=3) # 正常
        6

 

#coding=utf-8

# def test(x,y,*args):
#     print(x,y,args)
# 
# test(1,2,3,4,5)

def test1(x,y,**args):
    print(x,y,args)

test1(1,2,a=3,b=4)

 

14.Java基础_函数/函数重载/参数传递

14.Java基础_函数/函数重载/参数传递

  • Java函数和函数重载
 1 /*
 2     函数定义：
 3     public static 返回类型 func(参数){
 4         方法体；
 5     }
 6 
 7     函数重载
 8     在调用时,Java虚拟机会通过参数的不同来区分同名的函数
 9     满足：
10         1.多个函数在同一个类中
11         2.多个函数具有相同函数名
12         3.多个函数的参数不相同(类型不同或者数量不同)
13     注意：不能通过返回值来判定两个函数是否构成重载
14 
15     函数传参
16         1.传递基本类型
17         3.传递引用类型
18 
19  */
20 
21 public class func {
22 
23     //函数重载
24     //func1:两整数之和
25     public static int sum(int a,int b){
26         return a+b;
27     }
28     //func2:三整数之和
29     public static int sum(int a,int b,int c){
30         return a+b+c;
31     }
32     //func3:两浮点数之和
33     public static double sum(double a,double b){
34         return a+b;
35     }
36 
37     public static void main(String[] args) {
38         System.out.println(sum(5,10)); //fun1
39         System.out.println(sum(1,2,3)); //fun2
40         System.out.println(sum(1.2,1.8)); //fun3
41     }
42 }

 

  • 函数参数传递:

1.传递基本类型(传值)

将函数参数压入堆栈,并进入函数,在函数栈空间创建一个新的number变量并把200赋给它

函数返回,释放change栈空间,在main函数栈空间里的number变量值未被改变

 

2.传递引用类型

将函数参数压入堆栈,并进入函数,在函数栈空间创建一个新的arr数组变量并把堆内存数组的首地址赋给它

函数返回,释放change函数栈空间,在堆内存的数组元素arr[1]已经被改变

 

 

 

 

3. 参数传递

3. 参数传递

3. 参数传递

3.1 函数的参数分为形式参数和实际参数，定义函数时的参数是形式参数，调用函数时传递的参数值是实际参数。
3.2 C 语言中的函数参数传递是值传递，当调用函数时将实际参数值复制给形参。
3.3 实例
#include <stdio.h>
// 两个数的最大值
int max(int a,int b);
// 交换两个数（验证值传递）
void swap(int a,int b);
int main(void)
{
            //int m = max(1,2);
            //printf("m=%d\n",m);
            int a,b;
            a = 1;
            b = 2;
            swap(a,b);
            printf("a=%d,b=%d\n",a,b);
}
 
int max(int a,int b){
            printf("a=%d,b=%d\n",a,b);
            if(a>b){
                        return a;
            }else{
                        return b;
            }
}
void swap(int a,int b){
            int temp;
            temp = a;
            a = b;
            b = temp;
            printf("a=%d,b=%d\n",a,b);
}

该博客教程视频地址：http://geek99.com/node/986

<Java> 类 方法 参数传递 返回值类

类 方法 参数传递 返回值类

类

  1. 用class关键字可以传建一个类。
  2. 类中可以设置两种类型的元素：字段（有时被称为数据成员），方法（有时被称为成员函数）
  3. 字段
    1. 　　 字段即数据成员
    2. 　　 字段可以是任何类型的对象（可以是是引用类型，也可以是基本类型）
    3. 　　(3) 每个对象都有用来存储其字段的空间，普通字段是不可以在对象间共享的
      1. 两个对象都各自有他们自己的字段，虽然字段是同名的，但是这两个对象对这个字段的操作都是对自己的字段的操作，不能操作另一个对象的。
      2.  但是static修饰的字段，是在对象内共享的，他只有一份空间，不管是那个对象，对这个字段操作，都会影响所有的对象的这个字段，因为他们只能操作这一个字段。
    4. 　　修改字段的内容
      1.  如果想修改的数据位于对象所包含的其他对象中，那就多用一个’.’
      2.  ex: myPlane.leftTank.capacity=100;
    5. 基本成员的默认值
      1.  只有类内的字段时，才能有一个默认值。不是类内的字段的成员是没有初始默认值的，仍然会是一个任意值。

基本类型

默认值

boolean

false

char

null

byte

0(byte)

short

0(short)

int

0

long

0L

float

0.0f

double

0.0d
  1. 方法
    1. 方法签名：方法名+参数列表
    2. Java中的方法只能作为类的一部分来创建，即方法一定要属于一个类。
    3.  方法只能通过对象才能被调用。
      1. 也就是通过 对象名 . 方法名的方法
      2.  static方法是针对类调用的，不依赖与对象，因此可以通过，类名 . 方法名 的方法调用。
    4. a.f( ) 这种调用方法通常称为 发送消息给对象
    5.  f( )为消息，对象为a
  2. 参数列表
    1.  像所有传递对象的场合一样，参数列表里的参数传递也是引用。
      1.  java里面只有值传递 
    2.  那么如何理解参数传递的是引用呢？
      1. 区别引用传递和值传递
      2. 引用传递实参的地址给形参，而值传递是拷贝实参的值给形参。
      3.  区别引用传递和传递对象的引用
      4. 在传递对象的时候，传递的是引用，而引用的值是对象的地址，所以虽然传递的是一个地址，传递的是一个引用，但是传递的实际是引用的值，而不是引用的地址。
      5. 换句话说，传递对象的时候，传递的是堆栈空间里面引用的值，而不是堆栈空间里面的地址，只不过这个堆栈空间引用的值恰好是一个堆空间的地址而已。
    3. 而对于基本类型来讲，显然是值传递。
      1.  因为传递给形参的是拷贝的实参的值。不会影响实参的值。
    4.  所以可以知道 java里只有按值传递。
  3. 返回值
    1. return...
    2.  void类型可以没有return语句

android internet 参数传递

android internet 参数传递

OSC 请你来轰趴啦！1028 苏州源创会，一起寻宝 AI 时代

当 Activity 与 Activity/Service（或其它情况）有时与要进行参数传递，最常用也是最简单的方式就是通过 Intent 来处理。 
看如下代码： 
Intent intent = new Intent(...); 
Bundle bundle = new Bundle(); 
bundle.putString("NAME", "zixuan"); 
intent.putExtras(bundle); 
context.startActivity (intent); 或 context.startService (intent); 

当然，有传送就有接收，接收也很简单，如： 
Bundle bunde = intent.getExtras(); 
String name = bunde.getInt("NAME"); 
当然参数 KEY 要与传送时的参数一致。 

今天的关于Python 函数 参数传递和Python函数参数传递机制(超级详细)的分享已经结束，谢谢您的关注，如果想了解更多关于14.Java基础_函数/函数重载/参数传递、3. 参数传递、 类 方法 参数传递 返回值类、android internet 参数传递的相关知识，请在本站进行查询。

本文标签：

上一篇[PyTorch] PyTorch/python 常用语法 / 常见坑点（pytorch基本语法）

下一篇python-requests模块的讲解和应用

相关文章