'''
形参种类：
1）位置形参
    -- 普通位置形参
    -- 默认值形参
    -- 可变长位置形参

2）关键字形参
    -- 有默认值关键字形参
    -- 无默认值关键字形参
    -- 可变长关键字形参
'''


def fn1(a, b, *, x, y):
    pass


# fn1()
# 位置形参与关键字形参的分水岭 *

# 重点：
# 位置实参只能给位置形参进行传值
# fn1(10, 20, 30, 40)  # 只有两个位置，给了四个位置
# 关键字实参可以给位置形参与关键字形参进行传值
# fn1(x=30, y=40, a=10, b=20)



# part2
# 两个带默认值的形参
def fn2(a=10, *, x=20):
    print(a, x)
fn2(100, x=200)
# 总结：
# 1.有默认值的参数可以不用传值
# 2.*前有默认值的叫默认值参数，属于位置形参，可以被位置及关键字实参进行传值
# 3.*后有默认值的叫有默认值的关键字形参，属于关键字形参，只能被关键字实参进行传值

# def get_p(name, sex='男'):
#     pass
# get_p('Bob', '女')


# part3
def fn3(a, b=10, *, x, y=20, z):
    print(a, b, x, y, z)
fn3(100, x=200, z=300)
# 总结：
# 1.没有默认值的必须传参，有默认值的可以传也可以不传
# 2.位置有值的必须出现在无值之后，关键字顺序不做要求

# part4
def fn4(a, b=10, *args, x, **kwargs):
    print(a, b, x)
    print(args)
    print(kwargs)
fn4(10, 20, 30, x=100, y=200, z=300)
# 总结：
# 1.可变长是用来接收未接收完的值(接收0到n个)：
#   -- *args用来接收所以没有接收完的位置(只能接收位置实参)
#   -- **kwargs用来接收所以没有接收完的关键字(只能接收关键字实参)
# 2.*args必须出现在所以位置参数之后，**kwargs必须出现在所以参数之后

# 假设第一个位置永远是参数name
def func4(*args, **kwargs):
    name = args[0]  # 将name抽出来

def func44(name, *args, **kwargs):
    # name 可以直接接收，省了抽出来的过程
    pass



# part5
def fn5(*args, **kwargs):
    print(args, kwargs)  # args=(10, 20)  kwargs={'x': 100, 'y': 200}

def fn55(*args, **kwargs):
    print(args, kwargs)  # args=(10, 20)  kwargs={'x': 100, 'y': 200}
    fn5(*args, **kwargs)  # *args就会把元组打散传递，**kwargs就会把字典打散传递

fn55(10, 20, x=100, y=200)

# 容器类型可以打散传值
def temp(*args, **kwargs):
    print(args, kwargs)
ls = [1, 2, 3, 4, 5]
dic = {'a': 1, 'b': 2}
temp(*ls, **dic)
 
转载于:https://www.cnblogs.com/qiangyuzhou/p/10787374.html

 
数组元素不能作形参，那么结构体成员可以作形参使用么？
 
看书的时候看到说数组元素只能做函数实参，不能做函数形参。我的理解是：
 
int F(int a[10])，其实此处a是一个指针变量(也就是数组名，c把数组名作为指针变量)，所以我们可以不限定里面的数组大小，int F(int a[ ]),所以数组元素作形参没意义。
 
那么结构体成员呢？ 可以作为形参么？ 感觉自己写的时候，不好下手，不论是定义，还是初始化。所以想请教大神告诉。然后最好能写个小小的例子参考下。
 
比如void days(int judge.year，int judge.month，int judge.day) 事先定义好judge为一个结构体。这样可以么？ 能不能写个例子来看看具体怎么实现？
 
结构体
 
形参
 
实参
 
c语言
 
函数
 
分享到：
 
------解决方案--------------------
 
不知　lz　为何会有此种需求，
 
如果函数定义中需要使用某中聚集型数据类型中的多个元素，一般用此聚集型数据类型作形参(数组用指针，结构体可以用指针也可以用其本身)
 
如果函数定义中只需要使用某中聚集型数据类型中的某一个元素，一般用此元素的数据类型作形参
 
------解决方案--------------------
 
在参数里使用数组，实际上会退化成普通的指针。
 
结构体的话不是这样用的，参数是有参数类型和类型名组成的。参数名只是个普通的名称，不能定义成XX.YY的形式。你想要传递结构体的成员，这是你调用时的事情，你调用的时候可以A(p.x,p.y)，但不能实现指定好。或者你可以让完整的一个结构体类型做参数，也可以是这个结构体的指针或引用(C++)
 
------解决方案--------------------
 
4L。。。 楼主很明显的说了结构体成员，还写了例子，不知所云
 
5L说得对 楼主你听他的吧
 
------解决方案--------------------
 
是的。数组和结构体积巨大，不合适在栈使用和传递。以引用的方式使用(也就是指针的方式)。
 
typedef struct {
 
char *ch;
 
}st,*pst;
 
void fun( pst s){
 
s->ch = ( char*)malloc(1024*1024);
 
}
 
char* func(void){
 
char *p = (char*)malloc(1024*1024);
 
return p;
 
}
 
这个例子十分夸张，这里这是想说明为什么是引用而不是传值。
 
void days(int judge.year，int judge.month，int judge.day)这个不需要这样做。
 
void fun( pst s){
 
s->成员名；这样你就可以访问结构的任意成员。
 
}
 
你想单独使用结构成员，区分一下指针和变量就可以了。
 
函数声明 void days(int a，int b，int c)
 
如果是结构指针，这样传递void days(judge->year， judge->month， judge->day)
 
如果是结构变量，这样传递void days( judge.year， judge.month， judge.day)
 
------解决方案--------------------
 
并不是说数组不能作形参, 只是说即使定义了数组作形参,也会自动退化成指针.
 
------解决方案--------------------
 
引用:Quote: 引用:可以的！其实只是一个地址而已了！在参数的时候，数组和指针差不多！几乎一样的！
 
结构体也比较简单了！只是一个地址进去就好！
 
typedef struct Judge
 
{
 
int year;
 
int month;
 
int day;
 
}Judge_s;
 
void days(Judge_s *pJudge)
 
{
 
// TODO something;
 
}我的意思是结构体成员，不是结构体，就是说结构体里面的每一个具体成员
 
比如申明函数时void days(int judge.year，int judge.month，int judge.day)可以么？
 
事先定义好judge含有year，month，day三个成员。
 
可以的啊！如果只是需要某一个成员的话，那就把这个成员当成参数传进去就好了！
 
一个结构体成员传参也是一样的！只有类型匹配就好！
 
------解决方案--------------------
 
#include 
 
using namespace std;
 
struct Date
 
{
 
int year;
 
int month;
 
int day;
 
};
 
void ShowDate(Date &d)
 
{
 
cout<
 
cout<
 
<
 
<
 
}
 
void ShowDate(Date *d)
 
{
 
cout<
 
cout<year<
 
<month<
 
<day<
 
}
 
//个人觉得，形参就是体现实参的类型和个数而已。
 
//如果要数组元素做形参，直接定义个和数组元素
 
//同类型的形参不就行了吗？不是很明白这句话。
 
void ShowDate(int year,int month,int day)
 
{
 
cout<
 
cout<
 
<
 
<
 
}
 
int main()
 
{
 
Date date={2013,11,18};
 
ShowDate(date);
 
ShowDate(&date);
 
ShowDate(date.year,date.month,date.day);
 
return 1;
 
}
 
个人见解，不足之处还望见谅！楼主加油！共勉！
 
------解决方案--------------------
 

 
------解决方案--------------------
 
引用:Quote: 引用:在参数里使用数组，实际上会退化成普通的指针。
 
结构体的话不是这样用的，参数是有参数类型和类型名组成的。参数名只是个普通的名称，不能定义成XX.YY的形式。你想要传递结构体的成员，这是你调用时的事情，你调用的时候可以A(p.x,p.y)，但不能实现指定好。或者你可以让完整的一个结构体类型做参数，也可以是这个结构体的指针或引用(C++)感觉这时候x.x已经就是一个类似指定好数据类型的变量，把它看作整体，比如结构体x的成员int x  可以看作int x.x x.x当作整体。不就可以作为形参出现了么？ 那么是编译器不通过这中格式？ 可以不可以把x.x赋给一个类型相同的变量，就可以作为形参了？  这样不就意味着它实际是可以？ 只是不支持x.x这种格式？ 好吧，我都没办法用具体的函数实现，所以都是臆想的。。。
 
理解有点不妥！函数传参的时候，只要类型和函数的原型匹配就好了！至于是结构体的成员，还是结构体中成员的成员都是没有关系的！因为编译器也不会知道！它只是检查传进来的参数和函数原型是否匹配就好！
 
------解决方案--------------------
 
感觉int judge.year完全不合语法的东西能用吗？真心没看过...
 
------解决方案--------------------
 
引用:

 
当形参是const时，必须要注意关于顶层const的讨论。如前所述，顶层const的作用于对象本身：
 
const int ci=42;  //不能改变ci，const是顶层的
 
int i=ci；   //正确：当拷贝ci时，忽略了它的顶层const
 
int *const p=&i;  //const是顶层的，不能给p赋值
 
*p=0;    //正确：通过p改变对象的内容是允许的，现在i变成了0
 
和其他初始化过程一样，当用实参初始化形参时会忽略掉顶层const。换句话说，形参的顶层const被忽略掉了。当形参有顶层const时，传给它的常量对象或者非常量对象都是可以的：
 
void fcn(const int i){  /*fcn能够读取i，但是不能向i写值*/}
 
调用fcn函数时，既可以传入const int也可以传入int。忽略掉形参的顶层const可以产生意想不到的结果：
 
void fcn(const int i) {/*fcn能够读取i，但是不能向i写值*/}
 
void fcn(int i)  {/*....*/}//错误：重复定义了fdn(int)
 
在C++语言中，允许我们定义若干具有相同名字的函数，不过前提是不同函数的形参列表应该有明显的区别。因为顶层const被忽略了，所以在上面的代码中传入两个fcn函数的参数可以完全一样。因此第二个fcn是错误的，尽管形式上由差异，但实际上它的形参和第一个fcn的形参没什么不同。
 
指针或引用形参与const
 
形参的初始化方式和变量的初始化方式是一样的，所以回顾通用的初始化规则有助于理解下面的知识。我们可以使用非常量初始化一个底层的const对象，但是反过来不行；同时一个普通的引用必须用同类型的对象初始化。
 
int i=42;
 
const int *cp=&i;  //正确：但是cp不能改变i
 
const int &r=i;   //正确：但是r不能改变i
 
const int &r2=42;   //正确
 
int  *p=cp;    //错误：p的类型和cp的类型不匹配
 
int &r3=r;    //错误：r3的类型和r的类型不匹配
 
int  &r4=42;  //错误：不能用字面值初始化一个非常量引用
 
将同样的初始化规则应用到参数传递上可得如下形式：
 
int i=0;
 
const int ci=i;
 
string::size_type ctr=0;
 
void reset(int &i);
 
reset(&i);  //调用形参类型是int *的reset函数
 
reset(&ci);  //错误：不能用指向const int对象的指针初始化int *
 
reset(i);   //调用参数类型是int&的reset函数
 
reset(ci);  //错误：不能把普通引用绑定到const对象ci上
 
reset(42);  //错误：不能把普通引用绑定到字面值上
 
reset(ctr); //错误：类型不匹配，ctr是无符号类型
 
//find_char的第一个形参是对常量的引用
 
find_char("hello world",'o',ctr);//可以绑定到字面值常量上
 
要想调用引用版本的reset，只能使用int类型的对象，而不能使用字面值、求值结果为int的表达式、需要转换的对象或者const int类型的对象。类似的，要想调用指针版本的reset只能使用int*。
 
另一方面，我们能传递一个字符串字面值作为find_char的第一个实参，这是因为改函数的引用形参是常量引用，而C++允许我们用字面值初始化常量引用。
 
尽量使用常量引用
 
把函数不会改变的形参定义成(普通的)引用是一种比较常见的错误，这么做带来给函数的调用者一种误导，即函数可以修改它的实参的值。此外，使用引用而非常量引用也会极大地限制函数所能接受的实参类型。就像刚刚看到的，我们不能把const对象、字面值或者需要类型转换的对象传递给普通的引用形参。
 
关于函数传参的其他问题(const形参实参/可变形参)
 
const 形参和实参 当形参是 const 变量时,实参是 const 或者不是 const 变量都可以. 实参初始化形参时会忽略掉顶层 const: void gel(const int a){ ...
 
C语言之形参和实参
 
一 形参与实参 1).定义 形参:形式参数. 就是定义函数的时候,写在函数名小括号后面的参数叫形参 实参:实际参数. 就是调用函数的时候,调用函数时写在函数名小括号后面的参数就叫实参 2).注意项 a ...
 
const形参与非const形参
 
在程序设计中我们会经常调用函数,调用函数就会涉及参数的问题,那么在形参列表中const形参与非const形参对传递过来的实参有什么要求呢? 先来看一个简单的例子: #include 
 
c++形参改变实参(对指针的理解
 
这几天搞逻辑比较晕,居然把指针的概念都混淆了. eg:int *p;//当然不对指针初始化在有些编译器是通不过编译的,比如VS(尤其是选中了SDL) 指针p是一个对象,定义开始没有分配了内存空间,只是 ...
 
C#形参，实参，值传递参数，引用传递参数，输出参数，参数数组的学习
 
1)形参 形参顾名思义就是形式上的参数,不是实际的参数,它代替实际传入方法的值.在方法体代码中代表了值本身参与运算.形参定义于参数中,它不同于方法体内局部变量,因为是一个变量,在它的作用域内不允许存在 ...
 
c++形参和实参同名时，如何单步执行观察形参的变化。
 
c++形参和实参同名时,如何单步执行观察形参的变化? 方法:当程序运行到函数中时,添加变量观察即可.
 
关于Java中形参与实参的理解
 
今天阅读了一个写的非常棒的博文,通过此博文再次复习了Java中参数传递的知识(即值传递与引用传递的区别).参考网站http://www.cnblogs.com/binyue/p/3862276.htm ...
 
JavaScript中函数的形参和实参的实现原理剖析
 
我们都知道JS里面参数的传递是可以不一样的,比如我们有一个函数: 
 
[C++程序设计]有关形参与实参,及返回值说明
 
有关形参与实参的说明:(1) 在定义函数时指定的形参,在未出现函数调用 时,它们并不占内存中的存储单元,因此称它们是 形式参数或虚拟参数,表示它们并不是实际存在的数据,只有在发生函数调用时,函数max ...
 
随机推荐
 
【Linux学习】Vi 操作命令集合
 
Vi 操作命令集合 进入vi的命令 vi filename :打开或新建文件,并将光标置于第一行首 vi +n filename :打开文件,并将光标置于第n行首 vi + filename :打开文 ...
 
sql server T-SQL 基础
 
SQL语言按照用途可以分为如下3类: ①DDL(Data Definition Language)  数据定义语言: 定义修改和删除数据库.表.索引和视图等 ②DML(Data Manipulatio ...
 
Deferred和Promise之间有什么区别呢？
 
一个promise就是一个由异步函数返回的对象. deferred对象就是jQuery的回调函数解决方案. 总结 jQuery 的ajax 就是返回一个promise 对象,里面含有done(), f ...
 
简洁之美 -约瑟夫环的python 解法
 
问题描述: 约瑟夫环问题:已知n个人(以编号1,2,3...n分别表示)围坐在一张圆桌周围.从编号为k的人开始报数,数到k的那个人出列:他的下一个人又从1开始报数,数到k的那个人又出列:依此规律重复下 ...
 
UGUI实现NGUI的UIEventListener功能
 
在unity中处理UI事件时,习惯了使用NGUI的UIEventListener,虽然UGUI也有AddListener,但是一个组件只能对应一个函数,不能在一个函数中同时处理多个事件,显得有些麻烦 ...
 
gitlab中批量删除本地以及远程tag的操作
 
git 批量删除标签# 删除所有远程标签git show-ref --tag | awk '{print ":" $2}' | xargs git push origin # 删除 ...
 
省钱版----查找 IoT 设备TTL线序__未完待续
 
作者:仙果 原文来自:省钱版—-查找 IoT 设备TTL线序 省钱版----查找 IoT 设备TTL线序__未完待续 缘由 在IoT固件调试分析的过程中,建议首先在IoT设备的板子上焊接调试线,这是能 ...
 
前端Js框架 UI框架汇总 特性 适用范围 选择
 
身为一个资深后端工程师,面对层出不穷的前端框架,总让人眼花缭乱,做一个综合解析贴,从全局着眼,让我们明白各种前端框架的应用范围,为如何选择前端框架,从不同的维度提供一些线索,做为一个长期优化贴,欢迎指 ...
 
Java NIO Test Case
 
package org.zwl.test.nio; import java.io.IOException; import java.net.InetSocketAddress; import java ...

 
return语句
 
语法：
 
return [表达式]
 
[ ]可以省略
 
作用：
 
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个对象的引用关系
 
说明：
 
1.return语句后跟的表达式可以省略，省略后相当于return None
 
2.如果函数没有return语句，则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句)
 
3.函数调用一定会返回一个对象引用
 
def myfun(a,b):
 
s=a+b#在函数内部定义的变量是局部变量
 
print("和是：",s)
 
return s#给调用者返回的值
 
# 此示例示意return语句的用法和执行过程
 
def myf1():
 
print("assdg")
 
print("vfsg")
 
return 100 #return语句执行后，后面的语句便不再执行，以遇到return马上回到调用函数的地方
 
print("wtehn")
 
v=myf1()#一遇到函数名加括号立马执行函数内容
 
print("我是返回值：",v)
 
练习：
 
写一个函数myMax,实现返回两个数的最大值：
 
如：
 
def myMax():
 
​ print(myMax(100,200)) #200
 
​ print(myMax(10,20)) #20
 
​ print(myMax(“abcd,”“abc”) #abcd
 
def myMax(a,b):
 
v=max(a,b)
 
return v
 
print(myMax(100,200))
 
print(myMax(20,10))
 
print(myMax("abcd","abc"))
 
写一个函数input_number()：
 
​ 。。。。。
 
此函数用来获取用户循环输入的整数，当用户输入负数时，结束输入
 
将用户输入的数以列表的形式返回，再用再建函数max,min,sum示出用户输入的最大值，最小值以及和
 
def input_number():
 
li=[]
 
sum=0
 
while 1:
 
i=int(input("请输入整数："))
 
if i<0:
 
break
 
if i not in li:
 
li.append(i)
 
for x in li:
 
sum+=i
 
print("最大值",max(li),"最小值：",min(li),"和：",sum)
 
return li
 
print(input_number())
 
Python函数的参数传递
 
传递方式
 
​ 位置传参
 
​ 序列传参
 
​ 关键字传参
 
​ 字典关键字传参
 
位置传参
 
实际参数(实参)的对应关系与形式参数(形参)的对应关系是按位置来一次对应的
 
示意：
 
def myFun(a,b,c):
 
pass
 
myFun(1，2，3)
 
说明：
 
实际参数和形式参数通过位置进行传递和匹配
 
实参个数必须与形参个数相同
 
# 此示例示意位置传参
 
def myFun(a,b,c):
 
print("a绑定的是：",a)
 
print("b绑定的是：",b)
 
print("c绑定的是：",c)
 
myFun(1,2,3)
 
序列传参
 
序列传参是指在函数调用过程中，用*将序列拆解后按位置传参的方式进行参数传递
 
def myFun(a,b,c):
 
print("a绑定的是：",a)
 
print("b绑定的是：",b)
 
print("c绑定的是：",c)
 
s=[1,2,3]
 
myFun(*s) #*表示把s拆开s[0,1,2]分别对应a,b,c
 
s2="asd"
 
myFun(*s2)
 
关键字传参
 
关键字传参是指传参时，按着形参的名称给形参赋值
 
实参和形参按照名称进行匹配，实参和形参可以不按位置分配
 
# 此示例示意关键字传参
 
def myFun(a,b,c):
 
print("a绑定的是：",a)
 
print("b绑定的是：",b)
 
print("c绑定的是：",c)
 
myFun(b=22,c=23,a=12) #实参和形参可以不按位置分配
 
字典关键字传参
 
是指实参为字典，将字典用**拆解后进行关键字传参
 
说明：
 
​ 字典的键名必须和形参名一致
 
​ 字典的键名必须是字符串
 
​ 字典的键名要在形参中存在
 
# 此示例示意字典关键字传参
 
def myFun(a,b,c):
 
print("a绑定的是：",a)
 
print("b绑定的是：",b)
 
print("c绑定的是：",c)
 
d={"c":12,"a":45,"b":23}
 
myFun(**d)#拆解字典后再传参
 
函数的综合传参
 
​ 函数传参方式，在能确定形参能唯一匹配到相应实参的情况下可以任意组合
 
说明：
 
传参时，先位置传参，后关键字传参
 
# 此示例示意综合传参
 
def myFun(a,b,c):
 
print("a绑定的是：",a)
 
print("b绑定的是：",b)
 
print("c绑定的是：",c)
 
myFun(100,*[200,400])
 
myFun(*"as",200)
 
myFun(1,**{"c":3,"b":5})
 
myFun(100,b=200,c=10)
 
myFun(**{"b":2,"c":2},a=1)
 
myFun(b=2,c=1,a=5)
 
练习
 
1.写一个函数sum3(a,b,c)
 
用于返回三个数的和
 
2.写一个函数pow3(x),用于返回x的三次方
 
用以上函数计算
 
1)，13+23+3**3
 
2)计算1+2+3的和的立方
 
def sum3(a,b,c):
 
d=a+b+c
 
return d
 
def pow3(x):
 
y=x**3
 
return y
 
print(sum(pow3(1),pow3(2),pow3(3)))
 
print(pow3(sum3(1,2,3)))
 
以下讲的是形参
 
函数的缺省参数
 
语法：
 
​ def 函数名(形参名1=默认实参，
 
​ 形参名2=默认实参2，
 
​ 形参名3=默认实参3.。。。)
 
说明
 
缺省参数必须自右至左依次存在，如果一个参数由缺省参数，则及右侧的所有参数必须有缺省参数
 
缺省参数可以有0个1个或多个，甚至全部都有缺省参数
 
如：
 
def test(a,b=10,c):------------------>错误！
 
# 以下示意缺省参数
 
def info(name, age=1, address="未填写"):
 
print(name,"今年", age,"岁", "家住：", address)
 
info('csaf',25)
 
info("暴风")
 
info("梵蒂冈",21,"浙江杭州")
 
练习
 
写一个函数，mySum(),可以传入两个实参或三个实参，
 
如果传入两个实参则返回两个实参的和
 
如果传入三个实参，则返回前两个实参和对第三个实参求余的结果
 
def mySum(a,b,c=None):
 
if c is None:
 
return a+b
 
return (a+b)%c
 
print(mySum(12,3))
 
print(mySum(12,4,5))
 
函数的形参定义方式
 
位置形参
 
星号元祖形参
 
命名关键字形参
 
双星号字典形参
 
位置形参
 
语法：
 
def 函数名(形参1，形参2，。。)：
 
语句块
 
星号元祖形参
 
语法
 
​ def 函数名(*元祖形参名)：
 
​ 语句
 
作用：
 
收集多余位置传参
 
说明：
 
元祖形参名通常用：“args”
 
练习
 
写一个函数，mySum,可以传入任意个实参的数字，返回所有实参的和
 
def mySum(*args):
 
return sum(args)
 
print(mySum(1,2,3,4,5,6,7,8))
 
命名关键字形参
 
语法：
 
def 函数名(*，命名关键字形参)：
 
语句
 
或
 
def 函数名(*args,命名关键字形参)：
 
语句
 
作用：
 
​ 所有的参数都必须用关键字传参或字典关键字
 
def fn(*,d,e): # * 是语法表示符
 
print("d=",d)
 
print("e=",e)
 
fn(d=200,e=300)# 所有传参必须是以关键字传参
 
fn(100,200) #不合法!不能用位置传参
 
fn(1,2,d=12,e=34) #不合法
 
def fn(*args,d,e):
 
print(args)
 
print("d=",d)
 
print("e=",e)
 
fn(1,2,d=12,e=34) # 合法
 
fn(*"as",**{"e":12,"d":4})
 
双星号字典形参
 
语法：
 
​ def 函数名(**字典形参名)：
 
​ 语句
 
作用：
 
收集多余的关键字传参
 
说明：
 
通常字典形参名定为
 
def func(**kwargs):
 
print("关键字参数个数是：",len(kwargs))
 
print("kwargs:",kwargs)
 
print(func(name="das",age=12))
 
函数的参数说明
 
缺省参数 位置形参 星号元祖形参 ，命名关键字形参和双星号字典形参可以混合使用
 
函数参数自左至右的顺序为：
 
位置形参
 
星号元祖形参
 
命名关键字形参
 
双星号字典形参
 
综合示例：
 
# # 综合示例
 
def f1(a,b,*args,c,**kwargs):
 
print("位置形参：",a,b)
 
print("星号元祖形参：",args)
 
print("关键字传参：",c)
 
print("双星号字典传参：",kwargs)
 
f1(12,34,*"gjfsdf",c=21,**{"name":"as","age":12})
 
函数不定长参数：
 
def fn(*args,**kwards):
 
pass
 
#可以接受任意的位置传参和关键字传参
 
def fn(*args, **kwards):
 
print(args)
 
print(kwards)
 
fn("as",12,2,23,34,45,**{"name":"dasf","afe":321})
 
练习
 
写一个myRange()函数，此函数返回一个符合rang规则的完整数列表
 
如：
 
L=myRange(3)
 
print(L) [0,1,2]
 
def myRange(start,stop=None,step=1):
 
li=[]
 
i=start
 
if stop is None:
 
stop=start
 
start=0
 
i=start
 
while i
 
li.append(i)
 
i+=1
 
if stop is not None:
 
while i
 
li.append(i)
 
i+=1
 
if step is not 1:
 
while i
 
li.append(i)
 
i+=step
 
return li
 
练习
 
​ 1.素数prime函数练习
 
​ 1)写一个函数isprime(x)判断x是否是素数，如果是返回True ,否则返回False
 
​ 2)写一个函数prime_m2n(m,n)
 
​ 返回从m开始到n结束(不包含n)的范围内的素数列表
 
​ 3)写一个函数primes(n),返回指定范围内素数(不包含n)的全部素数的列表，并打印这些素
 
​ 数
 
1)打印100以内的全部素数
 
2)打印100以内的全部素数和
 
def isPrimes(x):
 
if x<=1:
 
return False
 
for i in range(2,x):
 
if x%i!=0 or x==2:
 
return True
 
return False
 
def prime_m2n(m,n):
 
return [x for x in range(m,n) if isPrimes(x)]
 
def primes(n):
 
return prime_m2n(0,n)
 
print(prime_m2n(0,100))
 
print(sum(primes(100)))
 
2.修改之前的学生信息管理程序
 
​ 编写两个函数用于封装
 
​ 录入学生的信息和打印学生信息的功能
 
​ 1)def input_student():
 
​ #此函数获取学生信息，并返回学生信息的列表
 
​ 2) def output_student(L):
 
​ #以表格形式再打印学生信息
 
验证测试：
 
L=input_student()
 
output_student(L)
 
print(“在添加几个学生的信息”)
 
L+=input_student(L)
 
print(“添加后的学生信息如下：”)
 
l = []
 
def input_student():
 
while 1:
 
name = input("请输入学生姓名：")
 
if not name:
 
break
 
age = int(input("请输入学生年龄："))
 
score = int(input("请输入学生成绩："))
 
d = {} # 创建一个新的字典
 
d["name"] = name # 值 对 键
 
d["age"] = age
 
d["score"] = score
 
l.append(d)
 
def output_student(l):
 
print("+--------+-----+--------+")
 
print("| name | age |　score |")
 
print("+--------+-----+--------+")
 
for d in l:
 
t = ((d["name"]).center(8),
 
str(d["age"]).center(5),
 
str(d["score"]).center(8))
 
line = "|%s|%s|%s|" % t # t是元祖
 
print(line)
 
print("+--------+-----+--------+")
 
input_student()
 
output_student(l)