python对象类型与运算

简介:

一、对象相关术语

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

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

1
2
3
4
5
6
7
8
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()查看详细信息)

  • 创建特定类型的对象时,有时也将对象成为该类型的实例

  • 实例创建后,身份和类型就不可改变。如果对象的值是可以改变的成为可变对象;否则为不可变对象

    wKioL1iw7y6RkNB4AABDNJ7zTQI198.png-wh_50

  • 如果某个对象包含对其他对象的引用,则称为容器

  • 大多数对象拥有大量特有的数据属性和方法

    属性:与对象相关的值

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

二、类型的转换

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

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

三、数据类型的运算

    常见的数据类型有: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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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()
字符串大小写颠倒(大写变小写,小写变大写)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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)     深复制

wKiom1ixBTHDuPy6AABKdEYgfb0632.png-wh_50

  • 元组的操作和方法

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

()
定义空元组

l1 +l2

合并两个元组,返回一个新的元组,不会修改原元组。
l1*N

把l1重复N次,返回一个新元组。

in
成员关系判断字符 ,用法 obj in container (obj 是否在 container)

五、字典

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

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

    定义字典:

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

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

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

六、集合

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

  • 集合常用操作和方法:

len(s) 返回 中项目数
S.copy() 制作 的一份副本
S.difference(t) 求差集。 返回所有在 中不在 中的项目
s.intersection(t) 求交集。 返回同时在 和 中的项目
s.isdisjoint(t) 如果 和 没有相同项, 返回 true
s.issubset(t) 如果 是 的一个子集, 返回 true
s.issuperset(t) 如果 是 的一个超集, 返回 true
s.symmetric_difference(t) 求对称差集, 返回所有在 或 中, 但不同时在这两个集合的项
s.union(t) 求并集, 返回所有在 或 中的项
s|t 和 的并集 s&t 和 的交集
s-t 差集 s^t 对称差集
len(s) 集合项目数 max(s) 最大值
min(s) 最小值 all()、 any()、 cmp()
  • 可变集合(set)特有的操作和方法

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

七、python中的引用计数和垃圾收集器

    python中所有对象都有引用计数:当给对象分配一个新名称或者将其放入一个容器中, 其引用计数都会增加。使用 del 语句或者变量名重新赋值时, 对象的引用计数会减少。
    使用Sys.getrefcount()可以获得对象当前引用计数。一个对象的引用计数归零时, 它将被垃圾收集机制回收。

八、python的表达式和语句总结

    基本操作: x + y, x - y, x * y, x / y, x // y, x % y
    逻辑运算: x or y, x and y, not x 

    成员关系运算: x in y, x not in y
    对象实例测试: x is y, x not is y 

    一元运算: -x, +x, ~x:
    比较运算: x < y, x > y, x <= y, x >= y, x == y, x != y
    位运算: x | y, x & y, x ^ y, x << y, x >> y 

    幂运算: x ** y
    索引和分片: x[i], x[i:j], x[i:j:stride] 

    调用: x(...)
    取属性: x.attribute 

    匿名函数: lambda args: expression
    三元选择表达式: x if y else z 

    生成器函数发送协议: yield x 



本文转自 梦想成大牛 51CTO博客,原文链接:http://blog.51cto.com/yinsuifeng/1901162,如需转载请自行联系原作者

相关文章
|
4月前
|
Python
python对象模型
这篇文章介绍了Python中的对象模型,包括各种内置对象类型如数字、字符串、列表、字典等,以及如何使用`type()`函数来查看变量的数据类型。
|
4月前
|
Python
探索Python中的魔法方法:打造你自己的自定义对象
【8月更文挑战第29天】在Python的世界里,魔法方法如同神秘的咒语,它们赋予了对象超常的能力。本文将带你一探究竟,学习如何通过魔法方法来定制你的对象行为,让你的代码更具魔力。
47 5
|
9天前
|
缓存 监控 算法
Python内存管理:掌握对象的生命周期与垃圾回收机制####
本文深入探讨了Python中的内存管理机制,特别是对象的生命周期和垃圾回收过程。通过理解引用计数、标记-清除及分代收集等核心概念,帮助开发者优化程序性能,避免内存泄漏。 ####
21 3
|
21天前
|
机器学习/深度学习 存储 数据挖掘
Python 编程入门:理解变量、数据类型和基本运算
【10月更文挑战第43天】在编程的海洋中,Python是一艘易于驾驭的小船。本文将带你启航,探索Python编程的基础:变量的声明与使用、丰富的数据类型以及如何通过基本运算符来操作它们。我们将从浅显易懂的例子出发,逐步深入到代码示例,确保即使是零基础的读者也能跟上步伐。准备好了吗?让我们开始吧!
26 0
|
2月前
|
存储 缓存 Java
深度解密 Python 虚拟机的执行环境:栈帧对象
深度解密 Python 虚拟机的执行环境:栈帧对象
70 13
|
2月前
|
索引 Python
Python 对象的行为是怎么区分的?
Python 对象的行为是怎么区分的?
26 3
|
2月前
|
存储 缓存 算法
详解 PyTypeObject,Python 类型对象的载体
详解 PyTypeObject,Python 类型对象的载体
38 3
|
2月前
|
Python
深入解析 Python 中的对象创建与初始化:__new__ 与 __init__ 方法
深入解析 Python 中的对象创建与初始化:__new__ 与 __init__ 方法
21 1
|
2月前
|
缓存 Java 程序员
一个 Python 对象会在何时被销毁?
一个 Python 对象会在何时被销毁?
42 2
|
2月前
|
API Python 容器
再探泛型 API,感受 Python 对象的设计哲学
再探泛型 API,感受 Python 对象的设计哲学
22 2