python对象之对象基础2

【5】标准类型运算符

　　-5.1 对象值的比较

　　比较运算符用来判断同类型对象是否相等，所有的内建类型均支持比较运算，比较运算返回布尔值 True 或 False。早于 Python2.3 的版本，这些版本还没有 布尔类型，所以会看到比较结果为整型值 1 (代表 True)或 0 (代表 False)。

　　注意，实际进行的比较运算因类型而异。换言之，数字类型根据数值的大小和符号比较， 字符串按照字符序列值进行比较，等等。 

3 == 3
# True
3.1 <= 3.8
# True
5 + 4j >= 1- 3j
# True
'abc' == 'xyz'
#False
'abc' > 'xyz'
# False
'abc' < 'xyz'
# True
[1,'abc] == ['abc', 1]
# False
[1, 'abc'] == [1, 'abc]
# True

　　多个操作可以在同一行上进行，求值顺序为从左到右。

2 < 4 < 6
# (2 < 4) and (4 < 6)
# True
3 < 2 <5 != 3 <6
# False

　　-5.2 对象身份比较

　　对象可以被赋值到另一个变量(通过引用)。因为每个变量都指向同一个(共享的)数据对象，只要任何一个引用改变，该对 象的其它引用也会随之改变。

　　例1：foo1 和foo2 指向相同的对象

foo1 = foo2 = 4.3

　　当你从值的观点看这条语句时， 它表现的只是一个多重赋值，将 4.3 这个值赋给了 foo1 和foo2 这两个变量。这当然是对的， 不过它还有另一层含义。 事实是一个值为 4.3 的数字对象被创建，然后这个对象的引用被赋值给 foo1 和 foo2, 结果就是 foo1 和 foo2 指向同一个对象。 

　　下图演示了一个对象两个引用

　　

　　例2:foo1 和foo2 指向相同的对象

foo1 = 4.3
foo2 = foo1

　　这个例子非常类似上一个，一个值为 4.3 的数值对象被创建，然后赋给一个变量， 当执行 foo2 = foo1 时， foo2 被指向 foo1 所指向的同一个对象， 这是因为 Python 通过传递引用来 处理对象。foo2 就成为原始值 4.3的一个新的引用。 这样 foo1 和 foo2 就都指向了同一个对 象。示意图也和上图一样。 

　　例3:foo1 和 foo2 指向不同的对象 

foo1 = 4.3
foo2 = 3.0 + 1.3

　　这个例子有所不同。首先一个数字对象被创建，然后赋值给 foo1. 然后第二个数值对象被 创建并赋值给 foo2. 尽管两个对象保存的是同样大小的值，但事实上系统中保存的都是两个独 立的对象，其中 foo1 是第一个对象的引用， foo2 则是第二个对象的引用。图 4-2 演示给我 们这里有两个不同的对象，尽管这两个对象有同样大小的数值。 我们为什么在示意图中使用盒 子?没错，对象就象一个装着内容的盒子。当一个对象被赋值到一个变量，就象在这个盒子上 贴了一个标签，表示创建了一个引用。每当这个对象有了一个新的引用，就会在盒子上新贴一 张标签。当一个引用被销毁时， 这个标签就会被撕掉。当所有的标签都被撕掉时， 这个盒子 就会被回收。那么，Python 是怎么知道这个盒子有多少个标签呢? 

　　每个对象都天生具有一个计数器，记录它自己的引用次数。这个数目表示有多少个变量指 向该对象。 

　　Python 提供了 is 和 is not 运算符来测试两个变量是否指向同一个对象。 

a = [1,2,3,'python']
b = a
a is b 
# True
a is not b
# False

　　标准类型对象身份比较运算符 

运算符	功能
obj1 is obj2	obj1和obj2是同一个对象
obj1 is not obj2	obj1和obj2不是同一个对象

 

　　-5.3 布尔类型

　　布尔逻辑运算符 and， or 和 not 都是 Python 关键字，这些运算符的优先级按从高到低 的顺序列于表 4.3. not 运算符拥有最高优先级，只比所有比较运算符低一级。 and 和 or 运 算符则相应的再低一级。 

运算符	功能
not expr	expr的逻辑非（否）
expr1 and expr2	expr1 和expr2的逻辑与
expr1 or expr2	expr1 和expr2的逻辑或

if not(2 > 1):
    print('a')
else:
    print('b')

# b

x = 10
y = 20
z = 30
if (x < y) or (z < y):
    print('c')
# c     
if (x < y) and (y < z):
    print('d')
# d

【6】标准类型内建函数

　　除了这些运算符，我们刚才也看到，Python 提供了一些内建函数用于这些基本对象类型: cmp(), repr(), str(), type(), 和等同于 repr()函数的单反引号(``) 运算符。

　　下表表示标准类型内建函数:

函数	功能
cmp(obj1, obj2)	比较 obj1 和 obj2, 根据比较结果返回整数 i: 　 i < 0 if obj1 < obj2 i > 0 if obj1 > obj2 i == 0 if obj1 == obj2
repr(obj) 或 `obj`	返回一个对象的字符串表示
str(obj)	返回对象适合可读性好的字符串表示
type(obj)	得到一个对象的类型，并返回相应的 type 对象

 　　

　　-6.1 type()

　　　　type() 接受一个对象做为参数，并返回它的类型。它的返回值是一个类型对象。 

type(1)
# <type 'int'>
type('python')
# <type 'string'>
type(type(1))
# <type 'type'>

　　-6.2 cmp()      python3已经对这个函数废除

　　　　内建函数 cmp()用于比较两个对象 obj1 和 obj2， 如果 obj1 小于 obj2, 则返回一个负整数，如果 obj1 大于 obj2 则返回一个正整数， 如果 obj1 等于 obj2， 则返回 0。 

a, b = 2, 3
cmp(a,b)
# -1
b = 2
cmp (a,b)
# 0
a, b = 'abc', 'xyz'
cmp(a,b)
# -23
cmp(b,a)
#23

　　-6.3 str()和repr() (及``运算符)

　　内建函数 str() 和 repr() 或反引号运算符(``) 可以方便的以字符串的方式获取对象的 内容、类型、数值属性等信息。str()函数得到的字符串可读性好， 而 repr()函数得到的字符 串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的。 这两个函数接受一个对象做为其参数， 返回适当的字符串 

　　注：``已经不推荐使用了

str(4+2j)
#4+2j
str(1)
# 1
str
str(2e8)
#200000000.0
str([0,1,2])
#[0,1,2]
repr([0,1,2])
#[0,1,2]
`[0,1,2]`

　　-6.4 type() 和 isinstance()

　　　　 type()返回任意 Python 对象对象的类型，而不局限于标准类型。 

type('')
#<class 'str'>
s = 'python'
type(s)
#<class 'str'>
type(1)
#<class 'int'>
type(0+0j)
#<class 'complex'>
type(0.0)
#<class 'float'>
type([])
#<class 'list'>
type(())
#<class 'tuple'>
type({})
#<class 'dis'>
type(type)
#<class 'type'>

【7】以更新模型为标准类型分类

分类	Python 类型
可变类型	列表， 字典
不可变类型	数字、字符串、元组

　　通过id()来查看

　　不可变类型：

s = 'python'
print(id(s))
#4325967328
s = 'hello python'
print(id(s))
#4369273392
i = 0
print(id(i))
#4305209664
i += 1
print(id(i))
#4305209696

　　可变类型

aList = ['python',1,2,'hugo']
print(id(aList))
#4369008136
aList[1] = aList[1] + 1
print(aList)
#['python', 2, 2, 'hugo']
print(id(aList))
#4369008136

　　注意:列表的值不论怎么改变， 列表的 ID 始终保持不变。 

【8】以访问模型为标准的类型分类

分类	Python 类型
直接访问	数字
顺序访问	字符串、列表、元组
映射访问	字典

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/Jiangchuanwei/p/8471367.html