Python 内置函数详解2

我会带着你远行 2022-10-29 07:45 22阅读 0赞

### 文章目录 ###

*   *  hex 函数
     *  id 函数
     *  input 函数
     *  int 函数
     *  isinstance 函数
     *  issubclass 函数
     *  iter 函数
     *  len 函数
     *  list 方法
     *  locals 函数
     *  long 函数
     *  map 函数
     *  max 方法
     *  memoryview 函数
     *  min 方法
     *  next 函数
     *  oct 函数
     *  open 函数
     *  ord 函数
     *  pow 函数
     *  print 函数
     *  property 函数
     *  range 函数
     *  reduce 函数
     *  reload 函数

## hex 函数 ##

功能：用于将10进制整数转换成16进制，以字符串形式表示

> 语法：hex(x) x 为 10 进制整数

返回值：返回16进制数，以字符串形式表示

o1 = hex(255) #'0xff'
    print(o1)
    
    o2 = hex(-42) #'-0x2a'
    print(o2)
    
    o3 = hex(1)  # '0x1'
    print(o3)
    
    o4 = hex(12)  # '0xc'
    print(o4)
    
    o6 = type(hex(12))  #<class 'str'> # 字符串
    print(o6)

## id 函数 ##

id() 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址

> 语法 : id(\[object\]) object 对象

返回值：返回对象内存的地址

实例

a = 1
    print(id(a))        #140706105946368
    print(hex(id(a)))   #0x7ff8b1767100

## input 函数 ##

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型

Python2.x 中 input() 相等于 eval(raw\_input(prompt)) ，用来获取控制台的输入

raw\_input() 将所有输入作为字符串看待，返回字符串类型。

而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（int, float)

> 注意：input() 和 raw\_input() 这两个函数均能接收 字符串 ，但 raw\_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw\_input() 来与用户交互。  
> **python3 里 input() 默认接收到的是 str 类型，如果使用其它类型需要转换**

语法：input(\[prompt\]) prompt: 提示信息

在Python2.x中 raw\_input（）和input（），两个函数都存在，  
区别：

1.  raw\_input（）将所有输入作为字符串看待，返回字符串类型。
2.  input（）只能接收“数字”的输入，在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（int，float）

在Python3.x中，raw\_input（）和input（）进行了合并，删除了raw\_input（），仅保留了input（）函数，其接收任意任性输入，将所有输入替换为字符串处理，并返回字符串类型

## int 函数 ##

功能：用于将一个字符串或数字转换为整型

语法：class int(x, base=10)

参数：x 为字符串或数字，base 为进制数，默认十进制

返回值：返回整形数据

以下展示了使用 int() 方法的实例：

int()               # 不传入参数时，得到结果0
    int(3)              # 3
    int(3.6)            # 3
    int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18
    int('0xa',16)       # 10
    int('10',8)         # 8

总结：

*  若 x 为纯数字，则不能有 base 参数，否则报错；其作用为对入参 x 取整
 *  若 x 为 str，则 base 可略可有，base 存在时，视 x 为 base 类型数字，并将其转换为 10 进制数字。

若 x 不符合 base 规则，则报错。如

int("9",2)  #报错，因为2进制无9
    int("9") #9 #默认10进制
    
    int("3.14",8)
    int("1.2")
    #均报错，str须为整数
    
    int("1001",2) #9 
    # "1001"才是2进制格式，并转化为十进制数字9
    
    int("0xa",16) #10
    # ≥16进制才会允许入参为a,b,c...
    
    int("b",8) #报错
    
    int("123",8) #83
    #视123为8进制数字，对应的10进制为83

## isinstance 函数 ##

功能：判断一个对象是否是一个已知的类型，类似 type()

isinstance() 与 type() 区别：

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

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

语法： isinstance(object, classinfo)

参数：  
object - - - - - 实例对象  
classinfo - - - - - 可以是 int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False

实例1：

a = 2
    isinstance (a,int)  #True
    
    isinstance (a,str)  # False
    
    isinstance (a,(str,int,list))    # 是元组中的一个返回 True

实例2：

class A:
        pass
    class B(A):
        pass
        
    flag1 = isinstance(A(), A)  # returns True
    print(flag1)
    
    flag2 = (type(A()) == A)  # returns True
    print(flag2)
    
    flag3 = isinstance(B(), A)  # returns True
    print(flag3)
    
    flag4 = (type(B()) == A)  # returns False
    print(flag4)

## issubclass 函数 ##

功能：用于判断参数 class 是否是类型参数 classinfo 的子类

语法：issubclass(class, classinfo)

class - - - - - - - - 类  
classinfo - - - - - -类

返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False

实例：

class A:
        pass
    class B(A):
        pass
        
    print(issubclass(B,A))    # 返回 True

## iter 函数 ##

功能：用来生成迭代器

语法：iter(object\[, sentinel\])

参数：  
object – 支持迭代的集合对象  
sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的\_\_next\_\_()方法时，都会调用 object

返回值：迭代器对象

实例

lst = [1, 2, 3]
    for i in iter(lst):
        print(i)

## len 函数 ##

功能：方法返回对象（字符、列表、元组等）长度或项目个数

语法：len( s ) s对象

返回值：返回对象的长度

实例：

str = "runoob"
    len(str)             # 字符串长度 6
    
    l = [1,2,3,4,5]
    len(l)               # 列表元素个数 5

## list 方法 ##

功能：用于将元组转换为列表

提示：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中

语法：list( tup ) tup - - - - 要转换为列表的元组

返回值：返回列表

实例：

aTuple = (123, 'runoob', 'google', 'abc')
    aList = list(aTuple)
    
    print("列表元素 : ",aList)
    #列表元素 : [123, 'runoob', 'google', 'abc']

## locals 函数 ##

功能：会以字典类型返回当前位置的全部局部变量，对于函数, 方法, lambda 函式, 类, 以及实现了\_\_call\_\_ 方法的类实例, 它都返回 True

语法： locals()

参数：无

返回值：返回字典类型的局部变量

实例：

def runoob(arg):    # 两个局部变量：arg、z
        z = 1
        print (locals())
    runoob(4) # {'z': 1, 'arg': 4} # 返回一个名字/值对的字典

## long 函数 ##

功能：将数字或字符串转换为一个长整型

提示：Python3.x 版本已删除 long() 函数

语法：class long(x, base=10)

参数：  
x - - - - - - - 字符串或数字  
base - - - - -可选，进制数，默认十进制

返回值：返回长整型数

实例

long()      # 0L
    long(1)     # 1L
    long('123') # 123L

## map 函数 ##

功能：会根据提供的函数对指定序列做映射

提示：第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

语法：map(function, iterable, …)

参数：  
function - - - - - - 函数  
iterable - - - - - - - 一个或多个序列

返回值：Python 2.x 返回列表，Python 3.x 返回迭代器

实例1：python2.x

def square(x) :            # 计算平方数
        return x ** 2
    
    list1 = map(square, [1,2,3,4,5])   # 计算列表各个元素的平方 [1, 4, 9, 16, 25]
    print(list1))#直接返回列表，不需要转换
    
    list2 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数 [1, 4, 9, 16, 25]
    print(list2)
    
    # 提供了两个列表，对相同位置的列表数据进行相加
    list3 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) # [3, 7, 11, 15, 19]
    print(list3)

实例2：python3.x 返回的是迭代器，需要转换为 list 形式

def square(x) :         # 计算平方数
        return x ** 2
    map(square, [1,2,3,4,5])    # 计算列表各个元素的平方 <map object at 0x100d3d550> # 返回迭代器
    
    list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表 [1, 4, 9, 16, 25]
    list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数 [1, 4, 9, 16, 25]

## max 方法 ##

功能：返回给定参数的最大值，参数可以为序列

语法: max( x, y, z, … ) 参数为表达式

返回值：返回给定参数的最大值

## memoryview 函数 ##

功能：返回给定参数的内存查看对象(memory view)

提示：所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问

语法：memoryview(obj) obj - - - - 对象

返回值：返回元组列表

实例1：python 2.x

v = memoryview('abcefg')
    v[1]  #'b'
    v[-1] #'g'
    v[1:4] #<memory at 0x77ab28>
    v[1:4].tobytes() #'bce'

实例2：python 3.x

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

## min 方法 ##

语法和返回值和 max 相反

## next 函数 ##

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

语法：next(iterable\[, default\])

参数说明：  
iterable - - - - - 可迭代对象  
default - - - - - 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常

返回值：返回下一个项目

实例1：

# 首先获得 Iterator对象:
    it = iter([1, 2, 3, 4, 5])
    # 循环:
    while True:
        try:
            # 获得下一个值:
            x = next(it)
            print(x)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break

实例2：

it = iter([1, 2, 5, 4, 3])
    while True:
        x = next(it, 'a')
        if x == 'a':
            break
        print(x)

## oct 函数 ##

功能：将一个整数转换成 8 进制字符串

提示：  
Python2.x 版本的 8 进制以 0 作为前缀表示  
Python3.x 版本的 8 进制以 0o 作为前缀表示

语法：oct(x) x- - - 整数

返回值：返回 8 进制字符串

实例1：python2.x

oct(10)  # '012'
    oct(20)  # '024'
    oct(15)  # '017'

实例2：python3.x

oct(10)  #'0o12'
    oct(20)  #'0o24'
    oct(15)  #'0o17'

## open 函数 ##

功能：用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写

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

参数

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

## ord 函数 ##

功能：ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常

语法：ord© c 为字符

返回值：对应的十进制数

实例

ord('a') # 97
    ord('b') # 98

## pow 函数 ##

功能：方法返回 xy（x 的 y 次方） 的值

语法:

import math
    math.pow( x, y )

内置的 pow() 方法: pow(x, y\[, z\])

函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) % z

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float

参数：参数都为数值表达式

import math   # 导入 math 模块
    print "math.pow(100, 2) : ", math.pow(100, 2)
    # 使用内置，查看输出结果区别
    print "pow(100, 2) : ", pow(100, 2) 
    print "math.pow(100, -2) : ", math.pow(100, -2)
    print "math.pow(2, 4) : ", math.pow(2, 4)
    print "math.pow(3, 0) : ", math.pow(3, 0)

运行结果为：

math.pow(100, 2) :  10000.0
    pow(100, 2) :  10000
    math.pow(100, -2) :  0.0001
    math.pow(2, 4) :  16.0
    math.pow(3, 0) :  1.0

## print 函数 ##

功能：print() 方法用于打印输出，最常见的一个函数，在 Python3.3 版增加了 flush 关键字参数

提示：print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字

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

参数：

*  objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔
 *  sep – 用来间隔多个对象，默认值是一个空格
 *  end – 用来设定以什么结尾。默认值是换行符 \\n，我们可以换成其他字符串
 *  file – 要写入的文件对象
 *  flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新

返回值：无

实例1：

print(1)            # 1
    print("Hello World")# Hello World
    
    a = 1
    b = 'runoob'
    print(a, b)         # 1 runoob
    
    print("aaa""bbb")   #aaabbb
    print("aaa", "bbb") #aaa bbb
    print("www", "runoob", "com", sep=".")  # 设置间隔符 www.runoob.com

实例2：

import time
    print("---RUNOOB EXAMPLE ： Loading 效果---")
    print("Loading",end = "")
    for i in range(20):
        print(".",end = '',flush = True)
        time.sleep(0.5)

实例3：

import time
    scale = 50
    print("starting".center(scale//2,"-"))
    start = time.perf_counter()
    for i in range(scale+1):
        a = '*'*i
        c = (i/scale)*100
        dur = time.perf_counter()-start
        print("\r[{}]{:^3.0f}% 用时:{:.2f}s".format(a,c,dur),end="")
        time.sleep(0.2)
    print("\n"+"ending".center(scale//2,'-'))

## property 函数 ##

功能：在新式类中返回属性值

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

参数

*  fget - - - - 获取属性值的函数
 *  fset - - - - 设置属性值的函数
 *  fdel - - - - 删除属性值函数
 *  doc - - - - 属性描述信息

返回值：返回新式类属性

实例：

class C(object):
        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

如果给定 doc 参数，其将成为这个属性值的 docstring，否则 property 函数就会复制 fget 函数的 docstring（如果有的话）

将 property 函数用作装饰器可以很方便的创建只读属性：

class Parrot(object):
        def __init__(self):
            self._voltage = 100000
     
        @property
        def voltage(self):
            """Get the current voltage."""
            return self._voltage

上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法

property 的 getter,setter 和 deleter 方法同样可以用作装饰器：

class C(object):
        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 函数 ##

功能：python2.x range() 函数可创建一个整数列表，一般用在 for 循环中

注意：Python3 range() 返回的是一个可迭代对象(类型是对象)而不是列表类型， 所以打印的时候不会打印列表

语法：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)

实例

range(10)           # 从 0 开始到 10 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    range(1, 11)        # 从 1 开始到 11 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    range(0, 30, 5)     # 步长为 5 [0, 5, 10, 15, 20, 25]
    range(0, 10, 3)     # 步长为 3 [0, 3, 6, 9]
    range(0, -10, -1)   # 负数 [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
    range(0)            # []
    range(1, 0)         # []
    
    x = 'runoob'
    for i in range(len(x)) :
        print(x[i])
    ''' r u n o o b '''

实例2：

ran = type(range(10))
    print(ran) #<class 'range'>
    
    # 所以，不是列表，但是可以利用 list 函数返回列表，即：
    print(list(range(10))) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

实例3：

print([i for i in range(10)])
    # 用来做计算
    print([x*x for x in range(2,8)])

实例4：

# 两层循环,生成全排列的list
    print(type([m + n for m in 'ABC' for n in 'XYZ'])) # <class 'list'>
    print([m + n for m in 'ABC' for n in 'XYZ'])       #['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'] 
    
    # 这种方式生成单个strfor m in 'ABC':
    for n in 'XYZ':
       for m in 'ABC':
          print(type(m + n))
          print(m + n)

实例 5：

# 列出指定目录下的所有文件和目录
    import os
    print([d for d in os.listdir('E:/IT_information')])

实例 6：range 生成的列表，列表中的元素相互独立，即地址各不相同，这与 \* 号重复列表生成的列表大相径庭，前者类似深拷贝，后者则纯粹是浅拷贝

a = [0] * 3
    print(u'这是浅拷贝')
    for num in a:
       print(id(num))
    b = range(3)
    print(u'这是深拷贝')
    for num in b:
       print(id(num))

这是浅拷贝
    140728590561504
    140728590561504
    140728590561504
    这是深拷贝
    140728590561504
    140728590561536
    140728590561568

## reduce 函数 ##

功能：reduce() 函数会对参数序列中元素进行累积

函数将一个数据集合(链表，元组等)中的所有数据进行下列操作：用传给 reduce 中的函数 function (有两个参数)先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果

> 注意：Python3.x reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：from functools import reduce

语法：reduce(function, iterable\[, initializer\])

function - - - - - 函数，有两个参数  
iterable - - - - - 可迭代对象  
initializer - - - - 可选，初始参数

返回值：返回函数计算结果

实例：

from functools import reduce
    def add(x, y):  # 两数相加
       return x + y
    
    sum1 = reduce(add, [1, 2, 3, 4, 5])  # 计算列表和：1+2+3+4+5
    sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
    print(sum1)
    print(sum2)

实例 2:统计某字符串出现次数

from functools import reduce
    '''方法一'''
    sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. ']
    word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
    print(word_count)
    
    
    '''方法二'''
    sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. ']
    print(sentences[0].count('learning'))

实例3：反转字符串

str1="hello"
    print(reduce(lambda x,y:y+x,str1))
    # 输出 olleh

## reload 函数 ##

功能：用于重新载入之前载入的模块

> 语法： reload(module) module - - - 模块对象

返回值：返回模块对象

实例：

import sys
    from imp import reload
    sy1 = sys.getdefaultencoding()      #查看当前默认编码 'utf-8'
    sys.setdefaultencoding('ascii')     # 设置编码