高阶函数就是能够把函数当成参数传递的函数就是高阶函数,换句话说如果一个函数的参数是函数,那么这个函数就是一个高阶函数。
站在用户的角度思考问题,与客户深入沟通,找到西盟网站设计与西盟网站推广的解决方案,凭借多年的经验,让设计与互联网技术结合,创造个性化、用户体验好的作品,建站类型包括:网站设计、网站建设、企业官网、英文网站、手机端网站、网站推广、申请域名、网络空间、企业邮箱。业务覆盖西盟地区。
高阶函数可以是你使用 def 关键字自定义的函数,也有Python系统自带的内置高阶函数。
我们下面的例子中,函数 senior 的参数中有一个是函数,那么senior就是一个高阶函数;函数 tenfold 的参数不是函数,所以tenfold就只是一个普通的函数。
function:函数,可以是 自定义函数 或者是 内置函数;
iterable:可迭代对象,可迭代性数据。(容器类型数据和类容器类型数据、range对象、迭代器)
把可迭代对象中的数据一个一个拿出来,然后放在到指定的函数中做处理,将处理之后的结果依次放入迭代器中,最后返回这个迭代器。
将列表中的元素转成整型类型,然后返回出来。
列表中的每一个数依次乘 2的下标索引+1 次方。使用自定义的函数,配合实现功能。
参数的意义和map函数一样
filter用于过滤数据,将可迭代对象中的数据一个一个的放入函数中进行处理,如果函数返回值为真,将数据保留;反之不保留,最好返回迭代器。
保留容器中的偶数
参数含义与map、filter一致。
计算数据,将可迭代对象的中的前两个值放在函数中做出运算,得出结果在和第三个值放在函数中运算得出结果,以此类推,直到所有的结果运算完毕,返回最终的结果。
根据功能我们就应该直到,reduce中的函数需要可以接收两个参数才可以。
将列表中的数据元素组合成为一个数,
iterable:可迭代对象;
key:指定函数,默认为空;
reverse:排序的方法,默认为False,意为升序;
如果没有指定函数,就单纯的将数据安札ASCII进行排序;如果指定了函数,就将数据放入函数中进行运算,根据数据的结果进行排序,返回新的数据,不会改变原有的数据。
注意,如果指定了函数,排序之后是根据数据的结果对原数据进行排序,而不是排序计算之后的就结果数据。
将列表中的数据进行排序。
还有一点就是 sorted 函数可以将数据放入函数中进行处理,然后根据结果进行排序。
既然有了列表的内置函数sort,为什么我们还要使用sorted函数呢?
高阶函数就是将函数作为参数的函数。
文章来自
将函数作为参数传入,这样的函数称为高阶函数。 函数式编程就是指这种高度抽象的编程范式。
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。如下所示:
map(fun, lst),将传入的函数变量func作用到lst变量的每个元素中,并将结果组成新的列表返回。
定义一个匿名函数并调用,定义格式如--lambda arg1,arg2…:表达式
reduce把一个函数作用在一个序列[x1, x2, x3, …]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算。
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
闭包的定义?闭包本质上就是一个函数
如何创建闭包?
如何使用闭包?典型的使用场景是装饰器的使用。
global与nonlocal的区别:
简单的使用如下:
偏函数主要辅助原函数,作用其实和原函数差不多,不同的是,我们要多次调用原函数的时候,有些参数,我们需要多次手动的去提供值。
而偏函数便可简化这些操作,减少函数调用,主要是将一个或多个参数预先赋值,以便函数能用更少的参数进行调用。
我们再来看一下偏函数的定义:
类func = functools.partial(func, *args, **keywords)
我们可以看到,partial 一定接受三个参数,从之前的例子,我们也能大概知道这三个参数的作用。简单介绍下:
总结
本文是对Python 高阶函数相关知识的分享,主题内容总结如下:
1、Python类型操作符和内建函数总结
表4.5列出了所有操作符和内建函数,其中操作符顺序是按优先级从高到低排列的。同一种灰度的操作符拥有同样的优先级。注意在operator模块中有这些(和绝大多数Python)操作符相应的同功能的函数可供使用。
表4.5 标准类型操作符和内建函数
操作符/函数
描 述
结 果a
字符串表示
``
对象的字符串表示
str
内建函数
cmp(obj1, obj2)
比较两个对象
int
repr(obj)
对象的字符串表示
str
str(obj)
对象的字符串表示
str
type(obj)
检测对象的类型
type
值比较
小于
bool
大于
bool
=
小于或等于
bool
=
大于或等于
bool
==
等于
bool
!=
不等于
bool
不等于
bool
对象比较
is
是
bool
is not
不是
bool
布尔操作符
not
逻辑反
bool
and
逻辑与
bool
or
逻辑或
bool
2、Python数值类型操作符和内建函数
一、工厂函数
数值工厂函数总结类(工厂函数) 操作
bool(obj) b 返回obj对象的布尔值,也就是 obj.__nonzero__()方法的返回值。
int(obj, base=10) 返回一个字符串或数值对象的整数表 示, 类似string.atoi();
从Python 1.6起, 引入了可选的进制参数。
long(obj, base=10) 返回一个字符或数据对象的长整数表 示,类似string.atol(),
从Python1.6起, 引入了可选的进制参数 float(obj) ,
返回一个字符串或数据对象的浮点数 表示,类似string.atof()。
complex(str) or返回一个字符串的复数表示,或 者根据给定的实数,
complex(real, imag=0.0) (及一个可选 的虚数部分)生成一个复数对象。
二、内建函数
1、分类
Python 有五个运算内建函数用于数值运算:
abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)
其中abs()返回给定参数的绝对值。如果参数是一个复数, 那么就返回math.sqrt(num.real2 + num.imag2).
coerce()是一个数据类型转换函数,不过它的行为更像一个运算符.数coerce()为程序员提供了不依赖Python 解释器,而是自定义两个数值类型转换的方法。对一种新创建的数值类型来说, 这个特性非常有用.函数coerce()仅返回一个包含类型转换完毕的两个数值元素的元组.
divmod()内建函数把除法和取余运算结合起来, 返回一个包含商和余数的元组.对整数来说,它的返回值就是地板除和取余操作的结果.对浮点数来说,返回的商部分是math.floor(num1/num2),对复数来说,商部分是ath.floor((num1/num2).real).
pow()它和双星号 (**)运算符都可以进行指数运算.不过二者的区别并不仅仅在于一个是运算符,一个是内建函数.在Python 1.5 之前,并没有 ** 运算符,内建函数pow()还接受第三个可选的参数,一个余数参数.如果有这个参数的, pow() 先进行指数运算,然后将运算结果和第三个参数进行取余运算.这个特性主要用于密码运算,并且比 pow(x,y) % z 性能更好, 这是因为这个函数的实现类似于C 函数pow(x,y,z).
round()用于对浮点数进行四舍五入运算。它有一个可选的小数位数参数.如果不提供小数位参数, 它返回与第一个参数最接近的整数(但仍然是浮点类型).第二个参数告诉round 函数将结果精确到小数点后指定位数.
2、函数int()/round()/math.floor()它们之间的不同之处:
函数 int()直接截去小数部分.(返回值为整数)
函数 floor() 得到最接近原数但小于原数的整数.(返回值为浮点数)
函数 round() 得到最接近原数的整数.(返回值为浮点数)
3、进制转换函数:
返回字符串表示的8 进制和16 进制整数,它们分别是内建函数:
oct()和 hex(). oct(255)='0377'/hex(255)='0xff'
函数chr()接受一个单字节整数值(0到255),返回一个字符串(ASCII),其值为对应的字符.chr(97)='a'
函数ord()则相反,它接受一个字符(ASCII 或 Unicode),返回其对应的整数值.ord('A')=65
3、Python字符串函数
(一)标准类型操作符和标准内建函数
1)、标准类型操作符
,,=,=,==,!=,对象值得比较
注:做比较时字符串是按ASCII值的大小来比较的
is 对象身份比较
and,or,not 布尔类型
2)标准内建函数
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引号运算符(``) 可以方便的以字符串的方式获取对象的
内容、类型、数值属性等信息。str()函数得到的字符串可读性好, 而repr()函数得到的字符
串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的
isinstance(obj,type) 判断对象的类型
(二)序列操作
1、序列操作
字符串属于序列对象,可以使用所有序列的操作和函数
切片 [] [:] [::]
简单总结:
*索引(S[i])获取特定偏移的元素。
——第一个元素偏移为0
——(S[0])获取第一个元素。
——负偏移索引意味着从最后或右边反向进行计数
——(S[-2])获取倒数第二个元素(就像S[len(s)-2]一样
*分片[S[i:j]提取对应的部分作为一个序列
——右边界不包含在内
——分片的边界默认为0和序列的长度,如果没有给出的话S[:]
——(S[1:3])获取了从偏移为1,直到但不包括偏移为3的元素
——(S[1:])获取从偏移为1到末尾之间的元素
——(S[:3])获取从偏移为0直到但不包括偏移为3的元素
——(S[:-1])获取从偏移为0直到但不包括最后一个元素之间的元素
——(S[:])获取从偏移为0到末尾之间的元素,这有效地实现了顶层S拷贝
拷贝了一个相同值,但是是不同内存区域的对象。对象字符串这样不可变的对象不是很有用,但是对于可以实地修改的对象来说很有用。
比如列表。
扩展分片:第三个限制值 【步进】
完整形式:X[I:J:K]:这标识索引X对象的元素,从偏移为I直到J-1,每隔K元素索引一次。第三个限制值,K,默认为1
实例
Python Code
1
2
3
4
5
S='abcdefghijk'
S[1:10]
'bcdefghij'
S[1:10:2]
'bdfhj
也可以使用负数作为步进。
分片表达式
Python Code
1
2
"hello"[::-1]
'olleh'
通过负数步进,两个边界的意义实际上进行了反转。
3、成员操作符 in ,not in
返回布尔值True 或False
可以使用string模块来判断输入字符的合法性,可见成品中的idcheck.py
4、字符串连接
+ 连接字符串 ‘name’+' '+'jin'
字符串格式化 '%s %s' % ('name','jin')
join()方法 ' '.join(('name','jin')) ' '.join(['name','jin'])
5、删除清空字符串
del aString
aString=''
(三)、序列函数
序列类型函数
len(str) 返回字串的长度
enumerate(iter):接受一个可迭代对象作为参数,返回一个enumerate
max(str)/min(str):max()和min()函数对其他的序列类型可能更有用,但对于string类型它们能很好地运行,返回最大或者最小的字符(按照ASCII 码值排列),
zip([it0, it1,... itN]) 返回一个列表,其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组,第二个...,类推.
reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)
sorted(iter,func=None,key=None,reverse=False) 接受一个可迭代对象作为参数,返回一个有序的列表;可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.
注意:
sorted等需要在原处修改的函数无法用在字符串对象,但可以产生新的对象
sum处理的对象是数字,不能用在字符串
sorted(s)
['a', 'e', 'e', 'g', 'g', 'g', 'o']
(四)只适合于字符串类型的函数
1)raw_input()函数
内建的raw_input()函数使用给定字符串提示用户输入并将这个输入返回,下面是一个使
用raw_input()的例子:
user_input = raw_input("Enter your name: ")
prin user_input
2)str() and unicode()
str()和unicode()函数都是工厂函数,就是说产生所对应的类型的对象.它们接受一个任
意类型的对象,然后创建该对象的可打印的或者Unicode 的字符串表示. 它们和basestring 都
可以作为参数传给isinstance()函数来判断一个对象的类型
3)chr(), unichr(), and ord()
chr()函数用一个范围在range(256)内的(就是0 到255)整数做参数,返回一个对应的字符.unichr()跟它一样,只不过返回的是Unicode 字符
ord()函数是chr()函数(对于8 位的ASCII 字符串)或unichr()函数(对于Unicode 对象)
的配对函数,它以一个字符(长度为1 的字符串)作为参数,返回对应的ASCII 数值,或者Unicode
数值,如果所给的Unicode 字符超出了你的Python 定义范围,则会引发一个TypeError 的异常
(五)、只适用于字符串的操作符
1、格式化操作符 %
字符串格式化符号
格式化字符 转换方式
%c 转换成字符(ASCII 码值,或者长度为一的字符串)
%ra 优先用repr()函数进行字符串转换
%s 优先用str()函数进行字符串转换
%d / %i 转成有符号十进制数
%ub 转成无符号十进制数
%ob 转成无符号八进制数
%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大
小写)
%e/%E 转成科学计数法(e/E 控制输出e/E)
%f/%F 转成浮点数(小数部分自然截断)
%g/%G %e 和%f/%E 和%F 的简写
%% 输出%
格式化操作符辅助指令
符号 作用
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
sp 在正数前面显示空格
# 在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于
用的是'x'还是'X')
0 显示的数字前面填充‘0’而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
2、字符串模板: 更简单的替代品
由于新式的字符串Template 对象的引进使得string 模块又重新活了过来,Template 对象
有两个方法,substitute()和safe_substitute().前者更为严谨,在key 缺少的情况下它会报一
个KeyError 的异常出来,而后者在缺少key 时,直接原封不动的把字符串显示出
3、原始字符串操作符( r/R )
字符串抑制转义r'带特殊符号的字串'
myfile=open(r'C:\new\text.data','w')
4、Unicode 字符串操作符( u/U )
u'abc' U+0061 U+0062 U+0063
u'\u1234' U+1234
u'abc\u1234\n' U+0061 U+0062 U+0063 U+1234 U+0012
(六)字符串对象的方法:
1、删减
T2.lstrip() 移除字符串前面字符(默认空格),返回字符串
T2.rstrip() 移除字符串后面字符(默认空格),返回字符串
T2.strip() 移除字符串前后面空格,返回字符串 默认空格,可以其他字符 S.strip('"')
2、切割
partition(sep),
rpartition(sep),
splitlines([keepends]),#把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符
split([sep [,maxsplit]]),#以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
rsplit([sep[,maxsplit]]) #从右到左切割
备注:
partition()函数族是2.5版本新增的方法。它接受一个字符串参数,并返回一个3个元素的 tuple 对象。
如果sep没出现在母串中,返回值是 (sep, ‘’, ‘’);
否则,返回值的第一个元素是 sep 左端的部分,第二个元素是 sep 自身,第三个元素是 sep 右端的部分。
S.partition(';')
('', ';', ' generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n')
参数 maxsplit 是分切的次数,即最大的分切次数,所以返回值最多有 maxsplit+1 个元素。
s.split() 和 s.split(‘ ‘)的返回值不尽相同
' hello world!'.split()
['hello', 'world!']
' hello world!'.split(' ')
['', '', 'hello', '', '', 'world!']
S.split('\n',3)
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n']
超过最大切割个数后面的全部为一个元素
按行切割
S
'; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n'
S.splitlines()
['; generated by /sbin/dhclient-script', 'nameserver 172.16.10.171', 'nameserver 8.8.8.8', 'nameserver 172.16.0.2', 'nameserver 178.79.131.110', 'nameserver 202.96.199.133']
产生差异的原因在于当忽略 sep 参数或sep参数为 None 时与明确给 sep 赋予字符串值时 split() 采用两种不同的算法。
对于前者,split() 先去除字符串两端的空白符,然后以任意长度的空白符串作为界定符分切字符串
即连续的空白符串被当作单一的空白符看待;
对于后者则认为两个连续的 sep 之间存在一个空字符串。因此对于空字符串(或空白符串),它们的返回值也是不同的:
''.split()
[]
''.split(' ')
['']
3、变形
lower(),#全部小写
upper(),#全部小写
capitalize(),#首字母大写
swapcase(),#大小写交换
title()#每个单词第一个大写,其他小写
备注
因为title() 函数并不去除字符串两端的空白符也不会把连续的空白符替换为一个空格,
所以建议使用string 模块中的capwords(s)函数,它能够去除两端的空白符,再将连续的空白符用一个空格代替。
Python Code
1
2
3
4
' hello world!'.title()
' Hello World!'
string.capwords(' hello world!')
'Hello World!'
4、连接
join(seq)
join() 函数的高效率(相对于循环相加而言),使它成为最值得关注的字符串方法之一。
它的功用是将可迭代的字符串序列连接成一条长字符串,如:
conf = {'host':'127.0.0.1',
... 'db':'spam',
... 'user':'sa',
... 'passwd':'eggs'}
';'.join("%s=%s"%(k, v) for k, v in conf.iteritems())
'passswd=eggs;db=spam;user=sa;host=127.0.0.1'
S=''.join(T) #使用空字符串分割把字符列表转换为字符串
5、查找
count( sub[, start[, end]]),#计算substr在S中出现的次数
find( sub[, start[, end]]),#返回S中出现sub的第一个字母的标号,如果S中没有sub则返回-1。start和end作用就相当于在S[start:end]中搜索
index( substr[, start[, end]]),#与find()相同,只是在S中没有substr时,会返回一个运行时错误
rfind( sub[, start[,end]]),#返回S中最后出现的substr的第一个字母的标号,如果S中没有substr则返回-1,也就是说从右边算起的第一次出现的substr的首字母标号
rindex( sub[, start[, end]])
T2.find('ie') 字符串方法调用:搜索
find()----找到的第一个符合字符的index
rfind()-----找到最后一个符合的字符的index
备注:
find()函数族找不到时返回-1,index()函数族则抛出ValueError异常。
另,也可以用 in 和 not in 操作符来判断字符串中是否存在某个模板
6、替换
replace(old, new[,count]),#把S中的oldstar替换为newstr,count为替换次数。这是替换的通用形式,还有一些函数进行特殊字符的替换
translate(table[,deletechars]) #使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉
备注:
replace()函数的 count 参数用以指定最大替换次数
translate() 的参数 table 可以由 string.maketrans(frm, to) 生成
translate() 对 unicode 对象的支持并不完备,建议不要使用
7、判定
isalnum(),#是否全是字母和数字,并至少有一个字符
isalpha(),是否全是字母,并至少有一个字符
isdigit(),是否全是数字,并至少有一个字符 ,如果是全数字返回True,否则返回False
islower(),#S中的字母是否全是小写
isupper(),#S中的字母是否是大写
isspace(),#是否全是空白字符,并至少有一个字符
istitle(),S是否是首字母大写的
startswith(prefix[, start[, end]]), #是否以prefix开头
endswith(suffix[,start[, end]]),#以suffix结尾
备注:
这些函数都比较简单,顾名知义。需要注意的是*with()函数族可以接受可选的 start, end 参数,善加利用,可以优化性能。
另,自 Py2.5 版本起,*with() 函数族的 prefix 参数可以接受 tuple 类型的实参,当实参中的某人元素能够匹配,即返回 True。
8、填充
字符串在输出时的对齐:
center(width[, fillchar]), 字符串中间对齐
ljust(width[, fillchar]), 字符串左对齐,不足部分用fillchar填充,默认的为空格
rjust(width[, fillchar]), 字符串右对齐,不足部分用fillchar填充,默认的为空格
zfill(width), 把字符串变成width长,并在右对齐,不足部分用0补足
expandtabs([tabsize])把字符串中的制表符(tab)转换为适当数量的空格。
fillchar 参数指定了用以填充的字符,默认为空格
zfill的z为zero的缩写,顾名思义,是以字符0进行填充,用于数值输出
expandtabs()的tabsize 参数默认为8。它的功能是把字符串中的制表符(tab)转换为适当数量的空格。
9、编码
encode([encoding[,errors]]),
decode([encoding[,errors]])
这是一对互逆操作的方法,用以编码和解码字符串。因为str是平台相关的,它使用的内码依赖于操作系统环境,
而unicode是平台无关的,是Python内部的字符串存储
在Python中,访问一个属性的优先级顺序按照如下顺序:
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.__getattr__()方法。这个方法的完整定义如下所示:
[python] view plain copy
def __getattr__(self,attr) :#attr是self的一个属性名
pass;
先来阐述下什么叫数据描述符。
数据描述符是指实现了__get__,__set__,__del__方法的类属性(由于Python中,一切皆是对象,所以你不妨把所有的属性也看成是对象)
PS:个人觉得这里最好把数据描述符等效于定义了__get__,__set__,__del__三个方法的接口。
阐述下这三个方法:
__get__的标准定义是__get__(self,obj,type=None),它非常接近于JavaBean的get
第一个函数是调用它的实例,obj是指去访问属性所在的方法,最后一个type是一个可选参数,通常为None(这个有待于进一步的研究)
例如给定类X和实例x,调用x.foo,等效于调用:
type(x).__dict__["foo"].__get__(x,type(x))
调用X.foo,等效于调用:
type(x).__dict__["foo"].__get__(None,type(x))
第二个函数__set__的标准定义是__set__(self,obj,val),它非常接近于JavaBean的set方法,其中最后一个参数是要赋予的值
第三个函数__del__的标准定义是__del__(self,obj),它非常接近Java中Object的Finailize()方法,指
Python在回收这个垃圾对象时所调用到的析构函数,只是这个函数永远不会抛出异常。因为这个对象已经没有引用指向它,抛出异常没有任何意义。
接下来,我们来一一比较这些优先级.
首先来看类属性
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class A(object):
foo=3
print A.foo
a=A()
print a.foo
a.foo=4
print a.foo
print A.foo
上面这段代码的输出如下:
3
3
4
3
从输出可以看到,当我们给a.foo赋值的时候,其实与类实例的那个foo是没有关系的。a.foo=4 这句话给a对象增加了一个属性叫foo。其值是4。
最后两个语句明确的表明了,我们输出a.foo和A.foo的值,他们是不同的。
但是为什么a=A()语句后面的print
a.foo输出了3呢?这是因为根据搜索顺序找到了类属性。当我们执行a.foo=4的时候,我们让a对象的foo属性指向了4这个对象。但是并没有改变
类属性foo的值。所以最后我们print A.foo的时候,又输出了3。
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class A(object):
foo=3
a=A()
a.foo=4
print a.foo
del a.foo
print a.foo
上面的代码,我给a.foo赋值为4,在输出一次之后就del了。两次输出,第一次输出的是a对象的属性。第二次是类属性。不是说类属性的优先级比
实例属性的高吗。为啥第一次输出的是4而不是3呢?还是上面解释的原因。因为a.foo与类属性的foo只是重名而已。我们print
a.foo的时候,a的foo指向的是4,所以输出了4。
------------------------------------
然后我们来看下数据描述符这一全新的语言概念。按照之前的定义,一个实现了__get__,__set__,__del__的类都统称为数据描述符。我们来看下一个简单的例子。
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __get__(self,obj,type=None):
pass
def __set__(self,obj,val):
pass
def __del__(self,obj):
pass
class A(object):
foo=simpleDescriptor()
print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo
上面例子的输出结果如下:
[plain] view plain copy
{'__dict__': attribute '__dict__' of 'A' objects, '__module__': '__main__', 'foo': __main__.simpleDescriptor object at 0x005511B0, '__weakref__': attribute '__weakref__' of 'A' objects, '__doc__': None}
None
None
None
从输出结果看出,print语句打印出来的都是None。这说明a.foo都没有被赋值内容。这是因为__get__函数的函数体什么工作都没有做。直接是pass。此时,想要访问foo,每次都没有返回内容,所以输出的内容就是None了。
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __get__(self,obj,type=None):
return "hi there"
def __set__(self,obj,val):
pass
def __del__(self,obj):
pass
class A(object):
foo=simpleDescriptor()
print str(A.__dict__)
print A.foo
a=A()
print a.foo
a.foo=13
print a.foo
把__get__函数实现以下,就可以得到如下输出结果:
[plain] view plain copy
{'__dict__': attribute '__dict__' of 'A' objects, '__module__': '__main__', 'foo': __main__.simpleDescriptor object at 0x00671190, '__weakref__': attribute '__weakref__' of 'A' objects, '__doc__': None}
hi there
hi there
hi there
为了加深对数据描述符的理解,看如下例子:
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = 13;
print a.foo;
上面代码的输出是
16
6
第一个16为我们在对a.foo赋值的时候,人为的将13加上3后作为foo的值,第二个6是我们在返回a.foo之前人为的将它减去了10。
所以我们可以猜测,常规的Python类在定义get,set方法的时候,如果无特殊需求,直接给对应的属性赋值或直接返回该属性值。如果自己定义类,并且继承object类的话,这几个方法都不用定义。
-----------------
在这里看一个题外话。
看代码
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __init__(self):
self.result = None;
def __get__(self, obj, type=None) :
return self.result - 10;
def __set__(self, obj, val):
if isinstance(val,str):
assert False,"int needed! but get str"
self.result = val + 3;
print self.result;
def __del__(self, obj):
pass
class A(object):
foo = simpleDescriptor();
a = A();
a.foo = "13";
print a.foo;
上面代码在__set__ 函数中检查了参数val,如果val是str类型的,那么要报错。这就实现了我们上一篇文章中要实现的,在给属性赋值的时候做类型检查的功能。
-----------------------------------------------
下面我们来看下实例属性和非数据描述符。
[python] view plain copy
# -*- coding:utf-8 -*-
'''''
Created on 2013-3-29
@author: naughty
'''
class B(object):
foo = 1.3
b = B()
print b.__dict__
b.bar = 13
print b.__dict__
print b.bar
上面代码输出结果如下:
{}
{'bar': 13}
13
那么什么是非数据描述符呢?
简单的说,就是没有实现get,set,del三个方法的所有类。
让我们任意看一个函数的描述:
def call():
pass
执行print dir(call)会得到如下结果:
[plain] view plain copy
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
先看下dir的帮助。
dir列出给定对象的属性或者是从这个对象能够达到的对象。
回到print dir(call)方法的输出,看到,call方法,有输出的那么多个属性。其中就包含了__get__函数。但是却没有__set__和__del__函数。所以所有的类成员函数都是非数据描述符。
看一个实例数据掩盖非数据描述符的例子:
[python] view plain copy
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type
class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo
看输出:
('get', __main__.simpleDescriptor object at 0x02141190,
__main__.D object at 0x025CAF50, class '__main__.D')
15
可见,实例数据掩盖了非数据描述符。
如果改成数据描述符,那么就不会被覆盖了。看下面:
[python] view plain copy
'''''
Created on 2013-3-29
@author: naughty
'''
class simpleDescriptor(object):
def __get__(self,obj,type=None) :
return "get",self,obj,type
def __set__(self,obj,type=None) :
pass
def __del__(self,obj,type=None) :
pass
class D(object):
foo=simpleDescriptor()
d=D()
print d.foo
d.foo=15
print d.foo
代码的输出如下:
[plain] view plain copy
('get', __main__.simpleDescriptor object at 0x01DD1190, __main__.D object at 0x0257AF50, class '__main__.D')
('get', __main__.simpleDescriptor object at 0x01DD1190, __main__.D object at 0x0257AF50, class '__main__.D')
由于是数据描述符,__set __函数体是pass,所以两次输出都是同样的内容。
最后看下__getatrr__方法。它的标准定义是:__getattr__(self,attr),其中attr是属性名
1. 运算优先级
括号、指数、乘、除、加、减
2
如果你使用了非 ASCII 字符而且碰到了编码错误,记得在最顶端加一行 # -- coding: utf-8 --
3. Python格式化字符
使用更多的格式化字符。例如 %r 就是是非常有用的一个,它的含义是“不管什么都打印出来”。
%s -- string
%% 百分号标记 #就是输出一个%
%c 字符及其ASCII码
%s 字符串
%d 有符号整数(十进制)
%u 无符号整数(十进制)
%o 无符号整数(八进制)
%x 无符号整数(十六进制)
%X 无符号整数(十六进制大写字符)
%e 浮点数字(科学计数法)
%E 浮点数字(科学计数法,用E代替e)
%f 浮点数字(用小数点符号)
%g 浮点数字(根据值的大小采用%e或%f)
%G 浮点数字(类似于%g)
%p 指针(用十六进制打印值的内存地址)
%n 存储输出字符的数量放进参数列表的下一个变量中
%c 转换成字符(ASCII 码值,或者长度为一的字符串)
%r 优先用repr()函数进行字符串转换(Python2.0新增)
%s 优先用str()函数进行字符串转换
%d / %i 转成有符号十进制数
%u 转成无符号十进制数
%o 转成无符号八进制数
%x / %X (Unsigned)转成无符号十六进制数(x / X 代表转换后的十六进制字符的大小写)
%e / %E 转成科学计数法(e / E控制输出e / E)
%f / %F 转成浮点数(小数部分自然截断)
%g / %G : %e和%f / %E和%F 的简写
%% 输出%
辅助符号 说明
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号(+)
sp 在正数前面显示空格
# 在八进制数前面显示零(0),在十六进制前面显示“0x”或者“0X”(取决于用的是“x”还是“X”)
0 显示的数字前面填充“0”而不是默认的空格
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
变量可以指向函数,函数的参数可以接收变量,那么函数可以接收另一个函数作为参数,这种函数称为高阶函数。
1、把函数作为实参;2、把函数作为返回值。
python高阶函数有哪些?
map函数
map()是python内置的高阶函数,它接收两个参数,一个是函数,一个是序列,map将传入的函数依次作用到序列的每个元素,并且把结果作为新的列表返回。
filter函数
filter()同样也是接收一个函数和一个序列,和map()不同的是,filter函数把传入的函数依次作用于每个元素,然后返回返回值是True的元素。
reduce函数
reduce()把一个函数作用到一个序列上,这个函数必须接收两个参数,reduce把结果和序列的下一个元素做累积计算。
lambda函数
lambda()有时候传参数时不需要显示自定义的函数,直接传入匿名函数更方便;冒号前面的X,y表示函数参数,匿名函数不需要担心函数名的冲突,匿名函数也是一个函数对象,可以吧匿名函数赋值给一个变量,再利用变量来调用函数,匿名函数也可以作为返回值返回。
sorted函数
sorted()作为python内置高阶函数之一,其功能是对序列(列表、元组、字典、集合、字符串)进行排序。
文章名称:Python函数优先等级 python 优先级
链接分享:https://www.cdcxhl.com/article32/doojgsc.html
成都网站建设公司_创新互联,为您提供关键词优化、网站建设、网站导航、动态网站、用户体验、定制网站
声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联