python中的函数（形参，返回值，生成式，高阶函数，匿名函数）

1.函数

1.1 函数的定义和调用

定义函数的关键字：def

def       函数名称(参数)

注意：函数只有通过函数名调用的时候才会运行函数中的内容，否则运行为空

示例：定义求和函数

def add():##定义求和函数
    num1 = 20
    num2 = 30
    result = num1 + num2
    print('%d + %d = %d' %(num1,num2,result))

add()##调用求和函数

---

1.2 嵌套函数的定义和调用

def hello():
    print('hello')
    def python():
        print('python')
    python()##嵌套函数的定义和调用需要写在调用函数内部

hello()

---

2.函数+变量

def       函数名称(形参)

注意：形参的内容取决于实参的内容

def year(a):##定义函数（a为形参）
    print('hello',a)
    
year('2019')##调用函数（2019为实参）
year('2020')##形参的内容取决于实参的内容

---

3.四种形参

参数分为形参和实参。
形参分为：位置参数 、默认参数 、可变参数 、关键字参数

3.1 位置参数

要求：实参和位置参数的参数个数保持一致，且顺序保持一致

def Info(name,age):
    print(name,age)
    
Info('sam',11)###位置参数和实参顺序需要一致
Info(11,'sam')
Info(age=11,name='sam')##标记key值位置可以不一样

---

3.2 默认参数

形参和实参个数可以不一样

def mypow(x,y=2):##y=2为默认参数
    print(x**y)
    
mypow(4)
mypow(2,3)

---

3.3 可变参数

def mysum(*a):##* 表示可以接受多个参数
    sum = 0
    for item in a:
        sum += item
    print(sum)
    
mysum(1,2,3,4,5)

3.4 关键字参数

注意:kwargs为关键字参数，是一个字典,可以传任意多个键值对

def getInfo(name,age,**kwargs):##**kwargs关键字参数，是一个字典
    print(name,age)
    print(kwargs)
    
getInfo('linda',18,gender='female',hobbies=['coding','running'])

---

4.函数的返回值

注意：返回值的关键字为：return，如果有返回返回值，没有返回none

def mypow(x,y=2):
    return x ** y, x + y

a,b = mypow(3)
print(a,b)

---

5.函数的变量作用域

局部变量: 在函数内部定义的变量，只在函数内部起作用，函数执行结束，变量会自动删除
全局变量: 会始终生效

a = 1##全局变量
print('outside:',id(a)) ####id（a）变量在内存中存储的位置

def fun():
    a = 5##局部变量
    print('inside:',id(a))
fun()

print(a)
print(id(a))

a = 1
print('outside:',id(a))

def fun():
    global a##声明为全局变量
    a = 5
    print('inside:',id(a))
fun()

print(a)
print(id(a))

---

6.函数的生成式

6.1 列表生成式

[expression      for i in seq    if...]

示例：

转换成生成式：

s = '3 25 99'
k,a,b = [int(item) for item in s.split()]
print(k,a,b)

---

练习：求平方和

普通方法

列表生成式方法

print([item ** 2 for item in range(1,11)])

---

练习：求偶数的平方和

普通方法

列表生成式方法

print([item ** 2 for item in range(2,11,2)])

也可以继续加条件：

print([item ** 2 for item in range(1,11) if item %2 == 0])

---

练习：求所有质数

普通方法
列表生成式方法

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,101) if isPrime(i)])

---

6.2 字典生成式

1.示例

假设有20个学生，学生名为westosX,学生分数在60~100之间,筛选出成绩在90分以上得学生
方案一：

import random
stuInfo = {}
for i in range(20):
    name = 'student'+str(i)
    score = random.randint(60,100)
    stuInfo[name] = score
print(stuInfo)

highscore = {}
for name,score in stuInfo.items():
    if score > 90:
        highscore[name] = score
print(highscore)

---

方案二：（字典生成式）

import random
stuInfo = {}
for i in range(20):
    name = 'student'+str(i)
    score = random.randint(60,100)
    stuInfo[name] = score
    
print({name:score for name,score in stuInfo.items() if score >90})

---

2.所有的key值变大写

d = dict(a=1,b=2)

方案一：

d = dict(a=1,b=2)
print(d)

new_d = {}
for i in d:
    new_d[i.upper()] = d[i]
print(new_d)

---

方案二：（字典生成式）

d = dict(a=1,b=2)
print(d)

print({k.upper():v for k,v in d.items()})

---

3.大小写key值合并，统一以小写输出

d = dict(a=2, b=1, c=2, B=9, A=10)
输出{'a': 12, 'b': 10, 'c': 2}

方案一：

d = dict(a=2, b=1, c=2, B=9, A=10)

new_d = {}

for k,v in d.items():
     low_k = k.lower()
     if low_k not in new_d:
         new_d[low_k] = v
     else:
         new_d[low_k] += v
         
print(new_d)

---

方案二：（字典生成式）

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) for k in d})

---

7.高阶函数

7.1 定义

1.函数本身可以作为变量，给变量赋值

def fun(a,b):
    return a+b
    
a = fun(1,2)
print(a)

---

2.变量也可以指向函数

f = abs
print(f(-10))

---

3.函数也可作参数

def fun(x,y,f):
    return f(x),f(y)
    
print(fun(-10,34,abs))

---

8.内置高阶函数

8.1 map()函数

1.map函数的参数

map()函数接收两个参数，一个是函数，一个是序列
map将传入的函数依次作用到序列的每个元素，并且把结果作为新的序列返回

---

2.map函数求阶乘

生成10个[2，7]之间的随机数求阶乘

import random

def f(x):
    res = 1
    for i in range(1,x+1):
        res *= i
    return res
    
li = [random.randint(2,7) for i in range(10)]
print(li)

print(list(map(f,li)))

---

8.2 reduce累计函数

reduce:把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
如：
reduce( f , [x1,x2,x3,x4,x5] ) = f( f( f(x1,x2) , x3) ,x4)

注意：
python2:reduce是内置函数
python3:from functools import reduce

1.累乘

from functools import reduce
def multi(x,y):
    return x * y
    
print (reduce(multi,range(1,4)))

---

2.累加

from functools import reduce
def add(x,y):
    return x + y
    
print (reduce(add,[1,2,3,4,5]))

---

8.3 filter过滤函数

filter过滤函数和map()类似，也接收一个函数和一个序列
但是和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

练习：判断是否为偶数

def isodd(num):
    if num % 2 == 0:
        return True
    else:
        return False
        
print(list(filter(isodd,range(100))))

---

8.4 sorted排序函数

1. .sort()方法

li = [2,1,3,4]
li.sort()
print(li)

---

2. sorted函数

li = [48,9,6,7]
print(sorted(li,reverse=True))

---

3.指定排序方式

info = [
    # 商品名称 商品数量 商品价格
    ('apple1',200,32),
    ('apple2',40,12),
    ('apple3',40,2),
    ('apple4',1000,23),
    ('apple5',40,5)
]

 print(sorted(info))
 
 def sorted_by_count(x):
     return x[1]
 print(sorted(info,key=sorted_by_count))
 
 def sorted_by_price(x):
     return x[2]
print(sorted(info,key=sorted_by_price))

 def sorted_by_count_price(x):
     return x[1],x[2]
 print(sorted(info,key=sorted_by_count_price))
 

---

4.排序练习（移动0）

给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
在原始数组上进行移动操作， 勿创建新的数组;

输入:第一行是数组长度， 后续每一行是数组的一条记录
    4
    0
    7
    0
    2
输出:调整后数组的内容
    4
    7
    2
    0
    0

n = ''.join(input().split())
li = (int(i) for i in n)

def move_zero(item):
    if item == 0:
        return 2
    else:
        return 1
        
print(sorted(li,key=move_zero))

9.匿名函数

匿名函数的关键字为lambda,冒号前是形参，冒号后是返回值

print(lambda *args, **kwargs: (args, kwargs))

9.1 reduce+lambda

from functools import reduce

def add(x,y):
    return x+y
    
print(reduce((lambda x,y:x+y),[1,2,3,4,5]))

---

9.2 map+lambda

def mypow(x):
    return x ** 2
    
print(list(map(lambda x:x**2,range(6))))

---

9.3 fileter+lambda

print(list(filter(lambda x:x % 2 ==0,range(100))))

---

9.4 lambda移动数组中的0

nums = [0, 7, 0, 1, 2, 1, 5,1, 7, 8, 0, 67, 1, 3, 4]

nums = [0, 7, 0, 1, 2, 1, 5,1, 7, 8, 0, 67, 1, 3, 4]
print(sorted(nums,key=lambda x:1 if x==0 else 0))

---

10.函数的练习

练习：编写函数, 可以接收任意多个数并返回元组.

编写一个函数caculate, 可以接收任意多个数,返回的是一个元组.
元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.

def caculate(*args):##可变参数可以接收任意多个数
    avg = sum(args) / len(args)
    up_avg = []##定义空列表
    for item in args:
        if item > avg:
            up_avg.append(item)
    return avg,up_avg 返回
    
a = caculate(1,2,3,4,5,6,7)
print(a)

---

练习：编写一个函数, 接收字符串参数, 返回一个元组(大小写字母个数)

编写一个函数, 接收字符串参数, 返回一个元组,'ehllo WROLD
元组的第一个值为大写字母的个数, 第二个值为小写字母个数.

def fun(x):
    upper_count = 0
    lower_count = 0
    for i in x:
        if i.isupper():
            upper_count += 1
        elif i.islower():
            lower_count += 1
        else:
            continue
    return upper_count,lower_count
a = fun('ehllo WROLD')
print(a)

---

练习： 编写函数,返回列表，使下标前后逆序

编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形
数k, 返回一个新列表.
函数需求:
- 将列表下标k之前对应(bu包含k)的元素逆序;
- 将下标k及之后的元素逆序;
[1,2,3,4,5] 2 [2,1,5,4,3]

def fun(li,k):
    if k < 0 or k > len(li):
        return 'error k'
    return li[:k][::-1] + li[k:][::-1]
    
print(fun([1,2,3,4,5],2))

---

练习：模拟轮盘抽奖游戏

轮盘分为三部分: 一等奖, 二等奖和三等奖;轮盘转的时候是随机的,
如果范围在[0,0.08)之间,代表一等奖,
如果范围在[0.08,0.3)之间,代表2等奖,
如果范围在[0.3, 1.0)之间,代表3等奖,
模拟本次活动1000人参加, 模拟游戏时需要准备各等级奖品的个数.

import random

reword_dict = {
    '一等奖':(0,0.08),
    '二等奖':(0.08,0.3),
    '三等奖':(0.3,1)
}

def userfun():
    num = random.random()
    for k,v in reword_dict.items():
        if v[0] <= num < v[1]:
            return k
            
resultDict = {}
for i in range(1000):
    res = userfun()
    if res not in resultDict:
        resultDict[res] = 1
    else:
        resultDict[res] += 1
        
for k,v in resultDict.items():
    print(k,'--->',v)

---

练习：计算有多少个正整数n满足a<=n<=b,且k*f(n)=n

题目需求:
对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如:

 f(13) = 1**2 + 3**2 = 10
 f(207) = 2**2 + 0**2 + 7**2 = 53

下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,且k*f(n)=n
输入: 第一行包含3个正整数k，a, b, k>=1, a,b<=10**18, a<=b;
输出：输出对应的答案;

  示例:
    输入: 51 5000 10000
    输出: 3

def f(n):
    n = str(n)
    sum = 0
    for item in n:
        sum += int(item) ** 2
    return sum
    
s = input()
li = []
for item in s.split():
    li.append(int(item))
k,a,b = li

count = 0
for i in range(a,b+1):
    if k * f(i) == i:
        print(i)
        count += 1
print(count)

---

练习：编写程序计算有多少对质数的和等于输入的正整数

• 题目描述:
  给定一个正整数，编写程序计算有多少对质数的和等于输入的这个正整数，并输出结果，输入值小于1000。如：输入为10, 程序应该输出结果为2。（共有两对质数的和为10,分别为(5,5),(3,7)， [2,3,5,7]）
• 输入描述:输入包括一个整数n,(3 ≤ n < 1000)
• 输出描述:输出对数

num = int(input())
def isPrime(num):
    for i in range(2,num):
        if num % i == 0:
            return False
    else:
        return True
primeli = [i for i in range(2,num) if isPrime(i)]

primecount = 0
for item in primeli:
    if (num - item) in primeli and item <= num -item:
        primecount += 1
print(primecount)

---

---