day10 函数基础
1.函数的概念
1）定义(什么是函数)：函数就是对实现某一特定功能的代码的封装。（函数的本质其实就是功能，不同的函数有不一样的功能）
2）函数的分类:
系统函数: (别人造好的机器) python已经定以好的函数，程序员只需要在需要这些函数功能的时候调用就行了。例如:print、input、type、id、hex、sum、max、…
自定义函数: (自己造机器) 程序员自己定义的函数
2.函数的定义（造机器）
语法：**
def 函数名(形参列表):
函数说明文档
函数体
说明：
1）def - 关键字；固定写法
2）函数名 - 程序员自己命名的; 是标识符，不能是关键字；
所有字母都小写，单词之间用下划线隔开
见名知义(看到函数名大概知道这个函数的功能)
不使用系统的函数名、类名和模块名
3）( ): - 固定写法
4）形参列表 - a. 以 ‘变量1, 变量2, 变量3,…’ 的形式存在，也没有形参；
b. 形参的作用是将函数外面的数据传递到函数里面，定义函数的时候需不需要形参，
需要几个，看实现函数的功能需不需要额外的数据需要几个
5）函数说明文档 - 相当于机器的说明书，用来辅助别人更方便的去使用当前函数；
用三个双引号引起来的注释(不是一定要写)
6）函数体 - 和def保持一个缩进的一条或者多条语句；
函数体就是实现函数功能的代码段(核心)
写一个函数，求两个数的和
def sum2(num1, num2):
"""
(功能说明区)求指定两个数的和
:param num1: 要求和的数字中的第1个数字
:param num2: 要求和的数字中的第2个数字
:return: (返回值说明)
"""
print(num1 + num2)
sum2(10, 20)
sum2(100, 200)
练习1：写一个函数求一个整数的阶乘
N! = 1*2*3*4*...(N-1)*N
def factorial(n):
sum1 = 1
for x in range(1, n+1):
sum1 *= x
print(f'{n}!是:{sum1}')
factorial(5)
factorial(8)
factorial(10)
练习2：写一个函数，将指定字符串中指定的字符全部删除
def del_char(string, char):
# 方法一:
new_str = ''
for x in string:
if x != char:
new_str += x
print(new_str)
# 方法二：
# new_str = ''.join([x for x in string if x != char])
# print(new_str)
del_char('how are you?', ' ')
del_char('how are you?', 'o')
练习3：写一个函数，统计一个字典中指定值的个数
def value_count(dic, value):
count = 0
for x in dic:
if dic[x] == value:
count += 1
print(count)
value_count({'a': 10, 'b': 20, 'c': 10}, 20)
3. 函数的调用
(重要!)定义函数的时候不会执行函数体；调用函数的时候函数体才会执行！
1）调用函数(使用机器)
语法：
函数名(实参列表)
说明：
**函数名 - ** 需要使用的函数的名字(这个函数名必须是已经定义过的函数的函数名)
实参列表 - 多个数据用逗号隔开; 具体的个数看对应的函数的形参的个数
实参就是使用函数的时候通过形参具体传递到函数内部的数据
注意: 同一个函数可以调用多次
2）函数调用过程
第1步：回到函数定义的位置
第2步：传参(用实参给形参赋值, 保证每个参数都有值)
第3步：执行函数体
第4步：执行完函数体回到函数调用的位置接着往后执行
def sum2(num1, num2):
print(num1 + num2)
sum2(1, 2)
def fun1():
# list1 = [1, 2, 3]
# print(list1[5])
print('==========')
fun1()
04. 函数的参数
1. 位置参数 和 关键字参数
实参按照传递方式的不同分为 位置参数 和 关键字参数 两种
1. 位置参数
调用函数的时候让实参 和 形参一一对应(第一个实参给第一个形参赋值，第二个实参给第二个形参赋值…)
格式：数据1, 数据2, 数据3, …
def func1(x, y, z):
print(f'x:{x}, y:{y}, z:{z}')
func1(10, 20, 30) # x:10, y:20, z:30
func1(10, 30, 20) # x:10, y:30, z:20
2. 关键字参数
让实参 和 形参通过关键字 (形参名) 对应
格式：形参名1=数据1,形参名2=数据2,…
func1(x=100, y=200, z=300) # x:100, y:200, z:300
func1(z=30, x=10, y=20) # x:10, y:20, z:30
func1(10, z=30, y=20) # x:10, y:20, z:30
func1(x=20, 40, z=60) # 抱错！位置参数必须在关键字参数的前面
print(10, end='a')
print(10, 20, 30, sep=',')
def print(*data, end='\n', sep=' '):
pass
sorted([1, 23, 8], reverse=True)
3. 关键参数和位置参数混用
混用的时候位置参数必须在关键字参数前面
func1(10, z=30, y=20)
func1(x=20, 40, z=60) # 抱错！位置参数必须在关键字参数的前面
5. 参数默认值
定义函数的时候可以给以 ‘形参名=数据’ 的形式给参数赋 默认值，调用函数的时候有默认值的参数可以不赋值
注意: 有默认值的参数必须在没有默认值参数的 后面
def func2(x=1, y=10, z=100):
print(f'x:{x}, y:{y}, z:{z}')
func2(1, 2, 3) # x:1, y:2, z:3
func2(10, 20) # x:10, y:20, z:100
func2(10)
func2()
func2(y=200)
func2(z=300)
def func3(x, y, z=100):
print(f'x:{x}, y:{y}, z:{z}')
6.参数类型说明
定义函数的时候，可以对参数类型进行说明
1) 赋默认值，默认值是什么类型，参数类型说明就是什么类型
2) 形参名:数据类型
def func4(x=''):
pass
def func5(x: list) -> None:
x.append('100')
func5([])
7. 不定长参数
在形参前 加 * 或者 加 **,就可以让这个参数变成不定长参数。不定长参数的形参可以同时接受多个实参
1）带 * 的不定长参数
带 * 的参数会变成一个元组，元组中的元素就是对应的实参
注意：
a. 一个函数可以同时存在带 * 和不带 * 的参数，如果不带 * 的 在带 * 的后面，不带 * 的参数必须使用关键字参数
b.带 * 的参数必须使用位置参数
2）带 ** 的不定长参数
带 ** 的不定长参数会变成一个字典 ; 调用的时候用关键字参数传参，每个关键字就是字典的key，关键字后面的数据就是字典的 value
注意：
a. 定义的时候 不定长参数必须放在 ** 不定长参数的前面
b. 带 * 和带 ** 的不定长参数可以同时存在，但 * 是必须在 ** 前面。（如果同时存在可以让函数在调用的时候更加灵活）
def func6(*x):
print(f'x:{x}')
func6()
func6(10)
func6(10, 20)
func6(1, 2, 3, 4, 5)
练习：定义一个函数，可以求多个数的和
sum1(10, 20) sum1(10, 20, 30)
def sum1(*num):
s = 0
for x in num:
s += x
print(s)
sum1(10, 20) # 30
sum1(10, 20, 30) # 60
def func7(x, *y):
print(f'x:{x}, y:{y}')
func7(10) # x:10, y:()
func7(10, 20, 30, 40, 50) # x:10, y:(20, 30, 40, 50)
def func8(*x, y):
print(f'x:{x}, y:{y}')
func8(1, 2, 3, y=10)
def func9(**num):
print(num)
func9() # { }
func9(a=10, b=20) # {'a': 10, 'b': 20}
func9(x=100, y=200, z=300, m=0) # {'x': 100, 'y': 200, 'z': 300, 'm': 0}
def func10(x, **y):
print(f'x:{x}, y:{y}')
func10(10, a=20, c=30, d=40) # x:10, y:{'a': 20, 'c': 30, 'd': 40}
func10(a=1, b=2, c=3, x=100) # x:100, y:{'a': 1, 'b': 2, 'c': 3}
def func11(*x, y):
pass
def func12(*x, **y):
print(f'x:{x}, y:{y}')
func12(1, 2, 3)
func12(a=10, b=20)
func12(1, 2, a=3, b=4)
作业
-
编写一个函数，交换指定字典的key和value。
例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}def change(dict1): dict2 = {dict1[x]: x for x in dict1} print(dict2) return dict2 -
编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
例如: 传入'12a&bc12d-+' --> 'abcd'def func(str1): str2 = '' for x in str1: if 'a' <= x <= 'z' or 'A' <= x <= 'Z': str2 += x print(str2) return str2 -
写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
例如: 'abc' -> 'Abc' '12asd' --> '12asd'def func1(str1): str2 = '' if 'a' <= str1[0] <= 'z': str2 += chr(ord(str1[0]) - 32) else: str2 += str1[0] for x in str1[1:]: str2 += x print(str2) return str2 -
写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束
例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True 字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: Falsedef func2(s1, s2): T_F = s1[len(s1) - len(s2):len(s1)] == s2[:] print(T_F) return T_F -
写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
例如: '1234921' 结果: True '23函数' 结果: False 'a2390' 结果: Falsedef func3(t1): for x in t1: if not '0' <= x <= '9': print('False') break else: print('True') -
写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
例如: 'abH23好rp1' 结果: 'ABH23好RP1'def func4(t2): t3 = '' for x in t2: if 'a' <= x <= 'z': t3 += chr(ord(x) - 32) else: t3 += x print(t3) -
写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc' 原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'def func5(old_str, wids, chars): a = wids - len(old_str) print(chars*a + old_str) -
写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 结果: 0,4,6 列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '赵云' 结果: 0,4 列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '关羽' 结果: -1def func6(list1,element): list2 = [] for x, y in enumerate(list1): if y == element: list2.append(x) if element not in list1: list2.append(-1) print(list2) -
写一个自己的len函数，统计指定序列中元素的个数
例如: 序列:[1, 3, 5, 6] 结果: 4 序列:(1, 34, 'a', 45, 'bbb') 结果: 5 序列:'hello w' 结果: 7def func7(seps): print(len(seps)) -
写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
例如: 序列:[-7, -12, -1, -9] 结果: -1 序列:'abcdpzasdz' 结果: 'z' 序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98def func8(sequence): if type(sequence) != dict: print(max(sequence)) else: maxs_num = sequence[list(sequence)[0]] for x in sequence: if sequence[x] > maxs_num: maxs_num = sequence[x] print(maxs_num) -
写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在
例如: 序列: (12, 90, 'abc') 元素: '90' 结果: False 序列: [12, 90, 'abc'] 元素: 90 结果: Truedef func9(seqs1, index): if index in seqs1: print('True') else: print('False')