今日学习内容

常见内置函数

内置函数都是提前定义好的 直接可以使用
1.abs() 求绝对值
	print(abs(-66))  # 66
2.all() 所有数据值为Ture的时候，才会为Ture
	print(all([1, 2, 3, 4, 5, 0]))  # False
	print(all([1, 2, 3, 4, 5]))  # Ture
3.any() 所有数据值只要有一个为Ture 结果结束Ture
	print(any([1, 2, 3, 4, 5, 0]))  # True
	print(any([1, 2, 3, 4, 5]))  # True
4.bin() 将十进制转换成二进制 0b开头的为二进制
	print(bin(66))  # 0b1000010
5.oct() 将十进制转换成八进制 0o开头的为八进制
	print(oct(66))  # 0o102
6.hex() 将十进制转换成十六进制 0x开头为十六进制
	print(hex(66))  # 0x42
7.int() 类型转换 将其他进制转换成十进制
	print(int(0b1000010))  # 66
	print(int(0o102))  # 66
	print(int(0x42))  # 66
8.bytes() 转字符串转换成字节类型 针对于编码与解码
        res = '没有梦想跟咸鱼有什么区别'.encode('utf8')  # 编码
        print(res)  # b'\xe6\xb2\xa1\xe6\x9c\x89\xe6\xa2\xa6\xe6\x83\xb3\xe8\xb7\x9f\xe5\x92\xb8\xe9\xb1\xbc\xe6\x9c\x89\xe4\xbb\x80\xe4\xb9\x88\xe5\x8c\xba\xe5\x88\xab'
        res1 = res.decode('utf8')  # 解码
        print(res1)  # 没有梦想跟咸鱼有什么区别
        res = bytes('没有梦想跟咸鱼有什么区别'.encode('utf8'))
        print(res)  # b'\xe6\xb2\xa1\xe6\x9c\x89\xe6\xa2\xa6\xe6\x83\xb3\xe8\xb7\x9f\xe5\x92\xb8\xe9\xb1\xbc\xe6\x9c\x89\xe4\xbb\x80\xe4\xb9\x88\xe5\x8c\xba\xe5\x88\xab'
        res1 = str(res, 'utf8')
        print(res1)  # 没有梦想跟咸鱼有什么区别
9.callable() 判断某个变量是否可以加括号调用
call在IT专业名词中翻译成 调用>>>:加括号执行
	name = 'jason'
	def func():
        print('from func')
	print(callable(name))  # False
	print(callable(func))  # True
10.chr() 依据ASCII码表实现字符与数据的转换
	通过数据返回字符
	print(chr(65))  # A
	print(chr(97))  # a
11.ord()
	通过数字返回字母
	print(ord('A'))  # 65
	print(ord('a'))  # 97
12.复数 实部虚部 a = 10 + 8i
13.dir() 获取对象内部可以通过句点符获取的数据
	import time
	print(dir(time))
14.divmod() 获取除法之后的整数和余数
手上666数据 每页展示10条 需要多少条
	res_mun, more = divmod(666, 10)
	if more:
    	res_mun += 1
	print('总页数:%s' % res_mun)  # 总页数:67条
15.enumerate 枚举
循环打印数据值并且对应索引值
l1 = ['jason', 'joker', 'tony', 'kevin']
	for i, j in enumerate(l1, 10):
    	print(i, j)
# 10 jason
# 11 joker
# 12 tony
# 13 kevin
默认从0开始,可以自定义起始位
16.eval()与exec() 能够识别字符串中的python代码并运行
	res = 'print(666)'
	eval(res)  # 666 只能识别最简单的代码 复杂的识别不了
	exec(res)  # 666
17.exec()
	res = 'for i in range(2):print(i)'
	exec(res) # 能够识别复杂的代码
	# 0
	# 1
18.hash() 哈希算法 返回一串随机数字
	print(hash('jason'))  # -530783988812184929
19.help() 查看帮助信息
	help(len)
20.isinstance() 判断某个数据是否属于某个数据类型
	print(isinstance('哈哈', str))  # True
	print(isinstance('哈哈',int))  # False
21.pop() 幂指数
        print(pow(2, 3))
22.round() 四舍五入
	print(round(66.2))  # 66
	print(round(66.7))  # 67

可迭代对象

1.迭代如何理解
	迭代就是更新换代 每次迭代都需要基于上一次成果  例如手机上的软件更新换代 更新迭代
	手机上的软件更新专业名词>>>:软件版本迭代
2.代码演示
	属于迭代器
    while True:
        print('嘿嘿')
	属于迭代器
    count = 0
    while count < 10:
        print(count)
        count += 1
# 因为每一次打印的都基于上一次count加1得来的结果 这个就属于是迭代
3.如何判断可迭代对象
	可以对象当成我们要研究的目标 我们研究谁就把谁当成对象
'''
内置有__iter__方法的都叫可迭代对象
	1.内置是什么意思 通过句点符直接能够点出来的东西都叫内置
	2.__xxx__ 针对双下划线开头双下划线结尾的方法 官方统一读作双下xxx  
'''
可迭代对象有
	字符串 列表 字典 元组 集合 文件对象(本身就是迭代器对象)
不是可迭代对象
	整型 浮点型 布尔值 函数名
可迭代对象的作用就是为了让你循环取值 并且提供了一种让你不需要索引取值的方式

迭代器对象

迭代器对象给我们提供了一种不依赖索引取值的方式
正是因为有迭代器的存在 我们才能对字典 集合这些无序类型循环取值
为啥能够for循环字典 集合 不是因为本身就是获取 而是因为里面用了迭代器对象
1.如何判断迭代器对象
	内置有__iter__和__next__的对象都称为迭代器对象
2.可迭代对象与迭代器对象的关系
	可迭代器对象调用__iter__方法后就会变成迭代器对象
	迭代器对象调用__iter__方法无论多少次还是迭代器对象本身
3.迭代器对象迭代取值
 
        print(res.__iter__())
        print(res.__iter__().__iter__().__iter__())  # # 执行一次跟执行多次已经没有意义了 调用一次之后在调用的就是自己的本身

    res = 'jason'.__iter__()  # res此时已经是迭代器对象
        print(res.__next__())  # j # 迭代器在调__next__方法其实就是在迭代取值 从第一个开始取一个在取一个
        print(res.__next__())  # a
        print(res.__next__())  # s
        print(res.__next__())  # o
        print(res.__next__())  # n
        print(res.__next__())  # 没有了就会直接报错

    dict1 = {'name': 'jason', 'age': 18}
    res = dict1.__iter__()
        print(res.__next__())   # name
        print(res.__next__())  # age
        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迭代器反复使用
        l1 = ['jason', 'joker', 'tony', 'kevin']
        print(l1.__iter__().__next__())  # jason  每次都是产生了一个新的迭代器对象 如果是新的每次都会重新开始取
        print(l1.__iter__().__next__())  # jason
        print(l1.__iter__().__next__())  # jason
        print(l1.__iter__().__next__())  # jason


        res = l1.__iter__()   # 此时已经是迭代器对象  所以每次使用的都是同一个迭代器对象
        print(res.__iter__().__next__())  # jason
        print(res.__iter__().__next__())  # joker
        print(res.__iter__().__next__())  # tony
        print(res.__iter__().__next__())  # kevin
	4.2 针对双下方法
        l1 = ['jason', 'joker', 'tony', 'kevin']
        res = l1.__iter__()  # 等价于 iter(l1)
        res.__next__()  # 等价于 next(l1)
喜欢用那个方法就可以用那个方法 推荐使用前面这个 具有辨识度看到这个标识就知道是要变成迭代器了 迭代取值
	4.3 迭代器对象特殊地方(******) 为了节省内存
		可迭代器对象 迭代器对象 通过打印操作无法直接看出内部数据情况 这个时候他们都能够帮你节省内存 类似于一个加工厂 你要一个数据的时候就临时给你加工一个
        print(range(10))  # range(0, 10)
        l1 = [11, 22, 33]
        res = l1.__iter__()
        print(res)  # <list_iterator object at 0x000002A7B4E5B278>


        l1 = [11, 22, 33, 44, 55]
        res = map(lambda a: a + 2, l1)
        print(res)  # <map object at 0x0000026912F6B320>
        print(res.__next__())  # 13
        print(res.__next__())  # 24

python2中里面打印的直接就是一个列表
python3中打印看不到具体结果 为了节省内存

for循环的本质

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

标签：__,内置,7.11,迭代,res,next,.__,print
来源： https://www.cnblogs.com/lisony/p/16467762.html