Python迭代器、（高阶函数）、内置函数

目录

迭代器

range

start,stop

step

数学相关函数

进制相关

sorted

map

reduce

filter

---

迭代器

# 迭代器是作为访问集合元素的一种方式，可以记住访问遍历的位置的对象
# 从集合的第一个元素开始访问，直到导集合中所有元素被访问完毕
# 但是迭代器只能从前往后，一个一个遍历，不能后退
# 能被next()函数调用，并且不断返回下一个值的对象称为迭代器（Iterator迭代器对象）

# 首先range()函数返回了一个可迭代的对象，如果利用range函数遍历从左到右0~9
for x in range(10):
    print(x)

# 除了range函数，还有集合
ganyu = [1,2,3,4,5]
# 正常读取一个集合的内容
for i in ganyu:
    print(i)

# 那么如果有一个非常大的数据，一个数代表一个人的信息，那么一次看到的数据就是有限的
# for i in range(1,1000000):
#     print(i)

# iter
# 作用：可以把可迭代的对象转为一个迭代器对象
# 参数：可迭代的对象(如str、list、tuple、dict、set、range。。。)
# 返回值：迭代器对象
# 注意：迭代器一定是一个可以迭代的对象，但是可迭代对象不一定是迭代器
# 可迭代对象是什么？(如str、list、tuple、dict、set、range。。。)
# 迭代器是什么？使用方法是什么？
# 迭代器是一个可以记住遍历的位置的对象

# 定义一个列表，对于ganyu0来说，内部的参数就是一个可迭代对象
ganyu0=['ganyu1','ganyu2','ganyu3','ganyu4']
for x in ganyu0:
    print(x)
# 如上可以使用for循环来遍历数据的

# 如下可以把可迭代对象转为迭代器使用的
ganyu=iter(ganyu0)# 调用iter函数，将ganyu0传入
print(ganyu,type(ganyu))
# 输出<list_iterator object at 0x000001CC49A6ED00> <class 'list_iterator'>，list是列表，而后面变为iterator

# 迭代器的使用方法，使用next()函数去调用迭代器对象
a=next(ganyu)# ganyu就是刚才转化为的迭代对象
print(a)# 结果打印ganyu1
# 过程：先定义了一个列表，将这个列表定义为可迭代的对象，然后用iter函数转化为迭代器，使用next()访问，返回第一次访问的结果
# 每次访问一次，即从中取出一个，如果这个时候再访问ganyu0

# 迭代器的使用方法，使用list()函数去调用迭代器对象
b=list(ganyu)# list在这里把剩余的数据类型转为列表类型，如果此时调用list，那么将直接取出迭代器中的所有函数
print(b)

# 迭代器的使用方法，使用for循环去调用迭代器对象
for i in ganyu:
    print(i)

迭代器取值的方案
    1、next() 调用一次获取一次，直到数据被取完
    2、list() 使用list函数直接取出迭代器中的所有函数
    3、for    使用for循环遍历迭代器的数据
迭代器取值特点：取出一个少一个，直到都取完，最后再获取就会报错

'''
检测迭代器和可迭代对象的方法
'''
from collections.abc import Iterator,Iterable
varstr = '123456'
res = iter(varstr)

#type函数返回当前数据类型
# isinstance函数检测一个数据是否为一个指定类型
e=isinstance(varstr,Iterable)# True 是一个可迭代对象
f=isinstance(varstr,Iterator)# False 是一个可迭代对象
g=isinstance(res,Iterator)#True  可迭代对象
print(e,f,g)
# 迭代器一定是一个可迭代对象，但是可迭代对象不一定是一个迭代器

range

range函数能够创建一个指定的数字序列

注意：返回的是一个iterable，只是在许多方面表现得像一个列表， 所以打印的时候不会打印列表

函数语法：start,stop,[step]
		start：开始的值
		stop：结束的值
		step：可选，步长

start,stop

# range函数如果只写一个参数，意为默认从零开始到10前一位数为止，也就是9，将range生成的结果转换为列表打印输出
ganyu1 = range(10)
print(list(ganyu1))
# 如果是负数，输出为空
ganyu2 = range(-10)
print(list(ganyu2))
# 从5到9，第一个参数是开始的值，第二个参数是结束值之前的值
ganyu3 = range(5, 10)
print(list(ganyu3))

step

# 步长
ganyu4 = range(1, 10, 3)
print(list(ganyu4))
# 倒数，步长为1
ganyu5=range(10,0,-1)
print(list(ganyu5))
# 负数
ganyu6=range(-1,-5,-1)
print(list(ganyu6))

数学相关函数

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

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

'''
数学相关内置函数
'''
# 获取一个数的绝对值
print(abs(-100))
# 求和
print(sum([1, 2, 3]))
# 最大值
print(max([1, 2, 3, 4, 5]))
print(max(1, 2, 3, 3, 4, 5))
# 最小值
print(min([1, 2, 3, 4, 5]))
print(min(1, 2, 3, 3, 4, 5))
# 幂运算
print(pow(5,5))
# 四舍五入
print(round(88/9))# 基进偶退
# 保留两位小数
print(round(88/9,2))

进制相关

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

# int()将二级制转为整形
print(int(0b1111011))

# oct()转为八进制
print(oct(123))

# hex()转为十六进制
print(hex(123))

# ascii字符转换
'''
128位
'''
# 字符转ascii
print(ord('a'))
# 字符转ascii
print(chr(97))

sorted

对所有可迭代的对象进行排序操作

运行原理：把可迭代的数据内元素，依次取出，放入key函数中进行处理，并使用return结果进行排序，返回一个新的列表

'''
功能：排序
语法：sorted(iterable, cmp=None, key=None, reverse=False)
参数：iterable:可迭代数据（包括容器类型数据，range数据序列，迭代器）
	 key:可选，函数，可以是内置函数，也可以是自定义函数
     reverse:可选，是否反转，默认值为False
返回值：排序后的函数
'''

# 首先定义一个无序列表
ganyu = [1, 2, 3, 4, -1, 0, -2]
# 使用sorted函数
ganyu1 = sorted(ganyu)
print(ganyu1)  # 输出[-2, -1, 0, 1, 2, 3, 4]默认从小到大排序

# 从大到小【反转】
ganyu2 = [1, 2, 3, 4, -1, 0, -2]
ganyu3 = sorted(ganyu2, reverse=True)
print(ganyu3)

# key，使用abs作为sorted的key关键字参数使用
ganyu4 = sorted(ganyu2, key=abs)
print(ganyu4)  # 输出[0, 1, -1, 2, -2, 3, 4]，运行过程，首先将无序列表进行处理，转换为绝对值1,2,3,4,1,0,2，在进行排序后，转换回去


# 使用自定义函数
ganyu5 = [1, 2, 3, 4, 5]
def num(aa):
    return aa % 10# 对10取余然后排序
ganyu5 = sorted(ganyu5, key=num)
print(ganyu5)

# 使用lambda函数进行优化
ganyu5 = [1, 2, 3, 4, 5]
ganyu5 = sorted(ganyu5, key=lambda x:x%10)
print(ganyu5)

map

返回一个将function应用于iterable中每一项并输出其结果的迭代器

'''
语法：map(func, *iterables)
参数    func：函数 ==>自定义函数|内置函数
       *iterables：一个或多个可迭代数据
返回值：新的迭代器
功能：对传入的可迭代数据中的每个元素放入到函数中进行处理，返回一个新的迭代器
'''

# ['1', '2', '3', '4']更改为[1, 2, 3, 4]格式
# 方法一
ganyu = ['1', '2', '3', '4']
newlist = []
# 将字符串1转换为数字1，并且传入newlist列表中
for i in ganyu:
    newlist.append(int(i))  # 使用append将转换为int后的i追加到newlist中
print(newlist)

# 方法二
ganyu = ['1', '2', '3', '4']
res = map(int, ganyu)
print(res)  # <map object at 0x000002A41E8373D0>
print(list(res))

# 使用for in处理将[1,2,3,4]更改为[1,4,9,16]
ganyu1 = [1, 2, 3, 4]
newlist = []
for i in ganyu1:
    newlist.append(i * i)
print(newlist)

# 使用map自定义函数处理
ganyu2 = [1, 2, 3, 4]
def ganyu3(x):
    return x**2
res = map(ganyu3, ganyu2)
print(res)
print(list(res))

# 使用lamdba函数优化处理
ganyu2 = [1, 2, 3, 4]
print(list(map(lambda x:x**2, ganyu2)))

'''
'a','b','c','d'转为97,98,99,100
'''
ganyu2 = ['a','b','c','d']
res = map(lambda x:ord(x), ganyu2)
print(res)
print(list(res))

ganyu2 = ['a','b','c','d']
res = map(lambda x:ord(x.upper()), ganyu2)
print(res)
print(list(res))

reduce

每一次从iterable拿出两个元素，放入到function函数中进行计算，得出一个处理结果，然后把计算结果和iterable中的第三个元素，放入到function函数中继续运算，得出的结果和之后的第四个元素加入到function函数中继续处理，直到所有元素参与运算

# reduce在使用的时候，由于Python3.x reduce()已经被移到functools模块里，如果要使用，需要引入 functools模块来调用reduce()函数

from functools import reduce

'''
reduce()
语法： reduce(function, sequence[, initial])
            function：内置函数|自定义函数
            iterable：可迭代的对象
返回值：最终计算结果
功能：每一次从iterable拿出两个元素，放入到function函数中进行计算，得出一个处理结果，然后把计算结果和iterable中的第三个元素，放入到function函数中继续运算，得出的结果和之后的第四个元素加入到function函数中继续处理，直到所有元素参与运算

'''

# 将列表内的数字叠组成十百千位的数
# [1,2,3,4]==>1234
# 普通方法
ganyu = [1, 2, 3, 4]
ganyu1 = ""
for i in ganyu:
    ganyu1 += str(i)  # i为ganyu内的每一个数字，str将i转为字符串，再将每个字符串拼接
    ganyu2 = int(ganyu1)
print(ganyu2, type(ganyu2))


# reduce方法
# 定义函数
def ganyu3(x, y):
    return x * 10 + y
res = reduce(ganyu3, [1, 2, 3, 4])
print(res)
# 过程：首先定义了一个列表，reduce函数每一次从iterable中拿出两个元素，放入到function函数中进行计算，得出一个处理结果，也就是将1和2带入ganyu3这个自定义函数，将值*10+y后返回，以此类推

filter

用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表

'''
语法：filter(function,iterable)
			function：内置函数|自定义函数
            iterable：可迭代的对象
功能：过滤数据，把当前iterable中的每一个元素拿到function内进行处理，如果函数返回True，保留，反之丢弃
'''

# 保留所有的偶数
# 方法一
def ganyu(x):
    if x % 2 == 0:
        return x
ganyu1 = filter(ganyu, [1, 2, 3, 4, 5, 6])
print(list(ganyu1))

# 方法二
ganyu2 = [1, 2, 3, 4, 5, 6]
newlist = []
for i in ganyu2:
    if i % 2 == 0:
        newlist.append(i)
print(newlist)

# 方法三
ganyu3=filter(lambda a:True if a % 2 ==0 else False,[1,2,3,4,5,6])
print(list(ganyu3))