dir(obj) # 简单的列出对象obj所包含的方法名称，返回一个字符串列表

help(obj.func) # 查询obj.func的具体介绍和用法

if type(L) == type([]):

print("L is list")

if type(L) == list:

print("L is list")

if isinstance(L, list):

print("L is list")

# 哈希类型，即在原地不能改变的变量类型，不可变类型。可利用hash函数查看其hash值，也可以作为字典的key

"数字类型：int, float, decimal.Decimal, fractions.Fraction, complex"

"字符串类型：str, bytes"

"元组：tuple"

"冻结集合：frozenset"

"布尔类型：True, False"

"None"

# 不可hash类型：原地可变类型：list、dict和set。它们不可以作为字典的key。

1234, -1234, 0, 999999999 # 整数

1.23, 1., 3.14e-10, 4E210, 4.0e+210 # 浮点数

0o177, 0x9ff, 0X9FF, 0b101010 # 八进制、十六进制、二进制数字

3+4j, 3.0+4.0j, 3J # 复数常量，也可以用complex(real, image)来创建

hex(I), oct(I), bin(I) # 将十进制数转化为十六进制、八进制、二进制表示的“字符串”

int(string, base) # 将字符串转化为整数，base为进制数

# 2.x中，有两种整数类型：一般整数（32位）和长整数（无穷精度）。可以用l或L结尾，迫使一般整数成为长整数

float('inf'), float('-inf'), float('nan') # 无穷大, 无穷小, 非数

yield x # 生成器函数发送协议

lambda args: expression # 生成匿名函数

x if y else z # 三元选择表达式

x and y, x or y, not x # 逻辑与、逻辑或、逻辑非

x in y, x not in y # 成员对象测试

x is y, x is not y # 对象实体测试

x<y, x<=y, x>y, x>=y, x==y, x!=y # 大小比较，集合子集或超集值相等性操作符

1 < a < 3 # Python中允许连续比较

x|y, x&y, x^y # 位或、位与、位异或

x<<y, x>>y # 位操作：x左移、右移y位

+, -, *, /, //, %, ** # 真除法、floor除法：返回不大于真除法结果的整数值、取余、幂运算

-x, +x, ~x # 一元减法、识别、按位求补（取反）

x[i], x[i:j:k] # 索引、分片、调用

int(3.14), float(3) # 强制类型转换

a = 1; a.bit_length() # 1

a = 1024; a.bit_length() # 11

"""

# math模块

# Decimal模块：小数模块

import decimal

from decimal import Decimal

Decimal("0.01") + Decimal("0.02") # 返回Decimal("0.03")

decimal.getcontext().prec = 4 # 设置全局精度为4 即小数点后边4位

# Fraction模块：分数模块

from fractions import Fraction

x = Fraction(4, 6) # 分数类型 4/6

x = Fraction("0.25") # 分数类型 1/4 接收字符串类型的参数

"""

s = set([3,5,9,10]) # 创建一个数值集合，返回{3, 5, 9, 10}

t = set("Hello") # 创建一个唯一字符的集合返回{}

a = t | s; t.union(s) # t 和 s的并集

b = t & s; t.intersection(s) # t 和 s的交集

c = t – s; t.difference(s) # 求差集（项在t中, 但不在s中）

d = t ^ s; t.symmetric_difference(s) # 对称差集（项在t或s中, 但不会同时出现在二者中）

t.add('x'); t.remove('H') # 增加/删除一个item

s.update([10,37,42]) # 利用[......]更新s集合

x in s, x not in s # 集合中是否存在某个值

s.issubset(t); s <= t # 测试是否 s 中的每一个元素都在 t 中

s.issuperset(t); s >= t # 测试是否 t 中的每一个元素都在 s 中

s.copy();

s.discard(x); # 删除s中x

s.clear() # 清空s

{x**2 for x in [1, 2, 3, 4]} # 集合解析，结果：{16, 1, 4, 9}

{x for x in 'spam'} # 集合解析，结果：{'a', 'p', 's', 'm'}

"""

a = set([1, 2, 3])

b = set()

b.add(a) # error: set是不可哈希类型

b.add(frozenset(a)) # ok，将set变为frozenset，可哈希

type(True) # 返回<class 'bool'>

isinstance(False, int) # bool类型属于整型，所以返回True

True == 1; True is 1 # 输出(True, False)

"""

#共享引用及在原处修改：对于可变对象，要注意尽量不要共享引用！

#共享引用和相等测试：

L = [1], M = [1], L is M # 返回False

L = M = [1, 2, 3], L is M # 返回True，共享引用

#增强赋值和共享引用：普通+号会生成新的对象，而增强赋值+=会在原处修改

L = M = [1, 2]

L = L + [3, 4] # L = [1, 2, 3, 4], M = [1, 2]

L += [3, 4] # L = [1, 2, 3, 4], M = [1, 2, 3, 4]

S = '' # 空字符串

S = "spam’s" # 双引号和单引号相同

S = "s\np\ta\x00m" # 转义字符

S = """spam""" # 三重引号字符串，一般用于函数说明

S = r'\temp' # Raw字符串，不会进行转义，抑制转义

S = b'Spam' # Python3中的字节字符串

S = u'spam' # Python2.6中的Unicode字符串

s1+s2, s1*3, s[i], s[i:j], len(s) # 字符串操作

'a %s parrot' % 'kind' # 字符串格式化表达式

'a {1} {0} parrot'.format('kind', 'red')# 字符串格式化方法

for x in s: print(x) # 字符串迭代，成员关系

[x*2 for x in s] # 字符串列表解析

','.join(['a', 'b', 'c']) # 字符串输出，结果：a,b,c

str1 = "stringobject"

str1.upper(); str1.lower(); str1.swapcase(); str1.capitalize(); str1.title() # 全部大写，全部小写、大小写转换，首字母大写，每个单词的首字母都大写

str1.ljust(width) # 获取固定长度，左对齐，右边不够用空格补齐

str1.rjust(width) # 获取固定长度，右对齐，左边不够用空格补齐

str1.center(width) # 获取固定长度，中间对齐，两边不够用空格补齐

str1.zfill(width) # 获取固定长度，右对齐，左边不足用0补齐

str1.find('t',start,end) # 查找字符串，可以指定起始及结束位置搜索

str1.rfind('t') # 从右边开始查找字符串

str1.count('t') # 查找字符串出现的次数

#上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1

str1.replace('old','new') # 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new

str1.strip(); # 默认删除空白符

str1.strip('d'); # 删除str1字符串中开头、结尾处，位于 d 删除序列的字符

str1.lstrip();

str1.lstrip('d'); # 删除str1字符串中开头处，位于 d 删除序列的字符

str1.rstrip();

str1.rstrip('d') # 删除str1字符串中结尾处，位于 d 删除序列的字符

str1.startswith('start') # 是否以start开头

str1.endswith('end') # 是否以end结尾

str1.isalnum(); str1.isalpha(); str1.isdigit(); str1.islower(); str1.isupper() # 判断字符串是否全为字符、数字、小写、大写

mantra = """hello world

# mantra为"""hello world \n hello python \n hello my friend"""

S[0], S[len(S)–1], S[-1] # 索引

S[1:3], S[1:], S[:-1], S[1:10:2] # 分片，第三个参数指定步长，如`S[1:10:2]`是从1位到10位没隔2位获取一个字符。

int('42'), str(42) # 返回(42, '42')

float('4.13'), str(4.13) # 返回(4.13, '4.13')

ord('s'), chr(115) # 返回(115, 's')

int('1001', 2) # 将字符串作为二进制数字，转化为数字，返回9

bin(13), oct(13), hex(13) # 将整数转化为二进制/八进制/十六进制字符串，返回('0b1101', '015', '0xd')

name = "wang" "hong" # 单行，name = "wanghong"

name = "wang" \

"hong" # 多行，name = "wanghong"

"""

"this is %d %s bird" % (1, 'dead') # 一般的格式化表达式

"%s---%s---%s" % (42, 3.14, [1, 2, 3]) # 字符串输出：'42---3.14---[1, 2, 3]'

"%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234) # 对齐方式及填充："1234... 1234...1234 ...001234"

x = 1.23456789

"%e | %f | %g" % (x, x, x) # 对齐方式："1.234568e+00 | 1.234568 | 1.23457"

"%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x) # 对齐方式：' 1.23*1.23 *001.23* +1.23'

"%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"} # 基于字典的格式化表达式

"%(name)s is %(age)d" % vars() # vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量

# 普通调用

"{0}, {1} and {2}".format('spam', 'ham', 'eggs') # 基于位置的调用

"{motto} and {pork}".format(motto = 'spam', pork = 'ham') # 基于Key的调用

"{motto} and {0}".format('ham', motto = 'spam') # 混合调用

# 添加键 属性 偏移量 (import sys)

"my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'}) # 基于位置的键和属性

"{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'}) # 基于Key的键和属性

"first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C']) # 基于位置的偏移量

# 具体格式化

"{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159) # 输出'3.141590e+00, 3.142e+00, 3.14159'

"{fieldname:format_spec}".format(......)

# 说明:

"""

# 例子:

'={0:10} = {1:10}'.format('spam', 123.456) # 输出'=spam = 123.456'

'={0:>10}='.format('test') # 输出'= test='

'={0:<10}='.format('test') # 输出'=test ='

'={0:^10}='.format('test') # 输出'= test ='

'{0:X}, {1:o}, {2:b}'.format(255, 255, 255) # 输出'FF, 377, 11111111'

'My name is {0:{1}}.'.format('Fred', 8) # 输出'My name is Fred .' 动态指定参数

L = [[1, 2], 'string', {}] # 嵌套列表

L = list('spam') # 列表初始化

L = list(range(0, 4)) # 列表初始化

list(map(ord, 'spam')) # 列表解析

len(L) # 求列表长度

L.count(value) # 求列表中某个值的个数

L.append(obj) # 向列表的尾部添加数据，比如append(2)，添加元素2

L.insert(index, obj) # 向列表的指定index位置添加数据，index及其之后的数据后移

L.extend(interable) # 通过添加iterable中的元素来扩展列表，比如extend([2])，添加元素2，注意和append的区别

L.index(value, [start, [stop]]) # 返回列表中值value的第一个索引

L.pop([index]) # 删除并返回index处的元素，默认为删除并返回最后一个元素

L.remove(value) # 删除列表中的value值，只删除第一次出现的value的值

L.reverse() # 反转列表

L.sort(cmp=None, key=None, reverse=False) # 排序列表

a = [1, 2, 3], b = a[10:] # 注意，这里不会引发IndexError异常，只会返回一个空的列表[]

a = [], a += [1] # 这里实在原有列表的基础上进行操作，即列表的id没有改变

a = [], a = a + [1] # 这里最后的a要构建一个新的列表，即a的id发生了变化

a = [1, 2, 3, 4, 5, 6, 7]

a[1:4] = [] # a = [1, 5, 6, 7]

a = [0, 1, 2, 3, 4, 5, 6, 7]

del a[::2] # 去除偶数项(偶数索引的)，a = [1, 3, 5, 7]

D = {}

D = {'spam':2, 'tol':{'ham':1}} # 嵌套字典

D = dict.fromkeys(['s', 'd'], 8) # {'s': 8, 'd': 8}

D = dict(name = 'tom', age = 12) # {'age': 12, 'name': 'tom'}

D = dict([('name', 'tom'), ('age', 12)]) # {'age': 12, 'name': 'tom'}

D = dict(zip(['name', 'age'], ['tom', 12])) # {'age': 12, 'name': 'tom'}

D.keys(); D.values(); D.items() # 字典键、值以及键值对

D.get(key, default) # get函数

D.update(D_other) # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据

D.pop(key, [D]) # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常

D.popitem() # pop字典中随机的一项（一个键值对）

D.setdefault(k[, d]) # 设置D中某一项的默认值。如果k存在，则返回D[k]，否则设置D[k]=d，同时返回D[k]。

del D # 删除字典

del D['key'] # 删除字典的某一项

if key in D: if key not in D: # 测试字典键是否存在

# 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象

# 不可变对象：调用对象自身的任意方法，也不会改变该对象自身的内容，这些方法会创建新的对象并返回。

# 字符串、整数、tuple都是不可变对象，dict、set、list都是可变对象

D[(1,2,3)] = 2 # tuple作为字典的key

D = {k:8 for k in ['s', 'd']} # {'s': 8, 'd': 8}

D = {k:v for (k, v) in zip(['name', 'age'], ['tom', 12])} # {'age': 12, 'name': tom}

class Dict(dict):

def __missing__(self, key):

self[key] = []

return self[key]

dct = Dict()

dct["foo"].append(1) # 这有点类似于collections.defalutdict

dct["foo"] # [1]

a = [1, 2, 3] # a[1] = 0, OK

a = (1, 2, 3) # a[1] = 0, Error

a = ([1, 2]) # a[0][1] = 0, OK

a = [(1, 2)] # a[0][1] = 0, Error

D = (12) # 此时D为一个整数 即D = 12

D = (12, ) # 此时D为一个元组 即D = (12, )

output = open(r'C:\spam', 'w') # 打开输出文件，用于写

input = open('data', 'r') # 打开输入文件，用于读。打开的方式可以为'w', 'r', 'a', 'wb', 'rb', 'ab'等

fp.read([size]) # size为读取的长度，以byte为单位

fp.readline([size]) # 读一行，如果定义了size，有可能返回的只是一行的一部分

fp.readlines([size]) # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长。

fp.readable() # 是否可读

fp.write(str) # 把str写到文件中，write()并不会在str后加上一个换行符

fp.writelines(seq) # 把seq的内容全部写到文件中(多行一次性写入)

fp.writeable() # 是否可写

fp.close() # 关闭文件。

fp.flush() # 把缓冲区的内容写入硬盘

fp.fileno() # 返回一个长整型的”文件标签“

fp.isatty() # 文件是否是一个终端设备文件（unix系统中的）

fp.tell() # 返回文件操作标记的当前位置，以文件的开头为原点

fp.next() # 返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence]) # 将文件打操作标记移到offset的位置。whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。

fp.seekable() # 是否可以seek

fp.truncate([size]) # 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。

for line in open('data'):

print(line) # 使用for语句，比较适用于打开比较大的文件

open('f.txt', encoding = 'latin-1') # Python3.x Unicode文本文件

open('f.bin', 'rb') # Python3.x 二进制bytes文件

# 文件对象还有相应的属性：buffer closed encoding errors line_buffering name newlines等

# Python中的真假值含义：1. 数字如果非零，则为真，0为假。 2. 其他对象如果非空，则为真

# 通常意义下的类型分类：1. 数字、序列、映射。 2. 可变类型和不可变类型

spam = 'spam' # 基本形式

spam, ham = 'spam', 'ham' # 元组赋值形式

[spam, ham] = ['s', 'h'] # 列表赋值形式

a, b, c, d = 'abcd' # 序列赋值形式

a, *b, c = 'spam' # 序列解包形式（Python3.x中才有）

spam = ham = 'no' # 多目标赋值运算，涉及到共享引用

spam += 42 # 增强赋值，涉及到共享引用

[a, b, c] = (1, 2, 3) # a = 1, b = 2, c = 3

a, b, c, d = "spam" # a = 's', b = 'p', c = 'a', d = 'm'

a, b, c = range(3) # a = 0, b = 1, c = 2

a, *b = [1, 2, 3, 4] # a = 1, b = [2, 3, 4]

*a, b = [1, 2, 3, 4] # a = [1, 2, 3], b = 4

a, *b, c = [1, 2, 3, 4] # a = 1, b = [2, 3], c = 4

# 带有*时 会优先匹配*之外的变量 如

a, *b, c = [1, 2] # a = 1, c = 2, b = []

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

# 流的重定向

print('hello world') # 等于sys.stdout.write('hello world')

temp = sys.stdout # 原有流的保存

sys.stdout = open('log.log', 'a') # 流的重定向

print('hello world') # 写入到文件log.log

sys.stdout.close()

sys.stdout = temp # 原有流的复原

1 or 2 or 3 # 返回 1

1 and 2 and 3 # 返回 3

A = 1 if X else 2

A = 1 if X else (2 if Y else 3)

# 也可以使用and-or语句（一条语句实现多个if-else）

result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "big than 5")

while a > 1:

anything

else:

anything

# else语句会在循环结束后执行，除非在循环中执行了break，同样的还有for语句

for i in range(5):

anything

else:

anything

for (a, b) in [(1, 2), (3, 4)]: # 最简单的赋值

for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]: # 自动解包赋值

for ((a, b), c) in [((1, 2), 3), ("XY", 6)]: # 自动解包 a = X, b = Y, c = 6

for (a, *b) in [(1, 2, 3), (4, 5, 6)]: # 自动解包赋值

M = [[1,2,3], [4,5,6], [7,8,9]]

res = [sum(row) for row in M] # G = [6, 15, 24] 一般的列表解析 生成一个列表

res = [c * 2 for c in 'spam'] # ['ss', 'pp', 'aa', 'mm']

res = [a * b for a in [1, 2] for b in [4, 5]] # 多解析过程 返回[4, 5, 8, 10]

res = [a for a in [1, 2, 3] if a < 2] # 带判断条件的解析过程

res = [a if a > 0 else 0 for a in [-1, 0, 1]] # 带判断条件的高级解析过程

# 两个列表同时解析：使用zip函数

for teama, teamb in zip(["Packers", "49ers"], ["Ravens", "Patriots"]):

print(teama + " vs. " + teamb)

# 带索引的列表解析：使用enumerate函数

for index, team in enumerate(["Packers", "49ers", "Ravens", "Patriots"]):

print(index, team) # 输出0, Packers \n 1, 49ers \n ......

G = (sum(row) for row in M) # 使用小括号可以创建所需结果的生成器generator object

next(G), next(G), next(G) # 输出(6, 15, 24)

G = {sum(row) for row in M} # G = {6, 15, 24} 解析语法还可以生成集合和字典

G = {i:sum(M[i]) for i in range(3)} # G = {0: 6, 1: 15, 2: 24}

"""

def func():

print()

class Employee:

print()

print(func.__doc__) # 输出函数文档字符串

print(Employee.__doc__) # 输出类的文档字符串

"""

'first line' in open('test.txt') # in测试 返回True或False

list(map(str.upper, open('t'))) # map内置函数

sorted(iter([2, 5, 8, 3, 1])) # sorted内置函数

list(zip([1, 2], [3, 4])) # zip内置函数 [(1, 3), (2, 4)]

del X

x = [1,2,3,4,5,6]

x[:3] # 前3个[1,2,3]

x[1:5] # 中间4个[2,3,4,5]

x[-3:] # 最后3个[4,5,6]

x[::2] # 奇数项[1,3,5]

x[1::2] # 偶数项[2,4,6]

L = [1, 2]

I = iter(L) # I为L的迭代器

I.next() # 返回1

I.next() # 返回2

I.next() # Error:StopIteration

"""

myfunc('spam') # 函数调用

def myfunc(): # 函数定义

foo() # 还是输出1

"""数学运算类"""

abs(x) # 求绝对值，参数可以是整型，也可以是复数，若参数是复数，则返回复数的模

complex([real[, imag]]) # 创建一个复数

divmod(a, b) # 分别取商和余数，注意：整型、浮点型都可以

float([x]) # 将一个字符串或数转换为浮点数。如果无参数将返回0.0

int([x[, base]]) # 将一个字符串或浮点数转换为int类型，base表示进制

long([x[, base]]) # 将一个字符串或浮点数转换为long类型

pow(x, y) # 返回x的y次幂

range([start], stop[, step]) # 产生一个序列，默认从0开始

round(x[, n]) # 四舍五入

sum(iterable[, start]) # 对集合求和

oct(x) # 将一个数字转化为8进制字符串

hex(x) # 将一个数字转换为16进制字符串

chr(i) # 返回给定int类型对应的ASCII字符

unichr(i) # 返回给定int类型的unicode

ord(c) # 返回ASCII字符对应的整数

bin(x) # 将整数x转换为二进制字符串

bool([x]) # 将x转换为Boolean类型

"""集合类操作"""

basestring() # str和unicode的超类，不能直接调用，可以用作isinstance判断

format(value [, format_spec]) # 格式化输出字符串，格式化的参数顺序从0开始，如“I am {0},I like {1}”

enumerate(sequence[, start=0]) # 返回一个可枚举的对象，注意它有第二个参数

iter(obj[, sentinel]) # 生成一个对象的迭代器，第二个参数表示分隔符

max(iterable[, args...][key]) # 返回集合中的最大值

min(iterable[, args...][key]) # 返回集合中的最小值

dict([arg]) # 创建数据字典

list([iterable]) # 将一个集合类转换为另外一个集合类

set() # set对象实例化

frozenset([iterable]) # 产生一个不可变的set

tuple([iterable]) # 生成一个tuple类型

str([object]) # 转换为string类型

sorted(iterable[, cmp[, key[, reverse]]]) # 集合排序

L = [('b',2),('a',1),('c',3),('d',4)]

sorted(L, key=lambda x: x[1]), reverse=True) # 使用Key参数和reverse参数

sorted(L, key=lambda x: (x[0], x[1])) # 使用key参数进行多条件排序，即如果x[0]相同，则比较x[1]

"""逻辑判断"""

all(iterable) # 集合中的元素都为真的时候为真，特别的，若为空串返回为True

any(iterable) # 集合中的元素有一个为真的时候为真，特别的，若为空串返回为False

cmp(x, y) # 如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

"""IO操作"""

file(filename [, mode [, bufsize]]) # file类型的构造函数。

input([prompt]) # 获取用户输入，推荐使用raw_input，因为该函数将不会捕获用户的错误输入

raw_input([prompt]) # 设置输入，输入都是作为字符串处理

open(name[, mode[, buffering]]) # 打开文件，与file有什么不同？推荐使用open

"""其他"""

callable(object) # 检查对象object是否可调用

classmethod(func) # 用来说明这个func是个类方法

staticmethod(func) # 用来说明这个func为静态方法

dir([object]) # 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

help(obj) # 返回obj的帮助信息

eval(expression) # 计算表达式expression的值，并返回

exec(str) # 将str作为Python语句执行

execfile(filename) # 用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。

filter(function, iterable) # 构造一个序列，等价于[item for item in iterable if function(item)]，function返回值为True或False的函数

list(filter(bool, range(-3, 4)))# 返回[-3, -2, -1, 1, 2, 3], 没有0

hasattr(object, name) # 判断对象object是否包含名为name的特性

getattr(object, name [, defalut]) # 获取一个类的属性

setattr(object, name, value) # 设置属性值

delattr(object, name) # 删除object对象名为name的属性

globals() # 返回一个描述当前全局符号表的字典

hash(object) # 如果对象object为哈希表类型，返回对象object的哈希值

id(object) # 返回对象的唯一标识，一串数字

isinstance(object, classinfo) # 判断object是否是class的实例

isinstance(1, int) # 判断是不是int类型

isinstance(1, (int, float)) # isinstance的第二个参数接受一个元组类型

issubclass(class, classinfo) # 判断class是否为classinfo的子类

locals() # 返回当前的变量列表

map(function, iterable, ...) # 遍历每个元素，执行function操作

list(map(abs, range(-3, 4))) # 返回[3, 2, 1, 0, 1, 2, 3]

next(iterator[, default]) # 类似于iterator.next()

property([fget[, fset[, fdel[, doc]]]]) # 属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter

reduce(function, iterable[, initializer]) # 合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推

def add(x,y):return x + y

reduce(add, range(1, 11)) # 返回55 (注:1+2+3+4+5+6+7+8+9+10 = 55)

reduce(add, range(1, 11), 20) # 返回75

reload(module) # 重新加载模块

repr(object) # 将一个对象变幻为可打印的格式

slice(start, stop[, step]) # 产生分片对象

type(object) # 返回该object的类型

vars([object]) # 返回对象的变量名、变量值得字典

a = Class(); # Class为一个空类

a.name = 'qi', a.age = 9

vars(a) # {'name':'qi', 'age':9}

zip([iterable, ...]) # 返回对应数组

list(zip([1, 2, 3], [4, 5, 6])) # [(1, 4), (2, 5), (3, 6)]

a = [1, 2, 3], b = ["a", "b", "c"]

z = zip(a, b) # 压缩：[(1, "a"), (2, "b"), (3, "c")]

zip(*z) # 解压缩：[(1, 2, 3), ("a", "b", "c")]

unicode(string, encoding, errors) # 将字符串string转化为unicode形式，string为encoded string。

"""

import sys

sys.path

sys.argv # 获得脚本的参数

sys.builtin_module_names # 查找内建模块

sys.platform # 返回当前平台 出现如： "win32" "linux" "darwin"等

sys.modules # 查找已导入的模块

sys.modules.keys()

sys.stdout # stdout 和 stderr 都是类文件对象，但是它们都是只写的。它们都没有 read 方法，只有 write 方法

sys.stdout.write("hello")

sys.stderr

sys.stdin

import module1, module2 # 导入module1 使用module1.printer()

from module1 import printer # 导入module1中的printer变量 使用printer()

from module1 import * # 导入module1中的全部变量 使用不必添加module1前缀

from imp import reload

reload(module)

import dir1.dir2.mod # d导入包(目录)dir1中的包dir2中的mod模块 此时dir1必须在Python可搜索路径中

from dir1.dir2.mod import * # from语法的包导入

"""

from . import spam # 导入当前目录下的spam模块（错误: 当前目录下的模块, 直接导入即可）

from .spam import name # 导入当前目录下的spam模块的name属性（错误: 当前目录下的模块, 直接导入即可，不用加.）

from .. import spam # 导入当前目录的父目录下的spam模块

from string import * # 这里导入的string模块为sys.path路径上的 而不是本目录下的string模块(如果存在也不是)

from .string import * # 这里导入的string模块为本目录下的(不存在则导入失败) 而不是sys.path路径上的

_X # 变量名前加下划线可以防止from*导入时该变量名被复制出去

__all__ = ['x', 'x1', 'x2'] # 使用__all__列表指定from*时复制出去的变量名(变量名在列表中为字符串形式)

if __name__ == '__main__':

doSomething

# 模块属性中还有其他属性，例如：

__doc__ # 模块的说明文档

__file__ # 模块文件的文件名，包括全路径

__name__ # 主文件或者被导入文件

__package__ # 模块所在的包

import modulename as name

from modulename import attrname as name

M.name

M.__dict__['name']

sys.modules['M'].name

getattr(M, 'name')

class C1(C2, C3):

print("goodbey ", self.name)

I1 = C1('bob')

class FirstClass:

print("hello world")

class Manager(Person):

def giveRaise(self, percent, bonus = .10):

self.pay = int(self.pay*(1 + percent + bonus)) # 不好的方式 复制粘贴超类代码

Person.giveRaise(self, percent + bonus) # 好的方式 尽量调用超类方法

bob = Person('bob')

bob.__class__ # <class 'Person'>

bob.__class__.__name__ # 'Person'

bob.__dict__ # {'pay':0, 'name':'bob', 'job':'Manager'}

I1 = C1('bob'); I2 = C2('tom') # 此时I1和I2的spam都为42 但是都是返回的C1的spam属性

C1.spam = 24 # 此时I1和I2的spam都为24

I1.spam = 3 # 此时I1新增自有属性spam 值为2 I2和C1的spam还都为24

instance.method(arg...)

class.method(instance, arg...)

self.action() # 本类中不定义action函数 所以使用delegate函数时就会出错

# (2)定义action函数 但是返回异常

def action(self):

raise NotImplementedError("action must be defined")

# (3)上述的两种方法还都可以定义实例对象 实际上可以利用@装饰器语法生成不能定义的抽象超类

from abc import ABCMeta, abstractmethod

class Super(metaclass = ABCMeta):

@abstractmethod

def action(self): pass

x = Super() # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action

class A(B):

pass

a = A()

isinstance(a, B) # 返回True, A是B的子类 a也是B的一种

# OOP和组合: "has-a"的关系

pass

# OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取

# 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象

class wrapper:

return getattr(self.wrapped, attrname)

# 注:这里使用getattr(X, N)内置函数以变量名字符串N从包装对象X中取出属性 类似于X.__dict__[N]

x = wrapper([1, 2, 3])

x.append(4) # 返回 "Trace: append" [1, 2, 3, 4]

x = wrapper({'a':1, 'b':2})

list(x.keys()) # 返回 "Trace: keys" ['a', 'b']

class C1:

return 'self.name = %s' % self.__name

I = C1('tom')

print(I) # 返回 self.name = tom

I.__name = 'jeey' # 这里无法访问 __name为伪私有属性

I._C1__name = 'jeey' # 这里可以修改成功 self.name = jeey

class Spam:

print(message)

obj = Spam()

x = obj.doit # 类的绑定方法对象 实例 + 函数

x('hello world')

x = Spam.doit # 类的无绑定方法对象 类名 + 函数

x(obj, 'hello world')

x = Spam.selfless # 类的无绑定方法是函数 在3.0之前无效

x('hello world')

a = MyObject()

dir(a) # 使用dir函数

hasattr(a, 'x') # 测试是否有x属性或方法 即a.x是否已经存在

setattr(a, 'y', 19) # 设置属性或方法 等同于a.y = 19

getattr(a, 'z', 0) # 获取属性或方法 如果属性不存在 则返回默认值0

#这里有个小技巧，setattr可以设置一个不能访问到的属性，即只能用getattr获取

setattr(a, "can't touch", 100) # 这里的属性名带有空格，不能直接访问

getattr(a, "can't touch", 0) # 但是可以用getattr获取

# 一般创建了一个class的实例后, 可以给该实例绑定任何属性和方法, 这就是动态语言的灵活性

class Student(object):

pass

s = Student()

s.name = 'Michael' # 动态给实例绑定一个属性

def set_age(self, age): # 定义一个函数作为实例方法

self.age = age

from types import MethodType

s.set_age = MethodType(set_age, s) # 给实例绑定一个方法 类的其他实例不受此影响

s.set_age(25) # 调用实例方法

Student.set_age = MethodType(set_age, Student) # 为类绑定一个方法 类的所有实例都拥有该方法

class A(B, C):

pass

# 1.子类定义了__init__方法时，若未显示调用基类__init__方法，python不会帮你调用。

# 2.子类未定义__init__方法时，python会自动帮你调用首个基类的__init__方法，注意是首个。

# 3.子类显示调用基类的初始化函数：

class FooParent(object):

print(message + ' from Parent')

class FooChild(FooParent):

print(message + ' from Child')

fooChild = FooChild(10)

fooChild.bar('HelloWorld')

class Methods:

cmeth = classmethod(cmeth) # 调用内置函数，也可以使用@classmethod

obj = Methods()

obj.imeth(1) # 实例方法调用 <__main__.Methods object...> 1

Methods.imeth(obj, 2) # <__main__.Methods object...> 2

Methods.smeth(3) # 静态方法调用 3

obj.smeth(4) # 这里可以使用实例进行调用

Methods.cmeth(5) # 类方法调用 <class '__main__.Methods'> 5

obj.cmeth(6) # <class '__main__.Methods'> 6

@staticmethod

def smeth(x): print(x)

# 等同于:

def smeth(x): print(x)

smeth = staticmethod(smeth)

# 同理

@classmethod

def cmeth(cls, x): print(x)

# 等同于

def cmeth(cls, x): print(x)

cmeth = classmethod(cmeth)

def decorator(aClass):.....

C = decorator(C)

class Student:

__slots__ = ('name', 'age') # 限制Student及其实例只能拥有name和age属性

# __slots__属性只对当前类起作用, 对其子类不起作用

# __slots__属性能够节省内存

# __slots__属性可以为列表list，或者元组tuple

# 假设定义了一个类:C，该类必须继承自object类，有一私有变量_x

class C(object):