python学习之老男孩python全栈第九期_day009知识点总结

'''
# len
# 计算字符串的长度
# s = '金老板小护士'
# len(s)
# 不能用 len 怎么办
#low一点的方法
# count = 0
# for i in s:
# count += 1
# print(count)

s1 = '班主任阿娇'
# count = 0
# for i in s1:
# count += 1
# print(count)

#相当于把一段代码放到了一个地方
# 函数 可以多次的调用函数
def my_len(): # 定义函数（不执行，执行需要用到调用函数），my_len()：函数名
count = 0
for i in s1:
count += 1
print(count)
my_len() # 调用函数

# 函数特点：定义了之后，可以在任何需要它的地方调用
# 上边的my_len()
# 1. 不能变，只能计算字符串的长度
# 2. 只是输出了结果
# 3. 没有返回长度，只是单纯的打印
# 返回的重要性
# len() 内置函数

def my_len(): # 自定义函数
count = 0
for i in s1:
count += 1
return count # 添加返回值
# length = my_len()
# print(length)

'''
# 返回值的三种情况
# 1. 没有返回值----返回None
'''
# (1) 不写return
def func():
l = ['金老师','KID']
for i in l:
print(i)
ret = func()
print(ret) # None

'''
# (2) 只写return，没有返回值（结束这个函数的继续）
'''
def func():
l = ['金老师','KID']
for i in l:
print(i)
return # 遇到return，所有内容全部结束
print('qwewghfge)
ret = func()
print(ret) # None
---------------------------------------------------------------------
def func():
l = ['金老师','KID']
for i in l:
print(i)
if i == '金老师'：
return # 遇到return，所有内容全部结束（跳出当前函数）
# break,只是跳出当前循环，不跳出当前函数
print('qwewghfge)
ret = func()
print(ret) # None

'''
# (3) 写 return None-----最不常用的

# 2. 返回一个值（可以返回任何数据类型）
# 只要返回了，就可以直接接收
# 如果在一个程序中有多个return，那么只执行第一个
# 可以返回一个数(上面已经讲到)，也可以返回一个列表，也可以返回一个字典
# 返回一个列表
# def func():
# return [1,2,3,4]
# print(func())
# # 返回一个字典
# def func():
# return {'k', 'v'}
# print(func())

# 3. 返回多个值
# 多个返回值用多个变量接收，有多少个返回值就用多少变量接收
# 用一个变量接收，得到一个元组（好）
# def func2():
# return 1,2
# # r1,r2 = func2()
# # r1,r2,r3 = func2() #报错
# r1 = func() # 多个返回值可以用一个变量接收，但返回的是元组（不可变）
# print(r1)

# 参数
# 参数的语法
# 形参和实参的概念
s = '金老板小护士'
def my_len(s): # 自定义函数只需要0个参数，接收参数,形式参数(形参)
count = 0
for i in s:
count += 1
return count #返回值
ret = my_len(s) # 传递参数（传参），实际参数(实参)
ret = my_len('班主任最好看啦啦啦') # 传递参数（传参）
ret = my_len([1,2,3,4]) # 传递参数（传参）
print(ret)

def f1(l1):
for i in l1:
print(i)

def f2(l1):
f1(l1)
for i in l1:
print(i)
f2([1,2,3,4])
'''

1. 没有参数
定义函数和调用函数时括号里什么都不写
2. 有一个参数
传什么就是什么
3. 有多个参数
(1) 位置参数
(2)
'''
# 位置参数
# def my_sum(a, b):
# res = a+b # res 一般定义为结果(result)
# return res
# ret = my_sum(1, 2)
# print(ret)

# 站在实参的角度上：
# 按照位置传参
# 按照关键字传
# 混着用可以，但是必须先按照位置传参，再按照关键字传参
# 不能给多个变量传多个值

# def my_sum(a, b):
# print(a, b)
# res = a+b # res 一般定义为结果(result)
# return res
# ret = my_sum(b = 1, a = 2)
# print(ret)

# 混着用可以，但是必须先按照位置传参，再按照关键字传参
# def my_sum(a, b):
# res = a+b # res 一般定义为结果(result)
# return res
# ret = my_sum(1, b = 2) # 可以
# ret = my_sum(1, a = 2) # a 同时有两个值，b没有值。报错
# ret = my_sum(a = 1, 2) # 也会报错，混着用时必须先按照位置传参
# print(ret)

# 站在形参的角度上：
# 位置参数：必须传（多传少传都报错）
# 默认参数：可以不传，如果不传就是用默认的参数，如果传了就用传的
# def classmate(name,sex = '男'):
# print('%s:%s'%(name, sex))
# classmate('KID')
# classmate('小梦','女')
# classmate('大猛')
# classmate('灵均')

# 只有调用函数的时候
# 按照位置传：直接写参数的值
# 按照关键字传参： 关键字 = 值

# 定义函数的时候：
# 位置参数：直接定义参数
# 默认参数，关键字参数：参数名 = '默认的值'
# 动态参数：可以接收任意多个参数。参数名之前加 * ， 习惯参数名 args
# 动态函数只能按照位置传参，不能按照关键字传参
# *args:按照位置传参
# **kwargs:按照关键字传参
# 顺序： 位置参数，*args，默认参数，**kwargs！！！！！！！
# def classmate(name,sex): # 定义的是位置参数
# print('%s:%s'%(name, sex))
#
# classmate('KID','男') # 传参时，按照位置传参
# classmate(name = '灵均',sex = '男') # 传参时，按照关键字传参

# def classmate(name,sex = '男'):
# print('%s:%s'%(name, sex))
#
# classmate('KID','女')
# classmate('尹宁',sex = '女')

# 动态函数:可以接收任意多个参数
# 参数名之前加 * ,习惯参数名 args
# 计算多个数的和。
# def sum(*args): # args 只是一个参数名，可以任意换，但前面的 * ，不能少(加了 * ，就为动态参数)
# # 但一般情况下，约定俗成，都用args
# print(args) # 打印的是元组
# n = 0
# for i in args:
# n += i
# return n
# print(sum(1,2))
# print(sum(1,2,3))
# print(sum(1,2,3,4))
#---------------------------------------------------------------------------------------------------
# def func(*args):
# print(*args)
#
# func(1,2,3,'str','list','dict') # 按照位置传参
# func(1,2,3,'str',l = 'list') # 会报错。动态函数只能按照位置传参，不能按照关键字传参
# # --------------------------------------------------------------------------------------------------
# def func(*args,l = []):
# print(*args,l)
#
# func(1,2,3,'str',l = ['list',1]) # 动态函数只能按照位置传参，不能按照关键字传参

# 接收多个，但不知道多少个按照关键字传过来的参数：**kwargs
# 变量用kwargs，也是约定俗成
# def func(**kwargs):
# print(kwargs)
#
# func(a = 1, b = 2, c = 3) #{'a': 1, 'b': 2, 'c': 3}
# func(a = 1, b = 2,) #{'a': 1, 'b': 2}
# func(a = 1) #{'a': 1}

# 动态函数有两种：可以接收任意个参数
# *args ：接收的是按照位置传参的值组织成一个元组
# **kwargs ：接收的是按照关键字传参的值，组织成一个字典

# 这两种可以写一块
# def func(*args,**kwargs): # 约定了，必须 *args在前，**kwargs在后
# print(args,kwargs)
# 必须先按位置传，再按关键字传
# func(1,2,3,4,a = 'str',b = 'bbbb')

# 当有默认参数时，默认参数要在**kwargs之前。
# def func(*args,default = 2,**kwargs): # 约定了，必须 *args在前，**kwargs在后,默认参数在他俩中间
# print(args,kwargs)
# 必须先按位置传，再按关键字传
# func(1,2,3,4,a = 'str',b = 'bbbb') # 默认参数default = 2
# func(1,2,3,4,default = 1,a = 'str',b = 'bbbb') # 默认参数修改为1，且必须按照关键字修改默认参数

# 顺序： 位置参数，*args，默认参数，**kwargs
# def func(a, *args, b = 1, **kwargs):
# print(a,args,b,kwargs)
#
# func(1,23,24,b = 34,c = 56,d = 78) # 1 (23, 24) 34 {'c': 56, 'd': 78}

# 动态参数的另一种传参方式

# 针对 * args
def func(*args): # 站在形参的角度上，给变量加上 * ，就是组合所有传来的值
print(args)
# 把l里的内容全部打印
l = [1,2,3,1,4,5,6,7,8,9,5,6,3,2,1,4,8,5]
func(*l) # 站在实参的角度上，给一个序列加上*号，就是将这个序列按照顺序打散 结果是个元组

# 针对**kwargs
def func(**kwargs):
print(kwargs)

d = {'a':1, 'b':2} # 定义一个字典d
func(**d)

 

# 函数的注释
# def func():
# '''
#
# 这个函数实现了什么功能（必须写）
# 参数1：功能
# 参数2：
#
#
# :return: 说明返回的值什么（比如：是字符串或者列表的长度）
# '''
# pass

# 总结
# 1. 函数的定义
# 2. 函数的调用
# 3. 函数的返回值 return ：几种情况
# return的作用：1. 结束函数 ；2. 返回值
# 4. 函数的参数
# 形参：
# 位置参数：必须传参
# *args： 可以接收任意多个位置参数
# 默认参数： 可以不传
# **kwargs： 可以接收多个关键参数

# 实参：按照位置传参，按照关键字传参

# 函数
# 内置函数

# 自定义函数（今天研究的）

# 可读性强，复用性强
# def 函数名():
# 函数体
#return 返回值
# 所有的函数 只定义不调用就一定不执行
# 先定义后调用
# 函数名() # 不接受返回值
# 返回值 = 函数名() # 接收返回值

# 返回值
# 没有返回值：默认返回值：None
# 不写return：函数内的代码执行完毕，自动结束
# 只写return：结束一个函数
# return None
# 返回一个值：结束了函数且返回一个值，可以使任意的值
# 返回多个值：多个值之间用逗号隔开，接收的时候可以用一个变量接收（返回的是元组），也可以用等量的变量（返回的是列表）

# 参数
# 形参：定义函数的时候
# 位置参数：必须传
# *args：动态参数，可以接收任意多个按位置传入的参数
# 默认参数：可以不传 -- 陷阱
#**kwargs：动态参数，可以接收任意多个按关键字传入的参数

# 实参：调用函数的时候
# 按照位置传参数
# 按照关键字传参数
# 位置参数必须在关键字参数之前
# 不能对一个参数重复赋值