python3 内置函数（五）

bytes函数

描述：bytes函数返回一个新的bytes对象，该对象是一个区间[0,256]内的整数不可变序列

语法：class bytes([source[, encoding[, errors]]])

参数：

如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

返回值：返回一个新的bytes对象

python3中实例：

a = bytes([1,2,3,4])
print(a)        #b'\x01\x02\x03\x04'
print(type(a))      #<class 'bytes'> 

b = bytes('hello','ascii')
print(b)        #b'hello'
print(type(b))      #<class 'bytes'>

float()函数

描述：float()函数用于将整数和字符串转换成浮点数

语法：class float([x])

参数：x--整数或浮点数

返回值：返回浮点数

python3中实例：

a = float(1)           #1.0
b = float(120.0)       # 120.0
c = float(-120.1)      #-120.0
d = float('123')       # '123'字符串 123.0

print(a,b,c,d)

iter()函数

描述：iter()函数用来生成迭代器

语法：iter(object[, sentinel])

参数：object--支持迭代的集合对象

sentinel--如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

返回值：迭代器对象

python3中实例：

lst = [1,23,4]
for i in iter(lst):
    print(i)

# 运行结果：    
# 1
# 23
# 4

print()函数

描述：print()方法用来打印输出，最常见的一个函数

语法：print(*object, sep=' ' , end='\n' , file=sys.stdout)

参数：

objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。

返回值：无

python3中实例：

print("hello world")
# hello world

print("aaa""bbb")       
print("aaa","bbb")
# aaabbb
# aaa bbb

print("www","runoob","com",sep=".")  # 设置间隔符
# www.runoob.com

tuple函数

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

语法：tuple( seq )

参数：seq--要转换为元组的序列

返回值：返回元组

python3中实例：

list1 = ['Google','Taobao','Baidu']
tuple1 = tuple(list1)
print(tuple1)   
# ('Google', 'Taobao', 'Baidu')

callable()函数

描述：callable()函数用来检查一个对象是否是可以调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象object绝对不会调用成功

语法：callable(object)

参数：object--对象

返回值：可调用返回True，否则返回False

python3中实例：

P = callable(0)     #False
L = callable('taobao')     #False
print(P,L)

def add(a,b):
    return a + b
M = callable(add)
print(M)        #True

class A:
    def method(self):
        return 0
N = callable(A)
a = A()
K = callable(a)       # 没有实现 __call__, 返回 False
print(N,K)      #True False

class B:
    def __call__(self, *args, **kwargs):
        return 0
O = callable(B)
b=B()
J = callable(b)      # 实现 __call__, 返回 True

print(O,J)        #True True

format 格式化函数

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

python3中实例：

a = "{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
b = "{0} {1}".format("hello", "world")  # 设置指定位置
c = "{1} {0} {1}".format("hello", "world")  # 设置指定位置
print(a,b,c)
# 运行结果：
# hello world
# hello world
# world hello world

property()函数

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

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

参数：

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

返回值：返回新式类属性

python3实例：

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

chr()函数

描述：chr()用一个范围在(0~255)的整数作参数，返回一个对应的字符

语法：chr(I)

参数：i--可以是10进制也可以是16进制的数字

返回值：返回对应整数的ASCII字符

python3中实例

print("chr(0x30), chr(0x31), chr(0x61)")    # 十六进制
# 返回值chr(0x30), chr(0x31), chr(0x61)

print("chr(48), chr(49), chr(97)")          # 十进制
# 返回值chr(0x30), chr(0x31), chr(0x61)

frozenset()函数

描述：frozenset()返回一个冻结的集合，冻结集合不能添加或删除任何元素

语法：class frozenset([iterable])

参数：iterable--可迭代对象

返回值：返回新的frozenset对象，如果不添加参数，默认生成空集合

python3中实例：

a = frozenset(range(10))    # 生成一个新的不可变集合
print(a)
# 返回值frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

frozenset([0,1,2,3,4,5,6,7,8,9])
b = frozenset('taobao')
print(b)
# 返回值frozenset({'b', 'o', 't', 'a'})

vars()函数

描述：vars()函数返回对象object的属性和属性值的字典对象

语法：vars([object])

参数：object--对象

返回值：返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似 locals()。

python3中实例：

print(vars())
# 返回值{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': 
# <_frozen_importlib_external.SourceFileLoader object at 0x00000211465CC0F0>, '__spec__': None,
#  '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
# '__file__': 'D:/py mysql/venv/pymyql 1/neizhiduixiang.py', '__cached__': None}

class Taobao:
    a = 1
print(vars(Taobao))
# 返回值{'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'Taobao' objects>,
#  '__weakref__': <attribute '__weakref__' of 'Taobao' objects>, '__doc__': None}

taobao = Taobao()
print(vars(taobao))
# 返回值{}

classmethod修饰符

描述：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

语法：classmethod

参数：无

返回值：返回函数的类方法

python3中实例：

class A(object):
    bar = 1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()       # 调用 foo 方法

A.func2()           # 不需要实例化
# 运行结果：
# func2
# 1
# foo

getattr()函数

描述：getattr()函数用于返回一个对象属性值

语法：getattr(object, name[, default])

参数：object--对象

name--字符串，对象属性

default--默认返回值，如果不提供该参数，没有对应属性时，将触发AttibuterError

返回值：返回对象属性值

python3中实例：

class A(object):
    bar = 1
a = A()
c = getattr(a,'bar')        # 获取属性 bar 值
d = getattr(a,'bar2')        # 属性 bar2 不存在，触发异常
e = getattr(a,'bar2',3)     # 属性 bar2 不存在，但设置了默认值
print(c,d,e)
# 运行结果：
# 1
# AttributeError: 'A' object has no attribute 'bar2'
# 3

local()函数

描述：local()函数会以字典类型返回当前位置的全部局部变量

对于函数，方法，lambda函式，类，以及实现了__call__方法的类实例，它都返回True

语法：local()

参数：无

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

pytho3中实例：

def taobao(arg):     # 两个局部变量：arg、z
    a = 1
    print(locals())

taobao(4)    # 返回一个名字/值对的字典
# 运行结果 {'a': 1, 'arg': 4}

repr()函数

描述：repr()函数将对象转化为供解释器读取的形式

语法：repr(object)

参数：object--对象

返回值：返回一个对象的string格式

python3中实例：

s = 'taobao'
a = repr(s)
print(a)
# 执行结果'taobao'
dict = {'tao':'taobao.com','baidu':'baidu.com'}
b = repr(dict)
print(b)
# 执行结果{'tao': 'taobao.com', 'baidu': 'baidu.com'}

zip()函数

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

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

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

语法：zip([iterable, ....])

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

返回值：返回一个对象

python3中实例：

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) #返回一个对象
print(zipped)
# 执行结果<zip object at 0x000001AB6AA79688>
A = list(zipped)  # list() 转换为列表
B = list(zip(a,c)) # 元素个数与最短的列表一致
print(A,B)
# 执行结果：
# [(1, 4), (2, 5), (3, 6)]
# [(1, 4), (2, 5), (3, 6)]

a1, a2 = zip(*zip(a,b))  # 与 zip 相反，*zip 可理解为解压，返回二维矩阵式
C = list(a1)
D = list(a2)
print(C,D)
# 执行结果：
# [1, 2, 3]
# [4, 5, 6]