初始函数
获取任意一个字符串的元素的个数我们之前都会这样
s1 = 'fdskjlgfdgfdjkslgdfjkjafdsajk'
count = 0
for i in s1:
count += 1
print(count)
获取列表的元素的个数我们之前都会这样
l1 = [1, 2, 3]
count = 0
for i in l1:
count += 1
print(count)
这种面相过程式编程:
1. 代码重复
2. 代码可读性不高
初始函数
l1 = [1, 2, 3]
def new_len():
count = 0
for i in l1:
count += 1
print(count)
new_len()
函数：函数是以功能为导向，一个函数封装一个功能。登录，注册，文件的改的操作.....
函数减少代码的重复性，增强了代码的可读性。
函数的结构
l1 = [1, 2, 3]
def new_len():
count = 0
for i in l1:
count += 1
print(count)
new_len()
'''
def 关键字： 定义一个函数。紧跟一个空格。
new_len函数名：与变量命名规范一致。一定要具有可描述性。
():结构需要，传参使用。
: 分割符。
tab键：四个空格。缩进。函数体
'''
函数的调用
l1 = [1, 2, 3]
def new_len():
count = 0
for i in l1:
count += 1
print(count)
函数的执行写多少次，执行多少次。
new_len() # 函数名() 函数的执行者。调用者。
new_len() # 函数名() 函数的执行者。
new_len() # 函数名() 函数的执行者。
new_len() # 函数名() 函数的执行者。
new_len() # 函数名() 函数的执行者。
函数的返回值
一个函数就是封装一个功能，这个功能一般都会有一个最终结果的，比如你写一个登录函数，最终登录成功与否是不是需要返回你一个结果？还有咱们是不是都用过len这个函数，他是获取一个对象的元素的总个数，最终肯定会返回一个元素个数这样的结果：
s1 = 'abfdas'
print(len(s1)) # 6
而函数的返回值需要用return表示:
他有几个特性我们接下来用代码表示:
结束函数
l1 = [1, 2, 3]
def new_len():
for i in li:
print(i)
return
new_len()
注意:他结束的是函数不是循环
函数中没有return或者只写一个return,函数的调用者返回值是None
l1 = [1, 2, 3]
def new_len():
count = 0
for i in l1:
count += 1
return
print(new_len()) # new_len()他的返回值为None,需要打印才会显示.不打印的话只是调用,我学习中的困惑.
函数中return后面是单个值,函数的调用者得到的这个值就是他本身
def func():
print(111)
# return 100
# return [1, 2, 3]
return {'name': '普润特业'}
ret = func()
print(ret, type(ret))
函数中return后面是多个值,函数的调用者的到的是一个元祖.
def func():
print(111)
return 1, [22, 33]
ret = func()
print(ret, type(ret)) # (1, [22, 33])
return也可以返回计算后的结果
def func():
print(111)
# return 1+1+2 -- 4
# return 2 > 1 --Ture
ret = func()
print(ret)
函数的传参
我们上面研究了，函数的结构，函数的执行，以及函数的返回值。对函数有一个初步的了解，那么接下来就是一个非常重要的知识点，函数的参数。函数是以功能为导向的，上面我们写的函数里面的代码都是写死的，也就是说，这个函数里面的更改起来很麻烦，试想一下，我们使用探探，陌陌等软件，可不可以进行筛选，比如选择性别，年龄等，导出结果？ 再拿我们之前学过的len 这个len是不是可以获取字符串的总个数？是不是可以获取列表的总个数？你更改了len函数内部的代码了？没有吧？你看下面的例子：
之前的:
s1 = 'sfdas'
l1 = [1, 3, 7]
print(len(s1)) # 5
print(len(l1)) # 3
函数的传参：函数的拓展性
def new_len(a): # 定义函数时：参数：形参。
count = 0
for i in a:
count += 1
return count
l1 = [1, 2, 3]
s1 = 'fdsjaklsfjgfds'
print(new_len(l1)) # 函数的调用者：参数 实参。
print(new_len(s1)) # 函数的调用者：参数 实参。
print(len(s1))
实参角度
- 位置参数。
- 关键字参数。
- 混合参数.
位置参数
位置参数。： 从左至右，按照顺序，一一对应
def meet(sex,age,job,):
print('左划一下')
print('右划一下')
print(f'寻找性别{sex},年龄{age}岁,{job}')
print('聊天')
print('约吗')
print('约....')
meet('女','18~25','讲师')
写一个函数，接收两个数字的参数，将较大的数字返回。
def comp(a,b):
if a > b:
return a
else:
return b
ret = comp(1,2000)
print(ret)
三元运算符：简单的if else。
a1 = 1
b2 = 2
ret = a1 if a1 > b2 else b2
print(ret)
def comp(a,b):
ret = a if a > b else b
return ret
return a if a > b else b
ret = comp(1,2000)
print(ret)
关键字参数
关键字参数一一对应
def meet(sex,age,job,hight,weight,):
print('左划一下')
print('右划一下')
print(f'寻找性别{sex},年龄{age}岁,身高{hight},体重{weight},工作{job}')
print('聊天')
print('约吗')
print('约....')
meet(sex='女',job='学生',weight=120,hight=170,age='18~25')
混合参数
关键字参数一定在位置参数后面, --一一对应
def meet(sex,age,job,hight,weight,):
print('左划一下')
print('右划一下')
print(f'寻找性别{sex},年龄{age}岁,身高{hight},体重{weight},工作{job}')
print('聊天')
print('约吗')
print('约....')
meet('男',27,'ITC语言',weight=120,hight=175,)
形参角度
位置参数
与实参角度位置参数一样,从左到右,一一对应
def meet(sex,age,job,):
print('左划一下')
print('右划一下')
print(f'寻找性别{sex},年龄{age}岁,{job}')
print('聊天')
print('约吗')
print('约....')
meet('女','18~25','讲师')
默认参数
一定在位置参数后面,不传参即沿用默认的参数
open('文件的改',encoding='utf-8')
def meet(age,job,sex='女'):
print('左划一下')
print('右划一下')
print(f'寻找性别{sex},年龄{age}岁,{job}')
print('聊天')
print('约吗')
print('约....')
meet('18~25','幼师')
更改默认参数
meet('18~25','幼师',sex='laddy_boy')
meet('18~25','幼师','laddy_boy')
动态位置参数 *arg
def eat(food1,food2,food3):
print(f'我请你吃：{food1},{food2},{food3}')
eat('蒸羊羔','蒸熊掌','蒸鹿尾')
当给函数传入的参数数目不定时，之前的传参方式解决不了问题。
万能参数，动态参数。 *args
def eat(food1,food2,food3):
print(f'我请你吃：{food1},{food2},{food3}')
eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
def eat(args): 将实参角度：定义一个函数时， 所有的位置参数聚合到一个元组中。
print(args)
print(f'我请你吃：{args}')
eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
注意:重点在于*而不是args,args是程序员们约定俗成的
动态关键字参数**kwargs
def func(kwargs): 函数的定义时：将实参角度所有的关键字参数聚合成了一个字典，给了kwargs.
print(kwargs)func(name='alex',age=84,hobby='唱跳rap篮球')
*的魔性用法
在函数中
在函数的形参中*或者**(比如*args,**kwargs)代表聚合
def func(*args,**kwargs):
print(args) # (1, 2, 3,'大傻', '二傻', '三傻')
print(kwargs)
形参角度的最终顺序: 位置参数, *args, 默认参数, 仅限关键字参数, **kwargs
而在函数的实参中代表打散.
l1 = [1, 2, 3]
l2 = ['大傻', '二傻', '三傻']
func(l1,l2)
func(l1,l2) 当函数的执行时：*iterable 代表打散。
func([1, 2, 3],(11,22),'fdsakl') 当函数的执行时：iterable 代表打散。
在函数外:
处理剩余元素
a,b,*c = [1,2,3,4,5]
a,*c,b, = [1,2,3,4,5]
a,*c = range(5)
a,*c,b = (1,2,3,4,5,6)
print(a,c,b)