一、对象相关术语
python程序中保存的所有数据都是围绕对象的概念建立起来的
每个对象都有一个身份(两个变量名是否为同一对象用‘is’比较)、一个类型(对象类型用type()函数查看)和一个值(对象中的数据是否相同用‘==’比较)。
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 |
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() | 字符串大小写颠倒(大写变小写,小写变大写) |
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
转载于:https://blog.51cto.com/yinsuifeng/1901162