day10 函数

day10 函数

一，函数及其定义

1,函数定义：实现某一个特定功能的代码的封装

示例：封装一个求和函数

def sum(n):
    sum1=0
    for i in range(1,n+1):
        sum1+=i
    print(sum1)
# 完成封装
sum(60)
#调用函数

二，函数的分类—根据函数是由谁定义（创建）

1. 系统函数

2. 自定义函数

三，定义函数

定义语法

def 函数名（形参列表）:
    函数说明文档
    函数体

注意：

1. 函数名见名知意，所有字母小写，多个单词间用下划线隔开
2. 形参可以将函数外部的数据传递到函数里面，一个变量代表一个形参，也可以没有形参
3. 定义时是否需要形参由实现函数功能是否需要额外的数据

四，定义函数的基本步骤

1. 确定函数功能
2. 根据函数功能确定函数名
3. 确定参数，确认实现函数功能是否需要额外数据，需要几个
4. 实现函数功能
5. 写函数说明文档

创建函数形式：

def 函数名(形参列表)：
    函数说明文档
    函数体

示例：求10的阶乘

def foctor_10():
    sum1=1
    for i in range(1,11):
       sum*=i 
    print(sum1)   

示例：求任意一个数的阶乘

def factorial(x):
    sum1=1
    for x in range(1,x+1):
       sum1*=x
    print(sum1)

示例：求任意两个数字的和

def sum_xt(num1,num2):
    print(num1+num2)

示例：写一个函数，提取列表中所有的数字元素

def get_nums(list1):
    result=(x for x in list1 if type(x) in (int,float))
    print(result)

示例：写一个函数，提取指定字典中的所有值

def get_values(dic):
    result = [dic[key] for key in dic]
    print(result)

示例：写一个函数，统计一个字符串中另一个字符串出现的次数

def count_str(str1,str2)
   sount=0
   index=0
   length=len(str2)
   while index x len(str1):
       if str1[index:index+1] == str2:
           count += 1
           index += length
       else:
           index += 1 
   print(count)             
   

示例：定义一个函数，统计指定字符串中中文的个数

def count(str1):
    count=0
    for i in str1:
        if "\u4e08"<=i<="\u9fa5":
            count+=1
    print(count)

五，调用函数

函数名(实参列表)

注意：位置参数与关键字参数一起使用时，位置参数必须在关键字参数前面

​ 有默认值参数的形参必须放在无默认值参数的后面

函数调用过程：

1. 回到函数定义的位置
2. 传参（用实参给形参赋值）
3. 执行函数体
4. 确定函数返回值
5. 回到函数调用位置接着往后执行

六，参数类型设定

1. 无默认值参数，在参数后加类型名
2. 有默认值的参数，值的类型就是参数的说明类型

示例：

def funct(str1;str,list=[])

变量类型说明：

# type:变量

返回值类型说明

->int

七，不定长参数

函数参数引用注意：

​ 当位置参数与关键字参数混用时，位置参数必须在关键字参数之前

含义：参数的个数不确定

1. 带*的不定长参数

在定义函数的时候可以在某个参数前加*，则这个带*的参数就是一个不定长参数，可以同时接受多个实参

带*的参数会自动变成一个元组，接收到实参是元组中的元素

调用时必须用位置参数传参

示例：

def func(*x):
    print(x)

注意：此时的x作为元组存储数据

示例：

def funct(x,*y):
    print(x,y)
# 调用
funct(1,2,3,4,5)
此时的打印结果为：
1 (2, 3, 4, 5)

示例; 先不定长后定长

def funct(*x,y):
    print(x,y)
# 调用
funct(1,2,3,4,5)
此时调用本函数y必须用关键字参数，否则无法调用

注意;实际开发中定义的形式为

def funct(a,*,c,d):
    pass
此时的*只是为了强迫本函数时，后面函数必须使用关键字参数

2. 带** 的不定长参数

示例：

funct(**x):
    pass
# 调用：
funct(m=10,n=8)

说明：带**的不定长参数参数名可以任意添加，参数个数也可以任意添加，但是调用时只能用参数名调用，此时为创建了一个字典

示例；

def funct(**x):
    print(x)
# 调用
funct(name="皮皮",age="18")
# 此时的打印结果为
{'name': '皮皮', 'age': '18'}

八，函数返回值

含义：

​ 是函数内部传递到函数外部的数据

返回值的确定：

​ 返回值即为return关键字后面的表达式值，如没有return,返回值是None

函数返回值的确定：

​ 获取函数调用表达式的值就是获取函数的返回值

函数返回值的使用：

​ 函数调用表达式的值就是函数的返回值，函数返回值能做的事情，函数调用表达式都可以做

需要返回值的原因;

​ 如果实现函数的功能产生了新的数据，就应该将新的数据返回

​ 每次调用函数的时候，系统自动为这恶鬼函数创建一个临时栈区间，用来保存在函数中产生的数据，函数调用时系统会自动释放这块内存，只有返回值不会直接删除

九，return的作用

1. 确定函数的返回值
2. 提前结束函数（在执行函数体时遇到return，函数直接结束）

示例;

def funct():
    print("1111111111")
    return                     # return 后无东西返回值为none
    print("2222222222")
    print("3333333333")

---

---

---

函数作业：

1. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

      例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
           原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
   

def rjust(str1:str,width:int,char:str):
    len1=len(str1)
    if width <=len1:
        return str1
    return (width-len1)*char+str1

2. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

   例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
        列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
        列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1         

def index(list1:list,item):
    result=[]
    for index,x in enumerate(list1):
        if x ==item:
            result.append(index)
    if result:
        return ",".join([str(x) for x in result])
    else:
        return-1

1. 写一个自己的len函数，统计指定序列中元素的个数

       例如: 序列:[1, 3, 5, 6]    结果: 4
            序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
            序列:'hello w'    结果: 7
   

   3. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

     例如: 序列:[-7, -12, -1, -9]    结果: -1   
          序列:'abcdpzasdz'    结果: 'z'  
          序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
   

def max1(seq):
    if type(seq)==dict:
        new_seq=list(seq.values())
    else:
        new_seq=list(seq)
    t=new_seq[0]
    for x in new_seq[1:]:
        if x>t:
            t=x
    return t

4. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

    例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
         序列: [12, 90, 'abc']   元素: 90     结果: True     

5. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'

def update(dict1:dict,dict2:dict):
    for key in dict2:
        dict1[key]=dict2[key]