类型和运算

杂记

• dir获取对象属性， help获取帮助， type得到对象类型，isinstance可以用来类型测试

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> help(list.pop)
Help on method_descriptor:

pop(...)
    L.pop([index]) -> item -- remove and return item at index (default last).
    Raises IndexError if list is empty or index is out of range.

>>> type([])
<class 'list'>
>>> isinstance([], list)
True

数字

• python数字类型的完整工具包括:整数和浮点数、复数、固定精度的十进制数、有理分数、集合、布尔类型、无穷的整数精度、各种数字内置函数和模块

#八进制、十六进制、二进制、复数
>>> 0o10, 0x0A, 0b1100, (3 + 4j) + complex(1, 2), len(str(2 ** 100))
(8, 10, 12, (4+6j), 31)

• hex、oct、bin把一个整数转换为对应进制表示的字符串。int(str, base)根据给定的进制把字符串转为一个整数

#数字与字符串转换
>>> hex(0x12), oct(0o10), bin(10), int('0x12', 16), int('10', 9)
('0x12', '0o10', '0b1010', 18, 9)

• 表达式操作符

操作符	描述	例子	结果
x if y else z	三元选择表达式	1 if True else 2 1 if False else 2	1 2
x or y	逻辑或
x and y	逻辑与
not x	逻辑非
in, not in	成员关系	1 in [1, 2]	True
is, is not	对象实体关系测试 (基于内存身份的比较)
/	除法	1 / 2	0.5
//	除法 向下取整	-5 // 2, 5 // 2, 5.0 // 2	(-3, 2, 2.0)
**	幂运算	2 ** 3	8
(...)	元组，表达式，生成器表达式
{...}	列表，列表解析
[...]	字典、集合、集合和字典解析
x[i:j:k]	分片	[1, 2, 3, 4, 5, 6][1:4:2]	[2, 4]
< <= > >= == != | ^ & << >> ~ + - * x[i] x(...) x.attr	与C中表现一致

比较操作可以连续进行:1 < 2 < 0, 1 < 2 < 3 结果:(False, True)

>>> [0 and 'a', 1 and 'b', 2 or 'c', False or 'd', True and 'a' or 1]
[0, 'b', 2, 'd', 'a']

• math模块包含了C语言中math库的绝大部分工具

>>> import math
>>> math.log10(100)
2.0

• random模块提供了随机数支持

>>> import random
>>> random.random()  #提供0-1之间的任意浮点数
0.5158813464733368
>>> random.randint(1, 10)
9
>>> random.choice([1, 3, '4'])
3

• 小数是具有固定精度的浮点值 由 decimal 模块进行支持

• 分数明确的保留了分子和分母，由 fractions 模块进行支持

• 集合是一些唯一的、不可比变的对象的无序组合，支持数学理论上的集合的操作。集合只能包含不可变的对象类型，因此字典和列表不能嵌到集合中

>>> set({1, 'a', 2 - 1})
{'a', 1}

• 集合解析:运行一个循环并在每次迭代时收集一个表达式结果，通过一个循环变量来访问当前迭代值以用于集合表达式中

>>> {x ** 2 for x in [1, 2, 3]}
{1, 9, 4}

动态类型

• 在python中，类型属于对象而非变量名，每一个对象有两个标准头部信息:一个类型标示符，一个引用的计数器(python中的垃圾收集主要基于引用计数器)。每当一个变量名被赋予一个新对象时，之前那个对象若没有被别的变量名或对象引用的话，那么其占用内存就会被释放，这种计数被称为垃圾收集。变量总是一个指向对象的指针，而不是可改变的内存区域的标签，给变量赋一个新的值，并不是替换了原始的对象，而是让这个变量去引用了另一个完全不同的对象

>>> v0 = 1
>>> v1 = v0
>>> v1 = 2
>>> print(v0, ',', v1)
1 , 2
>>> L0 = [1]
>>> L1 = L0
>>> L2 = L0
>>> L1 += ['a']
>>> L2 = 1
>>> print(L0, ',', L1, ',', L2)
[1, 'a'] , [1, 'a'] , 1

• sys模块getrefcount()可以得到对象的引用次数

>>> import sys
>>> sys.getrefcount(1)
1127

字符串

• python中并有没单个字符这种类型，取而代之的是可以使用一个字符的字符串。字符串被划分为不可变序列这一类别，意味着其不可在原处被更改。空字符不会去结束一个字符串，实际上，python中没有字符会结束一个字符串。python会以十六进制显示非打印字符。

• 转义

转义	意义
\newline	表示连续
\other	不成转义时，保留\
其他	类似C的转义

raw可以抑制转义，raw字符串不能以奇数个\结尾

• 常见的字符串表达式

操作	解释	结果
''	空字符串
's"zn'	双引号和单引号相同	's"zn'
's\0\z\n'	转义	's\x00\\z\n'
r's\0\z\n'	Raw字符串	's\\0\\z\\n'
"""...""" '''...'''	三重引号字符串块
'a' + 'b'	合并	'ab'
'a' * 3	乘法	'aaa'
'abc'[1] 'abc'[-1]	索引	'b' 'c'
len('a')	求长度	1
'abc'.find('bc')	搜索	1
'abc'.replace('ab', 'sz')	替换	'szc'
'abc'.split() 'a b c'.split() 'a,b,c'.split(',')	分隔	['abc'] ['a', 'b', 'c'] ['a', 'b', 'c']
'-'.join('abc')	插入分隔符	'a-b-c'
'你好'.encode('utf8') '你好'.encode('gb2312') '你好'.encode() '你好'.encode('utf16')	转码	b'\xe4\xbd\xa0\xe5\xa5\xbd' b'\xc4\xe3\xba\xc3' b'\xe4\xbd\xa0\xe5\xa5\xbd' b'\xff\xfe`O}Y' #0xFFFE是前缀
b'\xe4\xbd\xa0\xe5\xa5\xbd'.decode() b'\xc4\xe3\xba\xc3'.decode('gb2312') b'\xff\xfe`O}Y'.decode('utf16') b'\x60\x4f\x7d\x59'.decode('utf16')	解码	你好 你好 你好 你好
'a'"b"'c'	自动合并	"abc"

• 索引与切片

  
  

>>> s0 = '0123456789'
>>> s0[:]
'0123456789'
>>> s0[::]
'0123456789'
>>> s0[2:5]
'234'
>>> s0[2::2]
'2468'
>>> s0[::2]
'02468'
>>> s0[::-2]
'97531'
>>> s0[3:-2]
'34567'
>>> s0[5:1:-1]
'5432'

• 字符串转换

函数	说明	例子	结果
chr	将ASCII码转为字符	chr(115)	's'
ord	将字符转为ASCII码	ord('s')	115
int	将字符串转为整数，可指定进制
float	将字符串转为浮点值	float('1.1')	1.1
str	转为字符串	str([12, '3']) str({1}) str('1')	"[12, '3']" '{1}' '1'
repr	转为字符串	repr([12, '3']) repr({1}) repr('1')	"[12, '3']" '{1}' "'1'"

• 尽管str(),repr()在特性和功能方面都非常相似，事实上repr()返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象，但str()则有所不同。str()致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值，但很适合用于print语句输出。需要再次提醒的是，并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象。eval()将字符串当成有效的表达式来求值并返回计算结果,往往运行较慢，它实际上会作为程序的一个片段编译并运行这个字符串。

• 字符串格式化方法一:
  字符串格式化表达式:是基于C语言的printf模型:在%操作符的左边放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标均已%开头，在%操作符右边放置一个或多个对象，这些对象将会插入到左侧格式化字符串中

格式化操作符	意义
s	字符串或任意对象
r	s, 但使用repr，而不是str
c	字符
d	十进制整数
i	整数
u	无符号整数
o	八进制整数
x, X	十六进制整数
e, E	浮点指数
f, F	浮点十进制
g, G	浮点e E或f F
%	常量%

>>> 'Hello %% %s %s %s szn' % ([1, '2'], 3, {4})
"Hello % [1, '2'] 3 {4} szn"

控制	意义	例子	结果
-	左对齐	'%-05.2f' % 1.234	'1.23 '
+	正负号	'%+5.2f' % 1.234	'+1.23'
0	补零	'%05.2f' % 1.234	'01.23'
*	表示由用户指定	'%0*.*f' % (5, 2, 1.1)	'01.10'

基于字典的字符串格式化:

>>> '%(n)s %(x)s' % {"n" : 1, "x" : 'szn'}
'1 szn'

• 字符串格式化方法二:
  字符串格式化调用方法:可以通过位置或者key，可以添加键、属性、偏移量

>>> '{0}, {2}, {1}, {name}'.format('a', 'b', 'c', name = 1)
'a, c, b, 1'
>>> import sys
>>> '{N[0]}, {0.platform}, {1[H]}'.format(sys, {"H" : "W"}, N = [1, 2])
'1, win32, W'

添加格式具体化(稍微举几个例子，书里BBB一大堆，不乐意看)

>>> '{0}, {1:0>10}'.format(0, 's')
'0, 000000000s'
>>> '{0}, {1:0<10}'.format(0, 's')
'0, s000000000'
>>> '{0}, {1:0^10}'.format(0, 's')
'0, 0000s00000'
>>> '{0:b}'.format(10)
'1010'
>>> '{0:X}'.format(10)
'A'
>>> '{0:.2f}'.format(1.234)
'1.23'
>>> '{0:0{1}.{2}f}'.format(1.234, 5, 2)
'01.23'

列表与字典

• 列表与字典都可以在原处修改，也可以增长或缩短，可以包含任意对象或被嵌套。列表是有序的，可以通过下标访问。字典是无序的，可以通过键访问

• 常用的列表操作

操作	解释	结果
list('abc')	由可迭代项目生产一个列表	['a', 'b', 'c']
len([1, 2, 3])	获取长度	3
[1, 2, 3][:] [1, 2, 3][1: 3]	切片	[1, 2, 3] [2, 3]
[1, 2] * 2	乘法	[1, 2, 1, 2]
L[i:j] = []	切片赋值
[...]	列表解析

>>> L = list('0123456')
>>> del(L[0])
>>> del[L[1:3]]
>>> L
['1', '4', '5', '6']

>>> L = list('0123456')
>>> L[0:3] = list('abc')
>>> L
['a', 'b', 'c', '3', '4', '5', '6']

>>> [x * 2 for x in "123"]
['11', '22', '33']

>>> list(map(abs, [-1, 1]))
[1, 1]

• 常用字典操作

>>> d = {'v' : 1, 'n' : 's'}
>>> len(d)
2
>>> del d['v']
>>> d
{'n': 's'}
>>> {x : x ** 2 for x in [1, 2]}
{1: 1, 2: 4}
>>> dict([('n', 'v'), (1, 2)])
{1: 2, 'n': 'v'}

• 任何不可变对象都可以作为字典的键

• dict.keys()返回的python3.0的视图对象类似于集合，支持交并集等集合操作，dict.values()返回的视图不是唯一的，所以不支持集合操作，dict.items()支持
  

元组、文件及其他

• 元组不能在原处进行修改，是有序的，支持包含其他复合对象，支持嵌套。元组的不变性只适用于元组本身顶层，不适用与元组中的元素

>>> (10)
10
>>> (10,)
(10,)
>>> tuple("123")
('1', '2', '3')
>>> t = ([],)
>>> t[0].append(1)
>>> t
([1],)

• 文件

常见文件操作	解释
fp = open(r'D:\1.dat', 'w')	open创建文件输入输出，默认打开方式为 r
fp.read	一次性读取文件或读取指定的N个字节到字符串
fp.readline	读取一行到字符串
fp.readlines	读取整个文件到字符串列表
fp.write	写入字符串到文件
fp.writelines	把列表内的所有字符串写入文件
fp.close	关闭文件
fp.flush	刷新
fp.seek	设置文件位置
fp.tell	获取文件位置
for line in open(r'D:\1.dat') : use line	迭代使用文件
open(r'D:\1.dat', encoding = 'utf8')	打开utf8文件

• pickle模块能让我们直接在文件中存储几乎任何python对象

>>> fp = open(r'D:\1.dat', 'wb')
>>> v = [1, [2, {3, 'a'}, {4 : 'b'}], 5]
>>> import pickle
>>> pickle.dump(v, fp)
>>> fp.close()
>>> 
>>> fp = open(r'D:\1.dat', 'rb')
>>> vOut = pickle.load(fp)
>>> vOut
[1, [2, {3, 'a'}, {4: 'b'}], 5]

• 切片以及copy方法只能做顶层复制，不能够复制嵌套的结构，若需要拷贝深层嵌套则需要使用copy模块的deepcopy

>>> v = [[0], 1]
>>> v1 = v.copy()
>>> v2 = v[0:1]
>>> v1[0].append('a')
>>> v1[1] = 2
>>> v, v1, v2
([[0, 'a'], 1], [[0, 'a'], 2], [[0, 'a']])

>>> v = [[0], 1]
>>> import copy
>>> v1 = copy.deepcopy(v)
>>> v1[0].append('a')
>>> v, v1
([[0], 1], [[0, 'a'], 1])