一、对象相关术语
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，如需转载请自行联系原作者
