Python内置函数-数据类型相关

一、数字-数据类型相关

• bool
• int
• float
• complex 复数类型 复数存放的是一对浮点数，一个表示实数部分，另一个表示虚数部分（跟随一个字母j）

bool 根据传入参数的逻辑值创建一个新的bool值
# 未传入参数 False
>>> print(bool())
False

# 数值为0 或者空序列 False
>>> print(bool(0))
False
>>> print(bool([]))
False

>>> print(bool(1))
True

int根据传入的参数创建一个新的整数
# 不传参数结果为0
>>> print(int())
0
>>> print(int(3.3))
3
>>> print(int(6))
6

float根据传入的参数创建一个新的浮点数
# 不传参数结果为0.0
>>> print(float())
0.0
>>> print(float(5))
5.0
>>> print(float(5.5))
5.5
>>> print(float('6.6'))
6.6

# 根据传入参数创建一个新的复数
>>> complex() # 两个数值都不传
0j
>>> complex(1) # 传入一个数值
(1+0j)
>>> complex(1,2) # 传入两个数值
(1+2j)
>>> complex('1+2j') # 传入字符串
(1+2j)
>>>

二、数字-进制转换相关

• bin 整数转二进制
• oct 整数转八进制
• hex 整数转十进制

>>> bin(1)
'0b1' # 0b 开头 Binary system
>>> oct(1)
'0o1' # 0o 开头 Octal number system
>>> hex(1)
'0x1' # 0x开头 Hexadecimal
>>>

三、数字-数学运算

• abs 求数值的绝对值
• divmod 返回两个数的商和余数
• min 返回可迭代对象或者所有参数的最小值
• max 返回可迭代对象或者所有参数的最大值
• sum 对可迭代对象中每个数值元素进行求和
• round 对浮点数进行四舍五入求值，传入第二个参数取浮点数小数点后几位
• pow 返回两个数的幂运算值或与其指定整数的模值

# abs
>>> abs(-10)
10

# divmod
>>> divmod(10,3)
(3, 1) # 返回商和余数

# round
>>> round(3.14156) # 未输入取小数点后多少位，直接进行四舍五入
3
>>> round(3.14156,2) # 取小数点后两位
3.14

# pow
>>> pow(2,3) # 求2的3次方
8
>>> pow(2,3,3) # 求2的3次方除3的模值，等于pow(2,3)%3
2

# sum(iterable[, start]) 
  -- iterable 可迭代对象如list,tuple,set start 
  -- 指定相加的参数，如果没有设置这个值，默认为0
>>> sum([1,2]) # 对list求和
3
>>> sum([1,2],3) # 对list求和再加3
6
>>> sum((1,2,3,4)) # 对tuple求和
10

>>> sum(1,2) # 此处报错int不是可迭代对象
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

>>> sum(['g',1]) #元素不能为字符串
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> sum(['g','h']) #元素不能为字符串
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>>

#max(x, y, z, ....) 返回参数给定的最大值，参数可以为序列
    x,y,z 分别代表数值表达式

>>> max(1,2,3,4,5,1,6)
6
>>> max('g','h') # 比较字符串按ASCII码 进行比较
'h'
>>> max([1,2,3,3,2,2,1,2]) # 比较列表
3
>>> max([(1,2,3,4),(1,1,1,1)]) # 比较元祖
(1, 2, 3, 4)
>>> a={1:2,2:2,3:1,4:'aa'} # 比较字典 根据key比较
>>> max(a)
4

max(x,key=func) # max函数中传入函数
# 获取list中出现次数最多的元素
>>> a=[1,2,3,4,4,4,5,6]
>>> max(set(a), key=a.count) # 循环遍历a，count方法统计a中元素在a中个数
4

max实现原理
a=[1,2,3,4,4,4,5,6]

ma = a[0] # 假设第一项就是最大值
mi = a[0]

for i in set(a):
     if i > ma:
         ma = i
         
     if i < mi:
         mi = i

min函数同上

四、数据结构相关

• 列表元祖相关-list，tuple(可迭代对象)
• 字符串相关
  • str 返回一个对象的字符串表现形式（给用户），str只有encode方法，没有decode方法
  • bytes 根据传入的参数创建一个新的不可变字节串，bytes只有decode方法没有encode方法
  • bytearray 根据传入的参数（bytes类型）创建一个新的可变的字节数组
  • memoryview 根据传入的一个参数创建一个新的内存查看对象
  • chr 将整数转换成对应的Unicode字符
  • ord 将Unicode字符转换成对应的整数
  • ascii
    • 返回任何对象(str,list,dict等)的可读版本
    • 将所有非ASCII字符转换为转义字符
  • repr 返回一个对象的字符串表现形式（给机器）类可以通过定义__repr__()方法控制该函数对其实例的返回
  • format 格式化字符串

# list
>>> list() # 不传入参数创建空列表
[]
>>> list('abcd') # 传入可迭代对象创建一个新的列表
['a', 'b', 'c', 'd']

# 元祖
>>> tuple() # 不传入参数创建空元祖
()
>>> tuple('abcd') # 传入可迭代对象创建一个新元祖
('a', 'b', 'c', 'd')
>>> a = tuple('abcd')
>>> print(a)
('a', 'b', 'c', 'd')
>>> a[0] = 'e'  # 元祖对象不可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

# str 字符串类型
>>> str()
''
>>> str(None)
'None'
>>> str('abc')
'abc'
>>> str(123)
'123'

# bytes 不可变的二进制格式字节数据
>>> B=b'abcd' #小b定义一个bytes类型数据
>>> [i for i in B]
[97, 98, 99, 100]
>>> B[0] = 65 #bytes类型不可变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
>>>

# bytearray  可变的二进制字节数组
>>> S=b'abcd'
>>> barr = bytearray(S) # 传入bytes类型数据
>>> barr
bytearray(b'abcd')
>>> barr[0]=65 # bytesarray数组可变
>>> barr
bytearray(b'Abcd')
>>>

# memoryview
>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103

# chr 将整数转换成对应的Unicode字符
>>> chr(97)
'a'

# ord 将Unicode字符转换成对应的整数
>>> ord('a')
97

# ascii
>>> ascii('中文') #非ascii字符
"'\\u4e2d\\u6587'"

# 返回一个对象的字符串(给机器看)
>>> repr('hello')
"'hello'"
>>>

五、数据集合

• dict 字典
• set 集合 set中元素不可重复
• frozenset 不可变集合
• enumerate 返回一个可枚举的对象，该对象的next方法将返回一个tuple

# enumerate 
>>> list(enumerate(a)) # 返回元素在list的索引和元素
[(0, 'a'), (1, 'b'), (2, 'c')]

# frozenset 不可变集合
>>> a=frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> a[0]=9
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'frozenset' object does not support item assignment

# set
>>> a=set() #空集合
>>> a
set()
>>> a = set({1,1,2,3,4,5}) #set中重复元素自动去除
>>> a
{1, 2, 3, 4, 5}

# dict
>>> dict() # 不传入任何参数时，返回空字典。
{}
>>> dict(a = 1,b = 2) #  可以传入键值对创建字典。
{'b': 2, 'a': 1}
>>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
{'b': 2, 'a': 1}
>>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
{'b': 2, 'a': 1}

六、序列操作

• len 获取可迭代对象的长度如 str、list、tuple、set、dict
• all 集合中所有元素都为真则为真，集合为空的为真
• any 集合中任意一个元素为真则为真，集合为空的为假
• filter 元素过滤
• map 遍历每个元素，执行function操作
• reversed 反转序列生成新的可迭代对象，保留源列表
• sorted 对list、dict排序
• zip 创建一个迭代器，聚合来自每个迭代器的元素，返回一个由元组构成的迭代器，其中第i个元组包含来自每一组参数序列或可迭代量的第i元素。当最短输入可迭代被耗尽时，迭代器停止。使用单个可迭代参数，它返回1元组的迭代器。没有参数，它返回一个空迭代器
• slice 返回一个slice对象，表示由索引range(start, stop, step)指出的集合。start和step参数默认为None。切片对象具有只读属性start、stop和step，它们仅仅返回参数的值（或者它们的默认值）

# all
>>> a=[1,2,3,4]
>>> all(a)
True
>>> a[0]=0 # 集合中有一个元素为假
>>> all(a) 
False
>>> a=[] # 集合为空
>>> all(a)
True

# any
>>> a=[0,0,0,1,0]
>>> any(a)
True

# filter 构造一个序列，等价于[ item for item in iterable if function(item)]
  1、参数function：返回值为True或False的函数，可以为None
  2、参数iterable：序列或者可迭代对象
>>> a=[1,2,3,4,5,6,7]
>>> list(filter(lambda x:x%2==1,a)) # 删除偶数保存奇数
[1, 3, 5, 7]
利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

# map 遍历每个元素，执行function操作 等价于[ function(item) for item in iterable ]
  1、参数function：返回值为True或False的函数，可以为None
  2、参数iterable：序列或者可迭代对象
>>> a=[1,2,3,4,5]
>>> list(map(lambda x:x*x,a)) #求每个元素平方
[1, 4, 9, 16, 25]

# 注意
filter 执行之后元素个数小于等于执行之前的个数，元素值不会发生改变
map 执行之后元素个数不会发生改变，元素值会发生改变
reduce 为什么不在这儿？python3当众reduce不是内置函数，移到了functools模块

# reversed 反转原序列，保留原序列，生成一个新的可迭代对象
>>> a=list(range(10))
>>> print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b=reversed(a)
>>> print(b)
<list_reverseiterator object at 0x0000000002785160>
>>> list(b)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# sorted(iterable[, key][, reverse])
  iterable 序列或者可迭代对象
  key指示一个带有一个参数的函数
  reverse是一个布尔值。如果设置为True，那么列表中元素反过来比较来排序
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sorted(a) #sorted不会改变原列表
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a=[3,4,5,2,1,7,1,9,0,2]
>>> sorted(a) #sorted不会改变原列表
[0, 1, 1, 2, 2, 3, 4, 5, 7, 9]
>>> a
[3, 4, 5, 2, 1, 7, 1, 9, 0, 2]
>>> a.sort() #sort会改变原列表
>>> a
[0, 1, 1, 2, 2, 3, 4, 5, 7, 9]
>>> sorted(b.items())
[('a', 3), ('b', 1), ('c', 2)]
>>> sorted(b.items(), key=lambda x:x[1]) # 对字典进行value排序
[('b', 1), ('c', 2), ('a', 3)]

# zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
>>> x = [1,2,3] #长度3
>>> y = [4,5,6,7,8] #长度5
>>> list(zip(x,y)) # 取最小长度3
[(1, 4), (2, 5), (3, 6)]

# slice(start, stop[, step]) 相当于切片
  start 开始位置
  stop 停止位置
  step 步长
>>> l = (1,2,23,213,5612,342,43)
>>> sli=slice(1,5,2)
>>> sli
slice(1, 5, 2)
>>> l[sli] #取l中第一个元素开始到第五个元素结束的所有元素中2个
(2, 213)
>>> sl=slice(4,6) 
>>> l[sl] # 取l中第四个到第六个元素
(5612, 342)