【超全面】Python内置函数详解（三）-阿里云开发者社区

【超全面】Python内置函数详解（二）：https://developer.aliyun.com/article/1540493

44、memoryview()

**描述：**memoryview() 函数返回给定参数的内存查看对象(Momory view)。返回由给定实参创建的“内存视图”对象， Python 代码访问一个对象的内部数据，只要该对象支持缓冲区协议而无需进行拷贝

**语法：**memoryview(obj)

**参数：**obj – 对象

案例：

v = memoryview(bytearray("abcefg", 'utf-8'))
v[1]
98
v[-1]
98
 v[1:4]
<memory at 0x0000028B68E26AC8>
v[1:4].tobytes()
b'bce'

45、next()

**描述：**next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的iter() 函数一起使用。

**语法：**next(iterator[, default])

参数：

iterator – 可迭代对象

default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

案例：

it = iter([5,3,4,1])
next(it)
5
 
next(it)
3
 
next(it)
4

46、object()

**描述：**Object类是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类。返回一个没有特征的新对象。object 是所有类的基类。

**语法：**object()

参数：无

案例：无

47、open()

**描述：**open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

**语法：**open(name[, mode[, buffering]])

参数：

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

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

file 对象方法

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

file.readline()：返回一行。

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

for line in f: print（line ）：通过迭代器访问。

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

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

f.seek(偏移量,[起始位置])：用来移动文件指针。

偏移量: 单位为比特，可正可负

起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾

f.close() 关闭文件

案例：

f=open('test.txt',encoding='utf-8')   #打开文件
data=f.read()#文件操作
print(data)
f.close()  #关闭文件

48、pow()

**描述：**pow()方法返回 xy（x的y次方）的值。函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

**语法：**pow(x, y[, z])

参数：

x – 数值表达式。
y – 数值表达式。
z – 数值表达式。
案例：

pow(10, 2)
100

pow(4,3,5)
 4
等价于4**3%5

49、print()

**描述：**打印对象，此函数不解释

语法：

参数：

案例：

50、property()

**描述：**property() 函数的作用是在新式类中返回属性值。

**语法：**class property([fget[, fset[, fdel[, doc]]]])

参数：

fget – 获取属性值的函数

fset – 设置属性值的函数

fdel – 删除属性值函数

doc – 属性描述信息

案例：

暂不解释

51、range()

**描述：**range() 函数可创建一个整数列表，一般用在 for 循环中。

**语法：**range(start, stop[, step])

参数：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

案例：

list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
list(range(1, 11))     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]

for i in range(5):
    print(i)
0
1
2
3

52、reversed()

**描述：**reversed 函数返回一个反转的迭代器。

**语法：**reversed(seq)

**参数：**seq – 要转换的序列，可以是 tuple, string, list 或 range。

案例：

#反转列表
rev = reversed([1,4,2,3,1])
list(rev)
[1, 3, 2, 4, 1]


for i in rev:
    print(i)
1
3
2
4
1 
#反转字符串
rev = reversed('我爱中国')
list(rev)
['国', '中', '爱', '我']

for i in rev:
    print(i)
国
中
爱

53、round()

**描述：**round() 函数返回浮点数x的四舍五入值。

**语法：**round( x [, n] )

参数：

x – 数值表达式。

n --代表小数点后保留几位

案例：

round(10.0222222, 3)
10.022

54、set()

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

**语法：**class set([iterable])

**参数：**iterable – 可迭代对象对象；

案例：
#返回一个set对象，可实现去重：
a = [1,4,2,3,1]
set(a)
{1, 2, 3, 4}

55、slice()

**描述：**slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个表示由 range(start, stop, step) 所指定索引集的 slice对象

语法：

class slice(stop)

class slice(start, stop[, step])

参数：

start – 起始位置

stop – 结束位置

step – 间距

案例：

a = [1,4,2,3,1]
a[slice(0,5,2)] #等价于a[0:5:2]
[1, 2, 1]

56、sorted()

**描述：**sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

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

**语法：**sorted(iterable, key=None, reverse=False)#cmp 3.x已经没有了

参数：

iterable – 可迭代对象。

key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

案例：

a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表
a 
[5, 7, 6, 3, 4, 1, 2]
b
[1, 2, 3, 4, 5, 6, 7]
 
#利用key
L=[('b',2),('a',1),('c',3),('d',4)]


sorted(L, key=lambda x:x[1])  
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

#按年龄排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) 
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
#按降序
sorted(students, key=lambda s: s[2], reverse=True)  
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
 
#降序排列
a = [1,4,2,3,1]
sorted(a,reverse=True) 
[4, 3, 2, 1, 1]

57、staticmethod

**描述：**staticmethod 返回函数的静态方法。该方法不强制要求传递参数，如下声明一个静态方法：

语法：

class C(object):

@staticmethod

def f(arg1, arg2, …):

…

以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。

**参数：**无

案例：

class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

58 、str()

**描述：**返回一个 str版本的 object，str 是内置字符串 class

**语法：**class str(object=’’)

**参数：**object – 对象。

案例：

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

59、sum()

**描述：**sum() 方法对系列进行求和计算。

**语法：**sum(iterable[, start])

参数：

iterable – 可迭代对象，如：列表、元组、集合。

start – 指定相加的参数，如果没有设置这个值，默认为0。

案例：

a = [1,4,2,3,1]
sum(a)
11
 
sum(a,10) #求和的初始值为10
21

60、super（）

**描述：**super() 函数是用于调用父类(超类)的一个方法。super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

**语法：**super(type[, object-or-type])

参数：

type – 类。

object-or-type – 类，一般是 self

案例：

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3
3

61、tuple()

描述： 元组 tuple() 函数将列表转换为元组。

**语法：**tuple( iterable )

**参数：**iterable – 要转换为元组的可迭代序列。

案例：

tuple([1,2,3,4])
(1, 2, 3, 4)
 
tuple({'a':2,'b':4})    #针对字典 会返回字典的key组成的tuple
 ('a', 'b')

62、type()

**描述：**type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法：

type(object)

type(name, bases, dict)

参数：

name – 类的名称。

bases – 基类的元组。

dict – 字典，类内定义的命名空间变量。

案例：

type([2])
list

type({0:'zero'})
dict
x = 1          
type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
class X(object):
    a = 1
X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
X
 __main_

63、zip()

**描述：**zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 ***** 号操作符，可以将元组解压为列表。

**语法：**zip([iterable, …])

**参数：**iterable 一个或多个迭代器

案例：

创建一个聚合了来自每个可迭代对象中的元素的迭代器：
x = [3,2,1]
y = [4,5,6]
list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]

#搭配for循环，数字与字符串组合 
a = range(5)
b = list('abcde')
[str(y) + str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']

list1 = [2,3,4]
list2 = [5,6,7]
for x,y in zip(list1,list2):
    print(x,y,'--',x*y)
2 5 -- 10
3 6 -- 18
4 7 -- 28
#元素个数与最短的列表一致
list(zip(x,b))
 [(3, 'a'), (2, 'b'), (1, 'c')]
#与 zip 相反，zip(* ) 可理解为解压，返回二维矩阵式
a1, a2 = zip(*zip(a,b))          
a1
(0, 1, 2, 3, 4)
a2
('a', 'b', 'c', 'd', 'e'

【超全面】Python内置函数详解（三）

44、memoryview()

45、next()

46、object()

47、open()

48、pow()

49、print()

50、property()

51、range()

52、reversed()

53、round()

54、set()

55、slice()

56、sorted()

57、staticmethod

58 、str()

59、sum()

60、super（）

61、tuple()

62、type()

63、zip()

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【超全面】Python内置函数详解（三）

44、memoryview()

45、next()

46、object()

47、open()

48、pow()

49、print()

50、property()

51、range()

52、reversed()

53、round()

54、set()

55、slice()

56、sorted()

57、staticmethod

58 、str()

59、sum()

60、super（）

61、tuple()

62、type()

63、zip()

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像