LINUX是什么时候诞生的

#这是python函数的格式
def function_name(arg1,arg2[,...]):
     statement
 [return value]  

#以下是示例，定义TEST函数
>>> a=2
>>> b=2
>>> def test(b):
 ...     test=a*b
 ...     return test
>>> print test(10)
 20

Python中函数的参数传递
1.普通的参数传递

>>> def add(a,b):
return a+b

>>> print add(1,2)
3
>>> print add('abc','123')
abc123

2.参数个数可选,参数有默认值的传递

>>> def myjoin(string,sep='_'):
return sep.join(string)

>>> myjoin('Test')
'T_e_s_t'
>>> myjoin('Test',';')
'T;e;s;t'

>>> def myrange(start=0,stop,step=1):
print stop,start,step

SyntaxError: non-default argument follows default argument

参数sep的缺省值是'_' 如果这个参数不给定值就会使用缺省值 如果给定 则使用给定的值
需要注意 如果一个参数是可选参数 那么它后面所有的参数都应该是可选的,另外 可选参数的顺序颠倒依然可以正确的给对应的参数赋值 但必须清楚的指明变量名和值
3.个数可变参数

>>> def printf(fmt,*arg):
print fmt%arg

>>> printf ('%d is larger than %d',2,1)
2 is larger than 1

函数中的*arg必须是最后一个参数,*表示任意多个参数,*arg会把除了前面以外所有的参数放到一个tuple里面传递给函数,可以在函数中通过arg来访问
arg是一个tuple,可以通过访问tuple的方法在函数中访问arg
另一种方式传递任意个数参数是通过dictionary的方式来传递 同样也可以接受多个参数 但是每个参数需要指明名称对应关系比如a=1,b=2,c=3

>>> def printf(format,**keyword):
for k in keyword.keys():
print "keyword[%s] %s %s"%(k,format,keyword[k])

>>> printf('is',one=1,tow=2,three=3)
keyword[three] is 3
keyword[tow] is 2
keyword[one] is 1

这些方法可以混在一起用 但是一定要注意顺序,函数会先接受固定参数,然后可选参数,然后任意参数(tuple),然后字典任意参数(dict)

对象vs变量
在python中，类型属于对象，变量是没有类型的，这正是python的语言特性，也是吸引着很多pythoner的一点。所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。所以，希望大家在看到一个python变量的时候，把变量和真正的内存对象分开。
类型是属于对象的，而不是变量。
这样，很多问题就容易思考了。
例如：

对象vs变量
12
    nfoo = 1   #一个指向int数据类型的nfoo（再次提醒，nfoo没有类型）lstfoo = [1]   #一个指向list类型的lstfoo，这个list中包含一个整数1

可更改(mutable)与不可更改(immutable)对象
对应于上一个概念，就必须引出另了另一概念，这就是可更改（mutable）对象与不可更改（immutable）对象。
对于python比较熟悉的人们都应该了解这个事实，在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。那么，这些所谓的可改变和不可改变影响着什么呢？
可更改vs不可更改
12345
    nfoo = 1nfoo = 2lstfoo = [1]lstfoo[0] = 2

代码第2行中，内存中原始的1对象因为不能改变，于是被“抛弃”，另nfoo指向一个新的int对象，其值为2
代码第5行中，更改list中第一个元素的值，因为list是可改变的，所以，第一个元素变更为2。其实应该说，lstfoo指向一个包含一个对象的数组。赋值所发生的事情，是有一个新int对象被指定给lstfoo所指向的数组对象的第一个元素，但是对于lstfoo本身来说，所指向的数组对象并没有变化，只是数组对象的内容发生变化了。这个看似void*的变量所指向的对象仍旧是刚刚的那个有一个int对象的list。
如下图所示：

python的函数参数传递：传值？引用？
对于变量（与对象相对的概念），其实，python函数参数传递可以理解为就是变量传值操作，用c++的方式理解，就是对void*赋值。如果这个变量的值不变，我们看似就是引用，如果这个变量的值改变，我们看着像是在赋值。有点晕是吧，我们仍旧据个例子。
不可变对象参数调用
12345
    def changeint( a ):    a = 10nfoo = 2 changeint(nfoo)print nfoo #结果是2

这时发生了什么，有一个int对象2，和指向它的变量nfoo，当传递给changeint的时候，按照传值的方式，复制了变量nfoo的值，这样，a就是nfoo指向同一个int对象了，函数中a=10的时候，发生什么？（还记得我上面讲到的那些概念么），int是不能更改的对象，于是，做了一个新的int对象，另a指向它（但是此时，被变量nfoo指向的对象，没有发生变化），于是在外面的感觉就是函数没有改变nfoo的值，看起来像c++中的传值方式。
可变对象参数调用
12345
    def changelist( a ):    a[0] = 10lstfoo = [2]changelist(lstfoo )print nfoo #结果是[10]

当传递给changelist的时候，变量仍旧按照“传值”的方式，复制了变量lstfoo 的值，于是a和lstfoo 指向同一个对象，但是，list是可以改变的对象，对a[0]的操作，就是对lstfoo指向的对象的内容的操作，于是，这时的a[0] = 10，就是更改了lstfoo 指向的对象的第一个元素，所以，再次输出lstfoo 时，显示[10]，内容被改变了，看起来，像c++中的按引用传递。