Python教程034 python内置函数3

open()

用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。如果打开失败，返回OSError异常。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明：
file : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。这个参数是非强制的，默认文件访问模式为只读®。
buffering : 如果 buffering 的值被设为0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

不同模式打开文件的完全列表：
模式|描述 —|:– r模式|以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb模式|以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 r+模式|打开一个文件用于读写。文件指针将会放在文件的开头。 rb+模式|以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 w模式|打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb模式|以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 w+模式|打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb+模式|以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 a模式|打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 ab模式|以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 a+模式|打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 ab+模式|以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file对象方法

file.read([size])
size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回”“(空字串)

file.readline()
返回一行

file.readlines([size])
返回包含size行的列表,size 未指定则返回全部行

f.write(“字符串”)
写入字符串。如果要写入字符串以外的数据,先将他转换为字符串.

f.tell()
返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).

f.seek(偏移量,[起始位置])
用来移动文件指针.
偏移量:单位:比特,可正可负
起始位置:0-文件头,默认值;1-当前位置;2-文件尾

f.close()
关闭文件

ord©

与chr()函数相反，给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode码位的整数。

1
2
3
4


>>>ord('a')
97
>>>ord('€')
8364

pow(x, y[, z ])

求幂函数。对于int操作数，除非第二个参数为负数，否则结果与操作数具有相同的类型；在这种情况下，所有参数都转换为float，并传递float结果。例如，10**2返回100，而10**-2返回0.01。如果第二个参数为负，则必须省略第三个参数。如果存在z，x和y必须是整数类型，y必须是非负的。
pow(x,y) 等同于 x ** y
pow(2,10) —> 1024
pow(x,y,x) 等同于( x ** y) % z
pow(2,10,3) –>1

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

将objects打印到文本流文件中，由sep分隔，后跟end。sep、end、file和flush（如果存在），必须作为关键字参数提供。

property(fget=None, fset=None, fdel=None, doc=None)

返回一个属性。fget是获取属性值的函数。fset是设置属性值的函数。fdel是删除属性值的函数。Doc为属性创建一个DocString。如果制定doc，则doc将是属性的docstring。否则，属性将复制fget的docstring（如果存在）。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class C:
    def __init__(self):
        self._x = None
    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

如果c是C的实例，c.x将调用getter，c.x=value将调用setter，del c.x将调用deleter。

利用@语法糖，另一种写法。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class C:
    def __init__(self):
        self._x = None
    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x
    @x.setter
    def x(self, value):
        self._x = value
    @x.deleter
    def x(self):
        del self._x

range()

返回的是一个可迭代对象（类型是对象），而不是列表类型。
函数语法

1
2


range(stop)  
range(start, stop[, step])

参数说明：
start: 计数从start开始。默认是从0开始。
stop: 计数到stop结束，但不包括stop。
step: 步长，默认为1。

例如：

1
2
3
4


>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(0))
[]

repr(object)

将对象转化为供解释器读取的形式。

reversed(seq)

翻转函数,将序列倒序。返回的并不是原来的序列，会生成新的对象，根据需要转换。

例如：

1
2
3


a = [2,3,4,1,4,5]
print(reversed(a))       # list_reverseiterator object at 0x102268cc0>
print(list(reversed(a))) # [5,4,1,4,3,2]

round(number[, ndigits])

四舍五入。省略ndigits参数，则四舍五入到最接近的整数。

例如：

1
2
3
4


>>> round(1.556,2)
1.56
>>> round(1.556)
2

set([iterable])

创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

例如：

1
2
3
4


>>>x = set('runoob')
>>>y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除

setattr(object, name, value)

设置对象的属性。
setattr(x, 'foobar', 123) 相当于 x.foobar = 123。

slice()

实现切片对象，主要用在切片操作函数里的参数传递，返回一个切片对象。
slice语法：

1
2


slice(stop)  
slice(start, stop[, step])

参数说明：
start – 起始位置，默认值None
stop – 结束位置
step – 间距，默认值None

例如：

1
2
3
4
5
6
7
8


>>>myslice = slice(5) #设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] #截取 5 个元素
[0, 1, 2, 3, 4]

sorted()

请参照Python基础教程031 高阶函数)

sort与sorted区别

sort是应用在list上的方法，sorted可以对所有可迭代的对象进行排序操作。list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作。

staticmethod()

声明类的静态方法。

str()

将对象转化为适于人阅读的形式。

例如：

1
2
3
4
5
6


>>>s = 'abc'
>>> str(s)
'abc'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

sum(iterable[, start])

对系列进行求和计算。
iterable – 可迭代对象，如：列表、元组、集合。
start – 指定相加的参数，如果没有设置这个值，默认为0。

例如：

1
2
3
4


>>> sum((2, 3, 4), 0)   # 元组计算总和后再加0
9
>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加2
12

tuple([iterable])

将可迭代对象转换为元组。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


st = "Hello"
b = "World"
l =[1,2,3,4]
se = {1,2,3,4}
d = {1:"a", 2:"b", 3:"c", 4:"d"} #字典只转换key
print(tuple(st))
print(tuple(b))
print(tuple(l))
print(tuple(se))
print(tuple(d))

执行以上程序会输出如下结果：

1
2
3
4
5


('H', 'e', 'l', 'l', 'o')
('W', 'o', 'r', 'l', 'd')
(1, 2, 3, 4)
(1, 2, 3, 4)
(1, 2, 3, 4)

type(object)

返回一个对象的类型,返回值与object.class一样。

例如：

1
2
3
4
5
6


class X:
    a = 1

a = X()
print(type(a))
print(a.__class__)

执行以上程序会输出如下结果：

1
2


<class '__main__.X'>
<class '__main__.X'>

type(name, bases, dict)

生成一个类。使用三个参数，返回一个新的类型对象。这是动态声明类的方式。name是类名，成为name属性；bases元组逐个列出基类，成为bases属性；dict是包含类体定义的命名空间，成为dict属性。

例如，以下两个语句创建相同的类型对象：

1
2
3
4


class X:
    a = 1

X = type('X', (object,), dict(a=1))

vars([object])

本函数是实现返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。

例如：

1
2
3
4
5
6
7
8
9


>>> class ob:
...     i = 1
>>> vars(ob)
{'__module__': '__main__', 'i': 1, '__dict__': <attribute '__dict__' of 'ob' objects>, '__weakref__': <attribute '__weakref__' of 'ob' objects>, '__doc__': None}
>>> ob.__dict__
{'__module__': '__main__', 'i': 1, '__dict__': <attribute '__dict__' of 'ob' objects>, '__weakref__': <attribute '__weakref__' of 'ob' objects>, '__doc__': None}
>>> a = ob()
>>> vars(a)
{}

zip(*iterables)

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。我们可以使用list()转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。

例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped) # list()转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) #元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
zz=zip(a,b)
>>> a1, a2 = zip(*zz) #与zip相反，*zip可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

import(name, globals=None, locals=None, fromlist=(), level=0)

用于动态加载类和函数。这是一个高级函数，与importlib.import_module()不同，在日常的Python编程中不需要它。

转载请注明本网址。

文章目录