[Python基础]四、Python内置函数

[Python基础]Python内置函数

一、强制类型转换

int(x,base=10) : 将一个字符串或数字转换为整型。
float([x]) : 将整数和字符串转换成浮点数。
str(object='') : 返回一个对象的string格式。
bool([x]) : 转换为布尔类型。如果没有参数，返回 False。bool 是 int 的子类。
bytes([source[, encoding[, errors]]]): 返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。
list( seq ) : 将元组或字符串转换为列表。
iter(object[, sentinel])： 用来生成迭代器，返回一个可迭代的对象。object是支持迭代的集合对象。
dict() : 创建一个字典。
enumerate(sequence, [start=0]) : 将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，start指下标起始位置，一般用在 for 循环当中，返回一个枚举对象。
tuple( seq ) : 将列表转换为元组。
set(iterable) : 创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

int()函数参数

若 x 为纯数字，则不能有 base 参数，否则报错；其作用为对入参 x 取整

>>> int(2.5)
2
>>> int(-11.123)
-11

若 x 为 str，则 base 可略可有。默认10进制。base 存在时，视 x 为 base 类型数字，并将其转换为 10 进制数字。若 x 不符合base 规则，则报错。str须为整数，否则也会报错

>>>int("9",2)  #报错，因为2进制无9
>>> int("1.2")  #报错，str须为整数
>>>int("1001",2)
9

bytes()函数参数

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

>>> a = bytes(5)
>>> a
b'\x00\x00\x00\x00\x00'
>>> a = bytes('hello','ascii')
>>> a
b'hello'
>>> a = bytes([1,2,3,4])
>>> a
b'\x01\x02\x03\x04'
>>> a = bytes(range(50,60))
>>> a
b'23456789:;'
>>> a = bytes()
>>> a
b''

转换 int 为 bytes

bytes() 方法
struct.pack() 方法
int.to_bytes() 方法

定义python3字节序列类型bytes的三种方法

bytes([100,123,111])#0<=[ ]<256
bytes('Hello','utf-8')#第二个编码类型必须制定，没有默认
'Hello'.encode('utf-8')#编码方式可以改变，也可以省略，默认utf-8

iter()的用法

#判断一个对象是否可迭代
from collections import Iterable
isinstance(object,Iterable)

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

class data:
    list: list = [1, 2, 3, 4, 5, 6]
    index = 0
    def __call__(self, *args, **kwargs):
        item = self.list[self.index]
        self.index += 1
        return item
    def __iter__(self):
        self.i = iter(self.list)
        return self.i        
for item in iter(data(), 3):  #每一次迭代都会调用一次__call__方法,当__call__的返回值等于3是停止迭代
    print(item)

创建字典的方式

#1.创建空字典
>>> dic = {}
>>> dic = dict()
#2.直接赋值创建
>>> dic = {'spam':1, 'egg':2, 'bar':3}
#3.通过关键字dict和关键字参数创建
>>> dic = dict(spam = 1, egg = 2, bar =3)
#4.通过二元组列表创建
>>> list = [('spam', 1), ('egg', 2), ('bar', 3)] # 可迭代对象方式来构造字典
>>> dic = dict(list)
#5.dict和zip结合创建
>>> dic = dict(zip('abc', [1, 2, 3])) # 映射函数方式来构造字典
{'a': 1, 'b': 2, 'c': 3}
#6.通过字典推导式创建
>>> dic = {i:2*i for i in range(3)}
#7.通过dict.fromkeys()创建
>>> dic = dict.fromkeys(range(3), 'x')
#8.其他
>>> list = ['x', 1, 'y', 2, 'z', 3]
>>> dic = dict(zip(list[::2], list[1::2]))

二、输入输出

input([prompt]) ：接受一个标准输入数据，返回为 string 类型。

在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

>>> a=input() # 输入3
>>> a*2
33
>>> a=int(input())  #输入3
>>> a*2
6

print()

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) ：打印输出。

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

%运算符就是用来格式化字符串的。有几个%?占位符，后面就跟几个变量或者值，顺序要一一对应。如果只有一个%?，括号可以省略。
使用 repr() 或 str() 函数来实现将输出的值转成字符串。

>>> s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob' #str()：函数返回一个用户易读的表达形式。
>>> repr(s)
"'Hello, Runoob'"  #repr()：产生一个解释器易读的表达形式。
#  repr() 函数可以转义字符串中的特殊字符
>>> hello = 'hello, runoob\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoob\n'
# repr() 的参数可以是 Python 的任何对象
>>> repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"

python字符串格式化符号:

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
n1.n2	n1 表示显示的最小总宽度，小数点也算一位,若超出，则原样输出;n2 表示小数点后的位数
-	用做左对齐
+	在正数前面显示加号( + )
#	八进制数前显示 0o ，在十六进制前面显示’0x’或者’0X’(取决于用的是x还是X)
0	用于填充空格
(var)	映射变量(用于处理字典参数)
<sp>	在正数前面显示空格
%	%%输出一个单一的%

print("%6.3f" % 3.1) # 3.100
print("%7.3e" % 314.159265) #3.142e+02
				      #000000
print("%-6.2f" % 3.1) #3.10 
print("%+6.2f" % 3.1) # +3.10
print("%6.2f" % 3.1)  #  3.10

print("%x" % 100)    #64    
print("%#x" % 100)   #0x64    
print("%#X" % 100)   #0X64   
print("%#o" % 100)   #0o144
				 #00000
print("%5d" % 3) #    3
print("%05d" % 3)#00003

students = [{"name":"Wilber", "age":27}, {"name":"Will", "age":28}]
for student in students:
    print ("%(name)s is %(age)d years old" %student)  #Wilber is 27 years old  \n  Will is 28 years old
  

format()

通过{}和:来代替传统%方式。

#设置数字顺序指定格式化的位置，如果不设置指定位置，则按默认顺序
print('I {1} {0} {1}, and I\'am learning'.format('like', 'Python'))#I Python like Python, and I'am learning
#设置关键字指定格式化的内容
print('I {l} {p}, and I\'am learning'.format(p='Python', l='like'))#I like Python, and I'am learning
#利用元组传参，传参形式 *tuple
T = 'like', 'Python'
print('I {} {}, and I\'am learning'.format(*T))#I like Python, and I'am learning
print('I {0} {1}, and I\'am learning'.format(*T))#I like Python, and I'am learning
#字典传参
D = {'l':'like', 'p':'Python'}
print('I {l} {p}, and I\'am learning'.format(**D))#I like Python, and I'am learning
#列表传参
L0 = ['like', 'Python']
L1 = [' ', 'Lerning']
# `[]`前的0、1用于指定传入的列表顺序
print('I {0[0]} {1[1]}, and I\'am learning'.format(L0, L1)) #I like Lerning, and I'am learning

进制转换

字符	含义
b	二进制
c	Unicode 字符
d	十进制整数
o	八进制数
x	十六进制数，a 到 f 小写
X	十六进制数，A 到 F 大写

N = 99
print('{:b}'.format(N)) #1100011
print('{:c}'.format(N)) #c
print('{:d}'.format(N)) #99
print('{:o}'.format(N)) #143
print('{:x}'.format(N)) #63
print('{:X}'.format(N)) #63

填充与对齐
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充，且填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度。

N = 99
print('{:>8}'.format(N)) #99
print('{:->8}'.format(N)) #------99
print('{:-<8}'.format(N)) #99------
print('{:-^8}'.format(N)  #---99---

精度
:号后面设置精度（以.开始加上精度），然后用f结束，若不是设置，默认为精度为6，自动四舍五入，可带符号显示数字正负标志。
转义
可以使用大括号 {} 来转义大括号。

format()方法中文对齐问题解决方法

原因：系统默认填充的是英文空格，而输出占用的是中文字符的宽度。单位不一致，就会出现不能对齐的状况。
解决方法：将中文输出部分原先的默认英文空格填充换成中文空格填充chr(12288) ，即可解决问题。

三、数学函数

abs(x) : 函数返回x（数字）的绝对值。
max() : max() 方法返回给定参数的最大值，参数可以为序列。
min() :返回给定参数的最小值
sum(iterable[, start]) : iterable是可迭代对象如列表、元组、集合。start意思是元组计算总和后再加start后输出，默认为0
sorted(iterable, key=None, reverse=False) :返回重新排序的列表。
len(s) : 返回对象（字符、列表、元组等）长度或元素个数。参数可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）
divmod(a,b): 接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。
pow(x, y[, z]) : 计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
round( x [, n] ) : 获取指定位数的小数。n代表要保留的位数。
range(start, stop[, step]) : 左闭右开,步长为step。range(stop)等价于(0,stop)

max方法的参数

>>> a='1,2,3,4'#类型为字符串
>>> max(a)#max 返回了最大值
'4'
>>> a=[1,2,3,4]#类型是列表
>>> max(a)#max函数也返回了最大值
4
>>> a=[(1,2),(2,3),(3,4)]#列表里面的元素都由元组构成，元组都由数字组成              
>>> max(a) #按照元素里面元组的第一个元素的排列顺序，输出最大值（如果第一个元素相同，则比较第二个元素，输出最大值）据推理是按ascii码进行排序的
(3,4)
>>> a={1:2,2:2,3:1,4:'aa'} #比较字典里面的最大值，会输出最大的键值
>>> max(a)
4

sorted()函数的参数

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法会修改原始的 list（返回值为None），而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。如果我们不需要原来的数据而且数据是list类型，可以用sort方法，能够节省空间。否则要用sorted方法。

在python2中，sort方法可以有3个参数：key、cmp和reverse。但在python3中取消了cmp这个参数，只有key和reverse两个可选参数。参数reverse指定排序是正序还是倒序，默认是正序FALSE；参数key指定了只含一个参数的方法，这个方法用来从列表的每个元素中提取比较键。

#利用key进行倒序排序
>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1)
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

#通过 key 的值来进行数组/字典的排序
>>> array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
>>> array = sorted(array,key=lambda x:x["age"])
>>> print(array)
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

#先按照成绩降序排序，相同成绩的按照名字升序排序：
>>> d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
>>> ans = sorted(d1, key=lambda x:(-x['score'], x['name']))
>>> print(ans)
[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]

divmod()函数

python3该函数不支持复数。

• 如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
• 如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。
• 如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。

pow()与math.pow的区别

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

#!/usr/bin/python3
import math   # 导入 math 模块
print ("math.pow(100, 2) : ", math.pow(100, 2))  #math.pow(100, 2) :  10000.0
print ("pow(100, 2) : ", pow(100, 2)) #pow(100, 2) :  10000

range()函数返回值

Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。
Python2 range() 函数返回的是列表。

>>> type(range(10))
<class 'range'>
>>> list(range(0))
[]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(1, 0))
[]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

四、进制转换与编码

hex(int) : 将一个指定数字转换为16进制数。返回一个字符串，以 0x 开头。
oct(int) : 将一个整数转换成8进制字符串,以0开头
bin(int) : 返回一个整数 int 或者长整数 long int 的二进制表示字符串。结果以前缀 0b 开头。
chr(int) : 返回当前整数对应的Unicode数值。0 <= i <= 0x10ffff，可以是10进制也可以是16进制。
ord(str) : 返回一个单字符字符串的Unicode数值（十进制）

五、功能相关函数

eval(expression[, globals[, locals]]) : 执行一个字符串表达式，并返回表达式的值。globals必须是一个字典对象，locals可以是任何映射对象。
exec(object[, globals[, locals]]) : 执行储存在字符串或文件中的 Python 语句，返回值永远为 None。
filter(function, iterable) : 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断后返回 True 或 False，最后将返回True 的元素放到新列表中。
map(function, iterable, ...) : 根据提供的函数对指定序列做映射。返回迭代器对象。
zip([iterable, ...]) : 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
isinstance(object, classinfo)：判断一个对象是否为该类的一个实例。
type(object) ：返回对象的类型。
type(name, bases, dict)：name是类的名称，bases是基类的元组，dict是类内定义的命名空间变量。返回新的类型对象。
id([object])： 返回对象的内存地址。
hash(object)：返回一个对象的hash值，可以应用于数字、字符串和对象，不能直接应用于list、set、dictionary。在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
help([object])：用于查看函数或模块用途的详细说明。
issubclass(class, classinfo)：判断参数 class 是否是类型参数 classinfo 的子类。
globals() : 以字典类型返回当前位置的全部全局变量。
next(iterator[, default]) : 返回迭代器的下一个元素，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(seq) ： 生成一个反转序列的迭代器，可以是tuple, string, list 或 range。
callable(object)：检查一个对象是否是可调用的。如果返回 True，object仍然可能调用失败
compile(source, filename, mode[, flags[, dont_inherit]])：将一个字符串编译为字节代码。
complex([real[, imag]])：创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
frozenset([iterable])：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
getattr(object, name[, default])：返回一个对象属性值。
setattr(object, name, value)：设置属性值，该属性不一定是存在的。
all(iterable)：判断给定的可迭代参数iterable 中的所有元素是否都为 TRUE，如果是返回 TRUE，否则返回 False。
any(iterable)：判断给定的可迭代参数 iterable 是否全部为False，则返回False，如果有一个为 TRUE，则返回 TRUE。
__import__(name)：用于动态加载类和函数 。

eval()

eval这个函数就是在返回它觉得正确的那个值。

#使字符串本身的引号去掉，保留字符的原本属性。
>>> a = "123" #a为str
>>> b = eval(a)
>>> b
123 #b为int

#直接来提取用户输入的多个值。
>>> a,b = eval(input())

exec()

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr) #60
    exec(expr, {'x': 1, 'y': 2})  #33
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})   #34
    
func()

filter()

#!/usr/bin/python3
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist) #将迭代器转化为list后输出。
print(newlist)

map()

def square(x) :
    return x * x
a = map(square, [1,2,3,4,5])
b = list(map(square, [1,2,3,4,5]))
print(type(a),type(b)) #<class 'map'> <class 'list'>

zip()

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

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 2.x zip() 返回的是一个列表。

a = [1,2,3]
b = [4,5,6]
print(type(zip(a,b)),type(list(zip(a,b)))) #<class 'zip'> <class 'list'>
print(zip(a,b),list(zip(a,b))) #<zip object at 0x000001E8FC7E84C8> [(1, 4), (2, 5), (3, 6)]
zipped = list(zip(a,b)) #为[(1, 4), (2, 5), (3, 6)]
unzip = zip(*zipped)
print(type(unzip),list(unzip),type(list(unzip))) #<class 'zip'> [(1, 2, 3), (4, 5, 6)] <class 'list'>

type() 与 isinstance()区别

isinstance中的classinfo可以是直接或间接类名、基本类型或者由它们组成的元组。对于基本类型来说 classinfo 可以是：int，float，bool，complex，str，list，dict，set，tuple（注意str和dict）

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

class A:
    pass
 
class B(A):
    pass
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False