2 Python-运算符与表达式

2 运算符与表达式

转载请注明出处:(http://blog.csdn.net/lis_12/article/details/52710163)

2.1 数字操作

位操作(其它操作省略…)

操作	描述
x << y	左移
x >> y	右移
x & y	与
x | y	或
x ^ y	异或
~x	反

2.2 序列操作

x in s,查看x是否在s中,如果存在返回True,否则返回False;

序列的复制

a = [0,1]
b = [[2],3]
print a + b  #[0, 1, [2], 3]

c = [a]
print c      #[[0, 1]]
a[0] = 'a'
print c      #[['a', 1]]

d = 2 * b
print d      #[[2], 3,[2], 3]
b[0][0] = 'b'
print d      #[['b'], 3, ['b'], 3]

浅复制,b中放入的是对列表a的引用.(如果序列里面都是不可变类型,深浅复制无所谓了)

import copy
a = [0,1]
b = [[2],3]

c = copy.deepcopy([a])
print c      #[[0, 1]]
a[0] = 'a'
print c      #[[0, 1]]

d = copy.deepcopy(2*b)
print d      #[[2], 3,[2], 3]
b[0][0] = 'b'
print d      #[[2], 3,[2], 3]

深复制,对b和d中放入的不再是a的引用,而是一个新的对象.

序列的解包

所有的序列都可以解包为一列变量名称,将序列解析为变量时,变量的个数必须和序列中元素的个数相同.

变量的结构也必须与序列相同.

a = range(2)
x,y = a
print x,y            # 0 1

b = [range(2),2,3]
x,y,z = b
print x,y,z          # [0,1],2,3
(a,b),x,y = b
print a,b,x,y        #可以认为a,b解析了b[0]  0,1,2,3

**切片运算符

切片运算符s[i:j]从s中提取一个子序列,它所包含的的元素索引k的范围是i<=k

a = range(10)
print a[::2]    #[0, 2, 4, 6, 8]
print a[::-2]   #[9, 7, 5, 3, 1]
print a[0:5:2]  #[0, 2, 4]
print a[0:5:-2] #[]
print a[5:0:2]  #[]
print a[5:0:-2] #[5, 3, 1]
print a[:5:1]   #[0, 1, 2, 3, 4]
print a[:5:-1]  #[9, 8, 7, 6]
print a[5::1]   #[5, 6, 7, 8, 9]
print a[5::-1]  #[5, 4, 3, 2, 1, 0]
print a[5:0:1]  #[]
print a[-5::1]  #[5, 6, 7, 8, 9]
print a[-5::-1] #[5, 4, 3, 2, 1, 0]

list特有的切片操作

因为字符串和元组是不可变的,创建后不可修改,list可以修改.

操作	描述(r必须是可迭代的)
s[i] = x	索引赋值,s[i] = x将索引i处修改为引用x,负索引值将关联到列表结尾,超出范围后将引发indexerror异常.
s[i:j] = r	切片赋值,s[i:j]替换为r.(此时可能会扩展s,因为r的元素个数不一定)
s[i:j:step] = r	扩展切片赋值,这种限制较大,右边的参数必须与要替换的切片元素个数相同.
del s[i]	删除一个元素
del s[i:j]	删除一个切片
del s[i:j:step]	删除一个扩展切片

a = range(5)
a[0:2] = range(10,13)
print a              #[10, 11, 12, 2, 3, 4]
a[2:5] = range(-3,-1)
print a              #[10, 11, -3, -2, 4]
a[2:] = [2]
print a              #[10, 11, 2]
a[2:] = "abc"
print a              #[10, 11, 'a', 'b', 'c']

a = range(5)
a[0::2] = "abc"      #['a', 1, 'b', 3, 'c']
print a
a[0::2] = "an"       #ValueError,左右序列元素个数不同,提供了步数才会有个数的限制哦

del a[0]
print a              #[1, 'b', 3, 'c']],同时减少'a'的引用计数
del a[::2]           #['b','c']

序列的比较

比较两个序列的时候,首先比较首个元素,如果list1中的元素大于list2的元素,则认为list1>list2,如果list1中的元素小于list2的元素,则认为list1

2.3 字符串格式化

字符	输出格式
d,i	十进制
u	无符号数
o	八进制
x	十六进制或长整数
X	十六进制
f,e,E	浮点数
g,G	指数小于-4时使用
s	字符串或者任意对象,同str生成的字符串
r	同repr生成的字符串
c	单个字符
%	字面量%

格式化函数format

%3d	%s	%0.2f
整数，3将一个整数格式化为宽度为3的字符串，如果超过了3则这个限定没有意义啊	字符串	浮点数，只取小数点 后两位，会四舍五入

format(str,格式)

format("a","10s") # 'a         '
print "%10s"%"a"  # '         a'  和上面那个对齐方式不同
format("a","10d") # error
print "{0},{0}".format(11,22) #11,11
print "{0},{0},{1},{2}".format(11,22,33) # 11,11,22,33  中括号里面的数代表第几个参数
'''
help(str.format)
Help on method_descriptor:

format(...)
S.format(*args, **kwargs) -> string

Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
'''
print "{0:3d},{1:4s},{1:5s},{2}".format(11,"a",33) # ' 11,a   ,a    ,33'

2.4 字典,集合操作

…

2.5 增量赋值

+=,-=,,/,*,,%,&,|,^,>>,<<等操作

2.6 属性(.)运算符

如list.append()

2.7 函数调用()运算符

2.8 转换函数,(id(x)取地址)

函数	描述
repr(x)	将对象x转换为一个表达式字符串
format(x,[format])	将对象x转换为格式化字符串
eval(str)	对字符串求值并返回对象,
chr(x)	将整数转换为字符
unichr(x)	将整数转换为unicode字符
ord(x)	将字符转换为其整数值
hex(x)	整数转换为十六进制
bin(x)	整数转换为二进制
oct(x)	整数转换为八进制

str()和repr()函数返回的结果可能不同.

repr()创建一个表达式字符串,可以使用eval对他求值.

a = '1+2'
b = str(a)
c = repr(a)
print b      #1+2
print c      #'1+2'
print eval(b)#3
print eval(c)#1+2

2.9 布尔表达式与真值

运算符	描述
x or y	x为false,则返回y;否则返回x (ps:x为true时候,不会在检查y,即不会计算y的值)
x and y	x为false,则返回x;否则返回y (ps:x为false时候,不会在检查y,即不会计算y的值)
not x	如果x为false,则返回1;否则返回0

返回True的情况:

True,任意非零数字,非空字符串、列表、元组、字典

返回False情况:

False,0,None和空的字符串、列表、元组、字典

2.10 对象的比较与身份

值比较: x == y

身份比较: x is y,即id(x) == id(y)

2.11 **条件表达式

min_value = a if a < b else b

可以这么用啊- -!,这里略爽- -!谨记

列表解析,生成器表达式中

[a if a%2 else a + 1 for a in range(10)]

result:[1, 1, 3, 3, 5, 5, 7, 7, 9, 9]

lambda函数

f = lambda x,y:x if x > y else y