内置函数

内置函数

内置函数就是在系统安装完python解释器时，python解释器自带的函数

1. range()函数：遍历

range()函数
功能：能够生成一个指定的数字序列
参数：
    start : 开始的值 ，默认值为0
    stop  ： 结束的值
    [, step]： 可选，步进值 默认值为1
返回值： 可迭代的对象，数字序列

提取range()函数返回的数字序列的方法：

# 获取range函数返回的数字序列的方法
res = range(10)
# 1.转为list列表数据
print(list(res))

# 2.通过 for循环,进行遍历
for i in res:
    print(i)

# 3.转为迭代器，使用next函数调用
res = iter(res)
print(next(res))
print(next(res))

2.zip() 函数

zip()
功能：zip 函数是可以接受多个可迭代的对象，然后把每个可迭代对象中的第i个元素组合在一起，形成一个新的迭代器
参数：*iterables，任意个的 可迭代对象
返回值： 返回一个元组的迭代器   
#注意！返回的是一个迭代器，如果需要取出元素，需要用next()、list()、或者for循环
#【得看是几个值接收zip()！！，如果是一个，那这个值就是迭代器！如果是n个（n为迭代器中元组的个数），则返回n个元组；如果是a个（a不等于n），则会报错！】

var1 = '1234'
var2 = ['a','b','c','d']
var3 = ('A','B','C','D')
res = zip(var1,var2,var3)     #调用zip函数，只有一个res接收，则组成新的元组迭代器res
print(res,type(res))
>>><zip object at 0x000001C5ABB3D748> <class 'zip'>
print(next(res))
>>>('1', 'a', 'A')
for i in res:
    print(i)
>>>('2', 'b', 'B')
   ('3', 'c', 'C')
   ('4', 'd', 'D')
#注意！如果只print(list(res)),得到的是一个列表
>>>[('1', 'a', 'A'), ('2', 'b', 'B'), ('3', 'c', 'C'), ('4', 'd', 'D')]

# zip() 与 * 运算符相结合可以用来拆解一个列表:
# zip(*zip())可以将x个列表转变为元组，前期是有x个值接收
# 注意！这里特意写了是x个，为了和上面写的n区分，这俩个数不一样的！
# x是列表的个数，
# n是迭代器中元组的个数，也可以说是x个列表中最少的列表里元素的个数
var1 = '1234'
var2 = ['a','b','c','d']
print(*zip(var1,var2))
>>>('1', 'a') ('2', 'b') ('3', 'c') ('4', 'd')   #多个元组数据

a, b = zip(*zip(var1,var2))
print(a,b)
>>>('1', '2', '3', '4') ('a', 'b', 'c', 'd')     #是元组

#再强调一遍！zip()返回的是一个迭代器，*zip()返回的是组合好的多个元组
#但是！！为什么上面的a,b可以直接打印出元组呢？
【如果是一个值接收zip()
res = zip()
此时res是一个迭代器
如果是n个值接收zip()，n的值要和zip()中元组的个数相等，此时这n个值就是zip()从0开始的n个元组！】

var1 = '1234'
var2 = ['a','b','c','d']
res = zip(var1,var2)
print(res)
a,b,c,d = zip(var1,var2)
print(a,b,c,d)
>>><zip object at 0x0000025A4049D608>
   ('1', 'a') ('2', 'b') ('3', 'c') ('4', 'd')

3.其他内置函数

##3.1数据类型转换相关内置函数

• int() 将其它类型数据转为整型
• float() 转为浮点类型
• bool() 转为布尔类型
• complex() 转为复数
• str() 转为字符串类型
• list 转为列表类型
• tuple 转为元组类型
• dict 转为字典类型
• set 转为集合类型

3.2变量相关函数

• id() 获取当前数据的ID标识
• type() 获取当前数据的类型字符串
• print() 数据的打印
• input() 获取输入的数据
• isinstance() 检测是否为指定的数据类型

3.3数学相关函数

#获取绝对值
print(abs(-123))
>>>123

#求和
print(sum([1,3,4]))
>>>8

#获取最大值
print(max(1,3,4))
>>>4

#获取最小值
print(min([1,3,4]))
>>>1

#幂运算，返回 x 的 y 次幂
print(pow(4,3))
>>>64

#四舍五入
r = round(3.1415926)
print(r)
>>>3
r = round(3.1415926,2) #保留小数点后2位
print(r)
>>>3.14
a = round(3.5)        # 奇进偶退  1.5 = 2, 2.5=2, 3.5=4, 4.5=4
b = round(4.5)
print(a, b)
>>>4 4

3.4进制相关函数

# bin() 将数值类型转为二进制
print(bin(123)) # 0b1111011

# int() 将二进制转为整型
print(int(0b1111011)) #1 23

# oct() 转为八进制数 01234567
print(oct(123)) # 0o173

# hex() 转为十六进制数 0123456789abcdef
print(hex(123)) # 0x7b

3.5Ascii码及字符集

• Ascii 共计 128个字符，更新于 1986年 主要用于显示现代英语和其他西欧语言。

# 将字符转为 ascii
r = ord('a')
print(r)
>>>97

# 将ascii转为字符
r = chr(97)
print(r)
>>>a

4.高阶函数

4.1 sorted(iterable,[reverse,key])

sorted()：

• 功能：排序
• 参数：
  iterable 可迭代的数据 （容器类型数据，range数据序列，迭代器）
  reverse 可选，是否反转，默认为False，不反转， True反转
  key 可选， 函数，可以是自定义函数，也可以是内置函数
• 返回值： 排序后的结果
• 运行原理：
  把可迭代数据里面的元素，一个一个的取出来，放到key这个函数中进行处理，
  并按照函数中return的结果进行排序，返回一个新的列表

a = [8,5,7,3,6,5,9,10]
res = sorted(a)
tmp = sorted(a, reverse=True)  #逆序
n = sorted(a, key=abs)   #按绝对值排序
y = sorted(a, reverse=True, key=abs)
print(res, tmp, n, y)
>>>[-15, 3, 5, 5, 6, 7, 8, 9, 10] 
   [10, 9, 8, 7, 6, 5, 5, 3, -15] 
   [3, 5, 5, 6, 7, 8, 9, 10, -15] 
   [-15, 10, 9, 8, 7, 6, 5, 5, 3]

#使用自定义函数：
def func(n):
    n %= 2
    return n
arr = [3,2,9,6,8,4,5]
res = sorted(arr, key=func)
print(res)
>>>[2, 6, 8, 4, 3, 9, 5]  #注意输出顺序，是按输入顺序返回的

#优化版，使用lambda
arr = [3,2,9,6,8,4,5]
res = sorted(arr, key=lambda x : x %2)
print(res)
#也可以直接 print(sorted(arr, key = lambda x : x % 2))
>>>[2, 6, 8, 4, 3, 9, 5]

4.2 map(func, *iterables)

map():

• 功能：对传入的可迭代数据中的每个元素放入到函数中进行处理，返回一个新的迭代器
• 参数：func 函数 自定义函数|内置函数
  iterables：可迭代的数据
• 返回值：迭代器【注意是迭代器！！！】

arr = [-1,-2,-3,-4]
res = map(abs, arr)
print(res)           #此时的res是个迭代器
print(list(res))
>>><map object at 0x0000026EEE980A48>
   [1, 2, 3, 4]
'''
同2.zip()函数里面说的一样，看有几个值接收迭代器
如果是一个，那它就是迭代器，如果和元素一样多，就一人分配一个值
'''
arr = [-1,-2,-3,-4]
a,b,c,d = map(abs, arr)
print(a,b)
>>>1 2

#使用自定义函数
def func(n):
    n -= 1
    return n
arr = [1,3,5]
res = map(func,arr)
print(list(res))
>>>[0, 2, 4]

def func(n):
    n -= 1
    return n
arr = [1,3]
a,b = map(func,arr)
print(a,b)
>>>0 2

#优化版
arr = [1,3]
res = map(lambda x : x - 1,arr)
print(list(res))
>>>[0, 2]

#练习 ['a','b','c','d'] ==> [65,66,67,68]
arr = ['a','b','c','d']
res = map(ord,arr)
tmp = map(lambda x : x - 32, res)
print(list(tmp))
>>>[65, 66, 67, 68]

##4.3 reduce(func,iterable)

reduce():

• 功能：每一次从 iterable 拿出两个【划重点，两个！！】元素，放入到func函数中进行处理，得出一个计算结果，然后把这个计算结果和iterable中的第三个元素，放入到func函数中继续运算，得出的结果和之后的第四个元素，加入到func函数中进行处理，以此类推，直到最后的元素都参与了运算

• 参数：func： 内置函数或自定义函数

  ​ iterable： 可迭代的数据

• 返回值：最终的运算处理结果

使用 reduce函数时，需要导入 from functools import reduce

from functools import reduce

def func(a,b):               #函数里一定要是两个值
    return a + b
arr = [-3, 3, 5, 6]
res = reduce(func, arr)
print(res)
>>>11

arr = [-3, 3]
res = reduce(lambda x, y : x + y, arr)
print(res)
>>>0

#[5,2,1,1] ==> 5211
#普通方法
varlist = [5,2,1,1]
res = ''
for i in varlist:
    res += str(i)
res = int(res)
print(res,type(res))
>>>5211 <class 'int'>

#使用reduce()
from functools import reduce

def func(x,y):
    return x*10 + y
arr = [5,2,1,1]
res = reduce(func, arr)
print(res)
>>>5211

# 把字符串的 '456' ==> 456
# 要求不能使用int方法进行类型的转换时，如何解决上面的问题
from functools import reduce

def func(n):
    dict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return dict[n]
l = '456'
res = map(func,l)
print(reduce(lambda x, y: x * 10 + y, res))
>>>456

4.4 filter(func,iterable)

filter():

• 功能：过滤数据，把 iterable 中的每个元素拿到 func 函数中进行处理，如果函数返回True则保留这个数据，返回False则丢弃这个数据
• 参数：func 自定义函数
  itereble： 可迭代的数据
• 返回值：保留下来的数据组成的迭代器 【注意是迭代器！】

# 要求:保留所有的偶数，丢弃所有的奇数
arr = [1,2,3,4]
# 普通方法：
arr = [1,2,3,4]
a = []
for i in arr:
    if i %2 == 0:
        a.append(i)
print(a)

#使用filter()：
def func(n):           
    if n%2 == 0:         #这里可以写成  return n%2==0
        return True
arr = [1,2,3,4]
res = filter(func, arr)    #还是那句话，注意这里是迭代器
print(list(res))
>>>[2, 4]

#优化版：
arr = [1,2,3,4]
a,b =filter(lambda x : True if x%2 == 0 else False, arr)
print(a,b)