一、函数式编程
创建函数
一个函数式由关键字 def ，与函数名与括号冒号，和括号中的参数组成，当想要执行函数的时候只需要写上函数名加括号即可
格式： def function (parameter) 下面就创建一个函数
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#创建函数
def print_str():
print(“hello world”)
#调用函数
print_str()
第一个函数
变量的作用域
我们看一个例子，在下面代码中我们先把变量 a=“haha” 然后在函数中把 a=“heihei” 最后执行这个函数，并输出变量a的结果
我们发现为什么a不等于 “heihei”,而是我们之前赋值的 “haha” 这个现象我们马上揭秘
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = “haha”
#创建函数
def print_str():
a = “heihei”
print(“hello world”)
#调用函数
print_str()
print(“我是变量a:”,a)
变量的作用域例一
全局变量与局部变量
很明显变量的作用域就是变量在哪一个范围内生效，如果出了这个范围则无法使用
全局变量：通常全局变量存活在脚本运行结束，并且所有的函数都可以访问它
局部变量：只能局部变量所在的函数内部调用，并且除非把局部变量声明成全局变量否则，其他函数均无法调用，并且局部变量
当所在的函数执行完成后就不存在了
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = “haha”
#创建函数
def print_str():
a = “heihei”
print(“我是局部变量a:”,a)
#调用函数
print_str()
print(“我是全局变量a:”,a)
全局变量与局部变量
global
global就是可以把局部变量变成全局变量的，如果被声明的局部变量名与全局变量名一样的话，那么局部变量会覆盖全局变量，切
使用global声明变量需要在变量之前声明否则python会告诉你，你需要在 a 前面声明
报错提示：syntaxwarning: name ‘a’ is assigned to before global declaration global a
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = “haha”
#创建函数
def print_str():
global a
a = “heihei”
print(“我是局部变量a:”,a)
#调用函数
print_str()
print(“我是全局变量a:”,a)
gloable
二、传参与返回值
传参
函数用起来比较简单也容易理解，但是参数的变化就比较多了，在函数括号内就是参数，参数可以接收字符串，数字，也可以接收字典和列表
并且在调用的时候，我们还可以指定给哪个参数赋什么值
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#创建函数
def print_str(name,age,aender):
print(”’
name:%s
age:%s
aender:%s
”’%(name,age,aender))
#用户输入
in_name = input(“请输入你的名字：”)
in_age = input(“请输入你的年龄：”)
in_aender = input(“请输入你的性别：”)
#固定位置传参
print_str(in_name,in_age,in_aender)
print(“———————————-“)
#不固定位置传参
print_str(in_name,aender=in_aender,age=in_age)
传参
当我们想要传入列表或者字典时需要怎么办？
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def print_str(lists):
if type(lists) == list:
print(”’
name:%s
age:%s
aender:%s
”’%(lists[0],lists[1],lists[2]))
else:
print(”’
name:%s
age:%s
aender:%s
”’%(lists[“name”],lists[“age”],lists[“aenber”]))
#传入列表
userlist = [“ben”,”22″,”man”]
print_str(userlist)
print(“———————————-“)
#传入字典
userdict = {“name”:”ben”,”age”:”022″,”aender”:”man”}
print_str(userlist)
传入字典或列表
默认参数
在函数中还可以设置默认参数，默认参数的意思是这个参数你可以传值也可以不传值，当不传值的时候这个参数就等于默认值
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def print_str(lists,country=”china”):
if type(lists) == list:
print(”’
name:%s
age:%s
aender:%s
country:%s
”’%(lists[0],lists[1],lists[2],country))
else:
print(”’
name:%s
age:%s
aender:%s
country:%s
”’%(lists[“name”],lists[“age”],lists[“aenber”],country))
#传入列表
userlist = [“ben”,”22″,”man”]
print_str(userlist)
print(“———————————-“)
#传入字典
userdict = {“name”:”ben”,”age”:”022″,”aender”:”man”}
print_str(userlist,”america”)
默认参数
非固定参数
非固定参数的意义在于可以接收任意个值，在你的函数不确定用户想传入多少个值的时候使用，当然在调用有只有非固定参数的函数的时候我们可以不传参数。
非固定参数分一个*和两个*，*args会把传入的参数变成元祖，**kwargs把传入的参数变成字典，当然*ages可以是别的名称，但是在规范中最好使用*args，和**kwargs
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def print_str(*args,**kwargs):
print(“我是*”,args)
print(“我是**”,kwargs)
#传入列表
userlist = [“ben”,”22″,”man”]
print_str(userlist,”america”)
print(“———————————-“)
#传入字典
print_str(a = “1”,b = “2”)
非固定传参
既然形参可以带*和**，那么实参也是可以带*和**，那么*就是配合列表使用的，**就是配合字典的！
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def print_str(*args,**kwargs):
print(“我是*”,args)
print(“我是**”,kwargs)
#传入列表
userlist = [“ben”,”22″,”man”]
print_str(*userlist)
print(“—————-分隔符—————-“)
#传入字典
userdict = {“name”:”ben”,”age”:”022″,”gender”:”man”}
print_str(**userdict)
解参
实参带*就会把列表分解成 “ben”,”22″,”man” 一个一个单独的元素传入函数，而**会把字典分解成name=”ben”,age=”022″,gender=”man”
这种键值对传入函数。
形参与实参
形参:
变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用
函数后则不能再使用该形参变量
实参:
可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此
应预先用赋值，输入等办法使参数获得确定值
注！当普通参数和默认参数和非固定参数结合使用的时候，要遵循一个顺序，普通参数在默认参数前面，默认参数在非固定参数前面
返回值
在正常使用函数的时候，函数是可以把函数内部处理的结果返回给函数调用者的，在没有返回值得函数中会保留none传给函数调用者，返回值可以返回序列等
在函数执行的时候遇到return函数会停止执行，并返回结果
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#创建函数
def print_str(age):
if int(age) 3
for i in filter(add,[1,2,3,4,5]):
print(i)
#浮点型
print(float(11))
#格式化显示 更多方法请参考官方说明
print(‘{:,.2f}’.format(111111))
#根据传入的参数创建一个新的不可变集合
a = frozenset([1,2,3,4,5])
print(a)
#获取对象的属性值
class a():
def __init__(self,):
self.name = “123”
b = a()
print(getattr(b,’name’))
#返回当前作用域内的全局变量和其值组成的字典
print(globals())
#检查对象是否含有属性
class a():
def __init__(self,):
self.name = “123”
b = a()
print(hasattr(b,’name’))
#哈希值计算
#在当前环境中是唯一的
print(hash(‘hello’))
#help帮助
def funcs(args):
“””
function description
:param args: args = list
:return:
“””
pass
print(help(funcs))
#转换16进制
print(hex(44))
#显示对象的标识符
print(id(“123”))
#input标准输入
s = input(“user name：”)
print(s)
#int返回整数
print(int(1.2))
print(int(“2”))
#判断对象是否是类或者类型元组中任意类元素的实例
print(isinstance(“1”,int))
print(isinstance(1.1,(int,float)))
#判断类是否是另外一个类或者类型元组中任意类元素的子类
print(dir(str))
print(issubclass(bytearray,str))
print(issubclass(bool,int))
#根据传入的参数创建一个新的可迭代对象
a = iter(‘12345′)
print(next(a))
print(next(a))
#返回对象的长度len
a = [1,2,3,4]
#转换列表
print(list(“abcd”))
#返回当前作用域内的局部变量和其值组成的字典
def a():
print(locals())
s = 1
print(locals())
a()
#使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
def add(x):
return x+100
lists = [1,2,3,4]
for i in map(add,lists):
print(i)
#max：返回最大值
print(max(1,2,3))
print(max([1,2,3,4]))
#在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存；
s = memoryview(b’abcd’)
print(s[1])
#返回最小值
print(min(1,2,3))
print(min([2,3]))
#返回可迭代对象中的下一个元素值
a = iter(‘1234’)
print(next(a))
#创建一个新的object对象(新式类)
class b(object):
pass
#转化成8进制数字符串
print(oct(10))
#open文件操作
file = open(‘test.txt’,encoding=”utf-8″)
#ord：返回unicode字符对应的整数
print(ord(“a”))
#幂运算
print(pow(2,3))
#标准输出
print()
#property：标示属性的装饰器
#类中使用具体方法请百度，或者等待后续更新
property
#range：根据传入的参数创建一个新的range对象
range(10)
range(1,10)
“””repr（）函数得到的字符串通常可以用来重新获得该对象，repr（）的输入对python比较友好。
通常情况下obj==eval(repr(obj))这个等式是成立的。”””
obj=’python’
print(eval(repr(obj)))
#翻转序列
a = reversed([1,2,3,4,5])
print(list(a))
#round：对浮点数进行四舍五入求值
print(round(1.5))
#set 转换成集合
print(set([1,2,3]))
#setattr：设置对象的属性值
class a():
def __init__(self,age):
self.age = age
s = a(11)
print(s.age)
setattr(s,’age’,22)
print(s.age)
#根据传入的参数创建一个新的切片对象
c1 = slice(3)
c2 = slice(2,4)
c3 = slice(0,5,2)
s = [1,2,3,4,5,6]
print(s[c1])
print(s[c2])
print(s[c3])
#排序，返回一个新的列表默认按字符ascii码排序
a = [4,3,2,1,7]
print(sorted(a))
#标示方法为静态方法的装饰器
class b(object):
def __init__(self,age):
self.age = age
@staticmethod
def hello(args):
print(args)
b.hello(“hello world”)
#字符串类型
print(str(123))
#求和
print(sum([1,2,3,4]))
#根据传入的参数创建一个新的子类和父类关系的代理对象
class a(object):
def __init__(self):
print(“我是 a clase”)
class b(a):
def __init__(self):
print(“我是 b class”)
super().__init__()
b = b()
#元祖
tuple([1,2,3,4])
#type 返回对象的类型
print(type([1]))
print(type(“1”))
#返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
def func():
print(vars())
s = 1
print(vars())
func()
#聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
list1 = [1,2,3]
list2 = [“a”,”b”,”c”,”d”]
print(zip(list1,list2))
for i in zip(list1,list2):
print(i)
#__import__：动态导入模块
__import__
更多简学python第三章__函数式编程、递归、内置函数 相关文章请关注php中文网！