精华内容
下载资源
问答
  • 内置对象语言的标准的一部分。 python处理的每样东西都是一种对象,从技术上讲,这个表达式生成并返回一个新的字符串对象。这是python用来生成这个对象的一个特定语法。类似地,一个方括号地表达式会生成一个列表...

    python程序可分解为模块、语句、表达式以及对象。程序是由模块构成,模块包含语句,语句包含表达式,表达式建立并处理对象。其实像函数,模块和类这样的编程单元在python中也是对象,它们由def、class、import和lamba这样的语句和表达式创建。

    使用内置类型的优势:内置对象使程序更容易编写;他是扩展对象的组件;内置对象往往比定制的数据结构更有效率;内置对象是语言的标准的一部分。

    python处理的每样东西都是一种对象从技术上讲,这个表达式生成并返回一个新的字符串对象。这是python用来生成这个对象的一个特定语法。类似地,一个方括号地表达式会生成一个列表,大括号的表达式会建立一个字典等。可以看出,python中没有类型声明运行的表达式的语法决定了创建和使用对象的类型。更重要的是,一旦创建对象,他就和操作集合绑定了——只可以对字符串进行相关的操作。总之,python是动态类型的(它自动跟踪你的类型而不是要求声明代码),但是它也是强类型语言(你只能对一个对象进行适合该类型的有效操作)

    列表提供了其他对象的有序集合,而字典是通过键存储对象的。列表和字典都可以嵌套,可以随需求扩展和删减,并能够包含任意类型的对象。

    序列的类型:字符串、列表、元组(分片技术)非序列:字典、集合;不可变对象:数字、字符串、元组;列表和字典为可变对象。

    主要的内置对象
    对象类型 例子 常量/创建
    数字 123,1.23,3.14e-10,0o177,0x9ff,0b101010,3+4j,5J
    字符串 ‘spam’,"guido's",b'a\xolc',r"\temp\spam"
    列表 [1,[2,'three'],4]
    字典 {'food':'spam','taste':'yum'}
    元组 (1,'spam',4,'A')
    文件 open('data.txt','w')
    集合 set('abc'),{'a','b','c'}
    其他类型 类型,None、布尔型
    编程单元类型 函数,模块,类
    与实现相关的类型 编译的代码堆栈跟踪

    1、数字类型

    其包含:整数(无穷大小)和浮点数,以及更为少见的类型(有复数,固定精度的十进制,有理分数集合、布尔类型、无穷的整数精度以及各种数字内置函数和模块等)。

    支持一般的数学运算:+,*,-,/,>>,&,**(乘方);内置数学函数:pow,abs,round,int,hex,bin等。公用模块:random,math等。尽管数字主要是通过表达式、内置函数和模块来处理,它们如今也拥有很多特定于类型的方法。 

    python2.6有两种整数类型:一般整数(32位)和长整形(无穷精度),并且一个整数可以以l或L结尾,从而使其成为长整型。整数的值超过32位时会自动转换为长整型。python3只有一个单独类型,支持2.6长整型的无穷精度。 

    1)

    浮点型数值有两种显示形式:全精度,看作对象的代码形式repr;用户友好的形式str。从技术上讲,默认的交互模式回显和打印的区别就相当于内置repr和str函数的区别。

    左侧是显示的问题,这个问题出现在之前的版本中,而在3.8中没有了。第一种形式是全精度,可看作对象的代码形式repr,第二种是用户友好形式str
    >>> num = 1/3.0
    >>> num
    0.3333333333333333
    >>> '%e' % num
    '3.333333e-01'
    >>> '%4.2f'%num
    '0.33'
    >>> '{0:4.2f}'.format(num)
    '0.33'
    # 除了打印和回显之外,可以使用3种字符串格式化来显示数字的位数
    表达式操作符及优先级
    优先级 操作符 描述 优先级 操作符 描述
    1 {...} 字典、集合、集合和字典解析 14 x&y 位与,集合交集
    2 [...] 列表,列表解析 15 x^y 位异或,集合对称差
    3 (...) 元组,表达式,生成器表达式 16 x|y 位或,集合并集
    4 x.attr 属性引用 17 x<y,x<=y,x>y,x>=y,x==y,x!=y 大小比较,集合子集和超集值相等性操作符
    5 x(...) 调用(函数,方法、类及其他的调用) 18 x is y,x is not y 对象实体测试
    6 x[i:j:k] 分片 19 x in y ,x not in y 成员关系(可迭代对象,集合)
    7 x[i] 索引(序列、映射及其他)点号取属性运算,函数调用 20 not x  逻辑非
    8 x**y 幂运算 21 x and y 逻辑与(只有x,才会计算y)
    9 ~x 按位求补(取反) 22 x or y 逻辑或(只有x为假,才会计算y)
    10 -x,+x 一元减法,识别 23 x if y else z 三元选择表达式
    11 x*y,x%y,x/y,x//y 乘法,重复,余数/格式化,除法:真除法或floor除法 24 lamba args :expression 生成匿名函数
    12 x + y,x-y 加法/合并,减法,集合差集 25 yield x 生成器函数发送协议
    13 x<<y,x>>y 左移或右移y位      

    注意:当使用括号划分子表达式的时候,就会超越python的优先级规则。混合类型自动升级为更复杂的类型(仅在数字类型才适用。

    python还允许多个比较连续起来执行范围测试,如A<B<C等同于A<BandB<C

    X/Y:传统除法和真除法

    在python2.X中,为传统除法和真除法,这个操作会对整数省去小数部分,对浮点数保持小数部分。在3.X时,就会变成真除法(无论任何都会保持小数部分)

    X//Y:Floor除法

    对python2.X和3.X都可用,他会解除掉余数并且针对整数操作数返回一个整数,如果有任何一个操作数是浮点类型,则返回一个浮点数。//操作符叫做截断除法,其实叫floor除法,把结果向下截断到它的下层,即真正结果之下的最近的整数(不能称为真正的截断)。对于正数,二者相同,对于负数,它是一个floor结果。要做到真正意义上的截断(不管符号),可使用math.trunc函数

    >>> 5/2.0,5/-2.0
    (2.5, -2.5)
    >>> 5//2.0,5//-2.0
    (2.0, -3.0)
    >>> import math
    >>> math.floor(2.5)
    2
    >>> math.trunc(5/-2.0)
    -2
    # >>>2.0//0.4 >>> 4.0    ???
    可以使用一个_future_import在python2.X中打开python3.0的/,而不是用浮点数来强制它

    2)

    复数常量写成实部+虚部的写法,对复数的所有数字操作都会按照复数的运算法则进行。也可以通过内置函数complex(real,imag)来创建复数。python允许分解出实部和虚部作为属性,并可以通过标准的cmath模块中的工具处理。

    3)

    整数可以编写为十进制、十六进制(0x,0X开头)、八进制(0o,0O)和二进制(0b,0B)形式。内置函数hex(),oct(),bin()可以把整数转换为这3种进制表示的字符串。并且int(str,base)根据每个给定的进制把一个运行时字符串转换为一个整数。eval函数会把字符串作为python代码。bit_length方法可以查询以二进制表示一个数字的值所需的位数。

    >>> x=99
    >>> bin(x),x.bit_length()
    ('0b1100011', 7)
    >>> len(bin(256))-2
    9
    >>>
    
    >>> oct(64),hex(64),bin(64)
    ('0o100', '0x40', '0b1000000')
    >>> eval('0x40')
    64
    >>> '{0:o},{1:x},{2:b}'.format(64,64,64)
    '100,40,1000000'
    >>> '%o,%x,%X'%(64,255,255)
    '100,ff,FF'
    >>> int('0x40',16)
    64

    4)

    python有支持数字处理的内置函数(位于一个隐性的命名空间中,python自动搜索程序的变量名,所以不需要导入),还有一些常用的数学模块(外部组件,需要导入),如math模块,random模块。math模块包括更高级的数学工具,random模块可以作为随机数字的生成器和随机选择器。(看到模块,就要导入

    sum函数作用于数字的一个序列min和max函数接受一个参数序列或者单个参数round函数可以删除一个浮点数的小数位

    >>> pow(2,4),2**4
    (16, 16)
    >>> abs(-42.0),sum((1,2,3,4))
    (42.0, 10)
    >>> min(3,1,2,4),max(3,1,2,4)
    (1, 4)
    >>> round(2.567,2)
    2.57
    >>> round(2.467)
    2

    小技巧:python有3种方法计算平方根

    >>> 144**.5
    12.0
    >>> pow(144,.5)
    12.0
    >>> import math
    >>> math.sqrt(144)
    12.0

    random函数选出在0和1之间的任意浮点数, randin函数选择在两个数字之间的任意整数,choice函数在一个序列中任意挑选一项 

    >>> import math
    >>> math.pi
    3.141592653589793
    >>> math.sqrt(85)
    9.219544457292887
    >>> import random
    >>> random.random()
    0.28016242026253657
    >>> random.randint(1,20)
    8
    >>> random.choice([3,4,7,8,9])     # 这里从列表中选择
    3

    5)其他数字类型(除整数、浮点数、复数)

    小数数字:小数对象通过一个导入的模块调用函数创建,而不是通过运行常量表达式创建。它有固定的位数和小数点,是一个具有固定精度的浮点数。

    通过调用在decimal模块中的Decimal模块中的Decimal的构造函数创建一个小数对象,并传入一个字符串。当不同精度的小数在表达式中混编时,python自动升级为小数位最多的。Decimal.from_float (1.25)能将一个浮点对象创建一个小数对象,这个转化是精确的,但有时会产生较多的位数。

    >>> 0.1 +0.1 + 0.1 -0.3
    5.551115123125783e-17
    >>> print(0.1+0.1+0.1-0.3)
    5.551115123125783e-17
    >>> from decimal import Decimal
    >>> Decimal('0.1') + Decimal('0.1')+Decimal('0.1')-Decimal('0.3')
    Decimal('0.0')
    >>> a = Decimal.from_float(1.25)
    >>> a
    Decimal('1.25')

    decimal模块中的其他工具可以用来设置所有小数数值的精度、设置错误处理等。这个模块的一个上下文对象getcontext允许指定精度(小数位数)和舍入模式(舍入、进位等)。该全局性精度适用于调用线程中创建的所有的小数,是手动舍入和字符串格式化的一种替代方式。也可以使用上下文管理器语句localcontext来重新设置临时精度

    >>> import decimal
    >>> decimal.getcontext().prec = 4
    >>> decimal.Decimal(1)/decimal.Decimal(7)
    Decimal('0.1429')
    
    >>> with decimal.localcontext() as ctx:
    ...     ctx.prec = 2
    ...     decimal.Decimal('1.00')/decimal.Decimal('3.00')
    ...
    Decimal('0.33')

    分数类型:实现一个有理数对象,可避免了浮点数的某些不确定性和局限性。实际上,可自动简化结果。

    >>> from fractions import Fraction
    >>> x = Fraction(1,3)
    >>> y = Fraction(4,6)
    >>> x
    Fraction(1, 3)
    >>> y
    Fraction(2, 3)
    >>> print(y)
    2/3
    

    转换:浮点数对象方法as_integer_ratio能够产生它们的分子和分母比。分数有个方法from_float可将浮点数转换为分数float可接受一个Fraction作为参数,实现分数到浮点数的转换。另外,分数和浮点数的混合表达式,结果是浮点数;分数与整数混合,其结果是分数

    >>> (2.5).as_integer_ratio()
    (5, 2)
    >>> from fractions import Fraction
    >>> f=2.5
    >>> z=Fraction(*f.as_integer_ratio())
    >>> z
    Fraction(5, 2)
    >>> float(z)
    2.5
    >>> Fraction.from_float(1.75)
    Fraction(7, 4)

    注意:浮点数转换为分数在某些情况下会有精度损失,因为数字在最初的浮点数形式下是不精确的,limit_denominator通过最大分母值简化这样的结果。

    >>> (4/3).as_integer_ratio()
    (6004799503160661, 4503599627370496)
    >>> from fractions import Fraction
    >>> z = Fraction(1,3)
    >>> a = z+ Fraction(*(4/3).as_integer_ratio())
    >>> a
    Fraction(22517998136852479, 13510798882111488)
    >>> 22517998136852479/13510798882111488
    1.6666666666666665
    >>> a.limit_denoominator(10)
    Fraction(5, 3)

     集合(set):唯一的、不可变的对象的无序集合。既不是序列,也不是映射类型。要创建一个集合对象,向内置的set函数传递一个序列或者可迭代的对象。(集合不包含位置顺序,序列则包含)

    集合通过表达式操作符支持一般的数学集合运算,集合对象还提供对应数学集合操作的方法,以及更多的支持改变集合的方法。add方法插入一个对象、update是按照位置并集,remove根据值删除一个项目。

    >>> x = set('abcde')
    >>> y = set('bdxyz')
    >>> x|y
    {'e', 'y', 'b', 'c', 'x', 'd', 'a', 'z'}
    >>> z= x.intersection(y)                # 等价于 x&y
    >>> z
    {'b', 'd'}
    >>> z.add('SPAN')
    >>> z
    {'b', 'd', 'SPAN'}
    >>> z.update(set(['X','Y']))
    >>> z
    {'d', 'SPAN', 'b', 'Y', 'X'}
    >>> z.remove('b')
    >>> z
    {'d', 'SPAN', 'Y', 'X'}

    集合作为可迭代的容器,可用于len、for循环和列表解析这样的操作。由于它们是无序的,所以不支持索引和分片这样的操作。集合表达式往往需要两个集合,而基于它们的方法可传入任何可迭代类型。

    >>> for item in set('abc'): print(item*3)
    ...
    bbb
    ccc
    aaa
    >>> S = set((1,2,3))
    >>> S
    {1, 2, 3}
    >>> S.union([3,4])
    {1, 2, 3, 4}
    >>> S.intersection((1,3,5))
    {1, 3}
    >>> S.issubset(range(-5,5))
    True
    >>> S|[3,4]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unsupported operand type(s) for |: 'set' and 'list'
    

     集合常量:set([1,2,3])等价于{1,2,3}(集合新的常量格式)。集合像无值的字典,集合的项是无序的,唯一的,不可变的。它们的行为i和字典的键很像。由于字典键列表是视图对象,它支持像交集和并集这样类似集合行为的操作。不管如何创建集合,都会使用新的常量格式显示。但要创建空的集合并显示或从已有的可迭代对象构建集合,还是需要内置的set函数。

    注意:在python中{}仍然是一个字典

    >>> S1 ={1,2,3,4}
    >>> S1
    {1, 2, 3, 4}
    >>> S1 > {1,3}
    True
    >>> S1 - {1,2,3,4}
    set()
    >>> type({})
    <class 'dict'>

     不可变限制和冻结集合:集合只能包含不可变的对象类型。因此,列表和字典不能嵌入集合中,元组是可以嵌入的。集合本身是不可改变的,但不能直接嵌入其他集合,需要调用frozenset可创建不可变集合。

    >>> a=set()
    >>> a.add(1.23)
    >>> a.add([1,2,3])
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    >>> a.add((1,2,3))
    >>> a
    {1.23, (1, 2, 3)}
    >>> a.add(frozenset([4,5,6]))
    >>> a
    {1.23, frozenset({4, 5, 6}), (1, 2, 3)}

    集合解析:编写在花括号中,集合解析运行一个循环并在每次迭代时收集一个表达式的结果,通过一个循环变量来访问当前的迭代值,用于集合表达式中。

    >>> {x**2 for x in [1,2,3,4]}
    {16, 1, 4, 9}
    
    >>> type(True)
    <class 'bool'>

    使用集合的好处:集合(set)可以用来把重复项从其他集合(collection)中过滤掉

    >>> L = [1,2,1,3,2,3]
    >>> set(L)
    {1, 2, 3}

     

    布尔型:bool的值为True和False。新的变量名True和False是bool的实例,实际上仅仅是内置的整数类型int的子类。

    数字如果非,则为真。其他对象如果非空,则为真。所以像if这样地逻辑语句中,没必要使用布尔类型,所有对象的本质上依然是真或假。python还提供一个内置函数bool,用来测试一个对象的布尔值。

    >>> bool('spam')
    True

    当明确地用在真值测试时,True和False这些文字都变成1和0;当交互模式下运行地布尔测试时,结果会打印成True和False

    特殊的占位符对象None

    一般为超出范围的列表进行赋值操作,

    python还包括第三方开源扩展领域Numpy(矩阵和向量)

    展开全文
  • Python的常用内置对象

    2018-12-26 13:41:10
    表1: Python的内置对象 对 象 类 型 类型名称 示例 简要说明 数字 int, float, complex 1234, 3.14, 1.3e5, 3+4j 数字大小没有限制,内置支持复数及其 运算 字符串 str str ‘swfu...

    Python的常用内置对象

    对象是python语言中最基本的概念,在python中处理的一切都是对象。

    表1: Python的内置对象

    对 象 类 型 类型名称 示例 简要说明
    数字 int, float, complex 1234, 3.14, 1.3e5, 3+4j 数字大小没有限制,内置支持复数及其 运算
    字符串 str str ‘swfu’, “I’m student”, ‘’‘Python ‘’’, r’abc’, R’bcd’ 使用单引号、双引号、三引号作为定界 符,以字母r或R引导的表示原始字符串
    字节串 bytes b’hello world’ 以字母b引导,可以使用单引号、双引 号、三引号作为定界符
    列 表 list [1, 2, 3],[‘a’, ‘b’, [‘c’, 2]] 所有元素放在一对方括号中,元素之间 使用逗号分隔,其中的元素可以是任意 类型
    字 典 dict {1:‘food’ ,2:‘taste’, 3:‘import’} 所有元素放在一对大括号中,元素之间 使用逗号分隔,元素形式为“键:值”
    元 组 tuple (2, -5, 6), (3,) 不可变,所有元素放在一对圆括号中, 元素之间使用逗号分隔,如果元组中只 有一个元素的话,后面的逗号不能省略
    集 合 set frozenset {‘a’, ‘b’, ‘c’} 所有元素放在一对大括号中,元素之间 使用逗号分隔,元素不允许重复;另外, set是可变的,而frozenset是不可变的
    布 尔 型 bool True, False 逻辑值,关系运算符、成员测试运算 符、同一性测试运算符组成的表达式的 值一般为True或False
    空 类 型 NoneType None 空值
    异 常 Exception、 ValueError、 TypeError…… Python内置大量异常类,分别对应不同 类型的异常
    文 件 f = open(‘data.dat’, ‘rb’) open是Python内置函数,使用指定的 模式打开文件,返回文件对象
    其 他 可 迭 代 对 象 生成器对象、range对象、 zip对象、enumerate对象、map对象、filter对象 等 具有惰性求值的特点
    编程单元 函数(使用def定义) 类 (使用class定义) 模块 (类型为module) 类和函数都属于可调用对象,模块用来集中存放函数、类、常量或其他对象

    python中有许多内置对象可供编程者使用,内置对象可直接使用,如数字、字符串、列表、del等;


    Python变量

    Python属于强类型编程语言,Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言,变量的类型也是可以随时变化的。

    需要注意以下问题。

    1. 变量名必须以字母或下画线开头但以下画线 开头的变量在Python中有特殊含义,请参考第6章内容。
    2. 变量名中不能有空格或标点符号(括号、引号、逗号、斜线、反斜线、冒号、句号、问等)。
    3. 不能使用关键字作为变量名,Python关键字的介绍请见2.3节。要注意的是,直着Python版本的变 化,关键字列表可能会有所变化。
    4. 不建议使用系统内置的模块名、类型名或函数名以及已导人的模块名及其成员作为变量名,这会 改变其类型和含义,甚至会导致其他代码无法正常执行。可以通过difr(_ _ builtins_ _ )查看所有 内置对象名称。
    5. 变量名对英文字母的大小写敏感,例如student和Student是不同的变量
    >>> x = 4
    >>> print(type(x))
    <class 'int'>
    >>> x = 'Hello world.'
    >>> print(type(x))                 #查看变量类型
    <class 'str'>
    >>> x = [1,2,3]
    >>> print(type(x))
    <class 'list'>
    >>> isinstance(3, int)             #测试对象是否是某个类型的实例
    True
    >>> isinstance('Hello world', str)
    True
    >>> x = 3
    >>> x
    3
    >>> x**2
    9

    字符串和元组属于不可变序列,不能通过下标的方式来修改其中的元素值,试图修改元组中元素的值时会抛出异常。

    在Python中,允许多个变量指向同一个值 。

    x = 3 y = 3 x += 6内存变化如下:

    1. 赋值语句的执行过程是:首先把等号右侧表达式的值计算出来,然后在内存中寻找一个位置把值存放进去,最后创建变量并指向这个内存地址。
    2. Python采用的是基于值的内存管理方式,如果为不同变量赋值为相同值,这个值在内存中只有一份,多个变量指向同一块内存地址。 Python中的变量并不直接存储值,而是存储了值的内存地址或者引用,这也是变量类型随时可以改变的原因。
    3. Python具有自动内存管理功能,对于没有任何变量指向的值,Python自动将其删除。Python会跟踪所有的值,并自动删除不再有变量指向的值。尽管如此,显式使用 del 命令删除不需要的值或显式关闭不再需要访问的资源,仍是一个好的习惯,同时也是一个优秀程序员的基本素养之一。

    数字

    数字是不可变对象,可以表示任意大小的数字。

    >>> 999*99   #想乘
    98901
    >>> 999**99 		#幂运算,等价于内置函数pow()
    905697844958667709741956562802753100901389806139609538815019658231017504097064752403846139892968390554024852396172082441213697329994395340901282449426848216146865935961454742677324005498146550510264840271813301125214581059267630055862747172378231729576039278689152963667155086263379780844149098999
    >>> 0.3+0.2
    0.5
    >>> 0.5-0.2
    0.3
     0.4-0.1				#实数相减,结果稍有偏差
    0.30000000000000004

    Python中的整数类型可以分为

    • 十进制整数如,0、-1、9、123
    • 十六进制整数,需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数,必须以0x开头,如0x100xfa0xabcdef
    • 八进制整数,只需要8个数字0、1、2、3、4、5、6、7来表示整数,必须以0o开头,如0o350o11
    • 二进制整数,只需要2个数字0、1来表示整数,必须以0b开头如,0b1010b100

    浮点数又称小数

    15.2, 0.31, 3.14, -11.2

    Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性,类似于数学上使用逗号作为千位分隔符。

    >>> 1_000_000
    1000000
    >>> 1_2_3_4
    1234
    >>> 3.14159_26535_89793_83246
    3.14159265358979383246

    字符串

    • 用单引号、双引号或三引号界定的符号系列称为字符串。
    • 单引号、双引号、三单引号、三双引号可以互相嵌套,用来表示复杂字符串 ‘abc’、‘123’、“Python”、’’’ Tom said, “Let’s go” ‘’’。
    • 字符串属于不可变序列。
    • 空字符串表示为’'或 “”。
    • 三引号’’'或"""表示的字符串可以换行,支持排版较为复杂的字符串;三引号还可以在程序中表示较长的注释。

    常见的转义字符

    表2: 转义字符

    转义字符 含义 转义字符 含义
    \b 退格,把光标移动到前一列位置 \ 一个斜线\
    \f 换页符 \’ 单引号’
    \n 换行符 \” 双引号”
    \r 回车 \ooo 3位八进制数对应的字符
    \t 水平制表符 \xhh 2位十六进制数对应的字符
    \v 垂直制表符 \uhhhh 4位十六进制数表示的Unicode字符

    Python运算符

    表3: Python 运算符

    运算符 功能说明
    + 算术加法,列表,元组,字符串合并与连接,正号
    - 算术减法,集合差集,相反数
    * 算术乘法,序列重复
    / 真除法
    // 求整商,但如果操作数中有实数的话,结果为实数形式的整数
    % 求余数,字符串格式化
    ** 幂运算
    <,<=,>,>=,==,!= (值)大小比较,集合的包含关系比较
    or 逻辑或
    and 逻辑与
    not 逻辑非
    in 成员测试
    is 对象同一性测试,即测试是否为同一个对象或者内存地址是否相同
    |,^,&,<<,>>,~ 位或,位异或,位与,左移位,右移位,位求反
    &,|,^ 集合交集,并集,对称差集
    @ 矩阵相乘运算符

    Python关键字简要说明

    表4: 关键字

    关键字 含义
    False 常量,逻辑假
    None 常量,空置
    True 常量,逻辑假
    and 逻辑与运算
    as 在import或except语句中给对象器别名
    assert 断言,用来确认某个条件必须满足,可以来帮助调试程序
    break 用来循环中,提前结束break所在层次的循环
    class 用来定义类
    continue 用在循环中,提前结束本次循环
    def 用来定义函数
    del 用来删除对象或对象成员
    elif 用在选择结构中,表示else if 的意思
    else 可以用在选择结构、循环结构和异常处理结构中
    except 用在异常处理结构中,用来捕获特定类型的异常
    finally 用在异常处理结构中,用来表示不论是否发生异常都会执行的代码
    for 构造for循环,用来迭代序列或可迭代对象中的所有元素
    from 明确指定从哪个模块中导入什么对象,例如from math import sin;还可以与 yield 一起构成 yield表达式
    global 定义或声明全局变量
    if 用在选择结构中
    import 用来导入模块或模块中的对象
    in 成员测试
    is 同一性测试
    lambda 用来定义lambda表达式,类似于函数(匿名函数)
    nonlocal 用来声明nonlocal变量
    not 逻辑非运算
    or 逻辑或运算
    pass 空语句,执行该语句时什么都不做,常用作占位符
    raise 用来显式抛出异常
    return 在函数中用来返回值,如果没有指定返回值,表示返回空值None
    try 在异常处理结构中用来限定可能会引发异常的代码块
    while 用来构造while循环结构,只要条件表达式等价于True就重复执行限定的代码块
    with 上下文管理,具有自动管理资源的功能
    yield 在生成器行数中用来返回值
    展开全文
  • 本节书摘来自异步社区《Abaqus GUI程序开发指南(Python语言)》...2.4 内置对象类型 Python语言中提供了强大的对象类型作为语言的组成部分,内置对象使得程序编写更加容易,并且内置对象往往比自己定制的数据结构...

    本节书摘来自异步社区《Abaqus GUI程序开发指南(Python语言)》一书中的第2章,第2.4节,作者: 贾利勇 , 富琛阳子 , 贺高 , 周正光 更多章节内容可以访问云栖社区“异步社区”公众号查看。

    2.4 内置对象类型

    Python语言中提供了强大的对象类型作为语言的组成部分,内置对象使得程序编写更加容易,并且内置对象往往比自己定制的数据结构更有效率。Python语言中主要有如表2.1所示几类对象类型。


    9aeea5e8728d3edc5ea58bed5a9444023ee88ed0

    2.4.1 数字
    Python语言中的数字类型包括整型、浮点型、复数型等,与一般的C、C++等语言没有太大的区别,以下是几类数字类型的内置对象定义方法。

    【实例2.4】定义数字类型

    >>>a=5+5         #定义整形数据
    >>>a
    10
    >>> b=5**35       #长整型数据
    >>> b
    2910383045673370361328125L
    >>> c=3.14 
    >>> c
    3.14 
    >>> n=(5+4j) +(5+8j)  #定义复数类型数据
    >>>n
    (10+12j)
    >>>type(n)        #查询数据类型
    <type 'complex'>
    

    符号>>>表示代码在Abaqus GUI命令行交互窗口或者Abaqus PDE命令输入窗口中输入代码,符号>>>不是代码的组成部分。
    2.4.2 字符串
    字符串型数据一般用单引号或者双引号包络,并且单引号以及双引号必须成对出现。另外,当字符串内部包含有单引号或者双引号时,需要通过转义符“”实现,例如:

    >>>Str='what 's up with him'       #语法错误
    >>>Str='what \'s up with him'      #正确格式
    >>>Str="what \'s up with him"      #正确格式
    

    有关转义字符“”的使用方法读者可以参考其他Python语言的语法书,此处不再赘述。除了转义字符之外,字符串还支持格式化的替代表达,可以用一个变量或者表达式替代字符串中的部分字符,操作符为“%”。

    格式化操作符“%”的使用方法如下。

    (1)在“%”操作符的左侧放置一个需要进行格式化的字符串,这个字符串带有一个或者多个嵌入的转换目标,都以“%”开头(例如,%、%f、%s等)。

    (2)在“%”操作符的右侧放置一个(或多个,多个时需要嵌入到一个元组中)对象,这些对象将会插入到左侧想让Python进行格式化替代的字符串对应位置上去。

    以下是格式化操作符的使用实例。

    【实例2.5】格式化表达

    >>> str='%s, apple' % 'orange'
    >>> str
    'orange, apple'
    >>> n=8
    >>> str='%i apples' % n
    >>> str
    '8 apples'
    >>> 'pi=%f, g=%f' % (3.14, 9.18)
    'pi=3.140000, g=9.180000'
    

    表2.2所示的是Python语言中的字符串格式化代码,其中大部分与C语言相似,另外,表中一些格式化代码为同一类型的格式化提供了不同的格式选择,例如,%e、%f都可以表示浮点型数据,但是显示格式分别为指数型和浮点型,另外虽然%e和%E都是科学计数法的形式,但是有大小写的区分。


    <a href=https://yqfile.alicdn.com/95e61f863d6aca9f427ef6c51ff7afe424cea83e.png" >

    除了单引号和双引号字符串之外,Python中还有一种特殊的三重引号内的字符串常量格式,也被称作块字符串,这是一种对编写多行文本数据来说很便捷的语法。这种字符串以三重引号“'''”开头,并紧跟任意行数的文本,最后以同样的三重引号“'''”作为结尾。

    【实例2.6】三重引号的用法

    >>> str='''abc 
    ... def 
    ... ghi 
    ... xyz''' 
    >>> str 
    'abc\ndef\nghi\nxyz'
    

    可以看出,上述定义的字符串中包含四行,Python会把三重引号内部的文本收集到一起形成一个单独的多行字符串,并在代码换行处嵌入了换行字符“n”。三重引号字符串在程序需要输入多行文本的时候是很有用的,例如嵌入多行注释信息,另外也可以通过三重引号来废除多行代码,使其无效,当需要再次使用该部分代码时,只需要将三重引号去掉即可,这样就避免了每行行首都需要添加“#”注释带来的不便。例如:

    【实例2.7】使用三重引号注释以及废除代码

    '''以下几行代码的主要作用是创建菜单栏 
    并在菜单栏添加子菜单''' 
    menu = AFXMenuPane(self) 
    AFXMenuTitle(self, '主菜单', None, menu) 
    AFXMenuCommand(self, menu, '子菜单一', 
      afxCreatePNGIcon(r"icon\icon1.PNG"), 
      myForm1(self), AFXMode.ID_ACTIVATE) 
    AFXMenuCommand(self, menu, '子菜单二', 
      afxCreatePNGIcon(r"icon\icon2.PNG"), 
      myForm2(self), AFXMode.ID_ACTIVATE) 
    ''' 
    subMenu = AFXMenuPane(self)  
    AFXMenuCascade(self, menu, '子菜单三', None, subMenu) 
    AFXMenuCommand(self, subMenu, '子项目1', None, 
      self, AFXMode.ID_ACTIVATE) 
    AFXMenuCommand(self, subMenu, '子项目2', None, 
      self, AFXMode.ID_ACTIVATE) 
    '''
    

    另外,在使用Python读取文本时,经常需要按照一定的规则将每一行数据拆分成一系列子字符串,这种情况下通常需要使用split()函数来实现对一个长字符串的切分。

    【实例2.8】split()分割字符串

    >>> A="a b c d e f" 
    >>> B= A.split()         #以空格键对字符串进行分割 
    >>> B 
    ['a', 'b', 'c', 'd', 'e', 'f']
    

    上述情况下,字符串内部两个非空字符间的空格数量对分割结果没有影响,例如:

    >>> A="a b c d e      f"
    >>> B
    ['a', 'b', 'c', 'd', 'e', 'f']
    

    另外,当字符串中有具有分隔特征的符号时,例如逗号或者分号等,可以使用这些分隔符号对字符串进行分割。但是需要注意的是,当使用特定的分隔符进行分割时,空字符不会被忽略。

    >>> A="a;b; c; d; e ;f"
    >>> B= A.split(";")           #用分号进行切分
    >>> B
    ['a', 'b', ' c', ' d', ' e ', 'f']
    >>> A="a,b, c, d, e,    f"    
    >>> B= A.split(",")           #用逗号进行切分
    >>> B
    ['a', 'b', ' c', ' d', ' e', '    f']   #空字符未忽略
    

    2.4.3 元组
    元组型数据(tuple)由一系列元素组成,且对每个元素的数据类型不做限制,可以使用字符串、整型、浮点型的混合。元组在建立时,以小括号包括逗号(,)进行间隔,并且可以是多维数据。元组中的元素一旦确定是不允许修改的。

    【实例2.9】元组的定义及使用

    >>> one=('A')
    >>> type(one) 
    <type 'str'>
    

    注意上述代码中,小括号内没有逗号,所定义的类型为字符串型。

    >>> one=('A',)
    >>> type(one)
    <type 'tuple'>
    

    小括号内添加逗号,所定义类型便成为元组型。

    >>> pets=(("dog",2),("cat",3),("hamster",5))  #创建多维元组
    >>> len(pets)
    3               #其长度是按照第一维数据计算  
    >>> pets[2][0]         #调用元组中的某一个数据
    'hamster'
    

    2.4.4 列表
    列表型数据(list)指的是能够存储有序元组的数据结构,在Python语言中,列表中的所有元素都包括在方括号[]内,各元素之间使用逗号分割。与元组不同的是,用户可以对列表中的元素进行添加、删除、修改等操作,因此,列表是可操作的数据结构。

    【实例2.10】列表的定义

    >>>fruits=["apple","pear","medlar","lopuat","",]  #定义一维列表
    >>> fruits
    ['apple', 'pear', 'medlar', 'lopuat', '']
    >>> len(fruits)            #计算列表长度
    5
    >>> fruits=[["apple","pear","medlar","lopuat",""],["apple","pear","medlar","lopuat"]]
    >>> len(fruits)            # 定义二维列表,并计算其长度
    2
    >>>fruits[1][3]
    'lopuat'
    

    与元组型数据不同的是,列表末尾加不加逗号没有区别,列表中即使只有一个元素也是列表型数据,例如:

    >>> fruits=["apple","pear","medlar","lopuat",""]  #末尾不加逗号
    >>> fruits
    ['apple', 'pear', 'medlar', 'lopuat', '']
    >>> len(fruits)            #长度相同
    5
    >>> fruits=["apple"]          #单元素列表
    >>> type(fruits)
    <type 'list'>
    

    【实例2.11】列表的操作

    >>> myList = [0,1,2,1,2,3,2,3,4,3,4,5] 
    >>> myList.count(2)      #返回某一元素在list中出现的次数 
    3 
    >>> myList.index(5)      #返回某一元素在list中首次出现的索引号 
    11 
    >>> myList.index(4)      #当某一元素多次出现时,返回其首次出现时的索引号 
    8 
    >>> myList.insert(2,22)   #在列表中指定位置插入元素 
    >>> myList 
    [0, 1, 22, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5] 
    >>> myList.reverse()     #对列表中的元素反序排列 
    >>> myList 
    [5, 4, 3, 4, 3, 2, 3, 2, 1, 2, 22, 1, 0] 
    >>> myList.sort()       #对列表中元素进行排序 
    >>> myList 
    [0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 22] 
    >>> myList 
    [1, 9, 3] 
    >>> myList.append(33)     #在列表末尾添加新元素 
    >>> myList 
    [1, 9, 3, 33] 
    >>> myList.remove(9)    #移除列表中的元素 
    >>> myList 
    [1, 3, 33]
    

    2.4.5 字典
    字典型数据(dictionaries)是Python之中最灵活的内置数据结构类型,如果把列表看作是有序的对象集合,那么就可以把字典当成是无序的集合。两者的主要区别在于,在字典中元素是通过键来存取的,而不是通过顺序索引号来存取,字典中的元素没有特定的顺序,各个元素从左到右随机排列,以便快速查找,键提供的是字典中元素的象征性位置(非物理存储位置)。

    字典型数据用大括号{}包络,字典中的每一组元素都包含数据键key和数值value两部分,两者之间以冒号间隔,冒号前面是键key,后面是数值value。key是独一无二的,且不可改变,可以是字符串型、整型、浮点型或者元组等多种类型。字典中的两个元素之间用逗号隔开。当需要访问字典中的某一元素时,需要通过索引数据键来获取其对应的数据值。

    【实例2.12】字典的定义

    (1)dictionaries型数据以大括号包括逗号进行间隔。

    >>> insects={"AAA":5000,"BBB":200,"CCC":1200} #定义包含3个元素的字典
    >>> insects["AAA"]            #获取键"AAA"所对应的值
    5000
    

    另外,也可以采用以下方式对字典进行定义。

    >>> insects=dict(AAA=5000,BBB=200,CCC=1200)
    >>> insects
    {'AAA': 5000, 'BBB': 200, 'CCC': 1200}
    (2)dictionaries型数据以tuples作为key。
    
    >>> points3d={(3,7,2):"green",(4,4,6):"blue",(2,8,9):"yellow"} 
    >>> points3d[(3,7,2)]
    'green'
    

    【实例2.13】字典的操作

    dictionaries型数据调用keys()、values()、items()函数。
    
    >>> dict1=dict(AAA=5000,BBB=200,CCC=1200) 
    >>>v1= dict1.keys()    #获取字典的所有键值 
    >>> v1 
    ['AAA', 'BBB', 'CCC'] 
    >>> dict1.items()     #获取字典所有元素 
    [('AAA', 5000), ('BBB', 200), ('CCC', 1200)] 
    >>> dict1.items()[0]    #获取字典中某一元素 
    ('AAA', 5000) 
    >>> dict1.items()[0][1]   #获取字典中某一元素的键或者值 
    5000 
    >>> dict1.values()     #获取字典中的所有值 
    [5000, 200, 1200] 
    >>> del(dict1 ["AAA"])  #删除字典中某一键值对 
    >>> dict1 
    {'BBB': 200, 'CCC': 1200} 
    >>> dict1["DDD"]=999  #字典中添加新元素 
    >>> dict1               
    {'BBB': 200, 'CCC': 1200, 'DDD': 999} 
    >>> dict1.pop("CCC")   #pop函数,返回某键对应的值,并在字典中删除该键值对 
    1200 
    >>> dict1 
    {'BBB': 200, 'DDD': 999} 
    >>> dict1.clear()     #清空字典 
    >>> dict1 
    {}
    

    2.4.6 集合
    集合(set)又分为普通set和frozenset两类,都是无序的,都不属于sequence类型。set类型数据是可以改变的,可以增加、删除元素。frozenset是不可变的,frozenset可以作为字典的键。

    set中的数据都是独一无二的,如果某一set中已经含有了某数据,则使用add()函数时,不会再增添一个。

    【实例2.14】集合的定义

    >>> set_fox=set(("AA","BB","CC"))    #定义普通set 
    >>> set_fox=frozenset(("AA","BB","CC")) #定义frozenset 
    >>> "AA" in set_fox          #判断set中是否包含某一项 
    True
    set类型数据与元组和列表等不同的是,集合中的元素不支持索引,例如:
    
    >>> set_fox[1]            
    TypeError: 'set' object does not support indexing   #报错
    

    【实例2.15】集合的操作

    >>> set_fox.add("DD")             #集合中添加新元素 
    >>> set_fox 
    set(['AA', 'CC', 'DD', 'BB']) 
    >>> set_fox.remove('AA')           #删除集合中的元素 
    >>> set_fox 
    set(['CC', 'DD', 'BB']) 
    >>> set_fox.clear()               #清空集合元素 
    >>> set_fox 
    set([])
    

    2.4.7 布尔型
    Python的布尔类型扩展了Python中真假的概念,布尔类型有True或者False两个变量值,一般Python中判断语句的判断结果不使用1和0来表征判断结果的真假,而是采用布尔型的True或者False来表征。

    Python提供了一个内置的bool函数,它可以测试一个对象的布尔值,当一个对象为0或者空值时,测试结果为False,当对象为非零或非空时,测试结果为True。

    【实例2.16】布尔型

    >>> bool([])       #空值 
    False 
    >>> bool([''])       #含空字符串的非空列表 
    True 
    >>> bool(1)       #非零 
    True 
    >>> bool(0)       #零值 
    False
    

    2.4.8 None型
    除了上述内置对象类型之外,Python还有一个特殊对象:None。一般起到一个空的占位作用,类似于C语言中的NULL。None是一个真正的对象,并且真用内存空间。一般对于一个自定义函数,当不使用return指定其返回值时,默认地会返回None。另外,也可以通过None占用内存实现对可变对象的预分配。

    【实例2.17】None型

    >>> X=[None]*999 
    >>> X 
    [None, None, None, None,…, None, None]
    

    2.4.9 数据格式转换
    前面讲述的数据结构中,有多种数据类型是可以对其数据格式进行转换的。下面将介绍几种常用的数据转换函数。

    【实例2.18】数据格式转换

    (1)将字符串类型转化为列表类型

    >>> myString='noise' 
    >>> myList = list(myString)    
    >>> myList 
    ['n', 'o', 'i', 's', 'e'] 
    >>> myList[0] = 'p'       #将列表中第一元素重新赋值。 
    >>> myList 
    ['p', 'o', 'i', 's', 'e']
    

    (2)将字符串类型转化为元组类型

    >>> myTuple = tuple(myString)  
    >>> myTuple 
    ('n', 'o', 'i', 's', 'e')
    

    (3)将元组转化为列表

    >>> mylist=list(myTuple)  
    >>> mylist 
    ['n', 'o', 'i', 's', 'e']
    

    (4)将浮点型转化为整型

    >>> a=3.1415 
    >>> b=int(a)          
    >>> b 
    3
    

    (5)将整型转化为浮点型

    >>> c=float(b)         
    >>> c 
    3.0
    

    (6)将浮点型数据转化为字符串

    >>> c=3.0           
    >>> str(c)           
    '3.0'
    

    (7)返回ASCII码对应的字符

    >>> print chr(65) 
    A 
    >>> print chr(66) 
    B 
    >>> print chr(65)+chr(66) 
    AB 
    >>>
    

    (8)把字符串或者数字转化为复数

    >>> a=complex("2+5j")     #将字符串转化为复数 
    >>> a 
    (2+5j) 
    >>> b=complex(2,5)      #将数字转化为复数 
    >>> b 
    (2+5j)
    

    (9)将整数转化为十六进制数或者八进制数

    >>> hex(25)          #将整数转化为十六进制数 
    '0x19' 
    >>> oct(25)          #将整数转化为八进制数 
    '031'
    

    (10)将字符串或者数字转化为长整型数据

    >>> long("123")        #将字符串转化为长整型 
    123L 
    >>> long(123)         #将整数转化为长整型 
    123L 
    >>> long(123.5)         #将浮点型数据转化为长整型 
    123L
    

    2.4.10 对象查询与索引
    读者可以使用type()函数来查询某对象的数据类型,也可以通过min()和max()函数查询元组或者列表中数据的最小值或最大值。另外还可以通过index()函数查询某个索引号对应的元素值等,下面将简单介绍几种常用的对象操作函数。

    【实例2.19】对象查询与索引

    (1)type()函数

    >>> type(123) 
    <type 'int'> 
    >>> type(123.4) 
    <type 'float'> 
    >>> type(123+5j) 
    <type 'complex'> 
    >>> type("hello") 
    <type 'str'> 
    >>> type([1,2,3]) 
    <type 'list'> 
    >>> type((1,2,3)) 
    <type 'tuple'>
    

    (2)min()函数和max()函数

    >>> min(1,2,3,4,5)      #获取最小值 
    1 
    >>> max(1,2,3,4,5)      #获取最大值 
    5
    

    (3)index()函数

    >>> a=[111,222,333,444,555,666] 
    >>> a.index(555)       #获取某一元素的顺序号 
    4 
    >>> a[1:3]         #按顺序获取某几个元素 
    [222, 333]
    

    (4)len()函数

    >>> a=[111,222,333,444,555,666] 
    >>> len(a)          #获取某列表的长度 
    6
    展开全文
  • Python内置对象

    2019-05-05 23:22:48
    对象python语言中最基本概念之一,在python中处理一切都是对象,除了整数、实数、复数、字符串、列表、元组、字典、集合,还有 zip、 map、 enumerate、 filter等对象,函数和类也是对象 。 表1: Python...

    Python内置对象

    对象是python语言中最基本的概念之一,在python中处理的一切都是对象,除了整数、实数、复数、字符串、列表、元组、字典、集合,还有 zipmapenumeratefilter等对象,函数和类也是对象 。

    表1: Python的常用内置对象

    对 象 类 型 类型名称 示例 简要说明
    数字 int, float, complex 1234, 3.14, 1.3e5, 3+4j 数字大小没有限制,内置支持复数及其 运算
    字符串 str str 'swfu', "I'm student", '''Python ''', r'abc', R'bcd' 使用单引号、双引号、三引号作为定界 符,以字母r或R引导的表示原始字符串
    字节串 bytes b’hello world’ 以字母b引导,可以使用单引号、双引 号、三引号作为定界符
    列 表 list [1, 2, 3],['a', 'b', ['c', 2]] 所有元素放在一对方括号中,元素之间 使用逗号分隔,其中的元素可以是任意 类型
    字 典 dict {1:'food' ,2:'taste', 3:'import'} 所有元素放在一对大括号中,元素之间 使用逗号分隔,元素形式为“键:值”
    元 组 tuple (2, -5, 6), (3,) 不可变,所有元素放在一对圆括号中, 元素之间使用逗号分隔,如果元组中只 有一个元素的话,后面的逗号不能省略
    集 合 set frozenset {'a', 'b', 'c'} 所有元素放在一对大括号中,元素之间 使用逗号分隔,元素不允许重复;另外, set是可变的,而frozenset是不可变的
    布 尔 型 bool True, False 逻辑值,关系运算符、成员测试运算 符、同一性测试运算符组成的表达式的 值一般为TrueFalse
    空 类 型 NoneType None 空值
    异 常 Exception、 ValueError、 TypeError…… Python内置大量异常类,分别对应不同 类型的异常
    文 件 f = open('data.dat', 'rb') openPython内置函数,使用指定的 模式打开文件,返回文件对象
    其 他 可 迭 代 对 象 生成器对象、range对象、 zip对象、enumerate对象、map对象、filter对象 等 具有惰性求值的特点
    编程单元 函数(使用def定义) 类 (使用class定义) 模块 (类型为module 类和函数都属于可调用对象,模块用来集中存放函数、类、常量或其他对象

    Python常量与变量

    常量,一般是指不需要改变也不能改变的字面值,变量的值是可以变化的。

    Python属于强类型编程语言,Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言,变量的类型也是可以随时变化的。

    需要注意以下问题。

    1. 变量名必须以字母或下画线开头但以下画线 开头的变量在Python中有特殊含义,请参考第6章内容。
    2. 变量名中不能有空格或标点符号(括号、引号、逗号、斜线、反斜线、冒号、句号、问等)。
    3. 不能使用关键字作为变量名,Python关键字的介绍请见2.3节。要注意的是,直着Python版本的变 化,关键字列表可能会有所变化。
    4. 不建议使用系统内置的模块名、类型名或函数名以及已导人的模块名及其成员作为变量名,这会 改变其类型和含义,甚至会导致其他代码无法正常执行。可以通过dir(_ _ builtins_ _ )查看所有 内置对象名称。
    5. 变量名对英文字母的大小写敏感,例如student和Student是不同的变量
    >>> x = 4
    >>> print(type(x))
    <class 'int'>
    >>> x = 'Hello world.'
    >>> print(type(x))                 #查看变量类型
    <class 'str'>
    >>> x = [1,2,3]
    >>> print(type(x))
    <class 'list'>
    >>> isinstance(3, int)             #测试对象是否是某个类型的实例
    True
    >>> isinstance('Hello world', str)
    True
    >>> x = 3
    >>> x
    3
    

    在Python中,允许多个变量指向同一个值 。

    x = 3 y = 3 x += 6内存变化如下:

    1. 赋值语句的执行过程是:首先把等号右侧表达式的值计算出来,然后在内存中寻找一个位置把值存放进去,最后创建变量并指向这个内存地址。
    2. Python采用的是基于值的内存管理方式,如果为不同变量赋值为相同值,这个值在内存中只有一份,多个变量指向同一块内存地址。 Python中的变量并不直接存储值,而是存储了值的内存地址或者引用,这也是变量类型随时可以改变的原因。
    3. Python具有自动内存管理功能,对于没有任何变量指向的值,Python自动将其删除。Python会跟踪所有的值,并自动删除不再有变量指向的值。尽管如此,显式使用 del 命令删除不需要的值或显式关闭不再需要访问的资源,仍是一个好的习惯,同时也是一个优秀程序员的基本素养之一。

    数字

    数字是不可变对象,可以表示任意大小的数字。

    >>> 999*99   #想乘
    98901
    >>> 999**99 		#幂运算,等价于内置函数pow()
    905697844958667709741956562802753100901389806139609538815019658231017504097064752403846139892968390554024852396172082441213697329994395340901282449426848216146865935961454742677324005498146550510264840271813301125214581059267630055862747172378231729576039278689152963667155086263379780844149098999
    >>> 0.3+0.2
    0.5
    >>> 0.5-0.2
    0.3
     0.4-0.1				#实数相减,结果稍有偏差
    0.30000000000000004
    

    整数、浮点数

    Python中的**整数**类型可以分为
    
    * 十进制整数如,0-19123
    * 十六进制整数,需要16个数字0123456789、a、b、c、d、e、f来表示整数,必须以`0x`开头,如`0x10`、`0xfa`、`0xabcdef`
    * 八进制整数,只需要8个数字01234567来表示整数,必须以`0o`开头,如`0o35`、`0o11`
    * 二进制整数,只需要2个数字01来表示整数,必须以`0b`开头如,`0b101`、`0b100`
    
    **浮点数**又称小数
    
    `15.2, 0.31, 3.14, -11.2`
    
    Python 3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性,类似于数学上使用逗号作为千位分隔符。 
    
    ​```python 3.6.x 支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性```
    >>> 1_000_000
    1000000
    >>> 1_2_3_4
    1234
    >>> 3.14159_26535_89793_83246
    3.14159265358979383246
    

    分数

    >>> from fractions import Fraction
    >>> x = Fraction(3,5)
    >>> y = Fraction(3,7)
    >>> x
    Fraction(3, 5)
    >>> y
    Fraction(3, 7)
    >>> x.numerator  # 查看分子
    3
    >>> y.denominator  # 查看分母
    7
    

    高精度实数

    >>> from fractions import Decimal
    >>> 1/9
    0.1111111111111111
    >>> 1/3
    0.3333333333333333
    >>> Decimal(1/3)
    Decimal('0.333333333333333314829616256247390992939472198486328125')
    >>> Decimal(1/3) + Decimal(1/7)
    Decimal('0.4761904761904761640423089375')
    
    展开全文
  • Python编程语言的灵活特性支持多种编程思想,包括过程,面向对象和功能。 但最重要的是,用Python编程很有趣。 该语言支持而不是阻碍开发过程。 本文是有关Python编程的系列文章中的第一篇,介绍Python及其内置的...
  • Python内置对象可以分为简单类型和容器类型,简单类型主要是数值型数据,而容器类型是可以包含其他对象类型的集体,如序列、元组、映射等。 在简单类型对象中,Python的数值数据包括整型(int)、长整型(long)、...
  • python笔记2 python对象的动态类型

    千次阅读 2016-04-26 21:41:37
    从更正式的角度来讲,在P ython中,数据以对象的形式出现一一无论是Py t hon提供的内置对象,还是使用Python或是像C扩展库这 样的扩展语言工具创建的对象。尽管在以后才能确定这一概念,但对象无非是内存中的一部分...
  • 一、简介 如果你用过C或者C++,你该知道你的许多工作集中在实现数据结构上面。你需要管理内存分配,...Python提供了强大的对象类型作为Python语言的一部分,解决问题时,你不需要手工写代码来实现这些结构了。而且...
  • python对象类型

    2019-03-27 20:36:54
    python中常用的内置对象:数字、字符串、列表、字典、元组、文件、集合等 python程序中处理的每一样东西都是对象,而使用内置对象使python编程更加简单。 在python中没有类型声明,运行的表达式的语法决定了创建和...
  • python常用内置对象

    2020-03-27 15:20:51
    python中,变量存储是值得地址,不需事先声明,可以直接赋值使用,它是一种强类型编程语言,解释器会根据值或者运算自动推断变量类型,也是一种动态类型语言,变量类型可以随时改变。 python采用基于值得内存...
  • Python 编程语言具有很高灵活性,它支持多种编程方法,包括过程化、面向对象的和函数式。但最重要是,在 Python 中编写程序是件令人愉悦事。该语言对开发进程有支持作用,决不会妨碍它。本文是关于 Python...
  • Python对象类型

    2017-08-20 10:37:00
    Python提供了强大的对象类型作为语言的组成部分,事实上,除非有内置类型无法提供的特殊对象要处理,最好总是使用内置对象而不是使用自己的实现。下面是其原因: 内置对象使程序更容易编写: ...
  • Python语言中一切皆为对象,而每个对象属于某个数据类型。Python 数据类型包括内置的数据类型、模块中定义数据类型和用户自定义的类型。 通过字面量或调用对象的构造方法可以创建数据类型的实例对象,然后使用...
  • 对象是python语言中最基本概念,在python中处理一切都是对象。python中有许多内置对象可供编程者使用,内置对象可直接使用,如数字、字符串、列表、del等;非内置对象需要导入模块才能使用,如正弦函数sin(x),...
  • Python的数据类型内置类型

    千次阅读 2014-05-08 16:53:13
    内置对象类型有: Number(数字)、String(字符串)、List(列表)、Directory(字典)、Turple(元组)、File(文件)。 Number(数字): C语言数据类型主要包括:   包括整数和浮点数,整数相当于...
  • Python 作为当下编程语言“网红”,因为其应用广泛(Web/人工智能/大数据/机器学习/测试/运维/数据分析等等)、开发高效快速、简洁高效等特点,备受招聘企业青睐,无论是小长还是大厂,对掌握 Python 技能都...
  • Python 作为当下编程语言“网红”,因为其应用广泛(Web/人工智能/大数据/机器学习/测试/运维/数据分析等等)、开发高效快速、简洁高效等特点,备受招聘企业青睐,无论是小长还是大厂,对掌握 Python 技能都...
  • Python 作为当下编程语言“网红”,因为其应用广泛(Web/人工智能/大数据/机器学习/测试/运维/数据分析等等)、开发高效快速、简洁高效等特点,备受招聘企业青睐,无论是小长还是大厂,对掌握 Python 技能都...
  • Python内置数据类型 除了各种数据类型Python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后Python代码、运行时信息等等。因此,Python具备很强动态性。
  • 第4章 介绍Python对象类型Python知识结构为...简单来说:内置对象类型让编程变得更简单,并且内置对象类型更强大和高效,内置对象构成了每一个Python程序核心部分。 Python核心数据类型 下表是Python内置对象类型和一
  • 下面这些是我从IBMdeveloperwork里摘抄下来。具体网址:... 从其他语言过渡到 Python 编程语言时需要学习最重要课程之一是,Python每样东西都是对象。这一点可能并没有什么特别之处

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 505
精华内容 202
关键字:

python语言的内置对象类型

python 订阅