python day11

字符串的比较

1、单个字符的比较就是ascii码的比较（对应的十进制）

　　'A'->65     'a'->91

　　　　--->'a' > 'A'

2、多个字符的字符串比较就是一一对应的单个字符的比较，一旦比较出结果就终止比较

　　'aBc' < 'aA'

函数的参数

形参与实参

　　--实参：有实际意义的参数

　　　　　　--在函数调用中，（）里面传入的参数

　　--形参：本身没有意义，有实参对它进行赋值之后就具有意义

　　　　　　--在函数定义过程中，函数名后面（）中用来定义函数的参数

形参范畴

def add(n1,n2):　　　　#这里的n1,n2本身没有意义，但如果被什么意义的参数赋值，他就具有了什么意义

　　return n1,n2

实参范畴

print(add(1,2))　　　　#这里的1和2就是实参，实际传入函数的参数

形参是对实参的值拷贝（实参赋值给形参时，两个id地址一样）

　　当实参是不可变类型时，形参在函数内部发生发生改变对外部的实参没有影响

　　　　def fn(num):

　　　　　　num = 20

　　　　　　return num

　　　　num = 10

　　　　fn(num)　　　　#这里的num是实参

　　　　print(num)　　#虽然调用函数内部的num重新赋值，但是10是不可变类型，所以这里的num还是10

　　当实参是可变类型时，形参在函数内部发生改变，外界的实参随之变化

　　　　def fn(num):

　　　　　　num.append(1)

　　　　　　return num

　　　　num = [10]

　　　　fn(num)　　　　#这里的num是实参

　　　　print(num)　　#调用函数内部的num内部发生改变，这里[10]是可变类型，所以这里的num是[10,1]

实参的分类

def fn(n1,n2):

　　return n1,n2

1、位置实参

　　--一定按照位置进行传参，且形参和实参的位置必须要一一对应，不然报错

　　　　a = 10

　　　　b = 20

　　　　fn(a,b)

2、关键字实参

　　--用关键字指名道姓的传参，位置可以颠倒

　　　　fn(n1=10,n2=20)　　=>n1=10,n2=20

　　　　fn(n2=20,n1=10)　　=>n1=10,n2=20

#注：（传参规则）传参时，位置实参必须放在关键字实参之前

形参的分类

1、位置形参（无值位置形参）

　　可以被位置实参和关键字实参传值，必须传值

2、默认形参

　　可以被位置实参和关键字实参传值，可以不传值，采用默认值,只在定义的时候赋值一次,我们一般赋值不可变类型

3、可变长位置形参

　　可以接收位置形参和默认形参没有接收完的值，只能接收位置实参传值，接收数量0~N个，用元组接收，0个就是空元组

4、无值关键字形参

　　只能被关键字实参传值，必须传值

5、有值关键字形参

　　只能被关键字实参传值，可以不传值，采用默认值

6、可变长关键字形参

　　可以接收4和5没有接收完的值，只能接收关键字实参传值，接收数量0~N个，用字典接收，0个就是空字典

函数定义时的声明顺序：位置形参-->默认形参-->可变长位置形参-->无值关键字形参-->有值关键字形参-->可变长关键字形参

#注：1、位置形参传值时一定要按顺序传值，关键字形参传值时可以不按顺序

 　　 2、可变长位置形参只能接收位置实参，要想被附上值，前面的默认形参就没有意义。

　　  3、args和kwargs时可变长形参的变量名，所以是可以自定义的，但是我们约定俗成用args和kwargs

常出现的组合

1）def f1(*args,**kwargs): pass　　　　#第一类

----------------------------------------------------

2）def f2(a,b=10,**kwargs): pass  

3）def f3(a,*args,**kwargs): pass　　　 #第二类

----------------------------------------------------

4）def f4(a,*,x,**kwargs): pass

5）def f5(a,*args,x,**kwargs): pass　　   #第三类

打散机制

def fn(*args,**kwargs):

　　print(args)

　　print(kwargs)

*单列容器 会打散单列容器   #单列容器在print下也可以打散

　　作为参数进行传值时，必须在前面加上*，才可让单列容器被打散且全被args接收

**双列容器 会打散双列容器 　　

　　作为参数进行传值时，必须在前面加上**，才能把双列容器打散并被kwargs接收

案例：

def fn(*args,**kwargs):
    print(args)
    print(kwargs)
fn((1,2,3),{'a':1,'b':2})       #((1, 2, 3), {'a': 1, 'b': 2})
                                #  {}    不加*号都会被作为位置实参被args接收
                                
fn(*(1,2,3),**{'a':1,'b':2})    #(1, 2, 3)      成功打散案例
                                #{'a': 1, 'b': 2}

函数的嵌套调用

　　在被调用的函数中去调用其他的函数的功能

　　　　复用之前已经定义好的函数，功能一定是有重叠

#注：在提前声明的函数中可以嵌套调用之后声明的函数

　　  但是本函数的调用必须要在之后声明的函数（本函数里嵌套的函数）的之后

案例分析：

def max_two(n1,n2):     #求两个数的大着
    if n1 > n2:
        return n1
    return n2
print(max_two(10,11))
def max_three(n1,n2,n3):    #求三个数的大着
    a1 = max_two(n1,n2)
    return max_two(a1,n3)
print(max_three(12,11,14))
def max_four(n1,n2,n3,n4):     #求四个数的大着
    a1 = max_three(n1,n2,n3)
    return max_two(a1,n4)
print(max_four(12,123,242,523))