标签：__ 内置 7.11 迭代 res next .__ print

今日学习内容

常见内置函数

内置函数都是提前定义好的 直接可以使用
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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。