本文介绍了Python函数的定义、嵌套以及四种参数类型：位置参数、默认参数、可变参数和关键字参数。详细讲解了函数的返回值、局部和全局变量，并通过案例展示了如何使用函数。接着，文章探讨了列表生成式和字典生成器的用法。最后，重点阐述了Python的高阶函数，包括map、reduce和filter，以及内置的sorted排序函数。
##########函数的定义
##写一个函数
def hello(): ##定义一个函数
print('hello1')
print('hello2')
print('hello3')
hello() #调用函数
def sum_2_sum(): ##定义一个加法函数
num1 = 20
num2 = 30
result = num1 + num2
print('%d + %d = %d' %(num1,num2,result))
sum_2_sum() ##调用函数
#结果
hello1
hello2
hello3
20 + 30 = 50
##嵌套
def westos(): #函数的嵌套
print('is westos')
def python(): ##在嵌套一个名字是python的函数
print('python')
python() ##调用python这个函数时于定义python并列
westos() ##调用westos这个函数时在定义westos函数之外
def welcome(x): #定义函数的时候的变量 叫形参(形参可以任意起名)
print('hello',x)
welcome('alice') #真实的数据信息，调用函数时传递的参数 实参
welcome('coco')
#结果
is westos
python
hello alice
hello coco
###########函数的四大参数
参数：形参 实参。形参：位置参数 默认参数 可变参数 关键字参数。
#位置参数：形参和实参个数 位置必须保持一致
#默认参数 形参和实参可以不一致，如果没有传递值，用默认值
def getInfo(name,age):
print(name,age)
getInfo('laoli',38) ##当传递给函数的参数颠倒位置时，输出发生变化
getInfo(38,'laoli')
def mypow(x,y=2): ##定义一个幂次函数，默认参数2。
print(x**y)
mypow(4) ##x为4
mypow(2,4) ##当赋予y值，y的默认值改变
##结果
laoli 38
38 laoli
16
16
#可变参数：
def mysum(*a): ##*a表示输入可以多个
"""
:param a:
:return:
*a:可变参数
a：是元组数据类型
"""
sum = 0 ##给一个空的变量
for item in a: ##让item在输入中遍历
sum += item ##自加遍历元素
print(sum)
mysum(1,2,3,4,5,6) ##调用这个函数
##结果
21
#关键字参数
def getStuInfo(name,age,**kwargs): ## **kwargs是一个字典，可以传递任意多个key-value
"""
:param name:
:param age:
:param kwargs:
:return:
"""
print(name,age) ##输出普通参数
print(kwargs) ##输出关键字参数
getStuInfo('westos','20',gender='male',hobbies=['coding','running']) ##函数输入普通参数还有关键字参数
print(getStuInfo('westos','18')) ##输如普通参数，没有输入关键字参数
##结果
westos 20
{'gender': 'male', 'hobbies': ['coding', 'running']}
westos 18
{}
None
##############函数的返回值
返回值：函数运算的结果，当还需要进一步操作是，用return来返回
函数的执行结果，如果没有返回值，默认为None
一旦遇到return，函数执行结束，后面的代码不会执行
def mypow(x,y=2): ##定义行署
return x ** y, x + y ##返回值下一行代码不再获取，分别时幂次计算，和相加
print('hello')
print(mypow(3)) 输出
a,b = mypow(3) #对元组进行解包
print(a,b) ##分别输出两个值
##结果
(9, 5)
9 5
局部变量：在函数内部定义的变量，只在函数内部起作用，函数执行
结束，变量会自动删除
全局变量
a = 1
print('outside:',id(a))
def f():
# global a #声明a为全局变量。当这条命令有效时，a的值将会不仅在程序中有效，在函数外也有效
a = 5
print('inside:',id(a))
f()
print(a)
print(id(a))
##结果
outside: 9326560 ##最开始id
inside: 9326688 ##在函数里面的id
1 ##在外面的a值
9326560 ##在外面a的id不变
案例1:
编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所
有数.
def cacluate(*args): ##定义一个行署
avg = sum(args) / len(args) ##用自带工具求输入的和，以及输入的个数。将两者相除
up_avg = [] ##定义一个空列表
for item in args: ##item遍历输入
if item > avg: ##当其中元素，大于平均值
up_avg.append(item) ##将其添加到列表中
return avg, up_avg ##返回值
b = cacluate(1, 2, 3, 4, 5, 7, ) ##尝试输入字符
print(b) ##输出
##结果
(3.6666666666666665, [4, 5, 7])
案例2:
编写一个函数, 接收字符串参数, 返回一个元组,‘ehllo WROLD’
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
def f(x): ##定义函数
upper_count = 0 ##大写计数器
lower_count = 0 ##小写计数器
for i in x: ##i在输入中遍历
if i.isupper(): ##如果是大写，自加1
upper_count += 1
elif i.islower(): ##如果是小写，自加1
lower_count += 1
else: ##其他的话继续
continue
return upper_count,lower_count ##返回值
a = f('ehllo WROLDA') ##查看值
print(a) ##打印
##结果
(6, 5)
模拟轮盘抽奖游戏
轮盘分为三部分: 一等奖, 二等奖和三等奖;
轮盘转的时候是随机的,
如果范围在[0,0.08)之间,代表一等奖,
如果范围在[0.08,0.3)之间,代表2等奖,
如果范围在[0, 1.0)之间,代表3等奖,
模拟本次活动1000人参加, 模拟游戏时需要准备各等级奖品的个数.
import random ##随机产生数
print(random.random())
def people(): ##定义函数
li = [] ##空的列表
for i in range(1000): ##遍历1000个数
a = random.random() ##随机产生数
li.append(a) ##产生后放到列表中
return li ##返回列表的值
count_1 = 0 ##计数器1
count_2 = 0 ##计数器2
count_3 = 0 ##计数器3
for i in people(): ##在函数所产生的列表中进行遍历
if i >= 0 and i < 0.08: ##在0，0.08之间的数，自加1
count_1 += 1
elif i >= 0.08 and i < 0.3: ##在0.08与0.3之间的数自加1
count_2 += 1
elif i >= 0.3 and i < 1: ##在0.3到1之间的数自加1
count_3 += 1
print("一等奖：",count_1,"二等奖：",count_2,"三等奖：",count_3) 输出各层次奖的个数
#结果
0.13554217371840394
一等奖： 77 二等奖： 224 三等奖： 699
#################列表生成式
s = '51 5000 10000' ##给s的字符串
li = [] ##给一个空列表
for item in s.split(): ##将字符串分离，用item遍历，并加入列表中
li.append(int(item))
k,a,b = li ##将产生的值分别给与k、a、b
print(k,a,b)
k,a,b = [int(item) for item in s.split()] ##这个相当把上边的简写了一遍
print(k,a,b)
##结果
51 5000 10000
51 5000 10000
#生成一个列表，列表元素分别为[12,22,32…n2]
li = [] ##空列表
for i in range(1,10): ##在1-10循环
li.append(i ** 2) ##增加i的2次幂
print(li) ## 输出
print([i ** 2 for i in range(1,10)]) ##简写
#[expression for i in 序列 if...] ##列表生成式中有判断条件
print([i ** 2 for i in range(1,10) if i % 2 == 0]) ##为偶数的是
##结果
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[4, 16, 36, 64]
#1~num之间所有的质数
def isPrime(num): ##定义一个函数
for i in range(2,num): ##挑选出质数
if num % i == 0:
return False
else:
return True
print([i for i in range(2,21) if isPrime(i)]) ##列表生成式中带有条件
#结果
[2, 3, 5, 7, 11, 13, 17, 19]
(2018-腾讯-在线编程题)
- 题目描述:
给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整
数，并输出结果。输
入值小于1000。
如，输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别
为(5,5),(3,7)）
[2,3,5,7] - 输入描述:
输入包括一个整数n,(3 ≤ n < 1000) - 输出描述:
输出对数 - 示例1 :
输入:
10
输出:
2
num = int(input()) ##输入
def isPrime(num): ##定义函数
for i in range(2,num): ##遍历2到num之间
if num % i == 0: 看谁是偶数
return False 返回值
else: 否则返回True
return True
primeli = [i for i in range(2,num) if isPrime(i)] ##质数返回正确并将其输入到列表中
print(primeli) ##输出所返回的质数
"""
1.先拿出两个数
2.判断两个数之和是否等于num
"""
count = 0 ##计数器
for item1 in primeli: ##item1在质数中遍历
if (num - item1) in primeli and item1 <= num - item1: ##输入的数减去遍历的数要在列表中，遍历的数要小于等与前面相减的值
count += 1 ##自加一计数
print(count)
##结果
10
[2, 3, 5, 7]
2
###############字典生成器
#需求：假设有20个学生，学生名为westisX，学生分数在60-100之间
#选出成绩在90分以上的学生
import random
stuInfo = {} ##准备空的字典空间
for i in range(20): ##循环在20书中
name = 'westos' + str(i) ##连接符连接
score = random.randint(60,100) ##分数在60-100直接随机生成
stuInfo[name] = score ##将生成的分数放到字典中去
print(stuInfo) ##输出字典
print({name: score for name,score in stuInfo.items() if score >90}) 输出字典中分数大于90的人
##结果
{'westos0': 80, 'westos1': 84, 'westos2': 80, 'westos3': 71, 'westos4': 73, 'westos5': 65, 'westos6': 75, 'westos7': 94, 'westos8': 90, 'westos9': 65, 'westos10': 61, 'westos11': 77, 'westos12': 99, 'westos13': 61, 'westos14': 98, 'westos15': 93, 'westos16': 76, 'westos17': 100, 'westos18': 77, 'westos19': 84}
{'westos7': 94, 'westos12': 99, 'westos14': 98, 'westos15': 93, 'westos17': 100} ##这是大于90分的
#字典生成器
#需求：将所有的key值变为大写
d = dict(a=1,b=2) ##工厂函数给值
print(d)
print({k.upper(): v for k,v in d.items()}) ##将字典中的k都变为大写，在器和中k.v是在d中遍历出来的
#需求：大小写key的值和并，统一以小写输出
d = dict(a=2,b=1,c=2,B=9,A=10) ##用工厂函数
print({k.lower(): d.get(k.lower(),0) + d.get(k.upper(),0)#k变为小写，value中小写的如果没有返回0+大写的没有返回0.k是在字典d中
for k in d})
##结果
{'a': 1, 'b': 2}
{'A': 1, 'B': 2}
{'a': 12, 'b': 10, 'c': 2}
li = [[1,2,3],[4,5,6],[7,8,9]] ##在列表中嵌套列表
result = [] ##一个空的列表
print([j for i in li for j in i]) ##两个循环，外层的for来取出里边的列表，里边的for j in i取出列表中的数字，最终放到列表中
from itertools import chain ##另一种方法，是采用内置函数
print(list(chain(*li))) ##将列表变成链式，然后在转换为列表，在输出结果
##结果
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
########################高阶函数
print(abs(-11)) ##abs变正数函数
f = abs #函数本身也可以赋值给变量，变量可以指向函数
print(f(-10))
def fun(x,y,f): ##定义函数
return f(x),f(y)
print(fun(-10,24,abs)) #传递的参数包括函数名
##结果
11
10
(10, 24)
######map高阶函数
import random ##可用随机数
print(list(map(abs,[-1,2,-3,4]))) ##map分别用abs求列表中输入
#对于序列的每个元素求阶乘（10个2-9之间的随机数）
def f(x): ##这个函数作用是一个数的阶乘
res = 1
for i in range(1,x+1):
res *= i
return res ##返回值
li = [random.randint(2,9) for i in range(10)] ##生成10个2-9的数
print(li)
print(list(map(f,li))) ##用map，将列表中的给与输入到f函数中
#转化为整型并以列表形式输出
s = '1 3 5 7 9' ##字符串
print(list(map(int,s.split()))) ##可以字符串分离，用map，变成整型，然后再转换成列表输出
##结果
[1, 2, 3, 4]
[3, 2, 3, 2, 7, 7, 3, 7, 8, 8]
[6, 2, 6, 2, 5040, 5040, 6, 5040, 40320, 40320]
[1, 3, 5, 7, 9]
reduce:接收两个参数，把一个函数作用在一个序列上，reduce会把
结果继续和序列的下一个元素做累积计算
reduce(f,[a,b,c,d,e]) = f(f(f(a,b),c),d)
from functools import reduce
def multi(x,y):
return x*y
print(reduce(multi,range(1,5)))
filter过滤函数:接收一个函数和一个序列
filter函数把传入的函数依次作用于每个元素，然后根据返回值
是True汉时False来决定保留或者丢弃该元素
def isodd(num):
if num % 2 == 0:
return True
else:
return False
print(list(filter(isodd,range(20))))
##结果
24
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#####高阶函数sorted排序，默认从小到大
li = [2,1,3,4] ##给个列表
li.sort(reverse=True) ##反向排序
print(li)
a = sorted(li) #整向排序
print(a)
info = [('x1',200,32),('x2',40,12),('x3',40,2),('x4',1000,23),('x5',40,5),] ##列表中是元典
print(sorted(info)) ##整向排序
#按照商品数量
def sorted_by_count(x): ##定义函数
return x[1] ##由索引的中的1号位排序
#按照商品价格
def sorted_by_price(x): 由索引的2号位排序
return x[2]
#先按数量由小到大，如果数量一样
#再按价格由小到大
def sorted_by_count_price(x):
return x[1],x[2]
print(sorted(info,key=sorted_by_count)) ##输出的表达式
print(sorted(info,key=sorted_by_price))
print(sorted(info,key=sorted_by_count_price))
##结果
[4, 3, 2, 1]
[1, 2, 3, 4]
[('x1', 200, 32), ('x2', 40, 12), ('x3', 40, 2), ('x4', 1000, 23), ('x5', 40, 5)]
[('x2', 40, 12), ('x3', 40, 2), ('x5', 40, 5), ('x1', 200, 32), ('x4', 1000, 23)]
[('x3', 40, 2), ('x5', 40, 5), ('x2', 40, 12), ('x4', 1000, 23), ('x1', 200, 32)]
[('x3', 40, 2), ('x5', 40, 5), ('x2', 40, 12), ('x1', 200, 32), ('x4', 1000, 23)]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
