01.函数声明和调用
1.函数定义：函数就是对实现某一特定功能的代码段封装。
2.函数分类：内置函数和自定义函数。
1）内置函数：系统写好的，可以直接使用的函数。例如：print函数、input函数、sum函数、len函数等等
2）自定义函数：程序员自己去创建的函数
3.函数的定义（声明）：
a.固定格式
def 函数名（参数列表）:
函数体
b.格式说明：
def：python中声明函数的关键字
函数名：标识符、不能为关键字；PEP8（所有字母小写、多个单词用_隔开，见名知义）
（）：固定格式，必须写。
参数列表：参数名1，参数名2，···；参数可以有多个，也可以没有。这儿的参数也叫形参。参数是用来从函数的外面，向函数里面传值用的（将数据从函数的外面传递到函数的里面）
函数体：实现函数功能的代码段。函数体中可能会包含return语句。
c.初学者声明函数的过程：
第一步：确定函数功能
第二步：根据功能确定函数名
第三步：确定参数（确定有没有，确定有几个）
看实现函数的功能，需不需要从函数的外面传递 数据进来。需要几个就定义几个参数。
第四步：实现函数的功能
第五步：确定返回值
5.注意：（特别重要！！！）
函数体只有在调用的时候才会执行
6.函数的调用：
a.固定格式：
函数名(实参列表)
b.说明：
1.函数名：你要调用那个函数，就写对应的函数名。函数只能先声明才能调用。
2.实参列表：就是用来给形参赋值的
def my_sum(num1, num2):
print(num1 + num2)
print('=========')
print('=============1')
# 调用函数sum2
my_sum(99, 9)
print("++++++++++")
my_sum(99, 1)
print('=============2')
"""
=============1
108
=========
++++++++++
100
=========
=============2
"""
7.函数的调用过程：（重点！！！！！！！！）
a.第一步：回到函数的声明的位置
b.第二步：使用实参给形参赋值（传参）---传参的时候一定要保证每个形参都有值
c.第三步：执行函数体
d.第四步：将返回值返回给函数调用者
e.第五步：回到函数调用的地方，接着往后执行
# 练习：写个函数，打印一个整数的阶乘
def jie_cheng(n):
sum1 = 1
for x in range(1, n + 1):
sum1 *= x
print('%d!是：%d' % (n, sum1))
jie_cheng(5)
#5!是：120
def jie_cheng1(sum1,n):
for x in range(1, n + 1):
sum1 *= x
print('%d!是：%d' % (n, sum1))
jie_cheng1(1,5)
#5!是：120
02.函数的参数
1.参数：声明函数的时候的参数列表中的参数叫形参；调用函数的时候，参数列表中的参数叫实参。
2.传参：传参的过程就是使用实参给形参赋值的过程。一定保证每个形参都要有值
实参
1.位置参数：传参的时候实参的位置和形参的位置一一对应（第一个实参传给第一个形参，同理）
2.关键字参数:函数调用的时候通过'形参名=实参'的形式来传参
1.位置参数
def func1(a, b, c):
print(a, b, c)
func1(10, 'abc', True) # 10 abc True
2.关键字参数
func1(b='abc', a=4, c=5) # 4 abc 5
3.关键字参数和位置参数结合：只能最后一位才能关键字传参
func1(10, 20, c=30)
func1(10, 20, c=1)
3.参数的默认值
a.在声明函数的时候，可以给参数赋默认值。（可以给所有的参数赋默认值，也可以给部分参数赋默认值）
给部分参数赋默认值的时候，要求有默认值的参数必须放在参数列表的最后
b.调用参数有默认值的时候，有默认值的参数可以传参，也可以不传。
3.1声明函数的时候每个参数都有默认值(确定参数类型)
def func2(a=100, b='a', c=True):
print(a, b, c)
a.所有的参数都不传参，全部使用默认值
func2() # 100 a True
b.给部分参数传参
func2(10) # 10 a True
func2(b='abc') # 100 abc True
3.2 参数列表中，部分参数有默认值
def func3(a, b, c=20):
print(a, b, c)
#没有默认值的参数必须传参，有默认值的参数可传可不传
func3(100, 200) # 100 200 20
4.不定个数参数
a.python中通过在形参名前加*让这个形参变成一个元祖，来让这个形参可以同时接受多个实参。多个包含0个
# 写一个函数，计算多个数的和
def sum2(*nums):
nums1 = 0
for x in nums[:]:
nums1 += x
print(nums1, type(nums))
# 写一个函数，统计指定班级中所有学生的成绩
def class_info(class_name,*class_score):
print(class_name,class_score)
class_info('python1806',56,78,89,67,89,78)
def class_info2(class_name,class_loaction,*class_score):
print(class_name,class_score,class_loaction)
class_info2('班级名','地址',45,76,98,78)
5.对参数的类型进行说明
python不能直接约束一个变量的类型。但是可以通过说明，来提示用户调用函数的时候，参数的类型
def func4(name:str,age:int,study_id:str):
print(name,age)
print(study_id.rjust())
func4('abc','10','001')
03.函数的返回值
1.返回值：函数的返回值就是return关键字后面的表达式的值。就是函数调用表达式的结果
2.python中所有的函数都有返回值，默认是None(前提没有return)
说明：
a.如果函数体中没有return，函数的返回值就是None
b.调用函数的语句就是函数调用表达式
写一个函数，打印hello
def say_hello():
print('hello')
# 声明变量re，来保存函数调用后的结果
re = say_hello()
print(re)
2.return关键字（return只能写在函数体中）
a.确定返回值
b.结束函数(函数中只要遇到return，函数就直接结束)
c.单独的return相当于return None
def func1(n):
print(n)
return 100
print('=======')
re = func1(10)
print(re)
注意：看一个函数的返回值是多少，不是看函数中有没有return，而是看函数的执行过程中有没有遇到return。遇到了，就是return后面的结果，否则就是None.
练习：写一个函数判断一个数是否偶数，如果是返回True,否则返回False
def is_even_number(num1):
# if not num1%2:
# return True
# return False
return bool(not num1 % 2)
re = is_even_number(6)
print(re)
"""
什么时候函数需要返回值？
只要实现函数的功能会产生新的数据，就通过返回值将新的数据返回。
而不是打印它
"""
练习：
1.写一个函数，统计一个列表中浮点数的个数
def tj_list (list1):
count=0
for x in list1:
if isinstance(x,float):
count+=1
return count
print('有%d个'%(tj_list([23,17.0,34.4,45,'rt',67.7])))
2.写一个函数，将一个数字列表中所有的元素的值都变成原来的二倍
def lb_list(list2:list):
for x in range(len(list2)):
list2[x]*=2
return list2
re=lb_list([1,2,3,4])
print(re)
3.写一个函数，获取指定元素对应的下标
def indexs(list1:list,item):
#保存符合要求的所有下标
index_list=[]
for index in range(len(list1)):
if list1[index]==item:
index_list.append(index)
return index_list
all_index=indexs([10,'abc',89,10,0.12,10,98],10)
print(all_index)
#将第二个200换成'abc'
numbers=[1,200,89,200,89,87,200,9,90]
all_index=indexs(numbers,200)
numbers[all_index[1]]='abc'
print(numbers)