Python中函数的使用

函数就是通过关键字，将某些代码实现的功能进行封装。
在使用到该功能时，就不必编写该功能代码，直接利用关键字函数名来使用函数。
优点：方便阅读，简化工作，使代码更加简练。

函数的基本使用方法

函数的定义

定义函数的关键字：def
关键字后接函数名（）：，括号用来传参数。
然年换行写函数功能

def hello():
    print('hello westos1')
    print('hello westos2')
    print('hello westos3')

此时只有函数定义是不能使用该函数的，若想使用该函数，必须调用该函数。

函数的调用

def hello():
    print('hello westos1')
    print('hello westos2')
    print('hello westos3')
    
hello()      ##通过函数名调用该函数实现函数的功能

调用结果：

演示:
定义求和函数并调用

def add():
    a = 22
    b = 33
    result = a + b
    print('the result is %d'%result)
    
add()     ##进行调用

调用结果：

函数的嵌套

函数里是可以嵌套函数的

错误示例：

def linux():
    print('hello linux')
    def python():
        print('hello python')
        
linux()   ## 对linux进行调用

运行结果：

可以看到，此处对linux函数进行了调用，倒是linux内的嵌套函数python并没有被调用。且单独调用python函数也是不能行得通：

报错python未被定义，可见，python函数只能在函数linux内使用。

正确示例：
既然签到函数不能在外部单独调用，所以，在linux函数内部对python函数进行调用：

def linux():
    print('hello linux')
    def python():
        print('hello python')
    python() ## 在linux（）函数内调用python（）
    
linux()      ## 调用linux（）

调用结果：

函数中变量的使用

在上面的演示中，可以看到，定义的函数只能使用在单一的场景：
比如只能打印特定的字符，只能求和22 + 33
显然，不合理，函数功能过于单一，无太大使用意义。

所以，使用函数时，将函数里的参数定义为变量，让用户去指定。这样一来，函数的实用性和功能性就打打提高。

演示：

def hello(a):
    print('hello ',a )
    
hello('westos')
hello('linux')
hello('python')

其中，a为形式参数，用来接收用户输入
westos linux python为实际参数
输出结果：

函数中的参数

分为 形式参数 和 实际参数

形式参数：位置参数 默认参数 可变参数 关键字参数

位置参数

演示：

def Info(name,age):
    print(name,age)
    
Info('westos',18)
Info(18,'westos')
Info('westos',18,'haha')

输出结果：

总结：

• 形式参数和实际参数个数应保持一致。
• 参数的位置顺序也应保持一致。
  若在必须反着写的情况下，可以手动指定形参名称：

def Info(name,age):
    print(name,age)
    
Info(age=18,name='westos')

输出结果：

默认参数

演示：定义函数实现x的y次方，默认算x的平方：

def mypow(x,y=2): ##y=2为默认参数，当实参中未指定时，使用默认参数
    print(x**y)
    
mypow(2)
mypow(3)
mypow(2,3)
mypow(2,4)

运行结果：

可以看到，当实参为2时，结果为4。默认算平方
当实参为2，3时，结果为8，计算的是2的3次方
所以：在用户指定实参后，形参里默认参数使用实参的值，若用户未指定默认参数的值，那么就使用默认定义的参数。
在使用默认参数的情况下，形式参数和实际参数的个数可以保持不一致。

可变参数

*可以接收多个变量
演示：求和函数：

def mysum(*a):
    sum = 0
    for i in a:
        sum += i
    print(sum)
    
mysum(1,2,3,4,5)

运行结果：

可以看到：
*a接收了多个变量

关键字参数

**kwargs 实质上时一个字典，能够出传任意多个键值对

def Info(name,age,**kwargs):
    print(name,age)
    print(kwargs)
Info('westos',18,gender = 'male',study=['linux','python','java'])

运行结果：

返回值

函数的返回值就是函数的运算结果，若无返回值，返回none。
当还需要对函数进行操作时，需要给函数一个返回值。
关键字：return

若函数里出现return，则return后边语句不进行输出：

def mypow(x,y=2):
    return x ** y,x + y
    print('hello')
    
a,b = mypow(3)
print(a,b)

运行结果：

可以看到，return后的print语句并没有输出。

变量作用域

局部变量：在函数内部定义的变量，只在函数内部起作用，函数执行结束，变量会自动从内存中删除
全部变量：定义在整个环境中的变量

a = 1      ##全局变量
print('global:',id(a))    ##（id（）可以查看变量在内存中储存的位置）
def Info():
    a = 3   ##函数内部变量（局部变量）
    print(a)
    print('inside',id(a))
Info()       ##打印出内部变量在内存中储存的位置
print(a)     ##打印出a的值
print(id(a))  ## 打印出运行后a在内存中储存的位置

运行结果：

可以看到，在运行完成后a在内存中的存储位置和全局变量a的存储位置相同且值也相同。

也可以在函数中对局部变量中进行声明，使其升级为全局变量：

a = 1
print('global:',id(a))
def Info():
    global a
    a = 3
    print(a)
    print('inside',id(a))
Info()
print(a)
print(id(a))

运行结果：

演示：

def caculate(*args):
    ave = sum(args)/len(args)
    up_ave = []    ##定义空列表用来存放比平均数大的数
    for i in args:
        if i > ave:
            up_ave.append(i)
    return ave,up_ave 
    
a = caculate(2,3,5,7,9)
print(a)

运行结果：

演示2：

def func(a):
    upper_count = 0
    lower_count = 0
    for i in a:
        if i.isupper():
            upper_count += 1
        elif i.islower():
            lower_count += 1
        else:
            continue
    return upper_count,lower_count
b = func('HEllO WestOs')
print(b)

运行结果：

演示3;

def func(li,k):
    if k<0 or k>len(li): ##对k进行判断
        return 'error k'
    return li[:k][::-1] + li[k:][::-1]
    
print(func([2,3,4,5,6,7,8],4))

运行结果：
k值正确：

错误k值：

演示4：

def f(n):     ##实现各数字平方和函数
    n = str(n)
    sum = 0
    for i in n:
       sum += int(i) ** 2
    return sum
# 定义空列表，将存放拆分后的s，对k，a，b进行赋值。    
s = input()
li = []
k = s.split()
for i in k:
    li.append(int(i))
k,a,b= li
#定义加法器，并进行条件判断
count = 0
for t in range(a,b+1):
    if k * f(t) == t:
        count += 1
print(count)

运行结果：

生成式

列表生成式

现将给定字符串分开放入列表：

普通方法：

s = ' 10 20 30 '
li = []
for i in s.split():
    li.append(int(i))
a,b,c = li
print(li)

运行结果：

生成式方法:

s = ' 10 20 30 '
a,b,c = [int(i) for i in s.split()]
print(a,b,c)
	

运行结果：

演示：
将1~10的平方使出到一个列表中：
普通方法：

li = []
for i in range(1,11):
    li.append(i**2)
print(li)

运行结果：

列表生成式方法：

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

运行结果：

1~11间偶数的平方：

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

运行结果：

总结：
生成式的表达方法：

[想要的到的值  for i in seq if...]

演示：
要求：用户输入一个数，求1到这个数之间的质数：

def f(n):   #定义判断质数函数
    for i in range(2,n):
        if n % i == 0:
            return False
    else:
        return True
n = int(input())
print([i for i in range(0,n+1) if f(i)]) 打印出生成式

输出结果：

演示：
(2018-腾讯-在线编程题)

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

输入:
10
输出:
2

def f(n):
    for i in range(2,n):
        if n % i == 0:
            return False
    else:
        return True
n = int(input())
a = [i  for i in range(2,n) if f(i)]
count = 0
for p in a:
    if (n - p) in a and (n-p)<=p:
        count += 1
print(count)

运行结果：

字典生成式

普通方法：

import random
studentInfo={}
for i in range(20):
    name = 'westos'+str(i)
    score = random.randint(60,100)
    studentInfo[name] = score
hight_score={}
for k,v in studentInfo.items():
    if int(v) >= 90:
        hight_score[k] = v
print(hight_score)

运行结果：

字典生成式方法：

import random
studentInfo={}
for i in range(20):
    name = 'westos'+str(i)
    score = random.randint(60,100)
    studentInfo[name] = score
print({k:v for k,v in studentInfo.items() if v>=90  }) ##k:v为最终需要返回的值

运行结果：

演示：

普通方法：

d = dict(a=2,b=1,c=2,B=9,A=10)
new_d = {}
for k,v in d.items():
    lowk=k.lower()
    if lowk not in new_d:
        new_d[lowk] = v
    else:
        new_d[lowk] += v
print(new_d)

输出结果：

字典生成式方法：

d = dict(a=2,b=1,c=2,B=9,A=10)
new_d = {}
print({k.lower():d.get(k.lower(),0)+d.get(k.upper(),0) for k,v in d.items()})

运行结果：

高阶函数

高阶函数的实参为一个函数名，返回值为函数。即返回函数的函数。
函数可以给变量赋值，变量也可以指向函数。

演示：

def func(a,b,f):  ##将函数f当成一个参数传给func（）
    return f(a),f(b)
k= func(-5,10,abs)  
print(k)

输出结果：

内置高阶函数

map（）

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

演示：

a = [-1,3,-2,6，-8]
b = list(map(abs,a)) ##（map(abs,a)）的输出为一的对象，须转化为列表查看值
print(b)

输出结果：

演示：
生成10个2~7之间的数，计算他们的阶乘：

import random
def func(a):    ##定义阶乘函数
   res = 1
   for i in range(1,a+1):
       res *= i
   return  res

li = [random.randint(2,7) for i in range(10) ] ##列表生成式
print(li)
a = list(map(func,li))
print(a)

运行结果：

reduce（）

把一个函数作用在序列上，这个函数必须接收两个参数。
reduce（）把结果继续和序列的下一个元素做累积运算。
如：reduce（f，[x1,x2,x3,x4]）=f(f(f(1,2),3),4)
reduce（）在python2中是内置函数，直接可以使用。
在python3中，需要导入：

from functools import reduce

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

运行结果：

filter（）

演示，打印100内的偶数：

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

演示：
打印出2~100内所有质数：

def zhishu(num):
    for i in range(2,num):
        if num%i ==0:
            return False
    else:
        return True
print(list(filter(zhishu,range(2,101))))

运行结果：

sorted（）

可以对序列进行排序
排序普通方法：所使用排序方法进行排序

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

也可以添加参数进行逆序排序：

li= [5,4,6,3,7,1,2]
li.sort(reverse=True)
print(li)

输出结果：

使用sorted（）函数进行排序：

li= [5,4,6,3,7,1,2]
print(sorted(li))

使用sorted（）函数进行逆序排序：

li= [5,4,6,3,7,1,2]
print(sorted(li,reverse=True))

输出结果：

演示：

Info =[
    ##  商品 加格 数量
    ('apple1,200,32'),
    ('apple2,150,48'),
    ('apple3,80,75'),
    ('apple4,150,90')
]
print(sorted(Info))

运行结果：

可以看到，默认排序元组内的第一个元素进行排序。
可以使用以下方法进行指定排序：

Info =[
    ##  商品 价格 数量
    ('apple1',200,32),
    ('apple2',150,48),
    ('apple3',80,75),
    ('apple4',150,90)
]
def sorted_by_price(x):##定义函数，将第二个元素取出来
    return x[1]    
def sorted_by_count(x):
    return x[2]   ##将第三个元素取出来
print(sorted(Info,key=sorted_by_price))##通过关键字指定排序方式
print(sorted(Info,key=sorted_by_count))

输出结果：

也可以先按照加格进行排序，若加格相同，再按照数量进行排序：

Info =[
    ##  商品 加格 数量
    ('apple1',200,32),
    ('apple2',150,48),
    ('apple3',80,75),
    ('apple4',150,90)
]
def sorted_by_price(x):
    return x[1]
def sorted_by_count(x):
    return x[2]
def sorted_price_count(x):
    return (x[1],x[2])
print(sorted(Info,key=sorted_price_count))

输出结果：

演示：

s = ''.join(input().split())
li = [int(i) for i in s]
def sort(i):
    if i == 0:
        return 2
    else:
        return 1
print(sorted(li,key=sort))

定义的函数实质上将列表进行了转化：
[1,0,0,8,6]----->[1,2,2,1,1]

匿名函数

演示：使用匿名函数对列表中的数字进行求和：

from functools import reduce
a = [1,2,3,4,5]
print(reduce(lambda x,y:x+y,a ))

运行结果：

演示：
使用匿名函数进行求列表中数的平方：

print(list(map(lambda x:x**2,[1,2,3,4,5])))

运行结果：

演示：
打印100内所有的偶数：

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

演示：
使用匿名函数移动列表中的0

a = [1,0,0,8,6]
print(sorted(a,key=lambda x:2 if x==0 else 1 ))

运行结果：