黑龙江住房城乡建设厅网站,wordpress设置账号,我要自学网首页,杭州餐饮网站建设函数 在实现某个功能对应的代码的时候#xff0c;如果将实现功能对应的函数放到函数中#xff0c;那么下一次再需要这个功能的时候#xff0c;就可以不用再写这个功能对应的代码#xff0c;直接调用这个功能对应的函数。 1.什么是函数 函数就是实现某一特点功能的代码的封装…函数 在实现某个功能对应的代码的时候如果将实现功能对应的函数放到函数中那么下一次再需要这个功能的时候就可以不用再写这个功能对应的代码直接调用这个功能对应的函数。 1.什么是函数 函数就是实现某一特点功能的代码的封装 - 函数就把实现某一功能的代码打成一个包以后再需要这个功能的时候直接使用函数就行了。 1) 函数分类 a.系统函数已经造好的机器由系统创建好函数只需要在需要他们提供的功能的时候去调用它例如print、input、max、type等 b.自定义函数自己造机器由程序员自己创建的函数 2.定义函数创建函数
1) 语法 def 函数名形参列表 函数说明文档 函数体 2) 说明 a.def - 关键字固定写法 b.函数名 - 程序员自己; 两个要求是标识符、不是关键字 三个规范见名知义看到函数名大概知道这个函数的功能、不使用系统函数名、类名或者模块名、 所有字母都小写多个单词用下划线隔开 c.() - 固定写法 d.形参列表 - 以’变量名1变量名2变量名3…的形式存在这儿的每一个变量就是一个形参 形参的个数可以是任意多个0个、1个、2个 … 形参可以将函数外部的数据传递到函数里面 e.函数说明文档 - 本质就是一个多行注释 f.函数体 - 函数体就是好def保持一个缩进的一条或者多条语句至少一条 逻辑上函数体就是实现函数功能的代码 3) 初学者定义函数的步骤 第一步确定函数功能 第二步确定函数名 第三步确定形参看实现函数的功能需不需要额外的数据需要几个 第四步通过函数体实现函数功能这个时候直接将形参作为对应的数据使用 第五步确定函数返回值 第六步写函数说明文档 # 案例定义一个函数求任意两个数的和
def sum_2(num1, num2):print(num1 num2)
num1 33
num2 78
sum_2(num1, num2)# 案例统计一个字符串中中文的个数
def count_chinese(string):(功能说明区)统计一个字符串中中文的个数:param string: 参数说明需要统计的字符串:return: 返回值说明Nonecount 0for x in string:if \u4e00 x \u9fa5:count 1print(count)
count_chinese(国际化后即可ghjh)# 案例提取两个字符串中公共字符
def common_character(string1, string2):for x in string1:if x in string2:print(x, end)
common_character(fgjyuiy, fhgj)
print()# 案例求10!
def factorial(num):sum 1for x in range(1, num 1):sum * xprint(sum)
factorial(10)3.调用函数
1语法 函数名实参列表 2说明 函数名 - 必须是已经定义好的函数名 需要哪个函数功能就调用哪个函数就写哪个函数的函数名 () - 固定写法 实参列表 - 实参就是通过形参从函数外部传递到函数内部的数据 以‘数据1数据2数据3…的形式存在这儿的每个数据就一个实参实参的个数由形参的个数决定’ 重要结论定义函数的时候就执行函数体调用函数的时候才会执行调用多少次函数体就执行多少次。 调用过程每次调用函数的时候 1回到函数定义的位置 2传参用实参给形参赋值 3执行函数体 4确认返回值 5回到函数调用的位置接着往后执行 4.参数
1.位置参数和关键词参数 根据调用函数的时候实参提供方式的不同可以将实参分为位置参数和关键字参数 注意 a.如果位置参数和关键字参数一起使用那么位置参数必须在关键字参数的前面 b.不管以什么样的方式传参必须保证每个参数都有值并且每个参数只有一个值 1位置参数 直接将多个数据用逗号隔开让实参和形参从位置上一一对应 2关键字参数 以‘形参名实参名1形参名2实参名2…’形式存在的参数 # 位置参数
func1(10, 20, 30)
func1(20, 10, 30)# 关键词参数
func1(a10, b20, c30)
func1(b20, a10, c30)# 位置参数和关键字参数一起用
func1(10, b20, c30)
# func1(a10,20,c30) 会报错位置参数必须在关键字参数的前面
# func1(20,a10,c30) 会报错a赋值了多个值2.参数默认值 1定义函数的时候可以以‘形参名值’的方式给形参赋默认值有默认值的参数在调用函数的时候可以不用传参。 def func2(a1, b2, c3):print(fa:{a},b:{b},c:{c})func2() # a:1,b:2,c:3
func2(10) # a:10,b:2,c:3
func2(10, 20) # a:10,b:20,c:3
func2(10, 20, 30) # a:10,b:20,c:30
# 如果要跳过前面有默认值的参数直接给后面的参数传参必须使用关键字参数
func2(c30) # a:1,b:2,c:30
func2(b20) # a:1,b:20,c:32定义函数的时候可以有的参数有默认值有的参数没有默认值但是没有默认值的参数必须在有默认值参数的前面 def func3(a, b2, c3):
# def func4(a1,b,c3) 会报错没有默认值的参数必须放在有默认值的参数的前面print(fa:{a},b:{b},c:{c})3.参数类型说明 定义函数的时候可以对参数类型进行说明 1没有默认值的参数形参名类型名 2有默认值的参数默认值的数据类型就是参数类型 def func7(str1: str, list1: list, str2):print(str1.isdigit())print(list1[0])print(str2[0])5.返回值
1.什么是返回值 返回值就是从函数内部传递到函数外部的数据。 定义函数的时候需不需要添加返回值的建议看实现函数的功能有没有产生新的数据如果有新的数据就将新的数据作为返回值返回。 2.怎么确定函数返回值
- 怎么将一个数据作为函数的返回值返回 返回值就是return关键字后面的表达式的值函数内部产生的数据如果不用返回值返回是无法在函数外部使用 return 数据 def sum_2(num1, num2):result num1 num2return resultsum_2(10, 20)
print(sum_2(10,20))3.怎么使用函数返回值 函数调用表达式的值就是函数的返回值Python中每个函数的函数调用都是有结果的这个结果就是这个函数在调用的时候得到的返回值 函数调用表达式 - 调用函数的语句 注意每次调用函数的时候会执行函数体 def func1(num1):print(num)def sum_2(num1, num2):result num1 num2return resultresult1 sum([10, 20, 30])
print(fresult1:{result1})
result2 sum_2(10, 20)
print(fresult2:{result2})
result3 func1()
print(freslut3:{result3})# 删除指定数字列表中所有的负数
# 方法一创建新的列表储存返回值
def del_minus(nums: list):new_nums []for x in nums:if x 0:new_nums.append(x)return new_numslist1 [10, -10, 26, -78, 6]
result del_minus(list1)
print(result) # [10, 26, 6]# 直接删除原列表元素不需要返回值
def del_minus2(nums: list):for x in nums[:]:if x 0:nums.remove(x)list1 [10, -10, 26, -78, 6]
del_minus2(list1)
print(list1) # [10, 26, 6]4. return的作用 注意return只能在函数体中使用 1)将数据作为函数的返回值返回 2)结束函数执行函数体的时候如果遇到return函数直接结束 def func3(n):for x in range(1, n):if n % 3 0:return xprint(fx:{x})print(func3(5))
#x:1
#x:2
#x:3
#x:4
#None6.变量作用域 变量定义完成后的作用范围 根据变量作用域的不同可以将变量分为全局变量和局部变量 1全局变量 Python中没有定义在函数和类的变量默认都是全局变量 作用域从定义开始到程序结束 2局部变量 Python定义在函数中的变量 作用域从定义到函数结束 3全局变量和局部变量的存储原理 1全局变量默认保存在全局栈区间全局栈区间会在程序结束后自动释放。 2调用函数的时候系统会自动为这个函数创建一个临时栈区间用来保存函数中产生的数据局部变量就是保存在函数对应的临时栈区间中的函数对应的临时栈区间会在函数调用结束的时候自动释放 3在函数中可以通过关键字 global修改局部变量的保存方式 name 小明
def func1():global num1 #在函数内部定义全局变量用globalnum1 10global name #在函数中用global改变全局变量的值name 小花func1()
print(num1)
print(name)7.匿名函数(lambda) 没有名字的函数 函数名 lambda 形参列表返回值 相当于 def 函数名(形参列表): return 返回值 注意: 1.匿名函数的形参至少一个 2.匿名函数的调用和普通函数一样 3.无默认值的类型说明在匿名函数中不能用 # 案例定义一个匿名函数求任意两个数的和
sum_1 lambda a, b: a b
print(sum_1(1, 2))
print(sum_1(a1, b2))sum_2 lambda a1, b2: a b
print(sum_2())# 练习定义一个匿名函数判断指定的年是否是闰年
is_leap_year lambda year: year % 4 0 and year % 100 ! 0 or year % 400 0
print(is_leap_year(2000))
print(is_leap_year(2001))8.实参高阶函数 函数的参数是函数的函数就是实参高阶函数 给参数是函数的参数传参a.使用普通函数函数名b.使用匿名函数 重点掌握系统或者第三方库提供的实参高阶函数的用法 常见的实参高阶max、min、sorted、列表.sort、map、reduce def func5(x):print(x.split())func5(abc)
print(---------------------------------------华丽的分割线------------------------------------)# func6就是一个实参高阶函数
def func6(x):# x tx() # t()def t():print(t函数)func6(t)
print(---------------------------------------华丽的分割线------------------------------------)# func7是实参高阶函数
def func7(x):# x t2# x lambda n1, n2: n1 n2print(x(10, 20) 30)# print(t2(10, 20) 30) print(200 30)# print(30 30)
def t2(n1, n2):# n1 10, n2 20return n1 * n2 # return 200func7(t2)
func7(lambda n1, n2: n1 n2)max、min、sorted、列表.sort
1. max(序列) 直接比较序列中元素的大小求最大值 max(序列, key函数) - 按照函数制定的规则比较序列中元素的大小获取最大值 函数的要求 a. 有且只有一个参数(这个参数代表序列中的每个元素) b. 有一个返回值(返回值就是比较对象) nums [83, 67, 19, 22, 80, 77, 93]
print(max(nums))# 案例求个位数最大的元素
nums [83, 67, 19, 22, 80, 77, 93]
result max(nums, keylambda item: item % 10)
print(result) # 19# 案例求nums中绝对值最大的元素
nums [8, -283, 89, 100, 82, -34]
result max(nums, keylambda item: item ** 2)
print(result) # -283# 案例求students中分数最高的学生
students [{name: stu1, age: 18, score: 90},{name: stu2, age: 22, score: 98},{name: stu3, age: 25, score: 78},{name: stu4, age: 19, score: 81},{name: stu5, age: 20, score: 92}
]
result max(students, keylambda item: item[score])
print(result)# 案例按照分数的高度对学生从大到小排序
result sorted(students, keylambda item: item[score], reverseTrue)
print(result)# 练习1求list1中长度最长的字符串
list1 [你好, hello, how are you, thank you! and you, 好好学习天天向上]
result max(list1, keylambda item: len(item))
print(result)# 练习2求nums中十位数最小的元素
nums [92, 129, 37, 99, 150, 501]
result min(nums, keylambda item: item // 10 % 10)
print(result)# 练习3将所有的学生按照年龄值从小到大排序
students [{name: stu1, age: 18, score: 90},{name: stu2, age: 22, score: 98},{name: stu3, age: 25, score: 78},{name: stu4, age: 19, score: 81},{name: stu5, age: 20, score: 92}
]
students.sort(keylambda item: item[age])
print(students)# 练习4求nums中各个位之和最大的元素
nums [123, 78, 90, 201, 192, 330]
# 123 - 1 2 3
# 123 - 1、2、3, [1, 2, 3]# 方法1
result max(nums, keylambda item: sum([int(x) for x in str(item)]))
print(result)# 方法2
# 123 - eval(123)
# 123 - 123 - .join(123) - 123
result max(nums, keylambda item: eval(.join(str(item))))
print(result)# 方法3
def t(item):sum1 0for x in str(item):sum1 int(x)return sum1result max(nums, keyt)
print(result)2. map 基于原序列中的元素创建一个新的序列 1)map(函数, 序列) - 通过函数描述的规则基于序列中的元素创建一个新的序列 函数要求 a. 有且只有一个参数代表后面的这个序列中每个元素 b. 有一个返回值返回值就是新序列中元素 2)map(函数, 序列1, 序列2) 函数要求 a. 有且只有2个参数分别代表后面的两个序列中每个元素 b. 有一个返回值返回值就是新序列中元素 3)map(函数, 序列1, 序列2, 序列3,…) # 案例1将nums中所有的元素乘以10
nums [19, 870, 34, 61, 78]
result map(lambda item: item*10, nums)
print(list(result)) # [190, 8700, 340, 610, 780]# 案例2获取nums中所有元素的个位数
result map(lambda item: item % 10, nums)
print(list(result)) # [9, 0, 4, 1, 8]# 案例2将nums1和nums2中相同位置上的元素相乘得到一个新的序列
nums1 [10, 20, 30, 10]
nums2 [23, 30, 20, 55]
result map(lambda i1, i2: i1 * i2, nums1, nums2)
print(list(result)) # # [230, 600, 600, 550]# 练习1获取names中每个人的姓
names [何晓东, 张三, 李四, 王五, 王二, 赵六]
result map(lambda item: item[0], names)
print(list(result))# 练习2
students [{name: stu1, age: 18, score: 90},{name: stu2, age: 22, score: 98},{name: stu3, age: 25, score: 78},{name: stu4, age: 19, score: 81},{name: stu5, age: 20, score: 92}
]
subjects [电子信息, 金融数学, 园林设计, 经济, 计算机软件]# [电子信息-stu1, 金融数学-stu2,....]
result map(lambda i1, i2: f{i2}-{i1[name]}, students, subjects)
print(list(result))3. reduce 将序列中元素合并成一个数据基于原序列中所有的元素得到一个数据 reduce(函数, 序列, 初始值) - 按照函数制定的规则将序列中的元素合并成一个数据 函数的要求 a. 有且只有两个参数第一个参数指向初始值第二个参数代表序列中的每个元素 b. 需要一个返回值 返回值就是合并规则 初始值: 累积求数值和初始值是0 累积求数值乘积初始值是1 字符串合并初始值是空串(‘’) from functools import reducenums [12, 301, 40, 55, 112]
# 案例112 301 40 55 112 的结果
# 0 12 301 40 ... 112
result reduce(lambda x, item: x item, nums, 0)
print(result)# 案例12 * 301 * 40 * 55 * 112 的结果
# 1 * 12 * 301 * ... * 112
result reduce(lambda x, item: x * item, nums, 1)
#x表示初始值item表示序列中的每一个元素
print(result)# 案例123014055112 - 123014055112
# 12 301 40 ... 112
# str(12) str(301) ... str(112)
result reduce(lambda x, item: x str(item), nums, )
print(result) # 123014055112# 练习21052
nums [12, 301, 40, 55, 112]
# 0 2 1 0 5 2
# 0 12 % 10 301 % 10 ... 112 % 10
result reduce(lambda x, item: x item % 10, nums, 0)
print(result)迭代器
1. 什么是迭代器(iter) 1迭代器是容器型数据类型(可以遍历也转换成列表)无法直接提供一个迭代器只能将其他序列转换成迭代器。 2特点 a.打印迭代器的时候无法查看到元素有哪些 b.无法通过len获取迭代器中元素的个数 c.如果要使用迭代器中的元素必须将元素从迭代器中取出来(取走)取走的元素会从迭代器中永远消失(用一个就少一个) 3任何数据都可以作为迭代器的元素 1)创建迭代器
i1 iter(abc)
i2 iter([10, 20, 30, 40])
i3 iter((10, 1.23, abc, True, [10, 20]))2)打印迭代器无法查看元素
print(i1)
print(i2)3)迭代器无法统计个数
# print(len(i1)) # 报错2. 获取迭代器中的元素 无论以任何方式获取到了迭代器中的某个元素那么这个元素一定会从迭代器中消失。 1获取单个元素 next(迭代器) - 获取迭代器最前面的元素 2遍历迭代器 for 变量 in 迭代器: 循环体 print(next(i1)) # a
print(next(i1)) # b
print(next(i1)) # c
# print(next(i1)) # 报错print(next(i2)) # 10
print(list(i2)) # [20, 30, 40]
# print(next(i2)) # 报错print(---------------------------------------华丽的分割线------------------------------------)
for x in i3:print(x)print(list(i3)) # []生成器
1.什么是生成器 1容器是一种可以创建多个数据的容器生成器中保存的是创建数据的方法而不是数据本身。 2特点 a.打印生成器无法查看元素 b.不能通过len统计元素的个数 c.如果需要生成器中的数据必须将数据取出而且取一个就少一个 2.怎么创建生成器 调用带有yield关键字的函数就可以得到一个生成器 定义一个函数函数中写一个yield def func1():yieldprint(hello)return 100result func1()
print(fresult:{result})3.怎么控制生成器中元素的个数和元素的值 执行创建生成器的函数的函数体是会遇到几次yield对应的生成器就可以创建几个数据每次遇到yieldyield后面的值就是能创建出来的数据。 def func3(n):yield 100if n % 2 0:yield 200yield 300gen3 func3(3)
print(next:,next(gen3)) #next: 100
print(next:,next(gen3)) #next: 300
# print(next:,next(gen3)) #生成器为空了取不了数def func3(n):yield 100if n % 2 0:yield 200yield 300gen3 func3(3)
print(gen3)
#generator object func3 at 0x000002D9B4192120
print(list(gen3))
#[100, 300]
