杂记
- 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 21 if False else 2 |
12
|
| 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])
网友评论