精华内容
下载资源
问答
  • Python 内置对象

    万次阅读 2020-02-05 22:34:49
    内置类型有哪些 主要内置类型有数字、序列、映射、类、实例和异常 假值内置对象 被定义为假值的常量: None 和 False 任何数值类型的零:0, 0.0, 0j, Decimal(0), Fraction(0, 1) 空的序列和多项集: '', (), [], {}...

    内置类型有哪些

    • 主要内置类型有数字、序列、映射、类、实例和异常

    假值内置对象

    • 被定义为假值的常量: None 和 False
    • 任何数值类型的零:0, 0.0, 0j, Decimal(0), Fraction(0, 1)
    • 空的序列和多项集: '', (), [], {}, set(), range(0)

    数字类型

    • 数字类型有 整数, 浮点数 和 复数。布尔值属于整数的子类型
    • 构造器 int(), float()complex()可被用于生成特定类型的数字

    整数类型的附加方法

    方法 功能
    bit_length() 返回以二进制表示一个整数所需要的位数,不包括符号位和前面的零
    to_bytes(length, byteorder, *, signed=False) 返回表示一个整数的字节数组
    from_bytes(bytes, byteorder, *, signed=False) 返回由给定字节数组所表示的整数
    as_integer_ratio() 返回一对整数,其比率正好等于原整数并且分母为正数。 整数的比率总是用这个整数本身作为分子,1 作为分母

    浮点类型的附加方法

    方法 功能
    as_integer_ratio() 返回一对整数,其比率正好等于原浮点数并且分母为正数。 无穷大会引发 OverflowErrorNaN则会引发 ValueError
    is_integer() 如果 float 实例可用有限位整数表示则返回 True,否则返回False
    hex() 以十六进制字符串的形式返回一个浮点数表示。 对于有限浮点数,这种表示法将总是包含前导的 0x 和尾随的 p 加指数
    fromhex(s) 返回以十六进制字符串 s 表示的浮点数的类方法。 字符串 s 可以带有前导和尾随的空格

    迭代类型

    • Python 支持在容器中进行迭代的概念。 通过使用两个单独方法来实现的;它们被用于允许用户自定义类对迭代的支持

    • 容器对象要提供迭代支持,必须定义一个方法

      container.__iter__()

      返回一个迭代器对象。 该对象需要支持下文所述的迭代器协议。 如果容器支持不同的迭代类型,则可以提供额外的方法来专门地请求不同迭代类型的迭代器

    • 迭代器对象自身需要支持以下两个方法,它们共同组成了 迭代器协议

      iterator.__iter__()

      返回迭代器对象本身。 这是同时允许容器和迭代器配合 for 和 in 语句使用所必须的

      iterator.__next__()

      从容器中返回下一项。 如果已经没有项可返回,则会引发 StopIteration 异常

    生成器类型

    • Python 的 generator 提供了一种实现迭代器协议的便捷方式。 如果容器对象__iter__() 方法被实现为一个生成器,它将自动返回一个迭代器对象(从技术上说是一个生成器对象),该对象提供 __iter__()__next__() 方法

    序列类型

    • 基本序列类型有 list, tuplerange 对象

    通用序列操作

    • 大多数序列类型,包括可变类型和不可变类型都支持运算操作

    • 序列运算

      注: s 和 t 是具有相同类型的序列,n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限

      运算 结果
      x in s 如果 s 中的某项等于 x 则结果为 True,否则为 False
      x not in s 如果 s 中的某项等于 x 则结果为 False,否则为 True
      s + t s 与 t 相拼接
      s * n 或 n * s 相当于 s 与自身进行 n 次拼接
      s[i] s 的第 i 项,起始为 0
      s[i:j] s 从 i 到 j 的切片
      s[i:j:k] s 从 i 到 j 步长为 k 的切片
      len(s) s 的长度
      min(s) s 的最小项
      max(s) s 的最大项
      s.index(x[, i[, j]]) x 在 s 中首次出现项的索引号(索引号在 i 或其后且在 j 之前)
      s.count(x) x 在 s 中出现的总次数

    不可变序列类型

    • 不可变序列类型普遍实现而可变序列类型未实现的唯一操作就是对 hash() 内置函数的支持

    • 尝试对包含有不可哈希值的不可变序列进行哈希运算将会导致 TypeError

    可变序列类型

    • 序列运算

      以下表格中的操作是在可变序列类型上定义的

      注: 表格中的 s 是可变序列类型的实例,t 是任意可迭代对象,而 x 是符合对 s 所规定类型与值限制的任何对象

      运算 结果
      s[i] = x 将 s 的第 i 项替换为 x
      s[i:j] = t 将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容
      del s[i:j] 等同于 s[i:j] = []
      s[i:j:k] = t 将 s[i:j:k] 的元素替换为 t 的元素
      del s[i:j:k] 从列表中移除 s[i:j:k] 的元素
      s.append(x) 将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])
      s.clear() 从 s 中移除所有项 (等同于 del s[:])
      s.copy() 创建 s 的浅拷贝 (等同于 s[:])
      s.extend(t) 或 s += t 用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)
      s *= n 使用 s 的内容重复 n 次来对其进行更新
      s.insert(i, x) 在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
      s.pop([i]) 提取在 i 位置上的项,并将其从 s 中移除
      s.remove(x) 删除 s 中第一个 s[i] 等于 x 的项目。
      s.reverse() 就地将列表中的元素逆序。

    列表

    • 列表是可变序列,通常用于存放同类项目的集合

    • list([iterable]) 可以用多种方式构建列表

      • 使用一对方括号来表示空列表: []
      • 使用方括号,其中的项以逗号分隔: [a], [a, b, c]
      • 使用列表推导式: [x for x in iterable]
      • 使用类型的构造器: list() 或 list(iterable)

    元组

    • 元组是不可变序列,通常用于储存异构数据的多项集

    • tuple([iterable]) 可以用多种方式构建元组

      • 使用一对圆括号来表示空元组: ()
      • 使用一个后缀的逗号来表示单元组: a, 或 (a,)
      • 使用以逗号分隔的多个项: a, b, c or (a, b, c)
      • 使用内置的 tuple(): tuple() 或 tuple(iterable)

    range对象

    • range 类型表示不可变的数字序列,通常用于在 for 循环中循环指定的次数

    文本序列类型

    • 在 Python 中处理文本数据是使用 str 对象,也称为 字符串。 字符串是由 Unicode 码位构成的不可变 序列

      • 单引号: '允许包含有 "" 引号'
      • 双引号: "允许包含有 '' 引号"
      • 三重引号: '''三重单引号''', """三重双引号"""
    • 使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中

    • 作为单一表达式组成部分,之间只由空格分隔的多个字符串字面值会被隐式地转换为单个字符串字面值

    二进制序列类型

    • 操作二进制数据的核心内置类型是 bytesbytearray

    bytes 对象

    • bytes 对象是由单个字节构成的不可变序列

    构造器:

    bytes([source[, encoding[, errors]]])

    • bytes 字面值的语法与字符串字面值的大致相同,只是添加了一个 b 前缀
      • 单引号: b’同样允许嵌入 “双” 引号’。
      • 双引号: b"同样允许嵌入 ‘单’ 引号"。
      • 三重引号: b’’‘三重单引号’’’, b""“三重双引号”""

    bytearray 对象

    构造器:

    bytearray([source[, encoding[, errors]]])

    • bytearray 对象没有专属的字面值语法,通过调用构造器来创建

      • 创建一个空实例: bytearray()
      • 创建一个指定长度的以零值填充的实例: bytearray(10)
      • 通过由整数组成的可迭代对象: bytearray(range(20))
      • 通过缓冲区协议复制现有的二进制数据: bytearray(b'Hi!')

    集合类型

    • set 对象是由具有唯一性的 hashable 对象所组成的无序多项集set 对象是由具有唯一性的 hashable 对象所组成的无序多项集

    • 目前有两种内置集合类型,setfrozenset

    • set 类型是可变的 。其内容可以使用 add()remove() 这样的方法来改变。 由于是可变类型,它没有哈希值,且不能被用作字典的键或其他集合的元素。 frozenset 类型是不可变并且为 hashable。其内容在被创建后不能再改变;因此它可以被用作字典的键或其他集合的元素

    构造器:

    set([iterable])

    frozenset([iterable])

    映射类型

    • 映射属于可变对象

    • 字典是标准映射类型

    • 字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建

    构造器:

    dict(**kwarg)

    dict(mapping, **kwarg)

    dict(iterable, **kwarg)

    上下文管理器类型

    Python 的 with 语句支持通过上下文管理器所定义的运行时上下文这一概念。 此对象的实现使用了一对专门方法,允许用户自定义类来定义运行时上下文,在语句体被执行前进入该上下文,并在语句执行完毕时退出该上下文

    其他内置类型

    模块

    • 模块唯一的特殊操作是属性访问: m.namem 为一个模块而 name 访问定义在 m 的符号表中的一个名称。 模块属性可以被赋值

    类与类实例

    • 类定义是一条可执行语句,Python 程序中的所有数据都是由对象或对象间关系来表示的

    函数

    • 函数对象是通过函数定义创建的

    方法

    • 方法是使用属性表示法来调用的函数。 存在两种形式:内置方法和类实例方法

    代码对象

    • 代码对象被具体实现用来表示“伪编译”的可执行 Python 代码

    类型对象

    • 类型对象表示各种对象类型

    空对象

    • 此对象会由不显式地返回值的函数所返回。 不支持任何特殊的操作。 空对象只有一种值 None

    省略符对象

    • 此对象常被用于切片。 不支持任何特殊的操作。 省略符对象只有一种值 Ellipsis

    未实现对象

    • 此对象会被作为比较和二元运算被应用于它们所不支持的类型时的返回值。 未实现对象只有一种值 NotImplemented

    布尔值

    • 布尔值是两个常量对象 FalseTrue

    内部对象

    • 其中描述了栈帧对象、回溯对象以及切片对象等等

    特殊属性

    object.__dict__ 一个字典或其他类型的映射对象,用于存储对象的(可写)属性。
    instance.__class__ 类实例所属的类。
    class.__bases__ 由类对象的基类所组成的元组。
    definition.__name__ 类、函数、方法、描述器或生成器实例的名称。
    definition.__qualname__ 类、函数、方法、描述器或生成器实例的 qualified name
    class.__mro__ 此属性是由类组成的元组,在方法解析期间会基于它来查找基类。
    class.mro() 此方法可被一个元类来重载,以为其实例定制方法解析顺序。 它会在类实例化时被调用,其结果存储于 __mro__ 之中。
    class.__subclasses__() 每个类会保存由对其直接子类的弱引用组成的列表。 此方法将返回一个由仍然存在的所有此类引用组成的列表。
    展开全文
  • python 强大的内置类型让我接触到python的时候开始慢慢的喜欢上它了,感觉既方便又好用,下面我们先一起学习下内置对象类型的好处:1内置对象能够使得我们编写程序更容易。2内置的对象效率更高,看过python源码剖析...

    python 强大的内置类型让我接触到python的时候开始慢慢的喜欢上它了,感觉既方便又好用,下面我们先一起学习下内置对象类型的好处:

    1内置对象能够使得我们编写程序更容易。

    2内置的对象效率更高,看过python源码剖析的朋友应该发现python很多内置对象都是用C来实现的,
    这样比你自己用python去构造一些数据类型效率要高。

    python 核心的数据类型有:
    数字,字符串,列表,字典,元组等。

    下面详细的学习下python的核心数据类型:

    1 数字包括整数,浮点数等。
    2 字符串的相关教程可以看看:python字符串连接python 字符串替换和 python 字符串截取
    3 列表的相关教程:python列表python 列表解析
    4 字典的相关教程:python 字典 
    5 元组的相关教程:python 元组

    看完了上面的教程,相信你对python 对象类型了解的不错了。最后我推荐大家看下总结性的文章:
    python 数据类型

    展开全文
  • Python主要的内置数据类型有哪些

    千次阅读 2019-04-18 17:57:36
    Python基本内置数据类型有哪些: 一些基本数据类型,比如:整型(数字)(int)、字符串(str)、元组(tuple)、列表(list)、字典(dict)和布尔类型。 四种不同的数字类型: int(有符号整型) long(长整型[也可以...

    Python基本内置数据类型有哪些:
    一些基本数据类型,比如:整型(数字)(int)、字符串(str)、元组(tuple)、列表(list)、字典(dict)和布尔类型。
    四种不同的数字类型:
    int(有符号整型)
    long(长整型[也可以代表八进制和十六进制])
    float(浮点型)
    complex(复数)
    小整数对象——小整型对象池
    随着学习进度的加深,大家还会接触到更多更有趣的数据类型,python初学者入门时先了解这几种类型就可以了。
    基本内置数据类型对应符号
    1)整型——int——数字
    python有5种数字类型,最常见的就是整型int,int python方法很实用。例如:1234、-1234
    2)布尔型——bool——用符号==表示
    布尔型是一种比较特殊的python数字类型,它只有True和False两种值,它主要用来比较和判断,所得结果叫做布尔值。例如:==20 给出True,==35给出False
    3)字符串——str——用’ '或" “表示
    例如:'hello world’或者"hello”
    4)列表——list——用[ ]符号表示
    例如:[1,2,3,4]
    5)元组——tuple——用( )符号表示
    例如:(‘d’,‘c’)
    6)字典——dict——用{ }符号表示
    例如:{‘name’:‘coco’,‘country’:‘china’}
    示例:

    print(type(1))
    print(type({}))
    print(type(''))
    print(type((1,)))
    print(type([1]))
    print(type(True))
    
    **output**
    
    <class 'int'>
    <class 'dict'>
    <class 'str'>
    <class 'tuple'>
    <class 'list'>
    <class 'bool'>
    

    Python基本数据类型中哪些可变,哪些是不可变?
    python可变数据类型:列表list[ ]、字典dict{ }

    dict={'a':1,'b':2}
    dict['c']=3
    list=[1,2]
    list.append(3)
    print(dict)
    print(list)
    
    **output**
    
    {'a': 1, 'b': 2, 'c': 3}
    [1, 2, 3]
    

    python不可变数据类型:整型int、字符串str、元组tuple()

    展开全文
  •  python内置函数,是随着python解释器运行而创建的函数,不需要重新定义,可以直接调用,那python的内置函数有哪些呢,接下来我们就了解一下python的内置函数,这些内置函数中,有一些是面相对象的内容,还有一些是...

    Python内置函数

      python内置函数,是随着python解释器运行而创建的函数,不需要重新定义,可以直接调用,那python的内置函数有哪些呢,接下来我们就了解一下python的内置函数,这些内置函数中,有一些是面相对象的内容,还有一些是某些模块有关的,我们今天就先了解一些,那些涉及到某些模块以及面向对象的内容我们以后学到之后可再加深了解。

    abs()

    这个函数的就是将传入的数值取绝对值然后将绝对值。

    i = abs(-50)
    print(i)
    k = abs(50)
    print(k)
    
    
    输出结果:
    50
    50

    all()

    给all()这个函数传一个可迭代的数据,all()函数内部回去迭代,如果这里面所有被迭代的对象都是真值,all()函数就返回一个True,如果有一个不是真值就返回False。

    li = [1,2,3,4,5]    
    i = all(li)
    print(i)
    li1 = [1,2,3,0] #0为假值
    k = all(li1)
    print(k)
    
    
    输出结果:
    True
    False

    如何判断哪些是真值哪些是假值,真值有很多但是假值仅有几个我们通过拿到布尔值进行判断,通过一些的示例我们可以知道0,None,以及空值都是假的。

    print(bool(0))  #数字零为假
    print(bool(None))   #None为假
    print(bool("")) #空的字符串为假,这个空字符串不包含任何字符以及空格
    print(bool(())) #空的元组为假
    print(bool([]))#空的列表为假
    print(bool({}))#空的字典为假
    
    
    输出结果:
    False
    False
    False
    False
    False
    False

    any()

    这个any()和all()有些相似,相似的地方就是判断是否为真值,但是all()是所有为真输出True,any()是只要有一个是真就输出True。

    li = [1,0]
    i = any(li)
    print(i)
    li1 = [0,0,""]
    k = any(li1)
    print(k)
    
    
    输出结果:
    True
    False

    ascii()

    我们使用ascii()这个函数的时候,去传入对象的类(列表list,字典dict)中找__repr__这个方法,去执行这个方法,拿到这个方法的返回值。

    我们在这里举一个例子,这个例子涉及到类,没了解过的可以在我以后的博客文章中了解以后再来深入学习。

    class Nuo:
        def __repr__(self):
            return '123'
    
    obj = Nuo()
    print(ascii(obj))
    #这个使我们自己写的类,如果使用python中内部的__repr__方法
    
    
    li = list()
    print(ascii(li))    #列表的类中的__repr__方法返回的就是[]
    
    
    
    输出结果:
    123
    []

    bin()

    这个是二进制,可以将其它进制转换为二进制格式。

    oct()

    这个是八进制,可以将其它进制转换为八进制格式。

    int()

    这个是十进制,可以将其它进制转换为十进制格式。

    hex()

    这个是十六进制,可以将其它进制转换为十六进制的格式。

    以上四个的具体用法之前已经详细介绍,文章连接在这里:https://www.cnblogs.com/liudi2017/p/9171267.html

    bool()

    这个函数的作用是判断传入对象的真假,其实就是将传入的对象转换为bool值。

     

    print(bool(None))
    print(bool(1))
    print(bool("123"))
    
    输出结果:
    False
    True
    True

    bytes()

    这个表示字节

    字节和字符转的转换

    bytes("xxxx",encoding="utf-8")

    bytearrary()

    这个表示字节列表

    这两个我们仅仅知道这些即可,不需要太多的了解,很少会用到,我们以后用到会详细介绍。

     

    chr()

    接收一个数字,找到这个数字对应ascii码表中对应的元素。

    print(chr(97))    #在ascii码表中数值97对应的是小写字母a
    
    输出结果:
    a

    ord()

     这个函数的方法正好和chr()相对,它是将一个字符转换为ascii码中的数值。

    print(ord('p'))
    print(ord(' '))
    print(ord('_'))
    
    
    输出结果:
    112
    32
    95

    callable()

    判断对象是否可以执行,可以执行返回一个True,不可以执行返回一个False。

    def newfun():
        return 123
    
    
    newfun()
    r = callable(newfun)
    print(r)
    
    输出结果:
    True

    compile()

     接收一个字符串把这个字符串编译成python可以执行的代码,理解到这里就可以了。

    str = 'name = "alexsel";print(name)'
    obj = compile(str,'string','exec')
    exec(obj)
    
    输出结果:
    alexsel

    complex()

    函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
    如果第一个参数为字符串,则不需要指定第二个参数。
    这个在我们以后的学习中基本用不到。

    >>>complex(1, 2)
    (1 + 2j)
     
    >>> complex(1)    # 数字
    (1 + 0j)
     
    >>> complex("1")  # 当做字符串处理
    (1 + 0j)
     
    # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
    >>> complex("1+2j")
    (1 + 2j)

    dir()

    查询某个类提供了什么功能,下面示例就是查看列表这个类提供了什么功能。

    li=[]
    print(dir(li))
    
    
    输出结果:
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', ...........

    divmod()

    以元组的形式显示商和余数。

    >>> r=divmod(10,3)
    >>> print(r)
    (3, 1)

    eval()

    eval() 函数用来执行一个字符串表达式,并返回表达式的值。

    >>> a="1+3"
    >>> print(a)
    1+3
    >>> ret=eval("1+3")#把字符串转换为表达式
    >>> print(ret)  
    4
    >>>x = 7
    >>> eval( '3 * x' )
    21
    >>> eval('pow(2,2)')
    4
    >>> eval('2 + 2')
    4
    >>> eval("n + 4")
    85

    exec()

    执行一个字符串内的代码,无返回值(返回值为None),这个函数在我们介绍compile()的时候也用到过,可以上去看看之前的代码加深理解。

    >>> exec("print(123)")
    123

    filter()

    循环可迭代的对象,获取每一个参数,在函数里执行参数
    函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,
    然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
    格式:filter(函数,可迭代的对象)

    示例1

    def f1(x):
        if x>22:
            return True
        else:
            return False
    
    ret = filter(f1,[11,22,33,44])  #把返回为True的元素放到ret中
    for i in ret:  #用循环输出ret
        print(i)
    
    
    输出结果:
    33
    44

    示例2

    def f1(x):
        return x>22
    
    ret = filter(f1,[11,22,33,44]) #拿到传入函数的参数得到返回值得到元素。
    for i in ret:
        print(i)
    
    
    输出结果:
    33
    44

    map()

    map() 会根据提供的函数对指定序列做映射。
    第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
    格式:map(函数,可迭代的对象)

      def f1(x):
        return x+100
    
    ret = map(f1, [1,2,3,4,5])
    for i in ret:
        print(i)
    
    
    输出结果:
    101
    102
    103
    104
    105

    format()

    字符串格式化,字符串格式化我们以后会常常用到,这里就先不讲解,明天我们做一个详细的介绍。

    frozenset()

    创建一个不能添加元素的set格式,保存在set()中的数据是不能重复的,所以这个就是一个不能重复的,不可修改的数据类型。

    fset = frozenset([1,2,3,4,4])
    print(fset)
    
    输出结果:
    frozenset({1, 2, 3, 4})

    globals()

    获取当前代码里的所有的全局变量,下面的示例中出现里一些我们没有定义的全局变量,这些是python中需要用到的全局变量,自己生成的全局变量。

    name = 'alexsel'
    age = '47'
    obj = globals()
    print(obj)
    
    输出结果:
    {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': 
    <_frozen_importlib_external.SourceFileLoader object at 0x00000000020AB1D0>,
     '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 
    'C:/Users/Administrator/PycharmProjects/untitled1/Alexsel/new_one.py', 
    '__cached__': None, 'name': 'alexsel', 'age': '47', 'obj': {...}}

    local()

    获取当前代码里的所有的局部变量。

    hash()

    hash() 用于获取取一个对象(字符串或者数值等)的哈希值,一般用于字典key的优化。

    str = hash('alexsel')
    print(str)
    
    输出结果:
    9030579981152233445    

    #在 hash() 对对象使用时,所得的结果不仅和对象的内容有关,还和对象的 id(),也就是内存地址有关。

     

    id()

    用于查询某个对象的内存地址。

    name = 'alexsel'
    print(id(name))
    
    输出结果:
    37728920

    isinstance()

    判断某个对象是否由某一个类创建的。

    li=[11,22,33]
    t=isinstance(li,list)#判断li是否是由list类创建的
    print(t)
    a=isinstance(li,dict)#判断li是否是由dict类创建
    print(a)
    #如果某个类是当前类的父类也是支持的
    
    
    输出结果:
    True
    False

    issubclass()

    判断一个类是不是另一类的子类

    格式:issubclass(a,B),判断a是不是B的子类

    c = issubclass(list,object)
    print(c)
    
    输出结果:
    True

    iter()

    创建一个可以迭代的对象

    li = [1,2,3,4,5,6]
    for i in iter(li):
        print(i)
    
    
    输出结果:
    1
    2
    3
    4
    5
    6

    next()

    将一个可迭代的对象运行一个next就去一个值,取下一个值。

    a = iter([11, 22, 33, 44])
    print(a)
    r1 = next(a)
    print(r1)  
    r2 = next(a)
    print(r2)  
    
    
    输出结果:
    <list_iterator object at 0x0000000002120978>
    11
    22

    max()

    找到多个值中的最大值

    min()

    找到多个值中的最小值

    li = [11, 22, 33, 44]
    t = max(li)
    print(t)
    
    z = min(li)
    print(z)
    
    输出结果:
    44
    11

    memoryview()

    根据索引判断某个对象的的地址是多少
    函数返回给定参数的内存查看对象(Momory view)。
    所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。

    open()

    文件操作,操作文件的函数,这里做个简单的示例,明天会详细讲解。

    file1 = open('./text.txt',encoding='utf=-8')
    r1 = file1.read()
    print(r1)

    pow()

    返回x的y次方的值

    格式:pow(x,y)

    i=pow(2,10)
    print(i)
    
    
    输出结果:
    1024

    repr()

    返回__repr__的值,每个类中都写有__repr__方法,这个函数就是取到这个方法的返回值。
    repr() 函数将对象转化为供解释器读取的形式

    range()

    生成一个可以迭代的列表

    for i in range(4):  #从零开始生成,小于4
        print(i)
    print('--------')
    for k in range(7,9):    #大于等于7小于9
        print(k)
    
    
    输出结果:
    0
    1
    2
    3
    --------
    7
    8

    reversed()

    讲一个包含有多个元素的数据进行顺序的反转。

    li = [1,2,3,4,5,6]
    print(list(reversed(li)))
    
    
    输出结果:
    [6, 5, 4, 3, 2, 1]

    round()

    将一个数字进行四舍五入

    a = round(5.5)
    print(a)
    b = round(5.4)
    print(b)
    
    
    输出结果:
    6
    5

    slice() 函数实现切片对象,主要用在切片操作函数里的参数传递

    格式:slice(start,stop(step)

    start起始位置

    stop结束位置

    step每次切片间距

    li = [1,2,3,4,5,6,]
    slicetest = slice(3)
    print(li[slicetest])
    slicetest1 = slice(3,6,2)
    print(li[slicetest1])
    
    
    输出结果:
    [1, 2, 3]
    [4, 6]

    sorted()

    这个函数的功能是对含有多个元素的数据进行排序

    示例1

    li = [1, 22, 33, 222, 3, 1]
    print(li)
    le = sorted(li)# 生成新的值,不对原来的变量进行改变
    print(le)        #这个只能对同一个类型的数据进行排序
    print(li)
    li.sort()  # 不生成新的值,对原来的变量进行改变
    print(li)
    
    
    
    输出结果:
    [1, 22, 33, 222, 3, 1]
    [1, 1, 3, 22, 33, 222]
    [1, 22, 33, 222, 3, 1]
    [1, 1, 3, 22, 33, 222]

    示例2

    li = ["123","1","","a","99","c","you","","---","_","A","b","0","","",]
    print(li)
    le = sorted(li)# 生成新的值,不对原来的变量进行改变
    print(le)
    for i  in le:
        print(bytes(i,encoding="utf-8"))
    
    
    
    
    输出结果:
    ['123', '1', '', 'a', '99', 'c', 'you', '', '---', '_', 'A', 'b', '0', '', '']
    ['---', '0', '1', '123', '99', 'A', '_', 'a', 'b', 'c', 'you', '', '', '', '']
    b'---'
    b'0'
    b'1'
    b'123'#数字是先比较第一个元素,谁小谁在前面,第一个样就比第二个
    b'99'
    b'A'
    b'_' #字母比较ascii码,先比较第一个元素,谁小谁在前面,第一个
    b'a'            #一样就比第二个
    b'b'
    b'c'
    b'you'
    b'\xe4\xbd\xa0'#汉字比十六进制的大小
    b'\xe5\xbc\xa0'
    b'\xe7\x8e\x8b'
    b'\xe9\x88\xbe'

    staticmethod()

    返回函数的静态方法。

     sum()

    对一组数据求和。

    t=sum([11,22,33])
    print(t)
    
    输出结果:
    66

    super()

    在类的继承中,如果重定义某个方法,该方法会覆盖父类的同名方法,但有时,我们希望能同时实现父类的功能,这时,我们就需要调用父类的方法了,可通过使用super 来实现。

    tuple()

    tuple 函数将列表转换为元组。

    li = [1,2,3]
    
    print(tuple(li))
    
    输出结果:
    (1, 2, 3)

    type()

    查看所一个对象的类型

    li = [1,2,3]
    dic = {'key':'v1'}
    str = 'alexsel'
    print(type(li))
    print(type(dic))
    print(type(str))
    
    输出结果:
    <class 'list'>
    <class 'dict'>
    <class 'str'>

    zip()

    传入多个可以迭代的对象,将可迭代的对象里的元素打包在一起,打包成一个元组,返回由这些元组组成的列表。

    功能是从参数的多个迭代器中选取元素组合成一个新的迭代器。顾名思义,它就是一个将对象进行打包和解包的函数。

    li=[11,22,33,44]
    li2=["a","VV","c","aa"]
    r=zip(li,li2)
    print(r)
    for i in r :
        print(i)
    
    
    输出结果:
    <zip object at 0x00000000027F77C8>
    (11, 'a')
    (22, 'VV')
    (33, 'c')
    (44, 'aa')

    __import__

    函数功能用于动态的导入模块,主要用于反射或者延迟加载模块

    __import__(module) 相当于 import module

    转载于:https://www.cnblogs.com/liudi2017/p/9185694.html

    展开全文
  • # dir(对象),可以检测当前可以被对象使用的数据类型的方法有哪些 print("字符串的内置方法\n", dir(str_name)) print("列表的内置方法\n", dir(x)) print("元组的内置方法\n",dir(y)) print("字典的内置方法\n",dir...
  • python内置函数

    2018-07-06 13:31:00
    1、python中有很多内置函数,不需要引入模块,可以直接使用,如: 1 print 2 input 3 int 4 dict 5 set 6 list 7 len 8 str ...14 dir #看这个对象里面有哪些方法 15 sort...
  • 1.1Python的对象python内置对象类型很多,包括数字,字符串,列表,集合,元组,字典等等,在Python中,一切皆对象pickle腌制--在Python中,如果一些对象需要持久性存储,并且不丢失这个对象的类型和数据,则...
  • 0、dir()函数很重要,特别重要,同样位于builtin.py下,牛逼的内置函数牛逼 1、在理解dir()函数之前,...2、那么有哪些级别的对象呢?我这么列一下! a、package(同module) package的内容体在哪?就在__i...
  • 1.1Python的对象python内置对象类型很多,包括数字,字符串,列表,集合,元组,字典等等,在Python中,一切皆对象pickle腌制--在Python中,如果一些对象需要持久性存储,并且不丢失这个对象的类型和数据,则...
  • 初始化方法: 类名( ) 就可以创建一个对象 类名( ) 创建对象的时候,python解释...这个初始化方法是内置方法,是专门用来定义一个类据有哪些属性和方法的 class Cat: def __init__(self,name): self.name = name ...
  • Python一类工具叫做迭代工具,他们能从左至右扫描对象。这包括了for循环、列表解析、in成员关系测试以及map内置函数等。 而可迭代对象,顾名思义就是可以用在上述迭代工具环境中,通过一次次迭代不断产生结果的...
  • 话说当今编程界基本都是面向对象的编程了,面向对象编程优点非常明显,本节课将具体讲解Python中面向对象有哪些特性,以及如何使用! 学完此次课程,我能做什么? 学完此次课程我们会对Python面向对象有一定的了解...
  • 常见的内置类型有哪些 对象的三个特征:身份、类型、值 python内置类型 1.全局唯一的None 2.数值类型 3.迭代类型 4.序列类型 5.映射类型dict 6.集合类型 set 7.上下文管理类型 a = None b = None c = None ...
  • 在初步接触 python 时,我们就听过一句话:“在 python 中万物皆对象”。但是这个具体是如何体现的,我们却没有好好的去了解过。 所以 老Amy 就准备写一...在 python 中我们可以使用内置函数 id() 来查看某个对象的内存
  • python中一切皆对象,这使得python有着天然的自省特性,即能够运行过程中获取对象自身由哪些属性和方法组成。在阅读python源码和基于第三方库开发时,查看获取某个对象的具体构成内容很必要。python自带的inspect...
  • 2、列表和元组的异同有哪些? 1、Python中6个序列的内置类型分别是什么? Python包含6中内建的序列,即列表、元组、字符串、Unicode字符串、buffer对象和 xrange 对象。序列通用的操作包括:索引、长度、...
  • 通过__builtins__可以查看python内置的一些类、对象、函数、实例。 不难发现,__builtins__的返回值竟然达到了154个之多。内置函数只占一半,即便如此,就算是聪明绝顶的人也怕一时半会消化不了吧。 学英语同样是学...
  • python之可迭代对象

    2019-10-03 12:05:27
    1. 可迭代对象是什么? 字面意思分析:可以重复的迭代的实实在在的东西 专业角度: 内部含有'__iter__'方法的对象,就是可迭代对象 ...3. 查看内置函数内部有哪些方法 print(dir(str)) 4. 判断一个对象是否是可...
  • 目录 一、迭代器iterator 1.理解迭代器 2.迭代器函数iter和next 3.迭代器运用案例 二、生成器generator ...迭代器也称迭代对象,指可for ..... 迭代器用于迭代数据,记录每次访问的数据...(2)可迭代对象有哪些 列表,.
  • 1、Python中6个序列的内置类型分别是什么? Python包含6中内建的序列,即列表、元组...2、 列表和元组的异同有哪些Python有6个序列的内置类型,但最常见的是列表和元组。 列表和元组相似,具体包含下面几个方面:...
  • 2、 列表和元组的异同有哪些?相同点:异同点:A、定义不同B、是否可修改C、转换方式D、是否含内置方法 1、Python中6个序列的内置类型分别是什么? *Python包含6中内建的序列,即列表、元组、字符串、Unicode...
  • 1、Python中6个序列的内置类型分别是什么? Python包含6中内建的序列,即列表、元组、字符...2、列表和元组的异同有哪些Python有6个序列的内置类型,但最常见的是列表和元组。 列表和元组相似,具体包含下面几...
  • 列表和元组的异同有哪些? 列表和元组相似,具体包含下面几个方面: 相同点: 1、均具有序列的特性,均可以进行序列通用的操作; 2、通常均使用括号表示,且括号内的元素以逗号分隔值出现,数据项均不需要具有...
  • 掌握了python的基本语法和面向对象的设计思想后是学习了程序设计的“使用”规则, 具体实现和调用要依赖“标准库”和第三方库,去操纵...Python 常用的标准库以及第三方库有哪些? https://zhuanlan.zhihu.c...
  • 在前面的章节中,我们知道了可以用 `__slots__` 变量限制可绑定的属性,我们也知道了在构造类的时候,只要定义了 `__len__()` 方法,用户就能使用Python内置的 `len()` 函数获取该类实例的长度。我们知道**形如 `__...
  • 在之前我们已经说过了Python中的内置的主要的几种对象类型...那么对象有哪些特性呢 ?继承封装和多态,这时通用的思想 。 继承是为了提高代码的复用性,子类可以通过继承父类来实现父类中的方法,这就是光明正大...

空空如也

空空如也

1 2 3 4 5
收藏数 100
精华内容 40
关键字:

python内置对象有哪些

python 订阅