Python自定义函数基础
认识函数
什么是函数 — 函数就是实现某一特定功能的代码的封装
函数就是把实现某一个功能的所有的代码打成了一个包，
每次需要这个功能的时候不用再去重复去实现这个功能的代码了而是使用函数
函数的分类(按照函数是由谁创建/定义来进行分类)
系统函数 — 由Python定义的函数，这类函数只需要在需要他的功能的时候去调用它。
例：print()、type()、max()、min()…
自定义函数 — 由程序员自己定义的自己使用的函数
函数的定义
语法
def 函数名(形参)：
函数说明文档
函数体
说明
def — 固定写法
函数名 — 程序员自己命名
-
两个要求：是标识符；不是保留字 -
三个规范：见名知意；字母都小写多个单词用下划线隔开；不使用函数名类名和模块名。 (): — 固定写法 形参 — 格式：多个变量用逗号隔开；一个变量表示一个形参，也可以没有形参 形参作用：将函数外部的数据传递到函数内部 函数说明文档 — 多行注释 函数体 — 实现def保持一个缩进的一条或多条语句，函数体就是实现函数功能的代码 定义函数的步骤 第一步：确定函数的功能 第二步：根据功能确定函数名 第三步：确定形参：实现函数功能是否需要额外的数据、需要几个 第四步：利用形参提供的数据实现函数功能 第五步：确定返回值 第六步：写函数说明文档
def summary_of_numbers(number1,number2):
print(number1 + number2)
summary_of_numbers(999,1)
def bit_of_number(number):
print(number % 10)
bit_of_number(9789469)
def merge_string(string1,string2):
min_length = min(len(string1),len(string2))
string3 = ''
max_string = string1 if len(string1) >= len(string2) else string2
for index in range(min_length):
string3 += string1[index]
string3 += string2[index]
print(string3 + max_string[min_length:])
merge_string('12345','asd')
函数的调用
-
定义函数的时候不会执行函数体，调用函数才会执行；调用多少次函数体就执行多少次 -
调用函数的时候，实参的个数由被调用的函数的形参决定。实参给形参赋值的过程叫传参。 -
函数调用过程： ? 当代码执行到函数调用语句的时候： ? a)、回到定义函数的位置 ? b)、传参（用实参给形参赋值） ? c)、执行函数体 ? d)、确定返回值 ? e)、返回含糊是调用位置，继续往后执行 语法 函数名（实参） 说明 函数名 — 需要调用函数的函数名(这个函数名对应的函数必须是已经定义好的函数) () — 固定写法 实参 — 格式：多个数据用逗号隔开 ? 实参是用来给形参赋值的。(实参就是通过形参传递到函数内容的数据)
函数的参数
位置参数和关键字参数 — 根据调用函数的时候实参提供方式的不同，将实参分为位置参数和关键字参数
- 位置参数
直接提供实参对应的数据，让实参和形参在位置上一一对应
def func1(a,b,c):
print(f'a:{a},b:{b},c:{c}')
func1(1,2,3)
- 关键字参数
以形参1 = 实参1,形参2 = 实参2,形参3 = 实参3,…方式
func1(a=1,b=2,c=3)
func1(c=3,a=1,b=2)
- 混用
func1(1,b=2,c=3)
func1(1,c=3,b=2)
参数默认值
定义参数的时候可以以’形参名 = 值‘的形式提供默认值：
如果一个参数有默认值，那么在调用的时候有默认值的参数可以不用传参
跳过前面有默认值的参数给后面的参数传参使用关键字传参
如果定义函数的时候有的参数有默认值，有的参数没有，那么没有默认值的参数必须在有默认值参数的前面。
def factorial(n = 10):
product = 1
for i in range(1,n + 1):
product *= i
return product
print(factorial())
print(factorial(8))
参数类型说明
def func2(a:list , y:str):
a.append(999)
y.upper()
print(a,y)
func2([],'zzx')
带" * "的不定长参数 — 如果在一个形参前加“ * ”，那么这个形参可以接受任意多个实参
带 " * "的不定长参数的本质就是一个元组，对应的多个实参是元组中的元素
注意：带“ * ”的不定长参数，传参的时候只能使用位置参数
def func3(*x):
print(x)
func3()
func3(1)
func3(1,2,3,4)
def func4(*a,b):
print(a,b)
func4(1,2,3,4,b = 5)
def func5(**x):
print(x)
func5(a=1,b=2,c=3)
def summary(*numbers):
s = 0
for number in numbers:
s += number
return s
print(summary(1, 2, 3, 4, 5, 6, 7))
函数的返回值
- 返回值的作用
返回值作用就是将函数内部产生的数据传递到函数的外部
- 确定函数的返回值（怎么将数据作为返回值）
在函数体中通过return关键字返回函数的返回值：return 数据
注意：
1)、若执行函数体的时候没有遇到return，函数的返回值是None
? 2)、return还具有提前结束函数的功能（执行函数体的时候在哪儿遇到return函数就在哪儿结束）
? 3)、没有遇到return返回值是None
- 怎么在函数外部获取函数的返回值
获取函数调用表达式的值就是获取函数的返回值
每一个函数调用语句其实都有一个结果(都是一个数据),这个结果就是这次调用的时候函数的返回值
return后面的值是什么，函数外部函数调用表达式的结果就是什么
def numbers_in_string(string):
count = 0
for item in string:
if('9' >= item >= '0'):
count += 1
return count
print(numbers_in_string('asd85as'))
def factorial(n):
product = 1
for i in range(1,n + 1):
product *= i
return product
print(factorial(10))
练习
-
编写一个函数，交换指定字典的key和value。 例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}
def exchange(dict1:dict):
dict1 = {dict1[key]:key for key in dict1}
return dict1
dict1={'a':1, 'b':2, 'c':3}
dict2 =exchange(dict1)
print(f'交换字典{dict1}的key和value后为{dict2}')
-
编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串 例如: 传入'12a&bc12d-+' --> 'abcd'
def letters_in_string(string:str):
new_string = ''
for char in string:
if('a'<= char <= 'z' or 'A'<= char <= 'Z'):
new_string += char
return new_string
string1 = 'z9z9x+b-e*s/t'
print(f'取{string1}中所有的字母，然后拼接在一起产生的新的字符串为{letters_in_string(string1)}')
-
写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母 例如: 'abc' -> 'Abc' '12asd' --> '12asd'
def capitalize(string:str):
new_string = ''
if('a'<= string[0] <= 'z'):
char = chr((ord(string[0]) -32))
new_string = char + string[1:]
print(f'将{string}的首字母变成大写字母后:{new_string}')
else:
print(f'{string}的第一个字符不需要大写！')
string2 = input('请输入一个字符串:')
capitalize(string2)
-
写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束 例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
def is_end_by(str1:str,str2:str):
length = len(str2)
if(str1[-length:] == str2):
return True
else:
return False
string3 = 'abc231ab'
string4 = '231ab'
print(f'{string3}是否以{string4}结束:{is_end_by(string3,string4)}')
-
写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串 例如: '1234921' 结果: True
'23函数' 结果: False
'a2390' 结果: False
def isdigit(string:str):
for char in string:
if('0' <= char <= '9'):
continue
else:
return False
else:
return True
string5 = '1234921'
print(f'{string5}是否是纯数字字符串:{isdigit(string5)}')
-
写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母 例如: 'abH23好rp1' 结果: 'ABH23好RP1'
def mine_upper(string:str):
new_string = ''
for char in string:
if('a'<= char <= 'z'):
new_string += chr(ord(char) - 32)
else:
new_string += char
return new_string
string6 = 'wow!zzx太棒啦！^3^'
print(f'将{string6}中所有的小写字母变成大写字母后为：{mine_upper(string6)}')
-
写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充 例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc'
原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'
def mine_rjust(string:str,char:str,width:int):
length = len(string)
if(width <= length):
return string
else:
return char * (width - length) + string
string7 = 'abc'
char1 = '$'
width = 10
print(f'{string7}在{char1}的填充成宽度为{width}后为：{mine_rjust(string7,char1,width)}')
-
写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1 例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 结果: 0,4,6
列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '赵云' 结果: 0,4
列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '关羽' 结果: -1
def mine_index(list1:list,item):
list2 = []
for index,char in enumerate(list1):
if(item == char):
list2.append(index)
if(len(list2) == 0):
list2.append(-1)
return list2
list1 = [1, 2, 45, 'abc', 1, '你好', 1, 0]
item = 1
print(f'{list1}中指定元素{item}的所有下标为:{mine_index(list1,item)}')
-
写一个自己的len函数，统计指定序列中元素的个数 例如: 序列:[1, 3, 5, 6] 结果: 4
序列:(1, 34, 'a', 45, 'bbb') 结果: 5
序列:'hello w' 结果: 7
ef mine_len(sequence):
length = 0
for _ in sequence:
length += 1
return length
tuple1 = (1, 34, 'a', 45, 'bbb')
print(f'序列{tuple1}中元素的个数为:{mine_len(tuple1)}')
-
写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值 例如: 序列:[-7, -12, -1, -9] 结果: -1
序列:'abcdpzasdz' 结果: 'z'
序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98
def mine_max(string):
if(type(string) == dict):
string1 = {string[key] for key in string}
return max(string1)
else:
max_item = string[0]
for char in string[1:]:
if(max_item < char):
max_item = char
return max_item
dict3 = {'小明':90, '张三': 76, '路飞':30, '小花': 98}
print(f'序列{dict3}元素的最大值为:{mine_max(dict3)}')
-
写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在 例如: 序列: (12, 90, 'abc') 元素: '90' 结果: False
序列: [12, 90, 'abc'] 元素: 90 结果: True
def mine_in(string,item):
if (type(string) == dict):
for key in string:
if(item == key):
return True
else:
return False
else:
for char in string:
if(char == item):
return True
else:
return False
dict4 = {'小明':90, '张三': 76, '路飞':30, '小花': 98}
item1 = '小花'
print(f'序列{dict4}中，指定的元素{item1}是否存在:{mine_in(dict4,item1)}')
-
写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串 例如: 原字符串: 'how are you? and you?' 旧字符串: 'you' 新字符串:'me' 结果: 'how are me? and me?'
def mine_replace(string:str,old_str,new_str):
old_length = len(old_str)
new_string = ''
index= 0
while(index < (len(string))):
if(old_str == string[index:index + old_length]):
new_string += new_str
index += old_length
else:
new_string += string[index]
index += 1
return new_string
string8 = 'how are you? and you?'
old_str = 'you'
new_str = 'me'
print(f'将{string8}中{old_str}转换成{new_str}后为：{mine_replace(string8,old_str,new_str)}')
|