第六天

Posted ztx695911088

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第六天相关的知识,希望对你有一定的参考价值。

第一部分 函数初识

 

"""
函数:
作用:
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)






























 

以上是关于第六天的主要内容,如果未能解决你的问题,请参考以下文章

python第六天

第六天

第二次冲刺阶段第六天

DAY6第六天的代码练习

第六天

Alpha第六天