一、对象相关术语
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()查看详细信息)
创建特定类型的对象时,有时也将对象成为该类型的实例
实例创建后,身份和类型就不可改变。如果对象的值是可以改变的成为可变对象;否则为不可变对象
如果某个对象包含对其他对象的引用,则称为容器
大多数对象拥有大量特有的数据属性和方法
属性:与对象相关的值
方法:被调用时将在对象上执行某些操作的函数
二、类型的转换
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 |
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) 深复制 |
元组的操作和方法
容器类型,任意对象的有序集合,通过索引访问其中的元素,不可变对象,长度固定,支持异构和嵌套。虽然元组本身是不可变类型,但如果元组内嵌套了可变类型的元素,那么此元素的修改不会返回新元组。
() |
定义空元组 |
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 可以是集合, 序列或者支持迭代的任意对象。 |
七、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,如需转载请自行联系原作者