4.24函数基础学习笔记及作业
函数定义
1.函数的概念(什么是函数) - 机器
函数就是实现某一特定功能的代码的封装
(函数就是把实现某一功能的代码打包，以后在需要这段代码对应的功能的时候不需要在写这段代码，而是直接调用)
2.函数分类(根据函数是谁创建的)
1)系统函数 - Python自带的函数
2)自定义函数 - 有程序员自己创建的函数
3.定义函数/创建函数 - 造机器
语法:
def 函数名(形参列表):
函数说明文档
函数体
说明:
def - 关键字；固定写法
函数名 - 由程序员自己命名
要求：同标识符；不能是关键字
规范：见名知义；字母都小写；多个字母有下划线隔开；不使用系统函数名、类名、模块名
(): - 固定写法
形参列表 - 以’变量1, 变量2, 变量3, …'的形式存在，这儿的变量可有可无
形参的作用：将函数外部的数据传递到函数里面
怎么确定形参：看实现函数的功能需不需要额外的数据，需要几个
函数说明文档 - 本质就是一个多行注释，用来描述函数的功能和使用方法
函数体 - 结构上：和def保持一个缩进的一条或多条语句（至少依据）
逻辑上：函数体就是实现函数功能的代码
练习：定义一个函数实现求任意两个数的和
def sum1(a, b):
"""
函数功能说明区
:param a: 第一个数（参数说明）
:param b: 第二个数
:return: None（返回值说明）
"""
c = a + b
return c
print(sum1(1, 5))
练习1：定义一个函数，统计指定字符串中中文的个数
def count_chinese(count_str):
"""
统计字符串中中文的个数
:param count_str: 指定字符串
:return: 中文个数
"""
count = 0 # 统计中文个数
for x in count_str:
if '\u4e00' <= x <= '\u9af5':
count += 1
print(count)
str1 = '杨志强123ajoidfjao杨志强ajsdifj 我叫杨志强231'
count_chinese(str1)
练习2：定义一个函数，将指定的数据插入到指定列表的最前面
def first_insert_list(obj, insert_list: list):
"""
将指定的数据插入到指定列表的最前面
:param obj: 插入的数据
:param insert_list: 指定列表
:return: None
"""
insert_list.insert(0, obj)
练习3：定义一个函数，任意一个整数的阶乘
def factorial(n):
"""
输出任意一个整数的阶乘
:param n: 指定整数
:return: 指定整数的阶乘
"""
count_factorial = 1 # 存储阶乘计算结果
for x in range(1, n + 1):
count_factorial *= x
return count_factorial
print(factorial(5))
练习4：定义一个函数，求任意一个圆的面积
def area_circle(radius):
"""
求任意一个圆的面积
:param radius: 指定圆的半径
:return: None
"""
print(3.14 * radius * radius)
area_circle(3)
4. 函数的调用 - 使用机器
1) 定义函数不会执行函数体,调用函数才会执行函数体
def func1():
print('hello world')
2) 怎么调用函数
语法：函数名(实参列表)
说明：
函数名 - 需要那个函数的功能就调用那个函数，就写那个函数的函数名
注意：函数名必须是已经定义好的函数的函数名
() - 固定写法
是参列表 - 以’数据1, 数据2, 数据3, …'的形式存在
实参就是通过形参从函数外部传递到函数内部具体的数据
message = 'hello world! 你好，世界！'
count_chinese(message)
print(factorial(10))
3) 函数调用过程
当代码指向到函数调用语句的时候：
第一步： 先回到函数定义的位置
第二步： 传参
第三步： 执行函数体
第四步： 确定函数返回值
第五步： 回到函数调用位置，继续向后执行
函数返回值
1.返回值
返回值就是从函数内部传递到函数外部的数据
1) 怎么将确定函数返回值（怎么将指定的数据作为函数返回值）
看执行函数体的时候有没有遇到return，如果遇到return，return后面的值就是函数返回值；如果没有遇到return，则返回None
2) 怎么获取函数返回值
获取函数调用表达式的值就是获取函数的返回值
函数调用表达式：调用函数的语句
3) 什么时候需要返回值
如果实现函数的功能产生了新的数据，就应该将新的数据返回
原因：每次调用函数的时候，系统会自动为这个函数创建一个临时的栈区间，用来保存在函数中产生的数据
当函数调用结束的时候会自动释放这块内存（内存中的数据会被删除），只有返回值不会直接删除
def func1():
print(100)
print('x1:', func1())
def func2():
print('hello world!')
return 100
x2 = func2()
print('x2:', x2)
def func3(n):
if n % 2:
return 100
else:
return 200
x3 = func3(3)
print(f'x3:{x3}')
x4 = func3(4)
print(f'x4:{x4}')
def func4():
# 返回的是一个元组
return 100, 200
x5 = func4()
print(f'x5:{x5}')
def func5():
return 'abc'
a = 'abc'
b = func5()
print('abc'[-1], func5()[-1])
print('abc'.upper(), func5().upper())
2.return
return在函数中的两个作用：
1) 返回返回值
2) 提前结束函数
def func1():
print('====')
print('++++')
return 100
x = func1()
print(x)
函数的参数
1. 位置参数和关键字参数 - 根据实参传递方式分类
1) 位置参数：以’实参1, 实参2, 实参3, …'的形式存在，通过位置一一对应的方式来给形参赋值
2) 关键字参数：以’形参1=实参1, 形参2=实参2, 形参3=实参3, …'的形式存在，直接用=来确定实参和形参的对应关系
注意：位置参数和关键字参数可以混用，混用时位置参数必须在关键参数前
def func1(x, y, z):
print(f'x:{x}, y:{y}, z:{z}')
func1(10, 20, 30)
func1(x=20, y=30, z=40)
func1(z=30, y=20, x=10) # 参数位置可以打乱
func1(10, z=30, y=20) # 混用
2. 参数默认值 - 形参
定义函数的时候，可以通过’形参名=值’的方式给参数赋默认值；如果一个形参有默认值，那么在调用函数的时候这个形参可以不用赋值
注意：定义函数的时候，如果有的参数有默认值有的参数没有，那么没有默认值的参数必须在有默认值参数前
def func2(x, y=20, z=30):
print(f'x:{x}, y:{y}, z:{z}')
func2(10, 20)
func2(10, 20, 40)
func2(x=10, z=40)
3. 参数类型说明 - 定义函数的时候指定参数类型
参数类型说明可以提示使用者在调用函数时该传什么类型的数据；又可以让参数在函数体中使用时有代码提示
1) 方法1-没有默认值的参数: 形参:类型名
2) 方法2：给参数赋默认值，默认值的类型就是参数的类型
def func3(str1: str, list1=[]) -> None: # -> None 在定义函数时说明返回值
str1.upper()
func3('saf', [1, 20])
补充：变量类型说明
message = '["abc", "sjsiejfl", "sds"]'
list2 = eval(message) # type: list
list2.clear()
4. 不定长参数 - 解决参数个数不确定的问题
1) 带*的不定长参数
定义函数时，如果在某个形参前面加*，那么这个参数就变成一个不定长参数，调用的时候这个形参可以接受若干个实参
本质：如果形参有*，那么这个参数就会自动变成一个元组，他接受到的所有实参会作为这个元组的元素
注意：a. 带*的不定长参数在传参的时候只能使用位置参数
b. 定长参数和带*的不定长参数混用的时候，*前的定长参数必须用位置参数传参，*后的定长参数必须用关键字传参
2) 带**的不定长参数（只能使用关键字传参）
本质：如果形参前有**，那么这个参数就会自动变成一个字典，他接收到的所有实参作为这个字典的键值对
def func5(*num):
print(f'num:{num}')
func5()
func5(10)
func5(10, 20)
func5(10, 20, 30)
def func6(x, *num): # 至少一个参数
print(f'x:{x}, num:{num}')
func6(10)
func6(10, 20)
# 练习: 定义一个函数，求多个数的和
def sums(*num):
count_sums = 0
if len(num) == 0:
return count_sums
else:
for x in range(len(num)):
count_sums += num[x]
return count_sums
print(sums(10, 20, 30))
print('==================================华丽的分割线==============================')
def func9(**x):
print(f'x:{x}')
func9()
func9(a=10)
func9(a1=10, a2=20, b1=30, b2=40)
def func10(*args, **kwargs):
pass
作业
-
编写一个函数，交换指定字典的key和value。
例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}def exchange_dict(dict1: dict): result = {dict1[x]: x for x in dict1} return result dict1={'a': 1, 'b': 2, 'c': 3} print(exchange_dict(dict1)) -
编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
例如: 传入'12a&bc12d-+' --> 'abcd'def ectract_letter(str1: str): new_str = '' # 循环遍历需要提取的字符串；如果遇到字母就将字母添加到新字符串后 for x in str1: if 'a' <= x <= 'z' or 'A' <= x <= 'Z': new_str += x return new_str print(ectract_letter('12a&bc12d-+')) -
写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
例如: 'abc' -> 'Abc' '12asd' --> '12asd'def capitalize_(str1: str): new_str = '' # 存储转换后的字符串 # 如果原字符串首个元素为小写字母，就将其转换成大写 if 'a' <= str1[0] <= 'z': new_str += chr(ord(str1[0]) - 32) # 将后续元素添加到新字符串中 new_str += str1[1:] else: # 原字符串首个元素不是小写字母 new_str = str1 return new_str str3 = input('请输入你需要调整的字符串：') print(capitalize_('str3')) -
写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束
例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True 字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: Falsedef endwith_(str1: str, str2: str): # 获取str1与str2的长度 len1 = len(str1) len2 = len(str2) # 只有在str4_1中找到最后一个str4_2的位置等于1的长度减去2的长度就说明str4_1以str4_2结束 if str1.rfind(str2) == len1 - len2: print(True) else: print(False) str1 = input('请输入字符串1') str2 = input('请输入字符串2') endwith_(str1, str2) -
写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
例如: '1234921' 结果: True '23函数' 结果: False 'a2390' 结果: Falsedef isdigit_(str1: str): for x in str1: if not ('0' <= x <= '9'): print(False) break else: print(True) isdigit_('1234921') -
写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
例如: 'abH23好rp1' 结果: 'ABH23好RP1'def upper_(str6: str): result6 = '' # 遍历str6，将所有遍历到的小写字母的编码值减32,遍历到的其他字符直接添加到新字符串中 for x in range(len(str6)): if 'a' <= str6[x] <= 'z': result6 += chr(ord(str6[x]) - 32) else: result6 += str6[x] else: print(result6) upper_('abH23好rp1') -
写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc' 原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'def rjust_(width: int, str7_1: str,str7_2: str): len1 = len(str7_1) new_str7 = '' if width > len1: for x in range(width - len1): new_str7 +=str7_2 new_str7 += str7_1 print(new_str7) elif width == len1: print(str7_1) elif width < len1: print('输入字符串长度过长') return rjust_(7, 'abc', '^') -
写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 结果: 0,4,6 列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '赵云' 结果: 0,4 列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '关羽' 结果: -1def index_(list8: list, element8): count = -1 for x in range(len(list8)): if list8[x] == element8: print(x,end=', ') count = 1 if count == 0: print(-1) list8 = [1, 2, 45, 'abc', 1, '你好', 1, 0] element8 = 1 index_(list8, element8) -
写一个自己的len函数，统计指定序列中元素的个数
例如: 序列:[1, 3, 5, 6] 结果: 4 序列:(1, 34, 'a', 45, 'bbb') 结果: 5 序列:'hello w' 结果: 7def len_(element9_1): count = 0 if len(element9_1) == 0: return -1 for x in element9_1: count += 1 return count elenment9 = [1, 3, 5, 6] print(len_(elenment9)) -
写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
例如: 序列:[-7, -12, -1, -9] 结果: -1 序列:'abcdpzasdz' 结果: 'z' 序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98def max_(element10): if type(element10) == dict: count_max_dict = 0 for x in element10: if count_max_dict < element10.get(x): count_max_dict = element10.get(x) print(count_max_dict) else: max_value_element = element10[0] for x in element10: if x > max_value_element: max_value_element = x print(max_value_element) element_10 = {'小明':90, '张三': 76, '路飞':30, '小花': 98} max_(element_10) -
写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在
例如: 序列: (12, 90, 'abc') 元素: '90' 结果: False 序列: [12, 90, 'abc'] 元素: 90 结果: Truedef in_(element_11_1, element_11_2): for x in element_11_1: if x == element_11_2: return True return False print(in_((12, 90, 'abc'), '90')) -
写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
例如: 原字符串: 'how are you? and you?' 旧字符串: 'you' 新字符串:'me' 结果: 'how are me? and me?'def replace_(str_, str1, str2): new_str = "" olen = len(str1) tstr = str_ while tstr.find(str1) != -1: # 一直在tstr中寻找第一个需要替换的str1，直到找不到 new_str += tstr[0:tstr.find(str1)] + str2 tstr = tstr[tstr.find(str1)+olen:] new_str += tstr return new_str strx = 'how are you? and you?' str_old = 'you' str_new = 'me' print(replace_(strx, str_old,str_new)) -
定义一个自己的update函数，将一个字典中所有的键值对添加到另外一个字典中
def update_(dict1: dict, dict2: dict): for x in dict1: dict2.setdefault(x, dict1.get(x)) return dict2 dict_13_1 = {'name': '老坛酸菜泡面', 'price': 3.5, 'weight': 300, 'discount': 0.8} dict_13_2 = {'name': '财财', 'gender': '母狗', 'breed': '哈士奇', 'age': 3} print(update_(dict_13_2, dict_13_1))
4344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
