python基础20-迭代器

今日学习

常见内置函数

[参考](内置函数 — Python 3.10.5 文档)

abs()	aiter()	all()	any()	anext()	ascii()
bin()	bool()	breakpoint()	bytearray()	bytes()
callable()	chr()	classmethod()	compile()	complex()
delattr()	dict()	dir()	divmod()
enumerate()	eval（）	exec()
fileter()	float()	format()	frozenset()
getattr()	globals()
hasattr()	hash()	help()	hex()
id()	input()	int()	isinstance()	issubclass	iter()
len()	list()	locals()
map()	max()	memoryview()	min()
next()
object()	oct()	open()	ord()
pow()	print()	property()
range()	repr()	reversed()	round()
setattr()	slice()	sorted()	staticmethod()	str()|set()	sum()	supper()
tuple()	type()
vars()
zip()
import()

常见的内置函数

内置函数:提前定义好的 直接使用即可 很多内置函数的功能都非常的好用
    
# 1.abs()  求绝对值
# print(abs(-99))  # 99
--------------------------------------------------------
# 2.all()与any()  判断容器类型中的所有数据值对应的布尔值是否为True
# all()  所有的数据值都为True的情况下 结果才是True
# print(all([1, 2, 3, 4, 5, 0]))  # False
# print(all([1, 2, 3, 4, 5]))  # True
# any()  所有的数据值只要有一个为True 结果就是True
# print(any([1, 2, 3, 4, 5, 0]))  # True
# print(any([1, 2, 3, 4, 5]))  # True
------------------------------------------------------
# 3.bin() oct() hex()  十进制转其他进制
# print(bin(10))  # 0b1010
# print(oct(10))  # 0o12
# print(hex(10))  # 0xa
-----------------------------------
# 4.int()  类型转换 其他进制转十进制
# print(int(0b1010))
# print(int(0o12))
# print(int(0xa))
-------------------------------------------------
# 5.bytes()  类型转换
# res = '现在有多苦 将来就有多轻松'.encode('utf8')
# print(res)
# res1 = res.decode('utf8')
# print(res1)
# res = bytes('现在有多苦 将来就有多轻松','utf8')
# print(res)
# res1 = str(res,'utf8')
# print(res1)
------------------------------------------------------
# 6.callable()  # call在IT专业名词中翻译成 调用>>>:加括号执行
# 判断某个变量是否可以加括号调用
# name = 'jason'
# def index():
#     print('from index')
# print(callable(name))  # False
# print(callable(index))  # True
# 7.chr()  ord()  # 依据ASCII码表实现字符与数字的转换
# print(chr(65))  # A     65~90
# print(chr(97))  # a     97~122
# print(ord('A'))  # 65
# print(ord('a'))  # 97
-------------------------------------------
# 8.dir()  # 获取对象内部可以通过句点符获取的数据
# print(dir(str))
------------------------------------------
# 9.divmod()  # 获取除法之后的整数和余数
"""
手上有很多数据 每页展示10条 需要多少页
    通过代码自动计算

总数据         每页展示            需要多少页
 100            10                  10
 99             10                  10
 101            10                  11
 898            10                  ???
"""
# real_num, more = divmod(898, 10)
# if more:
#     real_num += 1
# print('总页数:%s' % real_num)
------------------------------------------------------
# 10.enumerate()  # 枚举
# name_list = ['jason', 'kevin', 'oscar', 'jerry']
# 需求:循环打印出数据值并且对应的索引值
# for i, j in enumerate(name_list, 100):  # 默认是从0开始 可以自定义
#     print(i, j)
----------------------------------------------------------
# 11.eval()  exec()  # 能够识别字符串中python代码并执行
# res = 'print(123)'
# eval(res)  # 不识别复杂结构的代码 只能识别最简单的
# exec(res)  # 能够识别复杂结构的代码
# res1 = "for i in range(10):print(i)"
# eval(res1)
# exec(res1)
-----------------------------------------------------
# 12.hash()  # 返回一串随机的数字(哈希值)
# print(hash('jason'))
# print(hash('123'))
----------------------------------------------------
# 13.help()  # 查看帮助信息
# help(len)
-----------------------------------------------------
# 14.isinstance()  # 判断某个数据是否属于某个数据类型
# print(isinstance(123,int))  # True
# print(isinstance(123,str))  # False
---------------------------------------------
# 15.pow()  # 幂指数
# print(pow(2, 3))  # 8
-----------------------------------------------------
# 16.round()  # 大致:四舍五入  可以课下百度查询详细说明
# print(round(98.3))
# print(round(98.6))

• 内置函数分类

  • 数学运算

  • abs：求数值的绝对值

  >>> abs(-2)
  2
  

  ♦ divmod：返回两个数值的商和余数abs：求数值的绝对值

   >>> divmod(5,2)
   (2, 1)
   >> divmod(5.5,2)
   (2.0, 1.5)
  

  ♦ max：返回可迭代对象中的元素中的最大值或者所有参数的最大值

  >>> max(1,2,3) # 传入3个参数 取3个中较大者
  3
  >>> max('1234') # 传入1个可迭代对象，取其最大元素值
  '4'
  >>> max(-1,0) # 数值默认去数值较大者
  0
  >>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者
  -1
  

  ♦ min：返回可迭代对象中的元素中的最小值或者所有参数的最小值

  >>> min(1,2,3) # 传入3个参数 取3个中较小者
  1
  >>> min('1234') # 传入1个可迭代对象，取其最小元素值
  '1'
  >>> min(-1,-2) # 数值默认去数值较小者
  -2
  >>> min(-1,-2,key = abs)  # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者
  -1
  

  ♦ pow：返回两个数值的幂运算值或其与指定整数的模值

   >>> pow(2,3)
   >>> 2**3
   >>> pow(2,3,5)
   >>> pow(2,3)%5
  

  ♦ round：对浮点数进行四舍五入求值

    >>> round(1.1314926,1)
    1.1
    >>> round(1.1314926,5)
    1.13149
  

  ♦ sum：对元素类型是数值的可迭代对象中的每个元素求和

  # 传入可迭代对象
  >>> sum((1,2,3,4))
  10
  # 元素类型必须是数值型
  >>> sum((1.5,2.5,3.5,4.5))
  12.0
  >>> sum((1,2,3,4),-10)
  0
  

  • 类型转换

  ♦bool：根据传入的参数的逻辑值创建一个新的布尔值

  >>> bool() #未传入参数
  False
  >>> bool(0) #数值0、空序列等值为False
  False
  >>> bool(1)
  True
  

  ♦ int：根据传入的参数创建一个新的整数

  >>> int() #不传入参数时，得到结果0。
  0
  >>> int(3)
  3
  >>> int(3.6)
  3
  

  ♦ float：根据传入的参数创建一个新的浮点数

  >>> float() #不提供参数的时候，返回0.0
  0.0
  >>> float(3)
  3.0
  >>> float('3')
  3.0
  

  ♦ complex：根据传入参数创建一个新的复数

    '''
    遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 
    寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
    '''
  >>> complex() #当两个参数都不提供时，返回复数 0j。
  0j
  >>> complex('1+2j') #传入字符串创建复数
  (1+2j)
  >>> complex(1,2) #传入数值创建复数
  (1+2j)
  

  ♦ str：返回一个对象的字符串表现形式(给用户)

  >>> str()
  ''
  >>> str(None)
  'None'
  >>> str('abc')
  'abc'
  >>> str(123)
  '123'
  

  ♦ bytearray：根据传入的参数创建一个新的字节数组

  >>> bytearray('中文','utf-8')
  bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
  

  ♦ bytes：根据传入的参数创建一个新的不可变字节数组

  >>> bytes('中文','utf-8')
  b'\xe4\xb8\xad\xe6\x96\x87'
  

  ♦ memoryview：根据传入的参数创建一个新的内存查看对象

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

  ♦ ord：返回Unicode字符对应的整数

  >>> ord('a')
  97
  

  ♦ chr：返回整数所对应的Unicode字符

  >>> chr(97) #参数类型为整数
  'a'
  12
  

  ♦ bin：将整数转换成2进制字符串

  >>> bin(3) 
  '0b11'
  

  ♦ oct：将整数转化成8进制数字符串

  >>> oct(10)
  '0o12'
  

  ♦ hex：将整数转换成16进制字符串

  >>> hex(15)
  '0xf'
  

  ♦ tuple：根据传入的参数创建一个新的元组

  >>> tuple() #不传入参数，创建空元组
  ()
  >>> tuple('121') #传入可迭代对象。使用其元素创建新的元组
  ('1', '2', '1'
  

  ♦ list：根据传入的参数创建一个新的列表

  >>>list() # 不传入参数，创建空列表
  [] 
  >>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表
  ['a', 'b', 'c', 'd']
  
  

  ♦ 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}
  

  ♦ set：根据传入的参数创建一个新的集合

  >>>set() # 不传入参数，创建空集合
  set()
  >>> a = set(range(10)) # 传入可迭代对象，创建集合
  >>> a
  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  

  ♦ frozenset：根据传入的参数创建一个新的不可变集合

  >>> a = frozenset(range(10))
  >>> a
  frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
  

  ♦ enumerate：根据可迭代对象创建枚举对象

  >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
  >>> list(enumerate(seasons))
  [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
  >>> list(enumerate(seasons, start=1)) #指定起始值
  [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
  

  ♦ range：根据传入的参数创建一个新的range对象

    '''
    遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 
    寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
    '''
  >>> a = range(10)
  >>> b = range(1,10)
  >>> c = range(1,10,3)
  >>> a,b,c # 分别输出a,b,c
  (range(0, 10), range(1, 10), range(1, 10, 3))
  >>> list(a),list(b),list(c) # 分别输出a,b,c的元素
  ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
  >>
  

  ♦ iter：根据传入的参数创建一个新的可迭代对象

  '''
    遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 
    寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
  '''
  >>> a = iter('abcd') #字符串序列
  >>> a
  <str_iterator object at 0x03FB4FB0>
  >>> next(a)
  'a'
  >>> next(a)
  'b'
  >>> next(a)
  'c'
  >>> next(a)
  'd'
  >>> next(a)
  Traceback (most recent call last):
    File "<pyshell#29>", line 1, in <module>
      next(a)
  StopIteration
  

  ♦ slice：根据传入的参数创建一个新的切片对象

  >>> c1 = slice(5) # 定义c1
  >>> c1
  slice(None, 5, None)
  >>> c2 = slice(2,5) # 定义c2
  >>> c2
  slice(2, 5, None)
  >>> c3 = slice(1,10,3) # 定义c3
  >>> c3
  slice(1, 10, 3)
  

  ♦ super：根据传入的参数创建一个新的子类和父类关系的代理对象

    '''
    遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006 
    寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
    '''
  #定义父类A
  >>> class A(object):
      def __init__(self):
          print('A.__init__')
  
  #定义子类B，继承A
  >>> class B(A):
      def __init__(self):
          print('B.__init__')
          super().__init__()
  
  #super调用父类方法
  >>> b = B()
  B.__init__
  A.__init__
  

  ♦ object：创建一个新的object对象

  >>> a = object()
  >>> a.name = 'kim' # 不能设置属性
  Traceback (most recent call last):
    File "<pyshell#9>", line 1, in <module>
      a.name = 'kim'
  AttributeError: 'object' object has no attribute 'name'
  

可迭代对象

1.迭代如何理解
	迭代就是更新换代，每次迭代都需要基于上一次的成果
	eg:手机上面的软件更新其实专业名词>>>:软件版本迭代
--------------------------------------------	
2.代码演示
 # 不属于迭代
    # while True:
    #     print('嘿嘿嘿')

    # 属于迭代
    n = 0
    while n < 10:
        print(n)
        n += 1
--------------------------------
3.如何判断可迭代对象
	内置有__iter__方法的都叫做可迭代对象
		1.内置是什么意思    通过句点符直接能够点出来的东西都叫内置
		2.__XXX__  针对双下划线开头双下划线结尾的方法 统一读作双下XXX
# int  # 整型不是可迭代对象
# float  # 浮点型不是可迭代对象
# str  # 字符串是可迭代对象
# list  # 列表是可迭代对象
# dict  # 字典是可迭代对象
# tuple  # 元组是可迭代对象
# set  # 集合是可迭代对象
# bool  # 布尔值不是可迭代对象
# def index():  # 函数名不是可迭代对象
#     print()
#f = open(r'01 考题讲解.py','r',encoding='utf8')  # 文件对象是可迭代对象

迭代器对象

作用:
	迭代器对象给我们提供了一种不依赖于索引取值的方式
	正是因为有迭代器对象的存在 我们才能对字典、集合这些无序类型循环取值
	
	1.如何判断迭代器对象
	内置有__iter__和__next__的对象都称为迭代器对象
------------------------------------------------	
2.可迭代对象与迭代器对象的关系
	可迭代对象调用__iter__方法之后就会变成迭代器对象
	迭代器对象调用__iter__方法无论多少次还是迭代器对象本身
------------------------------------------------------
3.迭代器对象迭代取值
	 # res = 'jason'.__iter__()  # res已经是迭代器对象
    # print(res.__next__())  # j
    # print(res.__next__())  # a
    # print(res.__next__())  # s
    # print(res.__next__())  # o
    # print(res.__next__())  # n
    # print(res.__next__())  # 没有了直接报错


    # d1 = {'name':'jason','pwd':123}
    # res = d1.__iter__()
    # print(res.__next__())
    # print(res.__next__())


    l1 = [11, 22, 33, 44, 55, 66, 77, 88]
    # 需求:不使用for循环 依次打印出列表中所有的数据值
    # 1.先将列表变成迭代器对象
    res = l1.__iter__()
    # 2.定义一个计数器
    count = 0
    # 3.编写while循环
    while count < len(l1):
        print(res.__next__())
        count += 1
------------------------------------------------------------
4.补充说明
	4.1.迭代器反复使用
         l = [11, 22, 33, 44]
        # print(l.__iter__().__next__())  # 11  每次都是产生了一个新的迭代器对象
        # print(l.__iter__().__next__())  # 11
        # print(l.__iter__().__next__())  # 11
        # print(l.__iter__().__next__())  # 11
        res = l.__iter__()
        print(res.__iter__().__next__())  # 11  每次使用的都是一个迭代器对象
        print(res.__iter__().__next__())  # 22
        print(res.__iter__().__next__())  # 33
        print(res.__iter__().__next__())  # 44
 	4.2.针对双下方法
    	res = l.__iter__()  # 可以简写iter(l)
		res.__next__()  # 可以简写next(res1)
	4.3.迭代器对象特殊的地方(******)
    	可迭代对象 迭代器对象 通过打印操作无法直接看出内部数据的情况
        这个时候他们都能够帮你节省内存
        	相当于是一个工厂 你要一个数据就临时给你造一个

for循环的本质

语法结构
	for 变量名 in 可迭代对象：
		for 循环代码块
1.for会自动将in后面的数据调用__iter__()变成迭代器对象
2.之后每次循环调用__next__()取值
3.最后没有值__next__()会报错 for能够自动处理该错误 让循环正常结束