今日学习

常见内置函数

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

常见的内置函数

内置函数:提前定义好的 直接使用即可 很多内置函数的功能都非常的好用
    
# 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能够自动处理该错误 让循环正常结束

标签：__,.__,20,迭代,python,res,next,print
来源： https://www.cnblogs.com/zongliang-ya/p/16467583.html