abs 取绝对值
print(abs(-1)) #结果1
all(...)
all(iterable) -> bool
Return True if bool(x) is True for all values x in the iterable.
If the iterable is empty, return True.
如果iterable的所有元素不为0、''、False或者iterable为空,all(iterable)返回True,否则返回False;函数等价于:
1 def all(iterable): 2 3 for element in iterable: 4 if not element: 5 return False 6 return True
示例:
1 >>> all(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0 2 True 3 >>> all(['a', 'b', '', 'd']) #列表list,存在一个为空的元素 4 False 5 >>> all([0, 1,2, 3]) #列表list,存在一个为0的元素 6 False 7 8 >>> all(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0 9 True 10 >>> all(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素 11 False 12 >>> all((0, 1,2, 3)) #元组tuple,存在一个为0的元素 13 False 14 15 >>> all([]) # 空列表 16 True 17 >>> all(()) # 空元组 18 True
注意:空元组、空列表返回值为True,这里要特别注意。
any(...)
any(iterable) -> bool
Return True if bool(x) is True for any x in the iterable.
If the iterable is empty, return False.
any(iterable)说明:参数iterable:可迭代对象;
如果当iterable所有的值都是0、''或False时,那么结果为False,如果所有元素中有一个值非0、''或False,那么结果就为True
函数等价于:
1 def any(iterable): 2 3 for element in iterable: 4 5 if element: 6 7 return False 8 9 return True
示例:
1 >>> any(['a', 'b', 'c', 'd']) #列表list,元素都不为空或0 2 True 3 4 >>> any(['a', 'b', '', 'd']) #列表list,存在一个为空的元素 5 True 6 7 >>> any([0, '', False]) #列表list,元素全为0,'',false 8 False 9 10 >>> any(('a', 'b', 'c', 'd')) #元组tuple,元素都不为空或0 11 True 12 13 >>> any(('a', 'b', '', 'd')) #元组tuple,存在一个为空的元素 14 True 15 16 >>> any((0, '', False)) #元组tuple,元素全为0,'',false 17 False 18 19 >>> any([]) # 空列表 20 False 21 22 >>> any(()) # 空元组 23 False
ascii
(object)
As repr()
, return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr()
using \x
, \u
or \U
escapes. This generates a string similar to that returned by repr()
in Python 2.
说明:
1. 返回一个可打印的对象字符串方式表示,如果是非ascii字符就会输出\x,\u或\U等字符来表示。与python2版本里的repr()是等效的函数。
>>> ascii(1) '1' >>> ascii('&') "'&'" >>> ascii(9000000) '9000000' >>> ascii('中文') #非ascii字符 "'\\u4e2d\\u6587'"
bin,oct,hex
print(bin(10)) #10进制转2进制 print(oct(10)) #10进制转8进制 print(hex(10)) #10进制转16进制
bytearray([source[, encoding[, errors]]])
返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。可以通过“字节与字节数组操作”章节来查看相关字节数组的内容。下面说明一下几种特别的使用方法:
1. 如果source是一个字符串,那么必须给出endcoding是什么样编码的,以便转换为合适的字节保存。
2. 如果source是一个整数,那么这个数组将初始化为空字节。
3. 如果source是一个有缓冲区接口的对象,那么只读的接口初始到数组里。
4. 如果source是一个迭代对象,那么这个迭代对象的元素都必须符合0 <= x < 256,以便可以初始化到数组里。
如果没有输入任何参数,默认就是初始化数组为0个元素。
例子:
#bytearray()函数 a = bytearray('1234深圳', 'utf-8') print(a) b = bytearray() print(b) c = [1,4,5,7,8] print(bytearray(c)) 输出结果如下: bytearray(b'1234\xe6\xb7\xb1\xe5\x9c\xb3') bytearray(b'') bytearray(b'\x01\x04\x05\x07\x08')
bytes
返回一个新的数组对象,这个数组对象不能对数组元素进行修改。每个元素值范围: 0 <= x < 256。bytes函数与bytearray函数主要区别是bytes函数产生的对象的元素不能修改,而bytearray函数产生的对象的元素可以修改。因此,除了可修改的对象函数跟bytearray函数不一样之外,其它使用方法全部是相同的。最后它的参数定义方式也与bytearray函数是一样的。
#bytes()函数 a = bytes('abc', 'utf-8') print(a) b = bytes(1) print(b) c = bytes([2,3,6,8]) print(c)
输出结果如下:
b'abc'
b'\x00'
b'\x02\x03\x06\x08'
callable 是否是可被调用的,返回True或False
print(callable(bytes)) print(callable(abs)) 打印结果: True True
chr() 函数用一个范围在range(256)内的(就是0~255)整数作参数,返回一个对应的字符
>>> chr(65) 'A'
ord() 函数是chr()函数(对于8位的ASCII字符串)或unichr()函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的ASCII数值,或者Unicode数值,如果所给的Unicode字符超出了你的Python定义范围,则会引发一个TypeError的异常。
>>>ord('a')
97
compile()--编译 执行字符串表示的函数,并为该函数提供全局变量
这个函数有什么用呢? 一个最简单的例子, 就是我们的代码, 会被解释器读取,解释器读取后的其实是字符串, 然后通过compile编译后, 又转换成python可识别的代码.这样python就能执行了.
这里就有一个例子, 是将一段str字符串, 通过compile编译为python代码. 具体如下:
参考自http://www.cnblogs.com/wupeiqi/p/4592637.html
本篇的内容从题目中就可以看出来,就是为之后剖析tornado模板做准备,也是由于该知识点使用的巧妙,所有就单独用一篇来介绍了。废话不多说,直接上代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!usr/bin/env python
#coding:utf-8
namespace
=
{
'name'
:
'wupeiqi'
,
'data'
:[
18
,
73
,
84
]}
code
=
'''def hellocute():return "name %s ,age %d" %(name,data[0],) '''
func
=
compile
(code,
'<string>'
,
"exec"
)
exec
func
in
namespace
result
=
namespace[
'hellocute'
]()
print
result
|
此段代码的执行结果是:name wupeiqi,age 18
上述代码解析:
- 第6行,code是一个字符串,该字符串的内容是一个函数体。
- 第8行,将code字符串编译成函数 hello
- 第10行,将函数 hello 添加到namespace字典中(key为hello),同时也将python的所有内置函数添加到namespace字段中(key为__builtins__),如此一来,namespace中的内容好比是一个个的全局变量,即
12345name = wupeiqi
data = [
18
,
73
,
84
]
def
hellocute():
return
"name %s ,age %d"
%
(name,data[
0
],)
- 第12行,执行Hello函数并将返回值复制给result
- 第14行,输入result
这段代码用的很是巧妙有木有,亮瞎狗眼有木有,居然把字符串变成了函数并且还为该函数提供了全局变量。对于该功能,它就是python的web框架中模板语言部分至关重要的部分,因为在模板处理过程中,首先会读取html文件,然后分割html文件,再然后讲分割的文件组成一个字符串表示的函数,再再然后就是利用上述方法执行字符串表示的函数。
complex([real[, imag]])
本函数可以使用参数real + imag*j方式创建一个复数。也可以转换一个字符串的数字为复数;或者转换一个数字为复数。如果第一个参数是字符串,第二个参数不用填写,会解释这个字符串且返回复数;不过,第二个参数不能输入字符串方式,否则会出错。real和imag参数可以输入数字,如果imag参数没有输入,默认它就是零值,这个函数就相当于int()或float()的功能。如果real和imag参数都输入零,这个函数就返回0j。有了这个函数,就可以很方便地把一个列表转换为复数的形式。
注意:当想从一个字符串的复数形式转换复数时,需要注意的是在字符串中间不能出现空格,比如写成complex(‘1+2j’),而不是写成complex(1 +2j’), 否则会返回ValueError异常。
#complex() print(complex(1)) print(complex('2+1j')) print(complex(2, 5)) l = [1, 3, 4, 5] for i in l: print(complex(i, 5)) 结果输出如下: (1+0j) (2+1j) (2+5j) (1+5j) (3+5j) (4+5j) (5+5j)
dict() 函数用于创建一个字典。返回一个字典
语法:
class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)
参数说明:
- **kwargs -- 关键字
- mapping -- 元素的容器。
- iterable -- 可迭代对象
>>>dict() # 创建空字典 {} >>> dict(a='a', b='b', t='t') # 传入关键字 {'a': 'a', 'b': 'b', 't': 't'} >>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典 {'three': 3, 'two': 2, 'one': 1} >>>
dir() 返回包含要查询对象的所有属性名称的列表
要查看python某个模块可以干什么,先要导入模块,之后用上面讲过的方式查看就可以。比如要查看sys模块都可以干什么,可以像下边这样操作:
>>> import sys # 获得属性列表,在这里是sys模块的属性列表 >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_compact_freelists','_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable','exit', 'flags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof','gettrace', 'getwindowsversion', 'hexversion', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoptions', 'winver']
divmod(a,b) 方法返回的是a//b(除法取整)以及a对b的余数,返回结果类型为tuple,参数:a,b可以为数字(包括复数)
>>> divmod(9,2) (4, 1) >>> divmod(11,3) (3, 2) >>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)
enumerate()
- enumerate()是python的内置函数
- enumerate在字典上是枚举、列举的意思
- 对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值
- enumerate多用于在for循环中得到计数
- enumerate()返回的是一个enumerate对象,例如:
例:
- 如果对一个列表,既要遍历索引又要遍历元素时,首先可以这样写:
list1 = ["这", "是", "一个", "测试"] for i in range (len(list1)): print i ,list1[i]
- 上述方法有些累赘,利用enumerate()会更加直接和优美:
list1 = ["这", "是", "一个", "测试"] for index, item in enumerate(list1): print index, item >>> 0 这 1 是 2 一个 3 测试
- enumerate还可以接收第二个参数,用于指定索引起始值,如:
list1 = ["这", "是", "一个", "测试"] for index, item in enumerate(list1, 1): print index, item >>> 1 这 2 是 3 一个 4 测试
eval() 将字符串str当成有效的表达式来求值并返回计算结果
语法: eval(source[, globals[, locals]]) -> value
参数:
source:一个Python表达式或函数compile()返回的代码对象
globals:可选。必须是dictionary
locals:可选。任意map对象
可以把list,tuple,dict和string相互转化。 ################################################# 字符串转换成列表 >>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" >>>type(a) <type 'str'> >>> b = eval(a) >>> print b [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]] >>> type(b) <type 'list'> ################################################# 字符串转换成字典 >>> a = "{1: 'a', 2: 'b'}" >>> type(a) <type 'str'> >>> b = eval(a) >>> print b {1: 'a', 2: 'b'} >>> type(b) <type 'dict'> ################################################# 字符串转换成元组 >>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))" >>> type(a) <type 'str'> >>> b = eval(a) >>> print b ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0)) >>> type(b) <type 'tuple'>
exec() 是Python的built-in函数。其作用很好描述,就是执行以string类型存储的Python代码
>>> i = 2 >>> j = 3 >>> exec("ans = i + j") >>> print("Answer is: ", ans) Answer is: 5 >>>
在上个例子里面,ans变量并没有显式的定义,但仍然可以在print函数中调用。这是exec语句执行了"ans = i + j"
中的代码,定义了ans变量。
filter()函数是 Python 内置的另一个有用的高阶函数,filter()函数接收一个函数 f 和一个list,这个函数 f 的作用是对每个元素进行判断,返回 True或 False,filter()根据判断结果自动过滤掉不符合条件的元素,返回由符合条件元素组成的新list。
例如,要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数,保留奇数,首先,要编写一个判断奇数的函数: def is_odd(x): return x % 2 == 1 然后,利用filter()过滤掉偶数: >>>filter(is_odd, [1, 4, 6, 7, 9, 12, 17]) 结果: [1, 7, 9, 17]
float() 函数功能将一个数值或者字符转换成浮点型数值
>>> float(3) 3.0 >>> float('3') 3.0
format() 函数
语法
它通过{}和:来代替%。
“映射”示例
通过位置
In [1]: '{0},{1}'.format('kzc',18) Out[1]: 'kzc,18' In [2]: '{},{}'.format('kzc',18) Out[2]: 'kzc,18' In [3]: '{1},{0},{1}'.format('kzc',18) Out[3]: '18,kzc,18'
字符串的format函数可以接受不限个参数,位置可以不按顺序,可以不用或者用多次,不过2.6不能为空{},2.7才可以。
通过关键字参数
In [5]: '{name},{age}'.format(age=18,name='kzc') Out[5]: 'kzc,18'
通过对象属性
class Person: def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return 'This guy is {self.name},is {self.age} old'.format(self=self)
In [2]: str(Person('kzc',18)) Out[2]: 'This guy is kzc,is 18 old'
通过下标
In [7]: p=['kzc',18] In [8]: '{0[0]},{0[1]}'.format(p) Out[8]: 'kzc,18'
有了这些便捷的“映射”方式,我们就有了偷懒利器。基本的python知识告诉我们,list和tuple可以通过“打散”成普通参数给函数,而dict可以打散成关键字参数给函数(通过和*)。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。
格式限定符
它有着丰富的的“格式限定符”(语法是{}中带:号),比如:
填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐,后面带宽度
:号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充
比如
In [15]: '{:>8}'.format('189') Out[15]: ' 189' In [16]: '{:0>8}'.format('189') Out[16]: '00000189' In [17]: '{:a>8}'.format('189') Out[17]: 'aaaaa189'
精度与类型f
精度常跟类型f一起使用
In [44]: '{:.2f}'.format(321.33345) Out[44]: '321.33'
其中.2表示长度为2的精度,f表示float类型。
其他类型
主要就是进制了,b、d、o、x分别是二进制、十进制、八进制、十六进制。
In [54]: '{:b}'.format(17) Out[54]: '10001' In [55]: '{:d}'.format(17) Out[55]: '17' In [56]: '{:o}'.format(17) Out[56]: '21' In [57]: '{:x}'.format(17) Out[57]: '11'
用,号还能用来做金额的千位分隔符。
In [47]: '{:,}'.format(1234567890) Out[47]: '1,234,567,890'
frozenset() 定义不可变集合,集合不能加也不能减
s1=frozenset({1,2,3,4}) print(type(s1))
globals()查看全局作用域
print(globals())
hash() 返回对象的哈希值,用整数表示。哈希值在字典查找时,可用于快速比较键的值,相等的数值,即使类型不一致,计算的哈希值是一样的
>>> 1.0 == 1 True >>> hash(1.0) >>> hash(1) >>> hash(1.0000)
help() 查看帮助文档
#给函数加文档解释,用到单引号,双引号,三引号 def func(): # ''' # test function # :return: # ''' pass print(help(func))
id() 是python解释器实现的功能,只是反映了变量在内存的地址,但并不是真实的内存地址
x=1
print(id(x))
input() 提供了promat参数,首先将参数值输出到标准的输出,并且不换行。函数读取用户输入的值,将其转换成字符串。
>>> s = input('please input your name:') please input your name:Ain >>> s 'Ain'
int() 将一个数字或base类型的字符串转换成整数
int(3.14) # 3 int(2e2) # 200 int(100, 2) # 出错,base 被赋值后函数只接收字符串 int('23', 16) # 35 int('Pythontab', 8) # 出错,Pythontab不是个8进制数
isinstance()来判断一个对象是否是一个已知的类型
举例: >>> isinstance(1, int) True >>> isinstance(1.0, float) True