python function

def function_name() :

　　函数体

　　return  ## 可以有，表示这个函数会结束，中断函数 并返回 一个值,这个值可以自己定义

　　　　　　## 没有return 返回None ，

 

执行成功 退出时0，失败非0

function_name()   ## 执行这个函数

function_name  >>>这个函数的内存地址

f= function_name

f()  >> 也会执行这个函数

 

函数接受返回值

ret = function_name()

print (ret)

def fun():
    print ("33333333")
    ret = 123
    try:
        print ("2222222")
    except Exception:
        ret = 456
    return  ret   

 

 

函数参数

def fun(user):

　　函数体

　　return xxx

函数 参数详细介绍

"""
形参：函数定义时候括号里面的参数
实参：函数调用阶段，括号里面的参数，在调用阶段建立对应关系

"""


# 无参数
def fun():
    print ("33333333")
    ret = 123
    try:
        print ("2222222")
    except Exception:
        ret = 456
    return  ret

print (fun()) # print ret
""


#多个参数
def show(arg,xxx): # 一定要是两个参数，
    print (arg,xxx)
show("1111","2222") # 按照位置顺序依次传给形参，位置参数
show(xxx=2222,arg=1111)  # 关键字参数
show("1111",xxx="2222") # 位置参数一定要放在关键字参数前面
# 不能是show(xxx="2222"，"1111")


# 默认参数，在函数定义阶段，已经为形参赋值了，默认参数 在调用阶段可以传值也可以不传
# 默认参数只在定义阶段赋值一次，后面赋值不会改变默认参数的值
# 默认参数的值 ，只能是不可变类型如元组，字符串，不能是列表，字典
def show(a1,a2="9999",a3="555"):  ## 默认参数只能放在后面
    print (a1,a2,a3)
show ("333") # 没有a2 值 就等于默认值 a1=333,a2=9999,a3=555
show("1111","2222")  #a1=1111,a2=2222,a3=555

# 指定参数
def show (a1,a2):
    print (a1,a2)

show (1,2)
show (a1=2,a2=1)
show(1,a2=3)

#动态参数
# 实参个数不确定
# "*" 接受多余的 位置参数


def show (x,y,*arg): # x,y 是位置参数，位置实参就是show(1,2,3,4),位置形参x=1，y=2 ，多余的实参传给* 元组里面
                                # 如果实参是 关键字参数需要指名道姓的赋值，x,y 要明确赋值，x=1,y=2
    print (arg,type(arg))
show (1,2,3,4)
# 转化为元组(3,4)
#1,2,(3,4)
show(5,6,*[7,8]) # 等于 show(5,6,7,8)> x=5,y=6,arg=(7,8)


# "**" 接受多余的关键字参数

def show (x,y,**arg): #位置形参 x，y
    print (arg,type(arg))
show (x=4,y=5,n1=1,n2=2,n3=3) # x=1 , y=2 , arg = {n1=1,n2=2,n3:3}，当函数传的是关键字实参，里面必须是要明确赋值x,y，x=4,y=5
#如果实参 是 采用 关键字参数赋值形式，必须明确在实参里面指明 x=4,y=5，如果不符和位置参数个数或变量名，就会报错
## 转化为字典
show(x=4,y=5,**{"n3":3,"n4":4}) # 等于 show(x=4,y=5,"n3"=3,"n4"=4)
dic = {"x":1,"y":2,"z":3}
show(**dic) #等于 show(x=1,y=2,z=3)

# 命名关键字参数
# 形参中，在 * 后面的参数就是
# 传参时，必须按照关键字实参形式传,
# 参数位置放值 （位置参数，默认参数，*args，命名参数）
def foo(x,y,*args,c=5,a,b): # c,a,b 是命名关键字参数
    print(x,y,a,b,)

foo(1,2,a=3,b=4)
foo(1,2,3,4,a=10,b=12)

def show (*args,**kwargs):
    print (args,type(args))
    print (kwargs,type(kwargs))
show (1,2,3,4,n1=1,n2=2,n3=3)
l=[5,6,7,8]
d={"k1":22,"k2":33,"k3":44}
show(l,d)  #当作两个元素，搞到一个元组，字典没有元素
## (([5, 6, 7, 8], {'k3': 44, 'k2': 33, 'k1': 22}), <type 'tuple'>)
##({}, <type 'dict'>)
show(*l,**d)
#((5, 6, 7, 8), <type 'tuple'>)
#({'k3': 44, 'k2': 33, 'k1': 22}, <type 'dict'>)

#
# #函数格式化
# s1 = “{0} is {1}”
# result = s1.format("alex","2b")
# print (result)
#
#
# s1 = “{0} is {1}”
# l=["alex","2b"]
# result = s1.format(*l)
# print (result)
#
# s1= "{name} is {acter}"
# result = s1.format(name="alex",acter= "sb")
# result = s1.format(**d)
# print (result)


#lambda   函数
#简单函数
func = lambda a:a+1
ret=func(99)
print (ret)
#ret=100
# a:形参，可以多个
# a+1 :函数体，只能一行，并把结果return

def foo(x,y,*args):
    print (x,y,args)
foo(1,2,3,4,5) #(1, 2, (3, 4, 5))
foo(1,2,*[3,4,5,6]) #(1, 2, (3, 4, 5, 6))
foo(*[1,2,3,4,5,6,7]) #(1, 2, (3, 4, 5, 6, 7))

def foo1(x,y,z):
#    print ("x=%s,'y'=%s,'z'=%s"%(x,y,z))
    print(x,y,z)
foo1(*[1,2,3]) #1, 2, 3
foo1(**{'z':2,'x':1,'y':3}) #1 3 2 # 输出还是 x，y，z 对应的值



def foo2(x,y,**kwargs):
    print (x,y,kwargs)
foo2(1,2,**{'a':1,'b':2}) #  1, 2, {'a': 1, 'b': 2} # 传入的是字典 **kwargs 就输出字典

foo2(1,y=2,a=1,b=2,c=3) #   1 2 {'b': 2, 'c': 3, 'a': 1} # 传入的是字典对应关系 **kwargs 也是输出字典

def foo3(x,y,*args,a,b,**kwargs): # a,b 必须要有值，可以是默认值也可以传值
    print ("x=%s,y=%s,args=%s,a=%s,b=%s,kwargs=%s"%(x,y,args,a,b,kwargs))
    if args:
        for i in args:
            print("args",i)
    if kwargs:
        for i in kwargs:
            print("kwargs",i)
foo3(1,2,3,4,5,a=3,b=6,c=4,d=5)
# x=1,y=2,args=(3, 4, 5),a=1,b=3,kwargs={'c': 4, 'd': 5}
# x=1,y=2,args=(3, 4, 5),a=3,b=6,kwargs={'d': 5, 'c': 4}

foo3(1,2,a=3,b=6,c=4,d=5)
# x=1,y=2,args=(),a=3,b=6,kwargs={'d': 5, 'c': 4}
foo3(1,2,a=3,b=6)
# x=1,y=2,args=(),a=3,b=6,kwargs={}

def foo4(a,b,c,d,*args,**kwargs):
    if args:
        for i in args:
            print("args",i)
    if kwargs:
        for i in kwargs:
            print("kwargs",i,kwargs[i])
    print(a,b,c,d,args,kwargs)
    mdadm_param = "mdadm -CR /dev/%s --level %s --raid-devices %s %s "%(a,b,c,d)
    for  i in kwargs:
        if i == "spare_devices" :
            mdadm_param += "--%s %s %s " %(i,kwargs[i][0],kwargs[i][1])
            continue
        if "bitmap" in i:
            mdadm_param += "--%s=%s " % (i, kwargs[i])
            continue
        mdadm_param += "--%s %s " %(i,kwargs[i])

    if "_" in mdadm_param:
         mdadm_param = mdadm_param.replace("_","-")

    print(mdadm_param)
foo4("md0","1","2","/dev/sdb /dev/sdc",
     metadata=1.2,bitmap="internal",
     bitmap_chunk="1M",
     spare_devices=[1,"/dev/sde"],
     write_journal="/dev/sdc",
     chunk = "64M")


"""
命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），
且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字

"""

 

 

 

 

 

 
def show (*args,**kwargs):
print (args,type(args))
print (kwargs,type(kwargs))
show (1,2,3,4,n1=1,n2=2,n3=3)
l=[5,6,7,8]
d={"k1":22,"k2":33,"k3":44}

show(l,d) #当作两个元素，搞到一个元组，字典没有元素
## (([5, 6, 7, 8], {'k3': 44, 'k2': 33, 'k1': 22}), <type 'tuple'>)
##({}, <type 'dict'>)

show(*l,**d)

#((5, 6, 7, 8), <type 'tuple'>)
#({'k3': 44, 'k2': 33, 'k1': 22}, <type 'dict'>)

 

#函数格式化
s1 = “{0} is {1}”
result = s1.format("alex","2b")
print (result)


s1 = “{0} is {1}”
l=["alex","2b"]
result = s1.format(*l)
print (result)

s1= "{name} is {acter}"
result = s1.format(name="alex",acter= "sb")
result = s1.format(**d)
print (result) 

 

 

 #lambda 函数
#简单函数
func = lambda a:a+1
ret=func(99)
print (ret)
#ret=100
# a:形参，可以多个
# a+1 :函数体，只能一行，并把结果return

 

 

 

 

 

内置函数

abs() 绝对值

all() 所有的元素都是真才是真

None ,空，False ，0  >>>  假

any() ,只有有一个真，就是真

In [30]: any(["",[],(),None])
Out[30]: False

In [31]: bin(10) # 二进制
Out[31]: '0b1010'