python加参数
Ⅰ python中函数参数带 ' ：'
def __init__(self, root: TreeNode):
等效于
def __init__(self, root):
: TreeNode只是对root参数的说明。
python 是弱类型语言，解释器不会对root传入的数据类型做限制，但你的这个类，是希望创建实例，传入的是TreeNode类对象，所以通过这种方式来提醒引用者。
Ⅱ 用python脚本怎么累加文件的参数
思路：
新建列表
for循环
os获取参数
list.append
Ⅲ Python方法的几种常见参数类型
无默认值参数（关键字参数）：
defmyfun(a):
print(a)
这是参数的最简单形式。这个a就是无默认值参数。在调用函数时必需为无默认值参数指定值。
无默认值参数可以通过两种方式来指定值：
#按参数定义顺序不指名传递值
myfun('/src/image')
#无视定义顺序，通过关键字指定值
myfun(a='/src/image')
无默认值参数在函数内部使用关键字作为变量名来访问
无默认值参数可以有多个，也是一些其它参数类型的基础。
默认值参数：
如果在定义时为参数指定一个默认值，那么，这个参数就可以在调用时不指定值：
defmyfun(a=''):
print(a)
#不为a指定值
myfun()
#按定义顺序为a指定值
myfun('/src/lib')
#通过关键字为a指定值
myfun(a='/src/lib')
在定义时，所有默认值参数只能出现在所有无默认值参数之后，也就是说，在函数的定义中，要先定义无默认值参数，再定义默认值参数。
不定长参数：
在参数名之前添加一个*号，则该参数称为不定长参数。一个函数只可以有一个不定长参数。不定长参数的定义位置没有限制，它可以定义在无默认值参数之间，也可以定义在默认值参数之后，或者它们之间的任何一个位置。
在调用时，不定长参数之后定义的无前两种类型的参数就只能使用关键字来指定值了。
不定长参数在函数内部被处理为一个tuple。
def_max(*e,base=9):
print('called"_max":')
print('e:',e)
print('base:',base)
#只向不定长参数传递了值
#输出:
#called"_max":
#e:(3,4,5)
#base:9
_max(3,4,5)
#也向默认值参数base传递了值
#输出:
#called"_max":
#e:(3,4)
#base:5
_max(3,4,base=5)
#直接通过一个元组传递不定长参数的值
#输出：
#called"_max":
#e:(3,4)
#base:5
p=(3,4)
_max(*p,base=5)
#使用混合方式传递不定长参数
#输出：
#called"_max":
#e:(3,4,5,6,7)
#base:10
p1=(3,4)
p2=(6,7)
_max(*p1,5,*p2,base=10)
调用函数时如果没有为不定长参数指定值，将导入一个空元组。
不定长关键字参数：
不定长关键字参数使用两个星号作为前缀与其它类型的参数区分，它在函数内被导入为一个字典。调用时需要为不定长关键字参数给出约定的关键字名，赋值形式如同无默认值参数。
一般情况下，不定长参数是作为最后一个参数来定义。
defmyfun(**kw):
print(kw)
myfun(base=1,home='aaaa')
以上只是基本的调用方式，有些时候，可以有更有趣的调用方式，例如定义了一个既含无默认值参数也含默认值参数的函数：
defiter_dir(homedir,exts='*',includesubdir=False,monoinfile=False,
titlere='^[^^].*',textengine=default_textengine,
encode=None):
调用时也可以用这样的方式来传递值：
kwgs={'homedir':'C:/Users/hunte/Documents/yun/阿瑟·C·克拉克',
'exts':'txt',
'includesubdir':True}
myiter=iter_dir(**kwgs)
forfileinmyiter:
pass
Ⅳ python 传参数cmd怎么往python中传参数
如果你用C给Matlab写过MEX程序，那么这个问题是很容易理解的（好像每次讨论Python问题时我总是把Matlab搬了出来…… 《在Matlab中把struct当成Python中的Dictionary使用》《Matlab和Python的几种数据类型的比较》）。
既然提到了MEX，就简单说一下：
一个Matlab可能形如
function ret=add3(a,b,c)
如果在C的层面实现这个函数，就会看到另一种景象：
void mexFunction(int nlhs,mxArray * plhs[],int nrhs,const mxArray * prhs[])
a,b,c三个参数的地址放在一个指针数组里，然后把这个指针数组的首地址作为参数prhs传递给函数，这说明Matlab函数的参数是传递指针的，而不是值传递。
纵然是传递的指针，但是却不能在函数里改变实参的值，因为标记为逗const地了。
Python是开放源码的，我没有看。所以下面很多东西是猜的。
Python在函数的参数传递时用的什么手法看实验一下（使用ActivePython2.5）：
首先介绍一个重要的函数：
>>> help(id)
Help on built-in function id in mole __builtin__:
id(...)
id(object) -> integer
Return the identity of an object. This is guaranteed to be unique among
simultaneously existing objects. (Hint: it's the object's memory address.)
看最后括号里那句：Hint:it's the object's address.（它是对象的地址）
有了这个函数，下面的事情就方便多了。
>>> a=0
>>> id(a)
3630228
>>> a=1
>>> id(a)
3630216
可以看出，给a赋一次值，a的address就改变了。在C的层面看，（也许真实情况不是下面的样子，但作为一个类比应该还是可以的）：
void * pa;
pa=malloc(sizeof(int));
*(int *)pa=0;
free(pa);
pa=malloc(sizeof(int));
*(int *)pa=1;
Python中每次赋值会改变变量的address，分配新的内存空间，所以Python中对于类型不像C那样严格要求。
下面看看Python函数参数传递时到底传的什么：
有一个函数：
>>> def changeA(a):
... print id(a)
... a=100
... print id(a)
设定一个变量var1：
>>> var1=10
>>> id(var1)
3630108
>>> changeA(var1)
3630108
3631012
>>> var1
10
调用函数后，从两次print的结果可以看出，传递确实是地址。但是即便如此，在函数内对形参的修改不会对实参造成任何实质的影响，因为对形参的重新赋值，只是改变了形参所指向的内存单元（changeA里两次调用print id(a)得到不同的结果），却没有改变实参的指向。在C的层面看也许类似下面的情节：
void changeA(void * pa)
{
pa=malloc(sizeof(int));
*(int *)pa=100;
free(pa);
}
精通C的你一眼就看出这个函数永远也改变不了它外面的世界。
也就是说虽然传递的是地址，但像changeA这样的函数改变不了实参的值。
也许会感到困扰看不，我已经在Matlab中习惯了。
一个最典型的例子就是Matlab中删除结构体成员的rmfield函数（参见《Matlab笔记三则》），
（Matlab版本7.0.1）
如果想删除结构体patient的name成员，用
rmfield(patient, 'name');
是永远达不到目的的（就像试图用双手抓住自己的领子，把自己提到空中）；
迷途知返的做法是：
patient = rmfield(patient, 'name');
Ⅳ python 类中增加类,如何调节增加类中的参数
可以在cateen init函数传递参数传递给kfc
Ⅵ 在python中，if前加参数是什么意思
这是个表达式
解释：如果bias有值的话self.bias赋值为bias；否则赋值为random.random()随机数。
Ⅶ python传入参数的问题
python在定义函数的时候，存在两种特殊定义，*和**的传值方式，正是因为这两种定义，python 函数的传值，非常灵活，在cpp编程的时候，不支持方法重载，因为没必要了。。。
在参数前面加个*号，表明这个函数会将这个变量代表的内容，转换为一个元祖，所以函数可以接收N个元素，这N个元素在函数里面转成一个元祖。比如这种
deffun1(*a):#定义
print(a)#1输出
print(*a)#2输出
x=[1,2,3]
fun1(x)#1调用
fun1(*x)#2调用
fun(1,2,3)#3调用
因为fun1定义的时候，告诉函数，x可以接受N个对象，这个对象在函数里面会转成一个元祖保存，所以在1调用的时候，x在fun1函数里面会被当成一个元祖，但我们知道，x其实是一个元祖，1调用的时候，就传了一个对象进去。所以，结果如下
（[1,2,3],） #1输出
[1,2,3] #2输出
为啥？1输出，清楚无误的告诉print（print也是函数，也支持*args方式传值），你直接把a对象打印出来，a对象是啥？一个包含1个对象的元祖，所以就是（x,）这样的结果。那2输出呢？2输出在调用的时候，在a对象前面已经拆解了元祖，所以，传给print函数的，是一个对象，就是x了。
同理，在2调用的时候，因为x对象被拆开，所以，func1被传入多个值，此时的a是一个元素和x相同的元祖。所以2调用的1输出，就是一个值，就是（1，2，3）。2输出，因为被拆解了再传给print，所以，print其实被传入了多个值，然后将这些值全部打印出来，所以结果是1，2，3.
那3调用呢？其实本质和2调用是一样的
那双星号呢？双星号是拆解key-val格式对的内容，在函数定义的时候，是默认讲传入的产生转为字典。而规律和上面说的单星号一致。如果用单星号去拆解key-val对象，只会拆解出key。后面的就不多说了。
为啥单引号拆解key-val对象，可以拆出key呢。。。源代码就这么执行的，为啥当初设计，理由是啥。。。不清楚。。
Ⅷ 批处理中运行python程序 并传入n个参数，怎么写。
python 包含一个"argparse"的模块，提供了异常强大的参数解析功能。下面是一个简单的例子
#!/usr/bin/envpython
#coding:utf-8
#
importsys
importargparse
if__name__=="__main__":
parser=argparse.ArgumentParser(
description='')
parser.add_argument(
'integers',metavar='int',nargs='+',type=int,
help='anintegertobesummed')
parser.add_argument(
'--log',default=sys.stdout,type=argparse.FileType('w'),
help='')
args=parser.parse_args()
args.log.write('%s '%sum(args.integers))
args.log.close()
$ ./test2.py 1 2 3 4 5 6 7
28
$ ./test2.py 633 132
765
$
Ⅸ python中怎样在参数中加入变量
1、临时添加，在一个shell窗口中
import sys
sys.path
sys.path.append(path)
但退出该shell窗口，即失效。
2 使用pth文件永久添加
使用pth文件，在 site-packages 文件中创建 .pth文件，将模块的路径写进去，一行一个路径，以下是一个示例，pth文件也可以使用注释：
# .pth file for the my project(这行是注释)
E:\DjangoWord
E:\DjangoWord\mysite
E:\DjangoWord\mysite\polls
这个不失为一个好的方法，但存在管理上的问题，而且不能在不同的python版本中共享
3 使用PYTHONPATH环境变量
使用PYTHONPATH环境变量，在这个环境变量中输入相关的路径，不同的路径之间用逗号（英文的！)分开，如果PYTHONPATH 变量还不存在，可以创建它！
路径会自动加入到sys.path中，而且可以在不同的python版本中共享！
Ⅹ python怎样接收参数
Python中函数参数的传递是通过“赋值”来传递的,函数参数的接收传递有四种形式：
1. F(arg1,arg2,...)
2. F(arg2=,arg3=...)
3. F(*arg1)
4. F(**arg1)
第1
种方式是最“传统”的方式：一个函数可以定义不限个数参数，参数(形式参数)放在跟在函数名后面的小括号中，各个参数之间以逗号隔开。用这种方式定义的函数在调用的时候也必须在函数名后的小括号中提供相等个数的值(实际参数)，不能多也不能少，而且顺序还必须相同。也就是说形参和实参的个数必须一致，而且想给形参1的值必须是实参中的第一位，形参与实参之间是一一对应的关系，即“形参1=实参1
形参2=实参2...”。很明显这是一种非常不灵活的形式。比如："def addOn(x,y): return x +
y"，这里定义的函数addOn，可以用addOn(1,2)的形式调用，意味着形参x将取值1,主将取值2。addOn(1,2,3)和addOn
(1)都是错误的形式。
第2种方式比第1种方式好一点，在定义的时候已经给各个形参定义了默认值。因此，在调用这种函数时，如果没有给对应的形式参数传递实参，那么这个形参就将使用默认值。比如：“def
addOn(x=3,y=5): return x +
y”，那么addOn(6,5)的调用形式表示形参x取值6，y取值5。此外，addOn(7)这个形式也是可以的，表示形参x取值7，y取默认值5。这时候会出现一个问题，如果想让x取默认值，用实参给y赋值怎么办?前面两种调用形式明显就不行了，这时就要用到Python中函数调用方法的另一大绝招
──关健字赋值法。可以用addOn(y=6)，这时表示x取默认值3，而y取值6。这种方式通过指定形式参数可以实现可以对形式参数进行“精确攻击”，一个副带的功能是可以不必遵守形式参数的前后顺序，比如：addOn(y=4,x=6)，这也是可以的。这种通过形式参数进行定点赋值的方式对于用第1种方式定义的函数也是适用的。
上面两种方式定义的形式参数的个数都是固定的，比如定义函数的时候如果定义了5个形参，那么在调用的时候最多也只能给它传递5个实参。但是在实际编程中并不能总是确定一个函数会有多少个参数。第3种方式就是用来应对这种情况的。它以一个*加上形参名的方式表示，这个函数实际参数是不一定的，可以是零个，也可以是N个。不管是多少个，在函数内部都被存放在以形参名为标识符的tuple中。比如：
对这个函数的调用addOn() addOn(2) addOn(3,4,5,6)等等都是可以的。
与第3种方式类似，形参名前面加了两个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中。这时候调用函数必须采用key1=value1、key2=value2...的形式。比如：
1. def addOn(**arg):
2. sum = 0
3. if len(arg) == 0: return 0
4. else:
5. for x in arg.itervalues():
6. sum += x
7. return sum
那么对这个函数的调用可以用addOn()或诸如addOn(x=4,y=5,k=6)等的方式调用。
上面说了四种函数形式定义的方式以及他们的调用方式，是分开说的，其实这四种方式可以组合在一起形成复杂多样的形参定义形式。在定义或调用这种函数时，要遵循以下规则：
1. arg=必须在arg后
2. *arg必须在arg=后
3. **arg必须在*arg后
在函数调用过程中，形参赋值的过程是这样的：
首先按顺序把“arg”这种形式的实参给对应的形参
第二，把“arg=”这种形式的实参赋值给形式
第三，把多出来的“arg”这种形式的实参组成一个tuple给带一个星号的形参
第四，把多出来的“key=value”这种形式的实参转为一个dictionary给带两个星号的形参。
听起来好复杂，实际是是很简单的。很直观，来看例子：
1. def test(x,y=5,*a,**b):
2. print x,y,a,b
就这么一个简单函数，来看看下面对这个函数调用会产生什么结果：
test(1) ===> 1 5 () {}
test(1,2) ===> 1 2 () {}
test(1,2,3) ===> 1 2 (3,) {}
test(1,2,3,4) ===> 1 2 (3,4)
test(x=1) ===> 1 5 () {}
test(x=1,y=1) ===> 1 1 () {}
test(x=1,y=1,a=1) ===> 1 1 () {'a':1}
test(x=1,y=1,a=1,b=1) ===> 1 1 () {'a':1,'b':1}
test(1,y=1) ===> 1 1 () {}
test(1,2,y=1) ===> 出错，说y给赋了多个值
test(1,2,3,4,a=1) ===> 1 2 (3,4) {'a':1}
test(1,2,3,4,k=1,t=2,o=3) ===> 1 2 (3,4) {'k':1,'t':2,'o':3}