Python内建方法 - 中国红客帝国官网-Honker EmPire For China - Powered by H.E.C
网络爱好者的栖息之地,让我们的网络技术更上一层楼!!!

Python内建方法

无法 技术文章

内建方法

说明:[,xxx]表示为可选参数。

abs(x)

返回x的绝对值,例如:

abs(-1.23) # 1.23

all(iterable)

如果iterable(迭代对象)的所有元素为真(或者iterable为空:[],”,()等),返回True。例如:

all('') # True
all([1,2,3,0]) # False

any(iterable)

如果iterable中只要又一个元素为真,就返回True。例如:

any([1,2,3,0]) # True

basestring()

它是str和unicode的超类,不能被调用或者实例化。只能用来测试一个对象是不是str或unicode的实例。例如:

a = u'a'
b = 'b'
isinstance(a, basestring) # True
isinstance(b, basestring) # True

bin()

整数转成二进制字符串

bin(3) # '0b11'

bool()

将一个值转化成布尔值。

bool(1) # True
bool(0) # True
bool('') # False
bool(' ') # True
bool([]) # False

bytearray()

结合memoryview,实现改变str类型对象的值。请移步python内建类型

callable(object)

如果object参数可调用,返回True;否则返回False。对类的调用,返回一个新的实例。对于实例,如果实例有call方法,则该实例也是可以调用的。例如:

class TestCallable(object):
    def __init__(self):
        pass

    def __call__(self):
        pass

callable(TestCallable) # True
callable(TestCallable()) # True

chr(i)

返回一个字符,该字符的ASCII码为整数i。i的取值范围:0 <= x < 255

chr(100) # 'd'
ord('d') # 100

classmethod(functions)

将传入的方法包装成类方法(类方法是指,类不需要实力化就可以直接调用的方法)。
类方法的第一个参数必须为类(约定俗称用cls代表),实例方法的第一个参数必须为实例(约定俗称为self),这两种接收参数的方法叫做:隐式第一参数(implicit first argument)。静态方法(通过@staticmethod装饰的方法)不需要如上述两个方法的隐式参数。

class C(object):
    @classmethod
    def f(cls, arg1, arg2):
        pass

注意:通过@classmethod修饰的方法,为类方法。类可以直接调用(如C.f());实例也可以直接调用(如C().f()),切记类方法中不能操作实例的属性。如果子类调用类方法,子类对象被传递为隐式的第一个参数(也就是cls为子类对象)。

cmp(x, y)

比较两个对象x和y,当x < y返回’-1’;x > y返回’1’;x == y返回0

cmo(1, 3) # -1
cmp(3, 1) # 1
cmp(1, 1) # 0

注意:bool(-1)结果为True

compile(source, filename, mode)

compile可以将字符串或者Unicode字符串编译成代码对象。代码对象可以通过exec或eval执行。

参数source:字符串或者AST(Abstract Syntax Trees)对象。 参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。

参数model:指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。

source ="if cmp(1, 1)==0: print 'yes'"
test_compile = compile(source, '', 'exec')
exec(test_compile)  #yes

注意:source是字符串,要注意引号和双引号,最后指定什么model,就用那种方法执行。compile返回的类型是code。

complex(str)

创建一个复数。

complex('1+2j') #可行
complex('1 + 2j') #报错(因为字符串中'+'或者'-'两遍不能有空白)

delattr(object, name)

参数是一个对象和一个字符串(name为字符串类型),字符串必须是该对象的某个属性名。效果是:删除该对象的name对应的属性。

class Test(object):
    def __init__(self):
        self.name = 'XueWeiHan'
test_delatter = Test()
test_delatter.name # XueWeiHan
delattr(test_delatter, 'name')
test_delatter.name # 报错,没有name属性,删除成功

dict()

创建一个新字典。

dict(a=1) # {'a': 1}

dir(object)

如果没有参数,返回当前本地作用域的名字列表。如果有参数,返回该参数的属性列表(属性和方法)。
如果类中定义了__dir__方法,则dir()会先默认从__dict__属性中收集信息。

import time
type(time)  # model
dir(time)   # ['__doc__','__file__',...,'sleep','strftime',]就是time.可以调用的属性和方法
class TestDir(object):
    def __dir__(self):
        return ['TestDir1', 'TestDir2']
dir(TestDir)  # ['TestDir1', 'TestDir2']

注意:dir()主要是方便交互环境

divmod(a, b)

效果:a除以b,返回商和余数的二元组(两个数组成的元组)

divmod(5, 2)  #(2, 1)

enumerate(sequence, start=0)

返回一个枚举对象。sequence必须是序列,迭代器iterator,或者支持迭代的对象:

迭代器Iterators:
迭代器仅是一容器对象,它实现了迭代器协议。它有两个基本方法:
1)next方法
返回容器的下一个元素
2)__iter__方法
返回迭代器自身

names = ['Xuweihan', 'James', 'Kobe']
enumerate_data = (names, start=0)  #这是个枚举类型数据
list(enumerate_data)  #[(0, 'Xuweihan'), (1, 'James'), (2, 'Kobe')]

list(enumerate(names, 1))  #[(1, 'Xuweihan'), (2, 'James'), (3, 'Kobe')]

# 实现
def enumerate(sequence, start=0):
    n =start
    for elem in sequence:
        yield n, elem
        n += 1

注意:enumerate是生成器,惰性计算。可以调用next()

eval(expression[,globals()[,locals()]])

expression参数被当作python表达式执行。使用globals()和locals()指定执行的代码中变量是全局变量还是本地变量。代码例子如下:

a = 1  #全局变量

def add_one():
    a = 2  #本地变量
    eval('a+1', globals())  #结果为 2
    eval('a+1', locals())  #结果为 3

execfile(filename[,globals[,locals]])

该函数类似exec(上面的那个),不同的是他解析一个文件,而不是字符串。它不同与__import__语句的地方在于,它不使用模块管理——它无条件的读入文件且不会创建一个新模块。
(不常用)

file()

file类型的构造函数。打开一个文件的时候,建议使用open()而不使用file()。file更适合类型检测例如:isinstance(f, file)。

filter(functions, iterable)

构造一个列表,列表的元素来自于iterable,返回对于这些元素function返回True的元素。iterable可以是个序列,支持迭代的容器或者一个迭代器。
filter函数相当于过滤,返回符合functions的列表中的元素。带判断的列表生成式:[i for i in list if i]

test_list = ['python', 'ruby', 'node.js']
result = filter((lambda x: x=='python'), test_list)  #结果:['python']

float()

将字符串或者数字转化成浮点数。

float('.3333')  #0.3333
float('a.333')  #报错
float(1)  #1.0

format(value[,format_spec])

将value转化成“格式化”的表现形式,格式由format_spec控制。

_string = '{name} is a pythoner'.format(name='Xueweihan')
print _string  # 'Xueweihan is a pythoner'

frozenset()

返回一个新的forzenset对象。就是一个不可变的集合,所以存在哈希值,可以作为字典的key。
注意:python的集合类型不支持整数。

getattr(object, name[,default])

返回object的属性值。name必须是个字符串。如果名字指明的属性不存在,则返回default参数。

例如:getattr(x, 'test')等于x.test。

globals()

globals(x),x成为全局变量。

hasattr(object, name)

参数是一个对象和一个字符串。如果对象含有该属性则返回True;否则返回False。

hash(object)

返回对象的hash值。hash值是整数,它被用于字典查找时快速比较字典的键。相同的数值有相同的hash(例如:1和1.0的hash值相同)

help([object])

调用帮助系统(主要用于交互式的使用过程中)。如果没有指定object的话,则进入交互式的help帮助系统。

hex()

将number类型的数据,转化成“0x”打头小写的十六进制字符串:

hex(33)  #'-0x21'

#float类型数据
float.hex(0.32)  #'0x1.47ae147ae147bp-2'

id(object)

返回对象的“表示”,这是一个整数,在对象的生命期内唯一且不变
注意:CPython中:id就是对象的内存地址。

id(33)  # 140300932661128

a = 33
id(a)  # 140300932661128

b = 33
id(b)  # 140300932661128

input()

获取用户的输入。

建议用:raw_input

int(x, base=10)

将数字或字符串x转化成一个整数,如果没有参数则返回0。

isinstance(object, classinfo)

如果参数object是参数classinfo的一个实例;或者是一个子类的实例,最终返回真。

推荐使用这个而不是用type进行判断。

isinstance(1, int)  #True

issubclass(class, classinfo)

如果class是classinfo的子类,则返回真。

iter(o[,sentinel])

返回一个iterator(迭代器)对象。如果没有第二个参数,o必须是个集合独享,要么支持迭代协议参考,要么支持序列协议。例如:

for x in [1, 2, 3]:
    pass

#等同于
it = iter([1, 2, 3])

while True:
    try:
        x = next(it)
    except StopIteration:
        break

如果有第二个参数sentinel,o必须是个可调用对象。使用场景:

# 读取一个文件的行,直到读到特定行
with open('test.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len(s)

返回对象的长度(元素的个数)。s可以是:序列或者集合。

len('xueweihan')  #9

list([iterable])

返回一个列表,其中的元素来自于iterable。iterable可以是个序列,支持迭代的容器,或者迭代器对象。

list('xueweihan')  #['x', 'u', 'e', 'w', 'e', 'i', 'h', 'a', 'n']

locals()

把传入的变量,修饰成局部变量。

long()

将一个字符串或者数字传化成一个长整数。

map()

遍历iterable的每个元素,并把元素作为参数传入function,返回结果的列表。

def add_two(num):
    return num+2
num_list = [1,2,3,4,5]
map(add_two, num_list) #[3,4,5,6,7]

max()

返回可迭代的对象中最大的元素。

memoryview()

返回memoryview对象,它允许Python代码访问对象的内部数据而不用复制,只要该对象支持缓冲区协议。
如有疑问请参考python内建类型memoryview

min()

返回可迭代的对象中的最小的元素。

next(iterator[,default])

通过调用iterator(迭代器)的next()方法,得到它的下一个元素。如果有default参数,在迭代器迭代完之后返回该参数;否则抛出StopIteration。

test_next_data = iter([1,2,3])
print next(test_next_data, 'Done')  #1
print next(test_next_data, 'Done')  #2
print next(test_next_data, 'Done')  #3
print next(test_next_data, 'Done')  #Done

注意:通过iter()返回的就是迭代器。

object()

object是所有新式类的基类

class A(object):
    pass
#继承于object的类为新式类

oct()

将任意一个整数转成一个八进制字符串。

open(name, [,mode[,buffering]])

打开文件的方法,返回一个file类型对象。如果文件不能打开抛出IOError。
mode:用什么方式打开文件。’r’读文件;’w’写文件;’a’附加。如果没有mode,默认是’r’。
buffering: 缓冲

ord()

参考:chr()

注意:如果是unicode,则返回unicode码

pow(x, y[,z])

返回x的y次幂:x**y
如果有z参数:(x**y) % z

print()

这个方法可以输出内容到file对象。
注意:不常用,为了使print语句失效,而是用print()函数。(print和print()不是一个东西)可以在你的模块上面使用future语句:from __future__ import print_function

property()

property其实就是个控制属性的权限的方法。同时实现,经property装饰的方法,可通过Object.xxx调用属性,把实例方法,变成实例的属性。这样做的好处是:可以在方法中实现限制条件,同时限制可执行的操作。

class Student(object):
    def __init__(self):
        self._name = None
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, value):
    if value != 'xueweihan':
        self._name = value
    @name.deleter
    def name(self):
        print 'del name!'
        del self._name
s = Student()
s.name = 'aaa'
s.name  #赋值成功'aaa'
s.name = 'xueweihan'
s.name  #赋值失败'aaa'
del s.name  #‘del name!’

注意:@property可以控制属性,比如只读属性:不实现@xxx.setter和@xxx.deleter就可以了

range(start, stop[,step])

用于创建列表,‘要头不要尾’。setp参数为步长

range(5)  #[0, 1, 2, 3, 4]
range(2, 4)  #[2, 3]
range(10, 20, 5)  #[10, 15]

raw_input()

获取控制台的输入

reduce(function,iterable[,initializer])

将带有两个参数的function累计地应用到iterable的元素上,从左向右。如果提供可选的参数initializer,它在计算时放在可迭代序列的最前面,并且当可迭代序列为空时作为默认值。例如:

reduce((lambda x,y: x+y), [1, 2, 3, 4])
#相当于计算(((1+2)+3)+4)

reload(module)

如果你重新修改了模块,并且不打算停止重新启动python解释器的情况下使用该模块的最新版本。那么就使用reload(),在reload之前就需要确保import过

# test_reload.py
print 'a'

import test_reload  #'a'
#修改test_reload.py ——> print 'b'

import test_reload  #什么都输出,因为没有之前已经import过了,所以没有重新加载

reload(test_reload)  #'b'重新加载成功!

repr(object)

精准的返回某个对象可打印形式的字符串。返回的值,可以通过eval()执行。

a = repr('a')  #"'a'"

reversed(seq)

返回一个反向的迭代器。seq必须是一个具有__reversed__()方法或支持序列协议的对象(实现__len__()和__getitem__()方法)。

test_reverse = reversed([1, 2, 3, 4])  #
test_reverse.next   #4

注意:可以编写一个定制的__reversed__()方法的可能。

round(number[, ndigits])

返回一个浮点数的近似值,保留小数点后ndigits位,默认ndigits为零。这个方法不好用,因为近似值不是四舍五入

round(2.675,2)  #2.67

set([iterable])

返回一个集合对象,iterable是可迭代的对象。

setattr(object,name,value)

给object的属性赋值,可以是存在的属性,也可以是不存的属性。例如:setattr(s, 'name','xueweihan')等同于s.name='xueweihan'

slice()

常用的切片方法:

a = [1, 2, 3]
a[1:2]  #2

sorted(iterable[,cmp[,key[,reverse]]])

用于iterable对象排序的方法。

cmp指定一个自定义的带有两个参数的比较函数(可迭代的元素),它应该根据第一个参数是小于、等于还是大于第二个参数返回负数、零或者正数:cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。 key指定一个带有一个参数的函数,它用于从每个列表元素选择一个比较的关键字:key=str.lower。默认值是None(直接比较元素)。 reverse是一个布尔值。如果设置为True,那么列表元素以反向比较排序。
class Student:
    def __init__(self, name, grade, age):
            self.name = name
            self.grade = grade
            self.age = age
    def __repr__(self):
            return repr((self.name, self.grade, self.age))

student_objects = [
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
]
sorted(student_objects, key=lambda student: student.age)   # sort by age
#结果为:[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

staticmethod(function)

返回一个静态方法。

class C(object):
    @staticmethod
    def f(arg1, arg2):
        pass

注意:静态方法基可以在类上调用C.f(),也可以在实例上调用C().f()。

str(object=”)

返回一个字符串,包含对象的友好可打印表达形式。
注意:print调用的就是对象的__str__方法

sum(iterable[,start])

将iterable的元素从左向右相加并返回总和。

sum([1, 2, 3])  #6
sum([1, 2, 3], 2)  #8

super()

用于显性的指定父类的方法。同时实现方法的绑定。

class C(B):
    def method(self, arg):
        super(C, self).method(arg)  #C的父类实例的method()

tuple([iterable])

返回一个元素,元素顺序和iterable的元素相同。

type(object)

返回object的类型。

type(name, bases, dict)

class X(object):
    a = 1

X = type('X', (object,), dict(a=1))  # 当传入三个参数时,返回一个新的类型对象。

unichr(i)

返回Unicode类型数据i的Unicode码。例如:unichr(97)返回字符串u'a'。

unicode(object=”)

返回object的Unicode版字符串

vars([object])

返回模块,类,实例或者其他任何具有__dict__属性的对象的__dict__属性。(key:value形式的__dict__属性)

xrange(x)

range()方法一样,区别就是它返回的是一个xrange对象而不是一个列表。惰性计算!当x很大的时候,一定要用xrange。

zip([iterable,…])

该函数返回一个元组的列表,其中第i个元素包含每个元素的序列的第i个元素。

x = [1, 2, 3]
y = [4, 5, 6]
#可用于转置矩阵
zipped = zip(x, y)  #[(1, 4), (2, 5), (3, 6)]

x2, y2 = zip(*zipped)
x == list(x2) and y == list(y2)  #True

__import__()
这种高级引入模块的方法,不常用,所以pass

标签: 暂无标签

免责声明:

本站提供的资源,都来自网络,版权争议与本站无关,所有内容及软件的文章仅限用于学习和研究目的。不得将上述内容用于商业或者非法用途,否则,一切后果请用户自负,我们不保证内容的长久可用性,通过使用本站内容随之而来的风险与本站无关,您必须在下载后的24个小时之内,从您的电脑/手机中彻底删除上述内容。如果您喜欢该程序,请支持正版软件,购买注册,得到更好的正版服务。侵删请致信E-mail:22365412@qq.com

同类推荐
评论列表