一、函数基本语法及特性
面向对象:(华山派)—类 —class
面向过程:(少林派)—过程 —df
函数式编程:逍遥派 —函数— df
一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这个函数的定义域编程
编程语言中函数定义:函数是逻辑结构化和过程化的一种编程方法:
python中函数定义方法:
def
test(x):
"The function definitions"
x
+
=
1
return x
test(x) #调用函数
def
:定义函数的关键字
test:函数名
():内可定义形参
"":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
x
+
=
1
:泛指代码块或程序处理逻辑
return
:定义返回值
函数的特性:保持程序一致性、程序可扩展、代码重用
*eval(b) 字符串转字典格式
举例:
func.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- #函数 def func1():
"""testing""" print('in the func1')
return 0 print('test end')
x = func1() print(x)
#过程,过程不需要返回值 def func2():
"""tesing2""" print('in the func2')
x = func1()
y = func2()
print('from func1 return is %s' %x) print('from func2 return is %s' %y)
import time def logger():
time_format='%Y-%m-%d %X' time_current=time.strftime(time_format)
with open('a.txt', 'a+') as f: #ab 以追加的方式打开二进制方式 f.write('time %s end action\n' %time_current)
def test1():
print ("test1 starting action...")
logger()
def test2():
print ("test2 starting action...")
logger()
def test3():
print ("test3 starting action...")
logger()
test1()
test2()
test3()
def t1():
print("IN T1") def t2():
print("IN T2")
return 0 def t3():
print("IN T3")
return 1,"Hello",['alex','lb'],{'WuDaLang':'lb'} #打印函数 x = t1()
y = t2()
z = t3() #打印函数返回值,#返回值数=0:返回None,返回值数=1:返回object,返回值数>1:返回元组tuple print(x) print(y)
"""testing""" print('in the func1')
return 0 print('test end')
x = func1() print(x)
#过程,过程不需要返回值 def func2():
"""tesing2""" print('in the func2')
x = func1()
y = func2()
print('from func1 return is %s' %x) print('from func2 return is %s' %y)
import time def logger():
time_format='%Y-%m-%d %X' time_current=time.strftime(time_format)
with open('a.txt', 'a+') as f: #ab 以追加的方式打开二进制方式 f.write('time %s end action\n' %time_current)
def test1():
print ("test1 starting action...")
logger()
def test2():
print ("test2 starting action...")
logger()
def test3():
print ("test3 starting action...")
logger()
test1()
test2()
test3()
def t1():
print("IN T1") def t2():
print("IN T2")
return 0 def t3():
print("IN T3")
return 1,"Hello",['alex','lb'],{'WuDaLang':'lb'} #打印函数 x = t1()
y = t2()
z = t3() #打印函数返回值,#返回值数=0:返回None,返回值数=1:返回object,返回值数>1:返回元组tuple print(x) print(y)
print(z)
二、参数与局部变量
定义:
形参- 函数定义中的为形参,譬如def test(x , y)
实参- 函数调用中的为实参, 譬如x = test(a,b)
默认参数- 函数定义中的关键参数,譬如def stu_register(name,age,country=“CN”) #注意,函数定义中关键参数一定要放在位置参数后边。
关键参数- 区别于位置参数,关键字参数可以让我们在调用函数的时候打乱参数传递的顺序
非固定参数-*arg 非关键字参数列表,**keywords 关键字参数列表
全局与局部变量(详见func2.py)
举例:
calc.py
#!/usr/bin/env python #Author is wspikh
# -*- coding: encoding -*-
def calc(x,y): # x y 形参
res = x**y
return (res)
return (res)
z = calc(2,3) # 2 3 实参
print(z)
defaultvalue.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*-
def stu_register(name,age,course,id=130,country="CN"): #country/id 默认参数 ,关键参数要放到位置参数后边,关键参数可以不按顺序。
print("----注册学生信息-----")
print("姓名:",name)
print("age:",age)
print("国籍",country)
print("课程",course)
print("地区",id)
print("姓名:",name)
print("age:",age)
print("国籍",country)
print("课程",course)
print("地区",id)
stu_register(“王二丫",22,"Python_devops")
stu_register(“张文宁",21,"Linux")
stu_register(“刘可素",24,"Linux")
非固定参数.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- def stu_register(name,age,*args): #*args会把多传入的参数变成一个元组形式 print(name,age,args)
stu_register("Alex",22,"CN","Python")
def stu_register2(name,age,*args,**kwargs): #**kwargs会把多传入的参数变成一个dict形式 print(name,age,args,kwargs)
stu_register2("Alex",22,"CN","Python",sex="male",province="HeBei")
stu_register("Alex",22,"CN","Python")
def stu_register2(name,age,*args,**kwargs): #**kwargs会把多传入的参数变成一个dict形式 print(name,age,args,kwargs)
stu_register2("Alex",22,"CN","Python",sex="male",province="HeBei")
func2.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- def test(x,y,z): #x y代表形参,1 2 代表实参,位置参数。形参和实参一一对应。 print(x)
print(y)
print(z) #位置参数调用,与形参一一对应 test(1,2,3) #关键字调用,与形参顺序无关,打印会按照位置形参顺序 test(y=4,x=8,z=10) #位置参数调用与关键字调用混用,要保持一一对应,关键字参数不能放在位置参数之前,打印会按照位置形参顺序 test(3,z=4,y=11)
#默认参数特点:调用函数的时候,非必传 def test(x,y=2):
print(x)
print(y)
test(1)
#参数组 def test(*args): #*代表args代表的参数个数不固定且*args只接受位置参数 print(args)
test(1,2,3,4,5)
test(*[1,2,3,4,5]) # args=tuple([1,2,3,4,5]) def test1(x,*args):
print(x)
print(args)
test1(0,1,2,3,4,5,6,7,8,9)
def test2(**kwargs): #**kwargs把N个关键字转换成字典方式 print(kwargs)
test2(name='alex',age=8,sex='F')
test2(**{'name':'alex','age':8})
def test3(name,**kwargs):
print(name)
print(kwargs)
print(y)
print(z) #位置参数调用,与形参一一对应 test(1,2,3) #关键字调用,与形参顺序无关,打印会按照位置形参顺序 test(y=4,x=8,z=10) #位置参数调用与关键字调用混用,要保持一一对应,关键字参数不能放在位置参数之前,打印会按照位置形参顺序 test(3,z=4,y=11)
#默认参数特点:调用函数的时候,非必传 def test(x,y=2):
print(x)
print(y)
test(1)
#参数组 def test(*args): #*代表args代表的参数个数不固定且*args只接受位置参数 print(args)
test(1,2,3,4,5)
test(*[1,2,3,4,5]) # args=tuple([1,2,3,4,5]) def test1(x,*args):
print(x)
print(args)
test1(0,1,2,3,4,5,6,7,8,9)
def test2(**kwargs): #**kwargs把N个关键字转换成字典方式 print(kwargs)
test2(name='alex',age=8,sex='F')
test2(**{'name':'alex','age':8})
def test3(name,**kwargs):
print(name)
print(kwargs)
test3('alex',age=18,sex='F')
def test4(name,age=18,*args,**kwargs): #*args只接受位置参数,参数组要放到最后 print(name)
print(age)
print(args)
print(kwargs)
test4('alex',18,sex='F',hobby='TSL') #结果中对于args,返回只能是空元组{} test4('alex',18,33,sex='F',hobby='TSL') #对于args,返回值为{33,} school = "oldboy" #定义全局变量 def change_name(name):
global school #在函数中定义全局变量,一定要掌握。 school = "OLDBOY" print("Before change:",name,school)
name = "Alex li" #这个函数就是这个变量的作用域 print("After change:",name,school)
name = "alex" change_name(name) print("last change is",name,school)
#列表、字典、集合能在函数中修改 names = ["Alex","Jack","Rain"] #names_tuple = (1,2,3,4) #元组不能改 def change_name():
names[0] = "jinjiaodawang" #names_tuple[0] = 3 print("inside func",names)
change_name() print(names)
print(age)
print(args)
print(kwargs)
test4('alex',18,sex='F',hobby='TSL') #结果中对于args,返回只能是空元组{} test4('alex',18,33,sex='F',hobby='TSL') #对于args,返回值为{33,} school = "oldboy" #定义全局变量 def change_name(name):
global school #在函数中定义全局变量,一定要掌握。 school = "OLDBOY" print("Before change:",name,school)
name = "Alex li" #这个函数就是这个变量的作用域 print("After change:",name,school)
name = "alex" change_name(name) print("last change is",name,school)
#列表、字典、集合能在函数中修改 names = ["Alex","Jack","Rain"] #names_tuple = (1,2,3,4) #元组不能改 def change_name():
names[0] = "jinjiaodawang" #names_tuple[0] = 3 print("inside func",names)
change_name() print(names)
func3.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- def funcD(a,b,*c):
print(a)
print(b)
print ("length of c is: %d" % len(c))
print (c)
funcD(1,2,3,4,5,6,7)
def funcE(a,b,c):
print("\n---你猜会有什么结果:---")
print(a)
print(b)
print(c)
print("---oh,原来是这样:---\n")
funcE(c=100,b=300,a=800)
print(a)
print(b)
print ("length of c is: %d" % len(c))
print (c)
funcD(1,2,3,4,5,6,7)
def funcE(a,b,c):
print("\n---你猜会有什么结果:---")
print(a)
print(b)
print(c)
print("---oh,原来是这样:---\n")
funcE(c=100,b=300,a=800)
def funcF(a,**b): #b是一个dict对象实例,它接受了关键字参数b和c。
print(a)
for x in b:
print(x + ":" +str(b[x]))
funcF(100,c="您好",d="这是一个精彩的世界!",b=200)
for x in b:
print(x + ":" +str(b[x]))
funcF(100,c="您好",d="这是一个精彩的世界!",b=200)
三、返回值
定义:函数中一定要有return返回值才是完整的函数。如果你没有
python 定义函数返回值,那么会得到一个结果是None对象,而None表示没有任何值。
注意:1 函数中只要存在return语句就意味着函数执行的结束
2 函数中没有指定return,函数返回值为NONE(默认)
return1.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- def maximum(x, y):
if x > y:
return x
elif x == y:
if x > y:
return x
elif x == y:
return '两个数相等'
else:
return y
print(maximum(2, 3)) #返回结果为3,因为逻辑上上都指定了return
return2.py
def maximum(x, y):
if x > y:
return x
elif x == y:
if x > y:
return x
elif x == y:
return '两个数相等'
#else:
#return y
print(maximum(2, 3)) #结果为NONE,因为没有指定return值
四、递归
定义:如果一个函数在内部调用自身本身,这个函数就是递归函数。
举例:
calc.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- #递归函数即函数内部调用自身本身 #有明确的结束条件 #每次进入更深一层递归时,问题规模相比上次递归都应有所减少 #递归效率不高,层次过多会导致栈溢出。 #一个死循环的例子 '''def calc(n): print(n) return cacl(n2) calc(10)''' def calc(n):
print(n)
if int(n/2) > 0:
return calc(int(n/2))
print("-->",n)
calc(10)
print(n)
if int(n/2) > 0:
return calc(int(n/2))
print("-->",n)
calc(10)
dgui.py
#!/usr/bin/env python #Author is wspikh # -*- coding: encoding -*- def digui(n):
sum = 0
if n <= 0:
return 1
else:
sum = 0
if n <= 0:
return 1
else:
return n * digui(n - 1)
print(digui(5))
五、匿名函数
定义:Python语言支持使用lambda 表达式作为匿名函数。
特性:使用
lambda
声明该行代码是一个lambda表达式,紧跟在后面的是函数的参数,多个参数用逗号
,
分割;然后使用冒号
:
分割开参数和函数体。
举例:
lambda.py
#!/usr/bin/env python
def use_lambda():
return lambda x: x * x
print(use_lambda()(5)) # 打印结果是25
#一种列表传值 def get_square(l): L=[] for i in l: L.append(i*i) print(L)
get_square([1,2,3,4])
#map函数 iter = map(lambda x: x*x ,range(50)) for i in iter: print('i : %d' %i)
r = map(lambda x,y : x*y,[1,2,3,4,5],[6,7,8,9,10]) for i in r: print('i : %d' % i)
六、函数式编程
定义:
函数式编程是一种编程模型,他将计算机运算看做是数学中函数的计算,并且避免了状态以及变量的概念。
我们知道,对象是面向对象的第一型,那么函数式编程也是一样,函数是函数式编程的第一型。在面向对象编程中,我们把对象传来传去,那在函数式编程中,我们要做的是把函数传来传去,而这个,说成术语,我们把他叫做高阶函数。Python对函数式编程提供部分支持。由于Python允许使用变量,因此,Python不是纯函数式编程语言。
七、高阶函数
定义:把函数A作为另一个函数B的参数传入,那么函数B称为高阶函数 Higher-order function
闭包:如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure)。
def closure():
x = 5
def sub():
return x * x
return sub
特性:变量可以指向函数,函数的参数能接收变量
ho.py
#!/usr/bin/env python #Author is wspikh
# -*- coding: encoding -*-
def add(x, y, f):
print(f(x) + f(y))
add(-5, 6, abs)
def f(x):
return x * x
def h(func,x):
return func(x) * func(x)
print(h(f,2 ))
def m(x):
def n():
return x ** x
return n
sub_func = m(2) print(sub_func())
#python中,对象和方法都是变量 def say_hello(name):
print('Hello,%s' % name)
say_hello("lovexiaowi" ) #等同于以下写法,给函数赋值给sh 变量
#sh = say_hello
return x * x
def h(func,x):
return func(x) * func(x)
print(h(f,2 ))
def m(x):
def n():
return x ** x
return n
sub_func = m(2) print(sub_func())
#python中,对象和方法都是变量 def say_hello(name):
print('Hello,%s' % name)
say_hello("lovexiaowi" ) #等同于以下写法,给函数赋值给sh 变量
#sh = say_hello
#sh("lovexiaowi)
八、 内置参数
内置参数.py
#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
print(all([0,1,-5]))
print(any([0,1,-5]))
#十进制转二进制
print(bin(10))
#过滤以及匿名参数
#Author is wspikh
# -*- coding: encoding -*-
print(all([0,1,-5]))
print(any([0,1,-5]))
#十进制转二进制
print(bin(10))
#过滤以及匿名参数
res = fil
ter(lambda n:n>=5, range(10))
for i in res:
print(i)
print("")
print("")
#map
res = map(lambda n:n*n,range(10)) # 等同于[i*2 for i in range(10)]
for i in res:
print(i)
print("")
print("")
#reduce
import functools
res = functools.reduce(lambda x,y:x+y,range(10))
print(res)
print("")
print("")
#globals
print(globals())
print("")
#十进制转十六进制
print(hex(255))
print("")
#十进制转八进制
print(oct(16))
print("")
#zip
a = [1,2,3,4,5]
b = ['a','b','c','d','e']
for i in zip(a,b):
print(i)
print(i)
print("")
print("")
#map
res = map(lambda n:n*n,range(10)) # 等同于[i*2 for i in range(10)]
for i in res:
print(i)
print("")
print("")
#reduce
import functools
res = functools.reduce(lambda x,y:x+y,range(10))
print(res)
print("")
print("")
#globals
print(globals())
print("")
#十进制转十六进制
print(hex(255))
print("")
#十进制转八进制
print(oct(16))
print("")
#zip
a = [1,2,3,4,5]
b = ['a','b','c','d','e']
for i in zip(a,b):
print(i)