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的世界里,魔法方法如同神秘的咒语,它们赋予了对象超常的能力。本文将带你一探究竟,学习如何通过魔法方法来定制你的对象行为,让你的代码更具魔力。
52 5
|
8天前
|
存储 数据处理 Python
Python如何显示对象的某个属性的所有值
本文介绍了如何在Python中使用`getattr`和`hasattr`函数来访问和检查对象的属性。通过这些工具,可以轻松遍历对象列表并提取特定属性的所有值,适用于数据处理和分析任务。示例包括获取对象列表中所有书籍的作者和检查动物对象的名称属性。
19 2
|
22天前
|
缓存 监控 算法
Python内存管理:掌握对象的生命周期与垃圾回收机制####
本文深入探讨了Python中的内存管理机制,特别是对象的生命周期和垃圾回收过程。通过理解引用计数、标记-清除及分代收集等核心概念,帮助开发者优化程序性能,避免内存泄漏。 ####
31 3
|
1月前
|
机器学习/深度学习 存储 数据挖掘
Python 编程入门:理解变量、数据类型和基本运算
【10月更文挑战第43天】在编程的海洋中,Python是一艘易于驾驭的小船。本文将带你启航,探索Python编程的基础:变量的声明与使用、丰富的数据类型以及如何通过基本运算符来操作它们。我们将从浅显易懂的例子出发,逐步深入到代码示例,确保即使是零基础的读者也能跟上步伐。准备好了吗?让我们开始吧!
29 0
|
2月前
|
存储 缓存 Java
深度解密 Python 虚拟机的执行环境:栈帧对象
深度解密 Python 虚拟机的执行环境:栈帧对象
76 13
|
2月前
|
索引 Python
Python 对象的行为是怎么区分的?
Python 对象的行为是怎么区分的?
30 3
|
2月前
|
存储 缓存 算法
详解 PyTypeObject,Python 类型对象的载体
详解 PyTypeObject,Python 类型对象的载体
50 3
|
2月前
|
Python
深入解析 Python 中的对象创建与初始化:__new__ 与 __init__ 方法
深入解析 Python 中的对象创建与初始化:__new__ 与 __init__ 方法
26 1
|
2月前
|
缓存 Java 程序员
一个 Python 对象会在何时被销毁?
一个 Python 对象会在何时被销毁?
50 2