第六天

第一部分 函数初识

"""
函数：
作用：
1. 简化代码
2. 把功能模块化
"""
# 打印出5行，每行5个*
print(("其他的代码块1"))
for i in range(5):
    print("*"*5)
print("其他的代码块2")
for i in range(5):
    print("*"*5)
print("其他的代码块3")

一、函数的定义
# 函数名： 标识符，规则
# 参数
# 函数体
# 返回值

# 函数的分类：内置函数（内建函数），自定义函数
1. 内建函数
print()
print(abs(-100))
a=-100
abs(a)
print(a)
print(abs(-100,-90))
abs()
abs("a")

# pass 占位符 ： 函数  if
if 3>1:
    pass
print()
for i in range(10):
    pass

2. 自定义函数
import keyword
keyword.kwlist
"""
格式：
def 函数名(参数，)：
    函数体
    return  返回值： 可以没有 None
    返回值是None（3种）：没有return，return None，return
"""

# def ps():
#     for i in range(5):
#         print("*"*5)
# 函数的调用
# 函数名（参数）

# 函数的参数
# def ps(line):
#     for i in range(line):
#         print("*"*5)
# ps(4)
# ps(5)
# ps(1)


二、函数参数的使用
1.位置参数（必须参数）
# 位置参数一旦定义了，就必须传入（默认参数情况不考虑）而且按照顺序传入
def ps(x,line):
    for i in range(line):
        print("*"*x)
ps(3,5)
ps(5,1) # 实际参数
# x line   形式参数
# 给函数参数进行赋值
# x=5,line=1

2. 默认参数
def ps(line,x=2):
    for i in range(line):
        print("*"*x)
ps(2,5)
ps(3)
# 默认参数和位置参数顺序：位置参数>默认参数
ps(3)

# 参数如果是可变对象,那么默认参数会随着函数调用次数而改变
def f(a=[]):
    a.append("b")
    print(a)
# f([1,2,3])
# f([1,2,3])
f()
f()

def f(a=[]):
    if a!=None:
        a=[]
        a.append("b")
        print(a)
f([1,2,3])
f([1,2,3])
f()
f()

3. 命名关键字参数:跟位置参数类似（如果有，就必须传（默认参数情况除外））
  命名关键字参数的格式 *,命名关键字参数1，命名关键字参数2，……
def ps(*,line,x):
    for i in range(line):
        print("*",x)
# 命名关键字参数的调用：传入名字=值
ps(line=2,x=3)
# ps(line=2) # 命名关键字参数个数也需要保证跟定义时候一样（默认参数情况除外）
# 参数传入的顺序可以不考虑，只有名字保证了
ps(x=3,line=4)
# 命名关键字参数的  作用
# 1. 程序可读性强
# 2. 传递参数可以忽略顺序
# 3. 当有默认值的时候，更加简化了调用

def ps4(*,line=5,x):
    for i in range(line):
        print("*"*x)
ps4(line=6)
# 位置参数 > 命名关键字参数
def ps5(line,*,x):
    for i in range(line):
        print("*",x)
# 位置参数调用的时候，也是可以 参数名=参数值
ps5(2,x=4)

# sort
a=[1,2,-5,3,4]
# a.sort(reverse=True)  # 降序
a.sort(key=abs)
print(a)

4. 可变参数:收集类型的参数：会把传入所有参数打包成元组的形式，传递给函数进行执行
   * args
# 求两个数的平方和
# def s(a,b):
#     return a**2+b**2
# print(s(1,2))
# # print(s(1,2,3))
def s(* args):
    s=0
    for i in args:
        s+=i**2
    return s
a=(1,2,3)
print(s(a))
print(s((1,2,3)))
# 拆包， *
print(s(*a))

# 练习一下 使用可变类型的参数，输入一系列数字，求他们的平方和


def list_demo():
    li=[1,2,3,4,5,6]
    li[2]=100
    print(li)
    li[2:4]=[33,44]
    print(li)
    # li[2:2]=101
    li[2:2]=[101]
    print(li)
    li[2:2]="abc"
    print(li)

    # 列表的索引赋值的时候，绑定一个元素(可变类型，不可变类型，（序列））
    # 列表的切片赋值的时候，绑定的一定是一个可迭代对象（数值类型、布尔类型）
    li[1]=[1,2,3]
    print(li)

  5. 关键字参数
  ** kwargs：将传入的参数打包成字典，传递给函数 打包
# 关键字参数，传递参数时，使用字典的形式，有几对键值对，就传几个，属于收集类型参数
# 需求 name  age 进行注册
def regist(name,age,**kwargs):
    print(name)
    print(age)
    print(kwargs)
regist("张三",20,job="teacher",gender="male")
d={"job":"teacher","gender":"male"}

# 拆包
regist("张三",30,**d)
regist("张三",30,job=d["job"],gender=d["gender"])

  6. 参数的组合
# 【可变参数 * args】 和【命名关键字参数 *，命名关键字参数】 ，不能同时使用
# def f(*,name,age,* args):
# def f(* args,* ,name,age,**kwargs)
    #参数名=参数值
# f(1,3,name="a",age=44,city="dd")
# 位置参数 > 默认参数 > 命名关键字参数/可变参数 > 关键字参数
def f1(a,b,c=0,* args,**kwargs):
    print("a={}; b={}; c={}; args={}; kwargs={}".format(a,b,c,args,kwargs))
# f1
f1(1,2)
f1(1,2,3)
f1(1,2,1,1)
f1(1,2,3,"hello","python")
f1(1,2,3,"hello","python",x=90)

def f2(a,b,c=0,*,d,**kwargs):
    print("a={}; b={}; c={}; args={}; kwargs={}".format(a,b,c,d,kwargs))
f2(1,2,d=99,e=None)
f2(1,2,d=99,e="None",e2="dddd")
# 命名关键字参数和关键字参数一定是用  参数名=参数值
f2(1,2,e=None,e2="ddd",d="777")

def f1(a,b,c=0,* args,**kwargs):
    print("a={}; b={}; c={}; args={}; kwargs={}".format(a,b,c,args,kwargs))
def f2(a,b,c=0,*,d,**kwargs):
    print("a={}; b={}; c={}; args={}; kwargs={}".format(a,b,c,d,kwargs))
args=(1,2,3,4)
kwargs={"d":99,"x":"****"}

f1(args,kwargs)
f1(*args,**kwargs)

# f2(args,kwargs)
args=(1,2,3)
f2(* args,**kwargs)

# def f3(a,b,c=0,* args,*,d,**kw):
#     pass

万能参数
def fun(* args, **kwargs):
    print("args={}   ;  kwargs={}".format(args,kwargs))
fun()
# 即使是万能参数，使用的时候，也不能随便传入参数，先传入不带名字的，再传入带名字的
fun(1,2,"e",d=0,c=2)
kw={"d":66}
fun(1,2,kw,d=0,c=2)
# 使用关键字参数的时候，key不能有多个同样的。
fun(1,2,kw,d=0,c=2)
# fun(1,2,kw,d=66,d=0,c=2)

def test(*a,b):
    pass
# 当在可变参数之后定义位置参数，会把位置参数转换成关键字参数（必须以名字=值）
test(1,2,3,b="dd")
# def test1(*a,**kw,b):
#     pass

# 总结：
"""
1. 位置参数，必须按照位置顺序。
2. 默认参数，不能使用可变对象作为默认值。
3. 命名关键字，必须传入的参数（有默认值的除外）
4. 可变参数，接受tuple
5. 关键字参数，接受dict
6. 可变参数和关键字参数的打包和拆包
"""
第二部分 返回值

"""
函数的返回值
"""
1.返回值
# 函数名、函数的参数、函数体、返回值
# 所有函数都有返回值，只不过是None还是非None的区别
def f():
    pass
    # 功能代码
    # return 返回值
# return: 写了返回
# 没有return：仍然相当于在函数的最后一行，定义了return None
def add(a,b):
    s=a+b
    return s
    print("这一行会不会执行")
# 函数执行的时候，遇见（1个）return就不会再继续执行
# 对函数的返回值进行赋值
s=add(1,3)

# 返回值的类型： 变量、表达式
def add1(a,b):
    return a+b
bb=add(10,2)
print(bb)

# 返回值的个数,无论有多少个return，都只能执行第一个return，函数即结束
def c(a,b):
    return a+b
    return a-b
    return a*b
print(c(4,5))
  返回多个返回值值， 可以应用元组
def c1(a,b):
    return a+b,a-b,a*b,a/b
print(c1(10,2))
t=c1(10,2)
print(t)
# 接受函数多个返回值，可以使用跟返回值数量相同的变量去接返回值
# 会给变量一一赋值，注意，必须数量一致
x,y,z,m=c1(10,2)
print(x,y,z,m)

  定义函数时，习惯是，返回值使用元组类型,预防客户端调用之后修改返回值
def c2(a,b):
    return [a+b,a-b,a*b,a/b]
li=c2(10,2)
print(li)
li[0]=2000

# 练习：
# 1. 自己写一个求绝对值的函数
def myabs(x):
    if x>=0:
        return x
    else:
        return -x

# 2. sort  key,key用自己写的绝对值函数取排序
li=[1,2,3,4,5,-9,-6]
  key获得函数的名字，用来运用到列表的每一个元素上，使用函数的返回值，进行排序
li.sort(key=myabs)
print(li)
# li=[[1,2,3],[3,4,5],[3,87,1]]

# 3. 求一元二次方程的解
# 4. 计算x的n次方，while解决

二、函数的传递方式
# python 不可变类型，可变类型
 传递的是不可变类型的时候，函数中的变量跟调用者的变量值是不同的
def myfunNo(a=1):
    a=a+2
    print("在myfunNo函数中a=",a)
x=10
myfunNo(x)
print("在调用端x=",x)
 
 可变类型：函数中的变量跟调用者的变量是同一个对象。
def myfunYes(L):
    L.append("_new")
    print("在myfunYes中的L",L)
L=[1,2,3,4]
myfunYes(L)
print("在调用端的L=",L)