python对象类型与运算

一、对象相关术语

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

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

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

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

对象类型也称为对象的类别，用于描述对象的内部表示及其支持的方法和操作(使用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//y

截断除法(只留商)

比较运算

x<<y

左移

x|y

按位或

x>>y

右移

x^y

按位异或

x&y

按位与

按位求反

四、序列类型

序列

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

字符串： 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

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

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

<code>In [</code><code>20</code><code>]: a[::</code><code>2</code><code>] </code><code>#所有奇数元素</code>

<code>In [</code><code>23</code><code>]: </code><code>len</code><code>(a) </code><code>#元组的长度</code>

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

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

字符串的操作和方法

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()

字符串大小写颠倒(大写变小写，小写变大写)

<code>In [</code><code>32</code><code>]: s</code><code>=</code><code>'beautiful is better than ugly.'</code>

<code>In [</code><code>33</code><code>]: s.capitalize()</code>

<code>Out[</code><code>33</code><code>]: </code><code>'Beautiful is better than ugly.'</code>

<code>In [</code><code>35</code><code>]: s.index(</code><code>'is'</code><code>)</code>

<code>In [</code><code>38</code><code>]: a</code><code>=</code><code>[</code><code>'beautiful'</code><code>,</code><code>'is'</code> <code>,</code><code>'better'</code><code>, </code><code>'than'</code><code>, </code><code>'ugly'</code><code>]</code>

<code>Out[</code><code>41</code><code>]: </code><code>'beautiful is better than ugly.'</code>

<code>Out[</code><code>42</code><code>]: </code><code>'beautiful is better than ugly.'</code>

<code>In [</code><code>43</code><code>]: s.replace(</code><code>'b'</code><code>,</code><code>'a'</code><code>)</code>

<code>Out[</code><code>43</code><code>]: </code><code>'aeautiful is aetter than ugly.'</code>

<code>Out[</code><code>44</code><code>]: </code><code>'beautiful is better than ugly.'</code>

<code>In [</code><code>46</code><code>]: s.split(</code><code>' '</code><code>)</code>

<code>Out[</code><code>46</code><code>]: [</code><code>'beautiful'</code><code>, </code><code>'is'</code><code>, </code><code>'better'</code><code>, </code><code>'than'</code><code>, </code><code>'ugly.'</code><code>]</code>

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

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

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次，返回一个新列表。

成员关系判断字符，用法 obj in container （obj 是否在 container）

列表的复制方式

l1=[1,2,3,4]

l2=l1 潜复制，同一个对象

l2=l1[:] 深复制，不是同一个对象

l2=copy.deepcopy(l1) 深复制

元组的操作和方法

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

()

定义空元组

合并两个元组，返回一个新的元组，不会修改原元组。

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

五、字典

字典属于可变类型(映射类型),使用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创建。和字典一样，集合也是无序排列、可以哈希的值；支持的方法有：集合关系测试，成员关系测试；可以迭代。集合部支持的操作有：索引、元素获取、切片等。

集合常用操作和方法：

返回 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

对称差集

集合项目数

最大值

最小值

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 可以是集合，序列或者支持迭代的任意对象。

七、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，如需转载请自行联系原作者

python对象类型与运算

继续阅读

来自python的【条件控制/语句循环/break/continue/else/pass】一、条件控制二、语句循环

无法解析的外部符号 wmain，该符号在函数 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink导出用例转换工具(XML2Excel)

YAML简介和PyYAML安全操作YAML支持的类型YAML的优点：yaml的基本语法python操作

Small tricks

libsvm for python 安装

学习软件测试基础测试第七天

Zeppelin 配置访问 REST APIApache Zeppelin Configuration REST API

【Torch】最简洁logging使用指南

27. Remove Element(列表)题目代码

Cloud Studio初体验

使用 ctypes 进行 Python 和 C 的混合编程

【python】【数据处理】画多维数据分布图

【python】netconf协议对接管理设备

「Python 网络自动化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 网络设备

在python中创建excel并写入