defpython_函数在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 ))

运行结果：