今日学习内容

一、常见内置函数

内置函数：提前定义好的，直接使用即可。

1. abs() 求绝对值

   print(abs(-23)) #23
   

2. all()与any() 判断容器类型中的所有数据值对应的布尔值是否为True

   all() 判断所有的数据值为True的情况下，结果才是True。
   print(all([1,2,3,0])) #False  
   print(any([1,2,3]))  #True
   
   any() 判断有一个数据值为True，结果就是True
   print(all([1,2,3,0])) #False 
   print(any([1,2,3]))  #True
   
   

3. bin() 十进制转二进制数、oct()十进制转八进制、hex()十进制转十六进制

   print(bin(10))  #0b1010
   print(oct(10))  #0o12
   print(hex(10))  #0xa
   

4. int() 类型转换 其他进制转十进制

   print(int(0b1010)) #10
   print(int(0o12))  #10
   print(int(0xa))  #10
   
   

5. bytes() 类型转换

   encode 编码 / decode 解码
   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专业名词中翻译成 调用 加括号执行

   判断某个变量是否可以加括号调用 结果是布尔值
   age = 18
   def index():
       print('oooooooo')
   print(callable(age))  #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
   879          10         ？
   '''
   real_num, more = divmod(879, 10) #将879 除以 10 的整数和余数分别赋值给real_num 和 more
   if more: #如果more不为0 也就是Flase，就执行自增1.
       real_num += 1
   print('总页数：%s' % real_num)
   
   

10. enumerate() 枚举

    name_list = ['xz', 'bx','wyb']
    需求：循环打印出数据值和对应的索引值
    
    for i, j in enumerate(name_list, 10): #第二个参数表示索引值的初始值，没有则表示默认索引值从0开始数。
        print(i, j)
    

11. eval() exec() 能够识别字符串中python代码并执行

    res = 'print(123)'
    eval(res)  #不能识别复杂结构的代码，只能识别最简单的
    exec(res)  #能够识别复杂结构的代码
    res1 = ' for i in range(5):print(i)
    eval(res1)  #报错
    exec(res1) 
    '运行结果：
            0
            1
            2
            3
            4
     '
    
    

12. hash() 返回一串随机的数字（哈希值）

    print(hash('xz'))
    print(hash('123'))
    '运行结果：
        -670029249535673465
        -7269584516413125198'
    
    

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)) #98
    print(round(98.6)) #99
    
    

二、可迭代对象

1. 迭代就是更新换代，每次迭代都需要基于上一次的成果

2. 迭代：

   n = 0
   while n < 10:
       print(n)
       n += 1
   
   

3. 判断可迭代对象

   1.内置有__iter__方法都叫做可迭代对象。

   2.内置是什么意思，通过 . 句点符直接点出方法都叫内置

   3.__xxx__ 针对双下划线开头双下划线结尾的方法，统一读做双下xxx

   '''
   可迭代对象
   	字符串，列表，字典，元组，集合，文件对象（本身就是迭代器对象
   不可迭代对象
   	整型，浮点型，布尔值，函数名
   可迭代对象能够支持for循环
   
   '''
   

三、迭代器对象

'''
作用：
	迭代器对象给我们提供一种一种不依赖于索引取值的方式
	迭代器存在，我们才能对字典，集合这些无序类型循环取值
'''

1. 判断迭代器对象

   内置有__iter__ 和__next__的对象都称为迭代器对象

2. 可迭代对象与迭代器对象的关系

   可迭代对象调用__iter__方法之后就会变成迭代器对象

   迭代器对象调用__iter__方法无论多少次还是迭代器对象的本身

3. 迭代器对象迭代取值

   res = 'xz'.__iter__() #res已经是迭代器对象
   print(res.__next__()) #x
   print(res.__next__()) #z
   print(res.__next__()) #没有了直接报错
   
   
   d1 = {'name':'xz','pwd':123}
   res = d1.__iter__()#先将可迭代对象转化成迭代器对象
   print(res.__next__()) #name
   print(res.__next__()) #pwd
   
   
   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. 补充说明

   1.迭代器反复使用
   	l = [11,22,33,44]
       print(l.__iter__().__next__()) # 每次都产生一个新的迭代器对象
       print(l.__iter__().__next__())
       print(l.__iter__().__next__())
       print(l.__iter__().__next__())
   '运行结果：
           11
           11
           11
           11'
       res = l.__iter__()
       print(res.__iter__().__next__()) #每次使用的都是一个迭代器对象
       print(res.__iter__().__next__())
       print(res.__iter__().__next__())
       print(res.__iter__().__next__())
   2.针对双下方法
   	res = l.__iter__() 可以简写成iter(l)
       res.__next__()   可以简写next(res1)
   3.迭代器对象特殊的地方
   	'节省内存！！！''
       可迭代对象，迭代器对象，通过打印操作无法直接看出内部数据的情况
       这个时候以上都可以减少一些内存。
       	相当于是一个共存，需要数据的时候临时造一个。
        迭代器 __next__() 后就能使用
   

四、for循环的本质

语法结构
	for 变量名 in 可迭代对象：
    	循环体代码
 for循环原理：
	1.for会自动将in后面的数据调用__iter__()变成迭代器对象
	文件对象也可以用for循环，因为本身就是迭代器对象，再次调用不变
    2.之后每次循环调用__next__()取值
    3.最后没有值__next__()会报错，for能够自动处理该错误的，让循环正常结束。

补充知识

1.使用列表实现队列和堆栈的效果
	队列:先进先出
	堆栈:先进后出
    # 1.使用列表实现队列和堆栈的效果
    # 	队列:先进先出
    # 	堆栈:先进后出

    # 队列
    # new_list = []
    # 先放数据
    # new_list.append(111)
    # new_list.append(222)
    # new_list.append(333)  # [111,222,333]
    # 再取数据  pop具有在上一个列表当中取出效果 后面有参数表示索引值从什么地方开始取
    # print(new_list.pop(0))
    # print(new_list.pop(0))
    # print(new_list.pop(0))


    # 堆栈
    # new_list = []
    # 先放数据
    # new_list.append(111)
    # new_list.append(222)
    # new_list.append(333)  # [111, 222, 333]
    # 再取数据  pop后面没参数，则表示默认在尾部取值。
    # print(new_list.pop())
    # print(new_list.pop())
    # print(new_list.pop())