Python基础知识3：函数、三元函数、lambda函数

函数：包含自定义函数、内置函数
1）自定义函数结构：包含五个部分：def关键字：识别用于创建函数
函数名：比如f1
()：()里面有参数
函数体：具体这个函数要实现的功能
return：返回值，如果无，则返回none
如下所示：


2）函数的调用：用函数名+()
形式为：函数名（参数1，参数2），比如f1（5,8）
3）函数的执行顺序：自上至下。
    而函数体只有在被调用的时候才执行
    如果要取函数的返回值，需要赋值。
    函数体中的return后的语句不再执行。



执行结果：


案例1：自定义函数，因为没有调用函数，所以函数体不执行
def f1():
print('123')
return "111"

案例2，调用函数，执行函数体。函数体中一旦执行到return，则立即终止，因此后面的print（456）永远不会执行。def f1():
print('123')
return "111"
  print(456)

f1()

案例执行结果为：123案例3，结果为123、111，因为有return把值给了r，print（r）打印出来111def f1():
print('123')
#遇到return，函数体立即终止，
   return "111"  #把111赋值给r
r=f1()print(r)
案例执行结果为：123、111案例4：当函数无return的时候，自动默认返回值为None；返回结果为123、None，因为没有return，r接受到的值为Nonedef f1():
print('123')
r=f1()print(r)案例执行结果为：123、none案例5：python传递的是引用，不是复制，如下的li经过函数体执行后，已经被引用了def f1(a1):
a1.append(999)
li=[11,22,33,44]
print(li)
f1(li)
print(li) #因为已经执行过li，所以li为新的值，参数传递的是引用，不是复制执行结果：[11, 22, 33, 44][11, 22, 33, 44, 999]
4）函数的参数：
比如f（x1，x2，x3=1），x1，x2，x3则为参数包含的参数类型有：            普通参数：形式参数和实际参数
            默认参数：提前给定值，比如x3
            指定参数：实际参数调用时，可以改变顺序指定            动态参数：
                *args
                **kargs
                万能参数*args,**kagrs
案例1：区分形式参数和实际参数：案例中的xxx为形式参数，调用函数时传递的为实际参数
#此处的xxx为形式参数
def f1(xxx):
print('123')
return xxx+'wee'

#此处的ggg为实际参数
r=f1("ggg")
print(r)
案例2：理解参数的调用普通参数，x1、x2，在f1里面按顺序传递

def f1(x1,x2):
return x1+x2
r=f1("ggg","ccc")#按顺序分别对应x1，x2

默认参数，如果设置，则该形式参数必须放后面，如x3，调用时不用再次传递def f1(x1,x2,x3="acb"):
return x1+x2+x3
r=f1("ggg","ccc")#此处不需要x3
指定参数，指定参数可以改变顺序指定

def f1(x1,x2,x3="acb"):
return x1+x2+x3
f1(x2="ggg",x1="ccc")
print(r)

案例3：动态函数（函数名前加*，或者**）：一个形式参数，可以接受多个实际参数。当形式参数带*时，默认将传递的参数放置在群组中
当实际参数为普通参数传递时，即使列表，也会被作为一个元素传递
当实际参数有*时，list所有的元素将相应的作为元祖的每一个元素

def f1(*x):
print(x,type(x))
f1("55",66,"ll")
li=[11,22,33,"hhhh"]
f1(li)
f1(*li)

执行结果：('55', 66, 'll') <class 'tuple'>([11, 22, 33, 'hhhh'],) <class 'tuple'>(11, 22, 33, 'hhhh') <class 'tuple'>
当为**时，默认传递的参数放置在字典中，实际参数必须为指定参数或字典案例4：如果形式参数为**，传递实际参数的时候也传递**，则会把整个字典传进去def f1(**x):
print(x,type(x))
f1(n1="hh",n2="kk")
dic={'k1':'n1','k2':'n2'}
f1(**dic)执行结果：
{'n1': 'hh', 'n2': 'kk'} <class 'dict'>{'k1': 'n1', 'k2': 'n2'} <class 'dict'>
案例5：万能参数：f1（*args,**args），必须*在前，**在后def f1(*a,**x):
print(a,type(a))
print(x,type(x))
f1(11,22,33,**{'k1':'n1','k2':'n2'})
执行结果(11, 22, 33) <class 'tuple'>{'k1': 'n1', 'k2': 'n2'} <class 'dict'>
关于万能参数的应用，就是str.format案例6：用占位符传递，这样是*arg的应用#0、1为占位符，后面的实际参数按顺序传递
s1="i am {0},age{1}".format("hh","2")
s2="i am {0},age{1}".format(*["hh","2"])
print(s1)
print(s2)
执行结果：i am hh,age2i am hh,age2
案例7：当形式参数为字符变量时，必须后面指定参数传递，为**arg的应用s1="i am {name},age{age}".format(name="hh",age="2")
dic={'name':'nn','age':'4'}
s2="i am {name},age{age}".format(**dic)
print(s1)
print(s2)执行结果：i am hh,age2i am nn,age4
5）全局变量：作用在全局，用大写表示，如果要修改且作用于全局，则需要加global案例1：全局变量：作用域在全局，用大写表示。
NAME="hh"
def f1():
age=18
  print(age,NAME)
def f2():
age = 19
  print(age, NAME)
f1()f2()
执行结果：


案例2：修改全局变量：如果要修改且对全局有用，则可以用globalNAME="hh"
def f1():
age=18
  global NAME
NAME = "hh3"
   print(age,NAME)
def f2():
age = 19
  print(age, NAME)
f1()f2()执行结果：

案例3：修改全局变量：不加global，则仅作用在函数内部NAME="hh"
def f1():
age=18
  NAME = "hh3"
  print(age,NAME)
def f2():
age = 19
  print(age, NAME)
f1()f2()执行结果：



6）三元\三目运算：即if..else的简称。
格式为："为真时的结果   if 判定条件    else 为假时的结果" ，
“condition ? true_part : false_part”
案例1：如果1==1条件成立，就等于前面的值，否则为后面的值hhhif 1==1:
name="alex"
else:
name="hhh"
#简写为以下：
name2="alex" if 1==1 else "hhh"6）lambda函数：目的就是简化用户定义使用函数的过程
案例1：lambda函数，简写函数，一个参数def f1(a1):
return a1+100
ret=f1(10)
print (ret)#案例可以简写f2=lambda a1:a1+100
r1=f2(19)
print(r1)案例2：lambda函数，简写俩参数f2=lambda a1,a2:a1*a2+100 #也可以默认值
r1=f2(19,10)
print(r1)
执行结果为：290案例3：应用lambda函数
words=[1,2,3,4,5,6]
key=lambda w:words[w]
r=key(2)
print(r)
执行结果为：3案例4：循环用法案例
word='the'
n=3
alphabet='uxyz'
s3=[word[0:i]+c+word[i+1:] for i in range(3) for c in alphabet]
print(s3)执行结果为：


7）python有很多内置函数，可以直接使用
可参考：http://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html



案例链接：https://pan.baidu.com/s/1nvgivdn 密码：mvfc