python对象类型与运算-阿里云开发者社区

一、对象相关术语

python程序中保存的所有数据都是围绕对象的概念建立起来的

每个对象都有一个身份(两个变量名是否为同一对象用‘is’比较)、一个类型(对象类型用type()函数查看)和一个值(对象中的数据是否相同用‘==’比较)。

In [1]: a=3

In [3]: type(a)   #查看变量类型

Out[3]: int

In [4]: b=3

In [5]: a is b    #比较两个变量的类型

Out[5]: True

In [6]: a==b      #值比较

Out[6]: True

对象类型也称为对象的类别，用于描述对象的内部表示及其支持的方法和操作(使用dir()可以查看变量所支持的操作，help()查看详细信息)
创建特定类型的对象时，有时也将对象成为该类型的实例
实例创建后,身份和类型就不可改变。如果对象的值是可以改变的成为可变对象；否则为不可变对象
如果某个对象包含对其他对象的引用，则称为容器
大多数对象拥有大量特有的数据属性和方法

属性：与对象相关的值

方法：被调用时将在对象上执行某些操作的函数

二、类型的转换

python中提供了大量的内置函数，用来实现不同数据类型之间的转换，其中常用的有：

str(), repr()或 format()：将非字符型数据转换为字符	int(): 转为整数
float(): 转换为浮点型	list(s): 将字串 s 转为列表;
tuple(s): 将字串 s 转为元组；	set(s)：将字串 s 转为集合;
frozenset(s): 将字串 s 转换为不可变集合;	chr(x): 将整数转为字符
dict(d)：创建字典；其 d 必须是(key, value)的元组序列;	ord(x): 将字符转换为整数值
hex(x)：将整数转换为 16 进制字符	bin(x)：将整数转换为 2 进制字符
oct(x)：将整数转换为 8 进制字符

三、数据类型的运算

常见的数据类型有：int、long、float、complex、bool。对于数字类型，其本身是不可变类型，属于字面量。

常用数字操作

操作	描述	操作	描述
x+y	加法	x**y	乘方
x-y	减法	x%y	取模
x*y	乘法	-x	一元减法
x/y	除法	+x	一元加法
x//y	截断除法(只留商)

比较运算

操作	描述	操作	描述
x<<y	左移	x\|y	按位或
x>>y	右移	x^y	按位异或
x&y	按位与	~x	按位求反

四、序列类型

序列

索引为非负整数的有序对象集合，支持迭代。

字符串： str,unicode	'' 不可变类型
元组： tuple	() 不可变类型
列表： list	[] 可变类型

所有序列都可使用的操作和方法：

s[i]	返回一个序列的元素i	min(s)	s中的最小值
s[i:j]	返回一个切片	max(s)	s中的最大值
s[i:j:stride]	返回一个扩展切片	sum(s [,init])	s中各项的和
len(s)	s中的元素数	all(s)	s中的所有项是否为true
any(s)	s中的任意项是否为true

In [16]: a=(1,2,3,76,9,0,56,34)        #定义元组

In [17]: a[2]                          #第三个元素(索引从0开始)

Out[17]: 3

In [19]: a[2:6]                        #索引大于等于2，小于6的元素

Out[19]: (3, 76, 9, 0)

In [20]: a[::2]                        #所有奇数元素

Out[20]: (1, 3, 9, 56)

In [23]: len(a)                        #元组的长度

Out[23]: 8

In [24]: any(a)                        #任意值是否为真

Out[24]: True

In [25]: min(a)                        #最小值

Out[25]: 0

In [26]: max(a)                        #最大值

Out[26]: 76

In [27]: sum(a)                        #元组所有元素之和

Out[27]: 181

字符串的操作和方法

s.captitalize()	首字符变大写
s.index(sub [,start [,end]])	找到指定字符串sub首次出现的位置，没找到则报错
t.join(s)	使用t作为分隔符连接序列s中的字符，成为字符串
s.lower()/s.upper()	转换为小写/大写
s.replace(old,new [,count])	替换一个子字符串
s.split([sep [,maxsplit]])	使用sep作为分隔符对一个字符串进行划分为列表，maxsplit指定最大次数
s.strip([chars])	删除char开头和结尾的空白字符
s.find()	返回子串第一个匹配的偏移位置
s.swapcase()	字符串大小写颠倒(大写变小写，小写变大写)

In [32]: s='beautiful is better than ugly.'

In [33]: s.capitalize()

Out[33]: 'Beautiful is better than ugly.'

In [35]: s.index('is')

Out[35]: 10

In [38]: a=['beautiful','is' ,'better', 'than', 'ugly']

In [41]: ''.join(s)

Out[41]: 'beautiful is better than ugly.'

In [42]: s

Out[42]: 'beautiful is better than ugly.'

In [43]: s.replace('b','a')

Out[43]: 'aeautiful is aetter than ugly.'

In [44]: s

Out[44]: 'beautiful is better than ugly.'

In [46]: s.split(' ')

Out[46]: ['beautiful', 'is', 'better', 'than', 'ugly.']

列表的操作和方法(可变序列)

列表属于容器类型，其拥有的特点是任意对象的有序集合，可以通过索引访问其中的元素，长度可变，支持异构和任意嵌套。

s[i]=v	项目赋值	del s[i]	项目删除
s[i:j]=t	切片赋值	del s[i:j]	切片删除
s[i:j:stride]=t	扩展切片赋值	del s[i:j:stride]	扩展切片删除

list(s)	将s转换为一个列表
s.append(x)	将一个新元素x追加到s末尾
s.extend(t)	将一个新列表t追加到s末尾
s.count(x)	计算s中x的出现次数
s.index(x,[,start[,stop]])	查找x出现的最小索引位置，可选参数start，stop用于指定搜索的起始和结束索引。
s.insert(i,x)	在索引i处插入x
s.pop([i])	返回元素i并从列表中移除，如果省略i，则返回列表中最后一个元素
s.remove(x)	搜索x并从s中移除
s.reverse()	颠倒s中的所有元素的顺序
s.sort([key [,reverse]])	对s中的所有元素进行排序，key是一个函数键值，reverse是一个标志，表示以倒序对列表进行排序。key和reverse应该始终以关键字参数的形式指定。
l1 +l2	合并两个列表，返回一个新的列表，不会修改原列表。
l1*N	把l1重复N次，返回一个新列表。
in	成员关系判断字符，用法 obj in container （obj 是否在 container）
列表的复制方式	l1=[1,2,3,4] l2=l1 潜复制，同一个对象 l2=l1[:] 深复制，不是同一个对象 l2=copy.deepcopy(l1) 深复制

元组的操作和方法

容器类型，任意对象的有序集合，通过索引访问其中的元素，不可变对象，长度固定，支持异构和嵌套。虽然元组本身是不可变类型，但如果元组内嵌套了可变类型的元素，那么此元素的修改不会返回新元组。

()	定义空元组
l1 +l2	合并两个元组，返回一个新的元组，不会修改原元组。
l1*N	把l1重复N次，返回一个新元组。
in	成员关系判断字符，用法 obj in container （obj 是否在 container）

五、字典

字典属于可变类型(映射类型),使用dict()函数可以创建。字典在其他编程语言中又称作关联数组或者散列表，主要通过键实现元素的存取；字典是一个无序集合(即不可通过索引对字典进行遍历)；是可变类型的容器，其长度可变，同时支持异构与嵌套。

任何不可变对象都可以作为字典的键(如：字符串、数字、元组等)；包含可变对象的列表、字典和元组不能用作键。

定义字典：

{key1:value1,key2:value2} {}：空字典

字典所支持的操作和方法：

len(m)	返回 m 中的项目数
m[k]	返回 m 中键 k 的项
m[k]=x	将 m[k]的值设为 x
Del m[k]	从 m 中删除 m[k]
K in m	如果 k 是 m 中的键，返回 true
m.clear()	删除 m 中的所有项目
m.copy()	返回 m 的一个副本
m.fromkeys(s [,value])	创建一个新字典并将 s 中所有元素作为新字典的键，键的值均为 value
m.get(k [,v])	返回 m[k]，找不到则返回 v
m.has_key(k)	如果 m 中存在 k 则返回 true；否则返回 false（ python3 中废弃，使用 in）
m.items()	返回由(key,value)对组成的一个序列
m.keys()	返回键值组成一个序列
m.pop(k [,default])	如果找到 m[k]，则返回并从 m 中删除，否则提供 defult 值；没提供则引发异常
m.popitem()	从 m 中删除一个随机的(key,value)对，并把它返回为一个元组
m.update(b)	将 b 中的所有对象添加到 m 中
m.values()	返回 m 中所有值得一个序列
m.setdefault(k [,v])	如果找到 m[k]，则返回 m[k]，否则返回 v，并将 m[k]的值设为 v

六、集合

集合使用函数set()创建，不可变集合使用frozenset创建。和字典一样，集合也是无序排列、可以哈希的值；支持的方法有：集合关系测试，成员关系测试；可以迭代。集合部支持的操作有：索引、元素获取、切片等。

集合常用操作和方法：

len(s)	返回 s 中项目数
S.copy()	制作 s 的一份副本
S.difference(t)	求差集。返回所有在 s 中不在 t 中的项目
s.intersection(t)	求交集。返回同时在 s 和 t 中的项目
s.isdisjoint(t)	如果 s 和 t 没有相同项，返回 true
s.issubset(t)	如果 s 是 t 的一个子集，返回 true
s.issuperset(t)	如果 s 是 t 的一个超集，返回 true
s.symmetric_difference(t)	求对称差集，返回所有在 s 或 t 中，但不同时在这两个集合的项
s.union(t)	求并集，返回所有在 s 或 t 中的项

s\|t	S 和 t 的并集	s&t	S 和 t 的交集
s-t	差集	s^t	对称差集
len(s)	集合项目数	max(s)	最大值
min(s)	最小值	all()、 any()、 cmp()

可变集合(set)特有的操作和方法

s.add(itme)	将 item 添加到 s 中，如果 item 已存在，则无效果
s.clear()	删除 s 中的所有项
s.difference_update(t)	从 s 中删除同时也在 t 中的所有项
s.discard(item)	从 s 中删除 item，如果 item 不存在则无效果
s.intersection_update(t)	计算 s 与 t 的交集，结果放入 s
s.pop()	返回一个任意的几何元素，并将其从 s 中删除
s.remove(item)	从 s 中删除 item，如果 item 不是 s 的成员，引发异常
s.symmetric_difference_update(t)	计算 s 与 t 的对称差集，结果放入 s
s.update(t)	将 t 中的所有项添加到 s， t 可以是集合，序列或者支持迭代的任意对象。