>>> a = 1 #int
>>> a = 1.5 #float
>>> a = True #bool
>>> a = 2+3j #complex

>>> mystr = '' #创建空字符串
>>> mystr = "a" #单个字符同样为字符串
>>> mystr = 'abcdefg'
>>> mystr[0] #索引值为正时，顺序从左向右取对应位置数据
'a'
>>> mystr[-1] #索引值为负时，顺序从右边向左取对应位置数据
'g'
>>> mystr[:] #未给出开始，结束索引；选择整个列表范围内的值
'abcdefg'
>>> mystr[:2] #切片选择0-2范围内的值，不包含索引为2的值
'ab'
>>> mystr[-3:] #切片选择从-3到最后位置的值
'efg'
>>> mystr[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
'ac'
>>> mystr[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
'gfedcba'
>>> mystr[0] = 1 #当对字符串数据对象进行值修改，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

>>> mylist = [] #创建空列表
>>> mylist = [1,2,3,4]
>>> mylist[0] #索引值为正时，顺序从左向右取对应位置数据
1
>>> mylist[-1] #索引值为负时，顺序从右边向左取对应位置数据
4
>>> mylist[:] #未给出开始，结束索引；选择整个列表范围内的值
[1,2,3,4]
>>> mylist[:2] #切片选择0-2范围内的值，不包含索引为2的值
[1,2]
>>> mylist[-3:] #切片选择从-3到最后位置的值
[2,3,4]
>>> mylist[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
[1,3]
>>> mylist[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
[4,3,2,1]
>>> mylist[0] = 'a' #修改列表第一个位置上的值为字母'a'
>>> mylist
['a',2,3,4]#列表为可变数据对象

>>> mytuple = (1,) #正确方式创建只含有一个数据的元组
>>> mytuple
(1,)#返回值为元组
>>> mytuple = (1) #错误方式创建只含有一个数据的元组
1#返回值为整型
>>> mytuple = (1, 2, 3, 4, 5)
>>> mytuple[0]
1
>>> mytuple[-1] #索引值为负时，顺序从右边向左取对应位置数据
4
>>> mytuple[:] #未给出开始，结束索引；选择整个列表范围内的值
(1, 2, 3, 4, 5)
>>> mytuple[:2] #切片选择0-2范围内的值，不包含索引为2的值
(1, 2)
>>> mytuple[-3:] #切片选择从-3到最后位置的值
(3, 4, 5)
>>> mytuple[0:4:2] #切片选择取索引0-4范围内的值(不包含索引4)，并且步长为2
(1, 3)
>>> mytuple[::-1] #切片选择整个索引范围内的值，步长为负值时，为逆序
(5, 4, 3, 2, 1)
>>> mytuple[0] = 'a' #当对元组数据对象进行值修改，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

#python2.x
>>> 5 / 3 #2中两整数做除法，结果还是整数
1 #结果为整数
>>> 5 / 3.0
1.6666666666666667 #只有在参与运算的数据类型中含有浮点数，结果才会成为浮点数
#python3.x
>>> 5 / 3
1.6666666666666667 #3中两整数做除法，结果会精确到浮点数
>>> 5 / 3.0
1.6666666666666667

>>> 5 // 3
1
>>> 5 % 3
2
>>> 5 ** 3
125

>>> round(5 / 3) #可以获取到5/3的四舍五入结果
2
>>> round(5 / 3, 2) #控制返回结果的精度为2
1.67

>>> a = 1
>>> not a #a的逻辑非
False
>>> b = 0
>>> a and b #a和b的逻辑与
0
>>> a or b #a和b的逻辑或
1

>>> a1 = [1,2,3,4,5]
>>> a2 = [1,2,3,4,5]
>>> a1 is a2 #a1和a2值虽相同，但并不是同一个数据对象
False
>>> id(a1)
2298768048584
>>> id(a2) #两数据地址并不相同
2298768048392

>>> a = 1
>>> b = 2
>>> a == b
False
>>> a != b
True
>>> a > b
False
>>> a < b
True
>>> a <= b
True
>>> a >= b
False

>>> a = 1
>>> ~a
-2

#a: 0000 0001 1
#b: 0000 0010 2
>>> a = 1
>>> b = 2
>>> a = a | b #按位或
#a: 0000 0011 3
#b: 0000 0010 2
>>> b = a ^ b #按位异或
#a: 0000 0011 3
#b: 0000 0001 1
>>> a = a ^ b #按位异或
#a: 0000 0010 2
#b: 0000 0001 1
>>> a
2
>>> b
1

>>> a = 1 #这里我们可以直接给a变量赋值为1，并没有提前对a进行声明

>>> a = 1
>>> a = 'abc' #对a重复复制并不会导致报错

>>> a, b = 1, 2
>>> a
1
>>> b
2

>>> a1 = 1 #Success
>>> _a = 1 #Success
>>> 1a = 1 #Error
File "<stdin>", line 1
   1a = 1
    ^
SyntaxError: invalid syntax

>>> a = 1
>>> ++a #这里的++a并不会报错，是因为+号被解释成了正号，正的正一等于1
>>> a
1 #结果同样可以看出a并没有实现自增
>>> --a #与++a同理，此时为负的负一
>>> a++ #后++报错
File "<stdin>", line 1
    a++
      ^
SyntaxError: invalid syntax
>>> a--
File "<stdin>", line 1
    a --
       ^
SyntaxError: invalid syntax

>>> a = 1
>>> id(a) #可以使用id函数查看当前变量值所处内存单元
1951315008
>>> b = a
>>> id(b)
1951315008
>>> import sys
>>> sys.getrefcount(a)
127 #当前有127个变量使用1这个值
>>> sys.getrefcount(b) #可以看到两个变量的引用计数相同
127
>>> del b #删除掉b
>>> sys.getrefcount(a)
126 #1的引用计数减少为126

>>> mydict = {1:'a',2:'b'}
>>> mydict
{1: 'a', 2: 'b'}

>>> mydict = dict(([1,'a'],[2,'b']))
>>> mydict
{1: 'a', 2: 'b'}

>>> mydict = dict.fromkeys([1,2],'a')
>>> mydict
{1: 'a', 2: 'a'}
#这样可以批量创建key值，但是缺点也暴露出来无法单独分配value值

>>> mydict = {1:'a',2:'b'}
>>> mydict.keys()
dict_keys([1, 2])

>>> mydict = {1:'a',2:'b'}
>>> mydict.values()
dict_values(['a', 'b'])

>>> mydict = {1:'a',2:'b'}
>>> mydict[1]
'a'
>>> mydict[2]
'b'
>>> mydict[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3

dict.get('key',default)

>>> for key in mydict:
...     print(key)
...     print(mydict[key])
...
1
a
2
b

>>> mydict = {1:'a',2:'b'}
>>> 1 in mydict
True
>>> 3 in mydict
False
#由于value值是可以重复的，所以判断value是没有意义的

>>> mydict = {1:'a',2:'b'}
>>> mydict[1] = 'c'
>>> mydict
{1: 'c', 2: 'b'}

>>> mydict = {1:'a',2:'b'}
>>> del mydict[1]
>>> mydict
{2: 'b'}

>>> mydict = {1:'a',2:'b'}
>>> mydict.pop(1)
'a'
>>> mydict
{2: 'b'}

>>> mydict = {1:'a',2:'b'}
>>> mydict.clear()
>>> mydict
{}

>>> mydict = {1:'a',2:'b'}
>>> del mydict
>>> mydict
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'mydict' is not defined
#字典被删除之后连变量都不见了

>>> myset = {[1,2,3]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
#可变数据对象不可hash，所以不能成为集合中数据元素

>>> myset = {1,2,3,4,5}
#直接通过大括号创建
>>> myset = set([1,2,3,1,2,3])
>>> myset
{1, 2, 3}
#通过工厂函数接收一个可迭代对象

>>> myset = frozenset([1,2,3,1,2,3])
>>> myset
frozenset({1, 2, 3})

>>> myset  = {1,2,3}
>>> for var in myset:
...     print(var)
...
1
2
3
#集合虽然无序，但是可以通过for循环迭代访问

>>> myset = {1,2}
>>> myset.add('abc') #更新字符串到集合中
>>> myset
{1, 2, 'abc'}
>>> myset.add((1,2,3)) #更新元组到集合中
>>> myset
{1, 2, 'abc', (1, 2, 3)}
>>> myset.add([1,2,3]) #更新列表到集合中报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

>>> myset = {1,2}
>>> myset.update('abc') #更新字符串
>>> myset
{1, 2, 'b', 'c', 'a'} #字符串被拆开
>>> myset.update([1,2,3]) #更新列表
>>> myset
{1, 2, 3, 'b', 'c', 'a'} #这里列表支持更新是因为存储的数据已经不再是列表，而是列表中的每一个实际数据
>>> myset.update((3,4,5)) #更新元组
>>> myset
{1, 2, 3, 4, 'b', 5, 'c', 'a'} #元组中的每一个数据都被拿出更新到集合中，并且去重

>>> myset = frozenset('abc')
>>> myset
frozenset({'a', 'b', 'c'})
>>> myset.add()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
#不可变集合不支持add更新
>>> myset.update()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'update'
#不可变集合不支持update更新

>>> myset = {1,2,3}
>>> myset.remove(3)
>>> myset
{1, 2}
>>> myset.remove(5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 5

>>> myset = {1,2}
>>> myset.discard(1)
>>> myset
{2}
>>> myset = {1,2}
>>> myset.discard(3)
>>> myset
{1, 2}

>>> myset = {1,2,3}
>>> del myset
>>> myset
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'myset' is not defined

>>> myset = {1,2}
>>> 1 in myset
True
>>> 3 in myset
False
>>> 2 not in myset
False

>>> a = {1,2}
>>> b = {1,2,3,4}
>>> a < b
True
>>> a.issubset(b)
True

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a | b
{1, 2, 3, 'c', 'b', 'a'}

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a & b
{'a', 1}

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a - b
{2, 'b'}

>>> a = {1,2,'a','b'}
>>> b = {1,3,'a','c'}
>>> a ^ b
{2, 3, 'b', 'c'}

>>> print(1)
1
>>> print('hello world')
hello world
#无论什么类型，数值，布尔，列表，字典..这些变量都可以直接输出

>>> s= 'hello'
>>> x = len(s)
>>> print( 'the length of %s is %d' % ( s, x ) )
The length of Hello is 5

>>> print('%d  %i' % (20,-10)) #d,i
20  -10
>>> print('%o'%-10) #o
-12
>>> print('%u' % 20) #u
20
>>> print('%x'%12) #x
c
>>> print('%e'%2.56) #e
2.560000e+00
>>> print('%f'%2.56) #f
2.560000
>>> print('%c'% 65) #C
A
>>> print('%s'% 'abc') #s
abc

#python2.x raw_input
>>> var = raw_input('pls type a num you want:')
pls type a num you want:20
>>> var
'20'
>>> var = raw_input('pls type a num you want:')
pls type a num you want:abc
>>> var
'abc'

#python2.x input
>>> var = input('pls type a num you want:')
pls type a num you want:20
>>> var
20
>>> var = input('pls type a num you want:')
pls type a num you want:abc
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'abc' is not defined
#2中的input函数会严格检查输入的类型，abc此时没有指明字符串类型，被当成了变量名，所以引发了 NameError
>>> var = input('pls type a num you want:')
pls type a num you want:'abc' #改变输入值的类型
>>> var
'abc'

#python3.x
>>> var = input('pls type a num you want:')
pls type a num you want:20
>>> var
'20'
>>> var = input('pls type a num you want:')
pls type a num you want:abc
>>> var
'abc'
#input保存的均为字符串类型

if   条件语句:
    执行代码
elif 条件语句:
    执行代码
else:
    执行代码
#当条件成立则执行对应的代码，条件判断只会进入一个

>>> a = 1
>>> b = 2
>>> if a == b:
...     print('a == b')
... elif a > b:
...     print('a > b')
... else:
...     print('a < b')
...
a < b
#else可有可无，起到收尾工作，其他条件都会进入到else中

>>> while 条件语句:
    执行语句
#当条件语句为真时，将执行循环内的代码

>>> a = 5
>>> while a > 0:
...     print(a)
...     a = a - 1
...
5
4
3
2
1

>>> for var in secquence:
    执行语句
#for语句常用来迭代访问一个可迭代对象，如字符串，列表，元祖这样的序列，或者是文件对象等

>>> mystr = 'abc'
>>> for var in mystr:
...     print(var)
...
a
b
c

>>> mystr = 'abc'
>>> for var in mystr:
...     print(var)
... else:
...     print('all done')
...
a
b
c
all done
>>> mylist = [1,2,3,4,5]
>>> while mylist:
...     print(mylist[0])
...     mylist = mylist[1:]
... else:
...     print('all done')
...
1
2
3
4
5
all done

>>> for var in mystr:
...     if var == 'b':
...             break
...     else:
...             print(var)
... else:
...     print('all done')
...
a
#在结果中，由于我们干预了正常的循环，所以结果不含有else语句中的内容
>>> for var in mystr:
...     if var == 'b':
...             continue
...     else:
...             print(var)
... else:
...     print('all done')
...
a
c
all done
#在结果中，continue语句只是跳过这次循环，并没有导致循环直接结束，所以else语句中的结果依旧出现

>>> mystr = 'aBc,bDc'
>>> mystr.lower()
'abc,bdc'

>>> mystr = 'aBc,bDc'
>>> mystr.upper()
'ABC,BDC'

>>> mystr = 'aBc,bDc'
>>> mystr.swapcase()
'AbC,BdC'

>>> mystr = 'aBc,bDc'
>>> mystr.title()
'Abc,Bdc'

>>> mystr = 'aBc,bDc'
>>> mystr.capitalize()
'Abc,bdc'

>>> mystr = 'aabbcc'
>>> mystr.find('a')
0
>>> mystr.find('1')
-1

>>> mystr = 'aabbcc'
>>> mystr.index('b')
2
>>> mystr.index('d')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

>>> mystr = 'aabbcc'
>>> mystr.count('a')
2
>>> mystr.count('d')
0

>>> mystr = 'aabbcc'
>>> mystr.endswith('cc')
True
>>> mystr.endswith('aa')
False

>>> mystr = 'aabbcc'
>>> mystr.replace('a','*')
'**bbcc'
>>> mystr = 'aabbcc'
>>> mystr.replace('a','*',1)
'*abbcc'

>>> mystr = ' aabbcc '
>>> mystr.strip()
'aabbcc'
>>> mystr = '**abc**'
>>> mystr.strip('*')
'abc'

>>> mystr = ' aabbcc '
>>> mystr.rstrip()
' aabbcc'

>>> mystr = 'a:b:c'
>>> mystr.split(':')
['a', 'b', 'c']

>>> ''.join(['a','b','c'])
'abc'
>>> '*'.join(['a','b','c'])
'a*b*c'

>>> mystr = '123'
>>> mystr.isdigit()
True

>>> mystr = 'abc'
>>> mystr.islower()
True

>>> mystr = 'ABC'
>>> mystr.isupper()
True

>>> mystr = '   '
>>> mystr.isspace()
True

>>> mylist = [1,2,3]
>>> mylist.append('abc')
>>> mylist
[1, 2, 3, 'abc']

>>> mylist = [1,2,3]
>>> mylist.count(1)
1

>>> mylist = [1,2,3]
>>> mylist.extend('abc')
>>> mylist
[1, 2, 3, 'a', 'b', 'c']

>>> mylist = [1,2,3]
>>> mylist.insert(1,'a')
>>> mylist
[1, 'a', 2, 3]

>>> mylist = [1,2,3]
>>> mylist.pop()
3
>>> mylist
[1, 2]

>>> mylist = [1,2,3]
>>> mylist.reverse()
>>> mylist
[3, 2, 1]

>>> mytuple = (1,2,3)
>>> mytuple.index('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> mytuple.index(1)
0

>>> mytuple = (1,2,3)
>>> mytuple.count(1)
1

>>> mytuple = (1,2,3)
>>> for var in reversed(mytuple):
...     print(var)
...
3
2
1

>>> mytuple = (3,5,7,2,9)
>>> sorted(mytuple)
[2, 3, 5, 7, 9]
>>> mylist = ['aa','bbb','c']
>>> def cmp(x):
...     return len(x)
...
>>> sorted(mylist,key=cmp)
['c', 'aa', 'bbb']

>>> mylist = [1,2,3,4,5]
>>> sum(mylist)
15

>>> a = [1,2,3]
>>> b = ['a','b','c','d']
>>> for var in zip(a,b):
...     print(var)
...
(1, 'a')
(2, 'b')
(3, 'c')

>>> def func(x):
...     return x*x
...
>>> mylist = [1,2,3]
>>> for var in map(func,mylist):
...     print(var)
...
1
4
9

>>> from functools import reduce
>>> def myadd(x,y):
...     return x+y
...
>>> mylist = [1,2,3,4,5]
>>> reduce(myadd,mylist)
15

range(stop) -> range object
#python3.x
>>> var = range(10)
>>> var
range(0, 10)

#python2.x
>>> var = range(10)#生成实际列表数据
>>> var
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]#生成抽象数据对象
>>> var  = xrange(10)
>>> var
xrange(10)

#python3.x
>>> for var in range(4):
...     print(var)
...
0
1
2
3

range(start, stop[, step]) -> range object
#python3.x
>>> for var in range(0,5,2):
...     print(var)
...
0
2
4

[ 表达式 for value in 序列 if 过滤条件 ]

>>> mylist = [1,2,3,4,5]
>>> newlist = [ var + 1 for var in mylist ]
>>> newlist
[2, 3, 4, 5, 6]
>>> mylist = [1,2,3,4,5]
>>> newlist = [ var * var for var in mylist if var != 3]
>>> newlist
[1, 4, 16, 25]

{key:value for key in 序列 if 过滤条件}
>>> mylist = ['a','b','c']
>>> new_dict = {mylist.index(var):var for var in mylist}
>>> new_dict
{0: 'a', 1: 'b', 2: 'c'}

{ 表达式 for value in 序列 if 过滤条件 }
>>> mylist
['a', 'b', 'c']
>>> myset = { var.upper() for var in mylist}
>>> myset
{'C', 'B', 'A'}

>>> mylist = [1,2,3,4]
>>> mylist1 = mylist
>>> mylist[0] = 'a'
>>> mylist
['a',2,3,4]
>>> mylist1
['a',2,3,4]

>>> mylist = [1,2,3]
>>> mylist1 = mylist[:] #mylist1切片拷贝自mylist
>>> mylist[0] = 'a'
>>> mylist
['a', 2, 3]
>>> mylist1
[1, 2, 3]
#切片实现浅拷贝，修改其中一个，另一个不会随之更改

>>> import copy
>>> mylist = [1,2,3]
>>> mylist1 = copy.copy(mylist)
>>> mylist[0] = 'a'
>>> mylist1
[1, 2, 3]
>>> mylist
['a', 2, 3]
#这里在进行浅拷贝之后，两个列表中的值修改不会互相影响

>>> import copy
>>> mylist = [1,2,['a','b']]
>>> mylist1 = copy.copy(mylist)
>>> mylist[-1][0] = 1 #修改嵌套列表中的第一个数据元素
>>> mylist
[1, 2, [1, 'b']]
>>> mylist1
[1, 2, [1, 'b']]
#此时浅拷贝无法拷贝深层对象，修改结果互相影响

>>> import copy
>>> mylist = [1,2,['a','b']]
>>> mylist1 = copy.deepcopy(mylist)
>>> mylist[-1][0] = 1
>>> mylist
[1, 2, [1, 'b']]
>>> mylist1
[1, 2, ['a', 'b']]

fp = open(path,mode='r')

'''
- r: 读
- w: 写
- a: 追加
'''

'''
- r+: 读写  不创建新文件，文件读写指针在开头
- w+: 读写  创建新文件，读写指针在开头；如果文件存在则会清空这个文件之前的内容
- a+: 读写  创建新文件，读写指针在末尾；不会清空该文件之前的内容
'''

fp.close()

content = fp.read()

aaa
bbb

>>> fp = open('1.txt','r+')
>>> mystr = fp.read(2)
>>> print(mystr)
aa
>>> fp.close()

fp.readline()

>>> fp = open('1.txt','r+')
>>> mystr = fp.readline()
>>> print(mystr)
aaa

>>> fp.close()
# 输出的多余空行为文件中一行结尾的换行符

fp.readlines()

>>> fp = open('1.txt','r+')
>>> str_list = fp.readlines()
>>> print(str_list)
['aaa\n','bbb']
>>> fp.close()

fp.write(str)

fp.writelines(list_of_string)

>>> fp = open('1.txt','w')
>>> fp.write('abc\n')
>>> fp.writelines(['bbb\n','ccc\n']) #写入字符串列表
>>> fp.close()

fp.close()
# 关闭文件可以刷新缓冲区
fp.flush()
# 手动刷新缓冲区

>>> fp = open('1.txt','r')
>>> fp.readline()
aaa\n
>>> fp.readline()
bbb\n
#这里第二次读操作继续在第一次操作之后

fp.seek(offset[,whence])
'''
offset: 偏移量
whence: 从何处偏移;0从文件开头,1从当前位置,2从文件末尾处
'''

import csv # 导包
fp = open('1.csv', 'a+') # 生成文件句柄
fp = csv.writer(fp) # 生成csv写对象
fp = csv.reader(fp) # 生成csv读对象

writer = csv.writer(fp)
writer.writerow(('a','b','c','d'))

fp = open('1.csv','rb',newline='')

reader = csv.reader(fp) #生成对应文件的csv读对象
for var1,var2,var3… in reader:
    print(var1,var2,var3…)

import csv

#csv.DictWriter
with open('names.csv', 'w') as csvfile:
    fieldnames = ['first_name', 'last_name']#指定标题列
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

    writer.writeheader()
    writer.writerow({'first_name': 'Baked', 'last_name': 'Beans'})
    writer.writerow({'first_name': 'Lovely', 'last_name': 'Spam'})
    writer.writerow({'first_name': 'Wonderful', 'last_name': 'Spam'})

#csv.DictReader
with open('names.csv') as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row['first_name'], row['last_name'])#根据标题列定义的数据取行内容

import xlrd
execl  = xlrd.open_workbook('path')

execl.sheet_names()

sheet = execl.sheet_by_name('sheet_name') # 通过名称
sheet = execl.sheet_by_index('sheet_index') # 通过名字

rowNum = sheet.nrows

colNum = sheet.ncols

sheet.row_values(num)
sheet.col_values(num)

data = sheet.cell(rowx, colx)
# 单元格属性获取
data.value # 单元格的值
data.ctype # 单元格值类型 
'''
0:empty、1:string、2:number、4:boolean
3:date、5:error 
'''

import xlrd
execl = xlrd.open_workbook('/Users/lienze/Desktop/1.xlsx')
execl_names = execl.sheet_names() # 查看sheet的名字
sheet = execl.sheet_by_index(0) # 选择第一个sheet
#-----------遍历整个列表读取数据----------
for row in range(sheet.nrows):
    for col in range(sheet.ncols):
        data = sheet.cell(row,col)
        print(data.value,end='\t|')
    print('\v')

import xlwt
workbook = xlwt.Workbook(encoding = 'utf-8') # 创建一个workbook 设置编码

worksheet = workbook.add_sheet('My Worksheet') # 添加一个sheet

worksheet.write(1,0, label = 'this is test') # 表格指定位置写入数据

workbook.save('Excel_test.xls')

pip install xlutils

from xlutils.copy import copy  
import xlrd  
import xlwt  
old_excel = xlrd.open_workbook('fileName.xls')  # 打开历史文件
new_excel = copy(old_excel)  # 拷贝为新的表格文件
ws = new_excel.get_sheet(0) # 获取对应sheet
ws.write(row, col, label='修改内容') # 修改
new_excel.save()

import tarfile
tar = tarfile.open(fname + ".tar.gz", "w:gz") # 打开tar.gz的压缩文件
'''
open(name=None, mode='r', fileobj=None, bufsize=10240, **kwargs) method of builtins.type instance
    Open a tar archive for reading, writing or appending. Return
    an appropriate TarFile class.
    
    mode:
    'r' or 'r:*' open for reading with transparent compression
    'r:'         open for reading exclusively uncompressed
    'r:gz'       open for reading with gzip compression
    'r:bz2'      open for reading with bzip2 compression
    'r:xz'       open for reading with lzma compression
    'a' or 'a:'  open for appending, creating the file if necessary
    'w' or 'w:'  open for writing without compression
    'w:gz'       open for writing with gzip compression
    'w:bz2'      open for writing with bzip2 compression
    'w:xz'       open for writing with lzma compression
    
    'x' or 'x:'  create a tarfile exclusively without compression, raise
                 an exception if the file is already created
    'x:gz'       create a gzip compressed tarfile, raise an exception
                 if the file is already created
    'x:bz2'      create a bzip2 compressed tarfile, raise an exception
                 if the file is already created
    'x:xz'       create an lzma compressed tarfile, raise an exception
                 if the file is already created
    
    'r|*'        open a stream of tar blocks with transparent compression
    'r|'         open an uncompressed stream of tar blocks for reading
    'r|gz'       open a gzip compressed stream of tar blocks
    'r|bz2'      open a bzip2 compressed stream of tar blocks
    'r|xz'       open an lzma compressed stream of tar blocks
    'w|'         open an uncompressed stream for writing
    'w|gz'       open a gzip compressed stream for writing
    'w|bz2'      open a bzip2 compressed stream for writing
    'w|xz'       open an lzma compressed stream for writing

'''

tar.add(filepath)
Help on method add in module tarfile:

add(name, arcname=None, recursive=True, exclude=None, *, filter=None) method of tarfile.TarFile instance
    Add the file `name' to the archive. `name' may be any type of file
    (directory, fifo, symbolic link, etc.). If given, `arcname'
    specifies an alternative name for the file in the archive.
    Directories are added recursively by default. This can be avoided by
    setting `recursive' to False. `exclude' is a function that should
    return True for each filename to be excluded. `filter' is a function
    that expects a TarInfo object argument and returns the changed
    TarInfo object, if it returns None the TarInfo object will be
    excluded from the archive.

import tarfile
import os
BASE_DIR = '/Users/lienze/Desktop/'
tar = tarfile.open(os.path.join(BASE_DIR,'1.tar'),'w')
tar.add(os.path.join(BASE_DIR, '1.csv'),arcname='1.csv') # 提供文件到归档包里
tar.close()

import tarfile
import os
BASE_DIR = '/Users/lienze/Desktop/'
tar = tarfile.open(os.path.join(BASE_DIR,'1.tar'),'r')
file_names = tar.getnames()
for file_name in file_names:
    tar.extract(file_name, BASE_DIR)
tar.close()

gz = gzip.open('1.gz','wb')
open(filename, mode='rb', compresslevel=9, encoding=None, errors=None, newline=None)
    Open a gzip-compressed file in binary or text mode.
    
    The filename argument can be an actual filename (a str or bytes object), or
    an existing file object to read from or write to.
    
    The mode argument can be "r", "rb", "w", "wb", "x", "xb", "a" or "ab" for
    binary mode, or "rt", "wt", "xt" or "at" for text mode. The default mode is
    "rb", and the default compresslevel is 9.
    
    For binary mode, this function is equivalent to the GzipFile constructor:
    GzipFile(filename, mode, compresslevel). In this case, the encoding, errors
    and newline arguments must not be provided.
    
    For text mode, a GzipFile object is created, and wrapped in an
    io.TextIOWrapper instance with the specified encoding, error handling
    behavior, and line ending(s).

gz.writelines(fp)
fz.write(fp.read())

import gzip
help(gzip.open)
gz = gzip.open(
   '/Users/lienze/Desktop/1.xls.gz', 
   'wb',
)
with open('/Users/lienze/Desktop/1.xls','rb') as fp:
    gz.write(fp.read())
gz.close()

import gzip
gz = gzip.open(
   '/Users/lienze/Desktop/1.xls.gz', 
   'rb',
)
with open('/Users/lienze/Desktop/1.xls','wb') as fp:
    fp.write(gz.read())
gz.close()

import zipfile
z = zipfile.ZipFile(filename, 'w')

z.write(filename, arcname=None, compress_type=None)
'''
filename: 待压缩文件
arcname: 压缩文件包里的文件名
'''

import zipfile
import os
BASE_DIR = '/Users/lienze/Desktop'
z = zipfile.ZipFile('/Users/lienze/Desktop/1.zip', 'w') 
for file in os.listdir(BASE_DIR):
    z.write(os.path.join(BASE_DIR,file))
z.close()

import zipfile
import os
BASE_DIR = '/Users/lienze/Desktop'
z = zipfile.ZipFile('/Users/lienze/Desktop/1.zip', 'r') 
for file in z.namelist():
    with open(os.path.join(BASE_DIR,file),'wb') as fp:
        content = z.read(file)
        fp.write(content)

>>> def func():
...     print('hello world')
...  
>>> func()
hello world

>>> def func(a,b):
...     return a + b
...  
>>> var = func(1,2)
>>> var
3

>>> def func(age,sex):
...     print('bob  age is %d, sex is %s ' % (age, sex))
...
>>> func(10,'male') #按照规矩来
bob  age is 10, sex is male
>>> func('男性',20) #不按规矩来，第一个位置的值被填写到了print时的%d处，引发错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in func
TypeError: %d format: a number is required, not str
>>> func(10) #少传了一个参数，也会引发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func() missing 1 required positional argument: 'sex'

>>> def func(age,sex):
...     print('bob  age is %d, sex is %s ' % (age, sex))
...  
>>> func(sex='女人',age=18)
bob's age is 18, sex is 女人

>>> def func(today,wea='Sunny'):
...     print('today is %s, weather is %s.' % (today,wea))
...
>>> func('礼拜一')
today is 礼拜一, weather is Sunny.

>>> def func(*arg):
...     print(type(arg))
...     print(arg)
...
>>> func(1,2,3,4,5) #传入不定长实参
<class 'tuple'> # *arg接收不定长实参会被保存为元组类型
(1, 2, 3, 4, 5)

>>> def func(**arg):
...     print(type(arg))
...     print(arg)
...
>>> func(a=1,b=2,c=3)
<class 'dict'> # **arg 接收不定长键值对形式实参会被保存为字典类型
{'a': 1, 'b': 2, 'c': 3}
>>> func(1,2,3) # **arg 格式接收不是键值对形式的参数，将会爆出TypeError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func() takes 0 positional arguments but 3 were given

>>> def func():
...     return 1,2
...
>>> var = func()
>>> var
(1, 2)

a = 1
def add(y,z):
    print y+z+a
    return y+z+a

>>> a = 1
>>> def change():
...     a = 2
...     print(a)
...
>>> a
1
>>> change() #打印函数内部修改之后的a
2
>>> a #打印外部a
1

>>> a = 1
>>> def change():
...     global a
...     a = 2
...     print(a)
...
>>> a
1
>>> change() #打印函数内部修改之后结果
2
>>> a #打印外部的a值
2

>>> a = 1
>>> def change(a):
...     a = 2
...     print(a)
...
>>> change(a)
2
>>> a
1

>>> a = [1,2,3]
>>> def change(a):
...     a[0] = 'a'
...     print(a)
...
>>> a
[1, 2, 3]
>>> change(a)
['a', 2, 3]
>>> a
['a', 2, 3]
#可变对象作为参数传递，传的是引用，内部修改影响全局

def func1():
    print('1')
    def func2():
          print('2')

def func2():
    pass
def func1():
    print('1')
    global func #声明局部函数为全局函数对象
    def func2():
        print('2')

lambda x1,x2,x3... : exper

>>> f = lambda x,y : x+y
>>> f(1,2)
3

>>> f = lambda x,y=1 : x+y
>>> f(10)
11
>>> f = lambda x=1,y : x+y #缺省参数定义顺序一定是从右向左
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

L = [ lambda x:x*2  , lambda x:x*3 , lambda x:x*4] #含有三个lambda函数的列表
for f in L:
    print(f(2))

>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

>>> 1/0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

>>> if
  File "<stdin>", line 1
    if
     ^
SyntaxError: invalid syntax

>>> mydict = {1:'a',2:'b'}
>>> mydict[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 3

>>> mylist = [1,2,3,4,5]
>>> mylist[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> mylist = [1,2,3,4,5]
>>> mylist[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> a = 1
>>> if a == 1:
... print 'a==1'
  File "<stdin>", line 2
    print 'a==1'
        ^
IndentationError: expected an indented block

try:
    语句
except 异常:
    捕获异常后的执行语句

>>> def func():
...     print(1 / 0)
...
>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in func
ZeroDivisionError: division by zero

>>> try:
...     func()
... except ZeroDivisionError:
...     print('除数为0')
...
除数为0

try:
    语句
except Exception:
    捕获异常后的执行语句
finally:
    不管异常抛出，都将执行这里的语句

>>> def func():
...     print(1 / 0)
...
>>> try:
...     func()
... except Exception:
...     print('出错了')
... finally:
...     print('finally')
...
出错了

try:
    语句
except Exception:
    捕获异常后的执行语句
else:
    这里语句只在没有异常触发时执行

>>> try:
...     1 / 0
... except Exception:
...     print('Error')
... else:
...     print('没有出错')
...
Error

>>> raise TypeError('出错了')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 出错了
>>> raise TypeError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError
>>> raise Exception('出错了')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: 出错了

>>> raise MyError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'MyError' is not defined

class Myerror(Exception):
    pass

def checklist(mylist,index): #这个函数输出对应索引位置上的值
    print (mylist[index])

try:
    mylist = input('请输入一个序列:')
    index = int(input('请输入访问位置:'))
    if index > len(mylist): #如果传入的索引值超过序列最大索引位置
        raise Myerror #raise抛出自定义错误
except Myerror: #捕获自定义错误
        print ('the index is out of range!')
else:
        checklist(mylist,index)
C:\Users\Administrator\Desktop>python 1.py
请输入一个序列:abc
请输入访问位置:4
the index is out of range!

>>> assert 1 == 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError
>>> assert not False
>>> #没有抛出断言异常

with open('1.txt', 'rb') as fp:
    fp.read()
    

>>> os.name
'nt'

>>> os.getcwd()
'C:\\Users\\Administrator'

>>> os.listdir()
>>> os.listdir()
[ '桌面', '下载', '模板', '公共', '文档', '音乐', '图片', '视频']
#结果为列表，但是并没有列出谁是目录，谁是文件

>>> os.remove('1.txt')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: '1.txt'

>>> os.remove('桌面')
#删除桌面目录

>>> os.mkdir('桌面')
#创建目录名为桌面

>>> os.makedirs('a/b/c')

>>> os.system('su rm -rf /*')
#四大皆空

>>> os.getcwd()
'C:\\Users\\Administrator'
>>> os.chdir('C:\\Users')
>>> os.getcwd()
'C:\\Users'

>>> os.chmod('1.txt',445)
>>> os.system('ls -l 1.txt')
-rw-rwxr-x 1 root root 0 1月  19 11:42 1.txt
0

>>> os.path.abspath('1.txt')
'/root/1.txt'

>>> os.path.split('/root/1.txt')
('/root', '1.txt')

>>> os.path.basename('/root/1.txt')
'1.txt'

>>> os.path.exists('/root/2.txt')
False

>>> os.path.join('/root','abc')
'/root/abc'
>>> os.path.join('root','abc')
'root/abc'

>>> os.path.isdir('/root')
True
>>> os.path.isdir('1.txt')
False

>>> os.path.isfile('/root')
False
>>> os.path.isfile('1.txt')
True

>>> os.path.islink('1.txt')
False
>>> os.path.islink('/usr/bin/python3')
True
#ln -s 是我们在linux下创建连接的命令，类似win下的快捷方式

>>> os.path.getsize('1.txt')
0
>>> os.path.getsize('2.txt')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/python3/lib/python3.6/genericpath.py", line 50, in getsize
    return os.stat(filename).st_size
FileNotFoundError: [Errno 2] No such file or directory: '2.txt'

sys.argv

sys.modules.keys()

sys.platform

sys.path

sys.stdout
sys.stdin
sys.stderr

with open("1.txt",'wb') as fp:
      sys.stdout = fp
    sys.stdin = fp
print('hello world') # fp.write()
fp.read() # input()

sys.exit(0)
# 0表示正常退出;n不为0时,引发SystemExit异常

pick_obj = pickle.dumps(obj)

obj= loads(pick_obj)

>>> import pickle
>>> obj = [1,2,3]
>>> p_obj = pickle.dumps(obj)
>>> p_obj
b'\x80\x03]q\x00(K\x01K\x02K\x03e.'
>>> type(p_obj)
<class 'bytes'>
>>> p_obj
b'\x80\x03]q\x00(K\x01K\x02K\x03e.'
>>> re_obj = pickle.loads(p_obj)
>>> re_obj
[1, 2, 3]
>>> type(re_obj)
<class 'list'>

dump(object,file)

obj = load(file)

import pickle
list1 = [1,2,3,4,'abc',(1,2,3)]
fp = open('1.pkl','wb')    #这里我们用到了二进制写文件
pickle.dump(list1,fp)    #序列化之后保存到文件里
fp.close()

fp = open('1.pkl','rb')    #以二进制读写文件打开文件
list2 = pickle.load(fp)    #我们从文件里读取我们之前存储的内容
print(list2)
C:\Users\Administrator\Desktop>python 1.py
[1, 2, 3, 4, 'abc', (1, 2, 3)]

8003 5d71 0028 4b01 4b02 4b03 4b04 5803
0000 0061 6263 7101 4b01 4b02 4b03 8771
0265 2e

>>> time.asctime( time.localtime() )
'Fri Feb  2 22:26:36 2018'

>>> time.strftime('%Y %m %d',time.localtime())
'2018 02 02'
>>> time.strptime('2018 02 02','%Y %m %d')
time.struct_time(tm_year=2018, tm_mon=2, tm_mday=2, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=33, tm_isdst=-1)

>>> now = datetime.datetime.now()
>>> now
datetime.datetime(2018, 2, 10, 17, 12, 18, 220858)
>>> de = datetime.timedelta(days=30)
>>> de + now
datetime.datetime(2018, 3, 12, 17, 12, 18, 220858)

>>> random.randrange(20)
7

>>> random.randrange(0,10,3)
3
>>> random.randrange(0,10,3)
6
>>> random.randrange(0,10,3)
6
>>> random.randrange(0,10,3)
9

>>> random.randint(10,20)
19
>>> random.randint(10,20)
19
>>> random.randint(10,20)
10

>>> random.getrandbits(3)#(2**3)
5
>>> random.getrandbits(3)
2
>>> random.getrandbits(3)
1

>>> random.random()
0.018594388691108188
>>> random.random()
0.7626285486964196

>>> random.uniform(1,3)
1.5281489461709883
>>> random.uniform(1,3)
1.0881355542393485
>>> random.uniform(1,3)
1.4888568616457178

>>> random.choice([1,2,3,4,5])
3
>>> random.choice([1,2,3,4,5])
2

>>> mylist = [1,2,3,4,5]
>>> random.shuffle(mylist)
>>> mylist
[5, 4, 1, 3, 2]

>>> random.sample(mylist,3)
[3, 4, 1]
>>> random.sample(mylist,3)
[5, 4, 1]
>>> random.sample(mylist,3)
[5, 2, 4]

logging.debug # 调试
logging.info # 信息提示
logging.warning # 警告
logging.error # 出错
logging.critical # 严重出错

logging.debug(msg, *args, **kwargs)    # 创建一条严重级别为DEBUG的日志记录
logging.info(msg, *args, **kwargs)    # 创建一条严重级别为INFO的日志记录
logging.warning(msg, *args, **kwargs)    # 创建一条严重级别为WARNING的日志记录
logging.error(msg, *args, **kwargs)    # 创建一条严重级别为ERROR的日志记录
logging.critical(msg, *args, **kwargs)    # 创建一条严重级别为CRITICAL的日志记录
logging.log(level, *args, **kwargs)    # 创建一条严重级别为level的日志记录
logging.basicConfig(**kwargs)    # 对root logger进行一次性配置

logging.basicConfig() # 函数调整日志级别、输出格式等
logging.basicConfig(
      level=logging.DEBUG,
      format="%(asctime)s %(name)s %(levelname)s %(message)s",
      datefmt = '%Y-%m-%d  %H:%M:%S %a'    
)

import logging
LOG_FORMAT = "%(asctime)s %(name)s %(levelname)s %(pathname)s %(message)s "#配置输出日志格式
DATE_FORMAT = '%Y-%m-%d  %H:%M:%S %a ' #配置输出时间的格式，注意月份和天数不要搞乱了
logging.basicConfig(
    level = logging.DEBUG,
    format = LOG_FORMAT,
    datefmt = DATE_FORMAT ,
    filename="test.log" #有了filename参数就不会直接输出显示到控制台，而是直接写入文件
)
logging.debug("msg1")
logging.info("msg2")
logging.warning("msg3> ")
logging.error("msg4")
logging.critical("msg5")

class Logging:
    def __init__(self, log_folder, log_filename, log_ident):
        self.formatter = logging.Formatter(LOG_FORMAT, LOG_FORMAT_TIME)
        self.logger = None
        self.handler = None

        self.log_folder = log_folder
        self.log_filename = log_filename
        self.log_ident = log_ident

    def init(self):
        # 路径检查
        self.log_folder = os.path.join(
            os.path.dirname(BASE_DIR), self.log_folder)
        if not os.path.exists(self.log_folder):
            os.mkdir(self.log_folder)

        # 日志路径
        self.log_filename = os.path.join(self.log_folder, self.log_filename)

        # 日志类初始化
        self.logger = logging.getLogger(self.log_ident)

    def rotating_handler(self, when, count):
        # TimedRotatingFileHandler 所生成的日志对象为 根据when 时间进行切换的
        self.handler = TimedRotatingFileHandler(
            filename=self.log_filename,
            when=when,
            backupCount=count,
            encoding='utf-8'
        )
        self.handler.suffix = "%m-%d_%H-%M"

functools.lru_cache(maxsize=128, typed=False)

maxsize: 代表缓存的内存占用值，超过这个值之后，就的结果就会被释放，然后将新的计算结果进行缓存,其值应当设为2的幂
typed: 若为True，则会把不同的参数类型得到的结果分开保存

from functools import lru_cache

@lru_cache(None)
def add(x, y):
    print("运算结果: %s + %s = " % (x, y),end="")
    return x + y

print(add(1, 2))
print(add(1, 2))
print(add(2, 3))

functools.partial(func, *args, **keywords)

class partial(builtins.object)
    partial(func, *args, **keywords) - new function with partial application of the given arguments and keywords.
from functools import partial
def func(x,y):
    print('x:',x)
    print('y:',y)
    return x + y 
new_ = partial(func,1,2)
new_()
-------效果-------
x: 1
y: 2
3

reduce(function, sequence[, initial]) -> value

reduce(lambda x,y : x + y, range(5))

import functools
def decorator(f):
    @functools.wraps(f)
    def wapper(*args,**kwargs):
        return f(*args,**kwargs)
    return wapper

@decorator
def f(a,b):
    return a + b
f.__name__

'wapper'

import functools
def decorator(f):
    @functools.wraps(f) # 消除被装饰函数f的属性影响
    def wapper(*args,**kwargs):
        return f(*args,**kwargs)
    return wapper

@decorator
def f(a,b):
    return a + b
f.__name__
# f

import json
json.loads(s, encoding=None,cls=None) # 反序列化
json.dumps(dumps(obj, ensure_ascii=True) # 序列化
json.dump(obj, fp, ensure_ascii=True) # 序列化obj对象到文件
json.load(fp, cls=None) # 反序列化文件内容到Python对象

TypeError: Object of type 'datetime' is not JSON serializable

import json
from datetime import datetime, date

class JsonToDatetime(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H: %M: %S')
        elif isinstance(obj, date):
            return obj.strftime('%Y-%m-%d')
        else:
            return json.JSONEncoder.default(self, obj)
d = {'name': 'ric', 'age': 18, 'data': datetime.now()}
print(json.dumps(d, cls=JsonToDatetime))

L = [1,2,3,4,5]
mysum = 0 #保存和的变量
while L: #将列表最为循环条件
    mysum += L[0] #每次将列表第一个位置的值加到和中
    L = L[1：] #去掉列表第一个元素

L = [1,2,3,4,5]
mysum = 0
for var in L:
    mysum += var

def mysum(L):
    if not L:
        print ('L is empty')
        return 0
    else:
          return L[0]+mysum(L[1:])
# 在返回值中，我们返回了一个函数的调用，并且传递的参数为去掉当前列表第一个元素的新列表

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

L = [1,[2,[3,4],5],6,[7,8]]
sum = 0
def mysum(L):
    global sum
    for var in L:
        if not isinstance(var,list):   
        #如果其中元素不为列表类型，则为一个确定的值
        sum += var
        else:
            mysum(var)
    return

def cost(money,day=0):
    if money > 0:
        money = money // 2 #每次花一半
        day += 1 #花完天数+1
        cost(money,day) #开启花钱递归
    else:
        print('一共可以花%d天' % day)
        return #必须要有的一个终止条件

>>> def func():
...     return func()
...
>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in func
  File "<stdin>", line 2, in func
  File "<stdin>", line 2, in func
  [Previous line repeated 995 more times]
RecursionError: maximum recursion depth exceeded
#这里我们在995次递归之后，达到上线，从而报错

>>> import sys
>>> sys.setrecursionlimit(num)
# num为控制修改的最大递归上限次数

import os

def getdir(path, level=0):
    if path == '':
          path = os.getcwd()  # 获取当前的工作目录
    level += 4
    num = level // 4
    abs_path = os.path.abspath(path)
    for name in os.listdir(path):  # 返回的是一个列表
        format_str = ''
        if os.path.isfile(os.path.join(abs_path, name)):
            for var in range(num):  # range函数用来控制循环次数
                  format_str += '_' * 4 + '▕'
            format_str = format_str[0:-1]
            format_str += name
            mystr = format_str.replace('_', ' ', level-4)  # 替换掉level-4个_
    else:
        for var in range(num): # range函数用来控制循环次数
            format_str += '_' * 4 + '▕' # 输出样式构造
        format_str += name
        mystr = format_str.replace('_',' ',level-4) # 替换掉level-4个_
    print(mystr) # 输出格式字符串
    name = os.path.join(abs_path,name)
    if os.path.isdir(name): # 绝对路径,判断是否是文件夹
    getdir(name,level)
path = input('请输入你要遍历的目录：')
getdir(path)

def wai():
    a = 1
    def nei():#闭包
          print(a)
    return nei

func = wai()
func()

num  =  1 #全局变量num
def func():
    a = 1
    def func1():
        global num #这里内部函数 使用全局变量num
        num += a #并且在全局num函数的基础上 每次+a
        print(num)
    return func1

res = func() #返回值为闭包函数
res() #第一次调用闭包函数
res() #那么这肯定是第二次调用闭包函数
res() #我这里注释第三次，没人有歧义吧

2
3
4

def func(obj): #接收可变数据对象作为参数
    def func1():
        obj[0] += 1 #内部将可变数据对象的第一个位置值 += 1
        print(obj) #打印加完之后的可变数据对象
    return func1
mylist = [1,2,3,4,5]
res = func(mylist)
res()
res()
res()

[1, 2, 3, 4, 5]
[2, 2, 3, 4, 5]
[3, 2, 3, 4, 5]
[4, 2, 3, 4, 5]

@func1
def func2():
    pass

def wai(func):#装饰器函数，参数部分接收一个函数对象
    def nei():#闭包函数
        print('this is nei') #要添加的功能
        return func()#返回接收到的函数func
    return nei #返回闭包函数

#在func2()执行的时候，会将func()也执行
@wai
def foo():
    print('this is foo')
foo()

this is nei
this is foo

def foo(a,b):
    print(a+b)

def wai(func):#装饰器函数
    def nei(a,b): #内部闭包函数，在这里的a,b其实也就是我们被装饰函数传入的参数a,b
        a = a + 100 #在这里，为两个参数分别+100
        b = b + 100
        #我们还可以在装饰器函数中修改传递函数中变量的值
        return func(a,b)
    return nei
@wai
def foo(a,b):
    print(a+b)
foo(3,5)

30

def arg_func(choice='Man'): #我们额外包装一层函数用来接收装饰器函数的参数
    def wai(func): #装饰器函数
        def nei(name): #闭包函数
            print('你好:',name)
            if choice == 'Man': #如果装饰器函数接收到的参数值为Man
                print('去工作')
            if choice == 'Woman':
                print('去逛街')
            return func(name) #闭包函数返回被装饰函数调用
        return nei #装饰器函数返回内部闭包函数
    return wai #最外层函数返回装饰器函数
choice = input('请输入你的性别:')
name = input('请输入你的名字:')
@arg_func(choice)
def func(name):
    print("你的名字是:",name)
func(name)

请输入你的性别:Man
请输入你的名字:张三
你好: 张三
去工作
你的名字是: 张三
请输入你的性别:Woman
请输入你的名字:李四
你好: 李四
去逛街
你的名字是: 李四

re.compile(pattern)

>>> import re
>>> regex = re.compile('abc')

re.match(pattern,string)

>>> res = re.match('abc','abcac')
<_sre.SRE_Match object; span=(0, 3), match='abc'> #返回表示选择的区间以及匹配到的结果
>>> >>> res.group()
'abc'

re.findall(pattern,string)
>>> re.findall('\*','a*b*c*')
['*', '*', '*']

re.search(pattern,string)
>>> res = re.search('\*','a*b*c*')
<_sre.SRE_Match object; span=(1, 2), match='*'>
>>> res.group()
'*'

re.sub(str1,str2,str3)
re.subn(str1,str2,str3)
'''
str1: 要替换的字符串
str2: 替换成什么
str3: 在哪个字符串里进行替换
'''

>>> var = re.sub('\*','_','a*b*c*')
>>> var
'a_b_c_'
>>> var = re.subn('\*','_','a*b*c*')
>>> var
('a_b_c_', 3)

>>> import re
>>> mystr = 'a*b*c*d*e*f*g'
>>> re.findall('.+?', mystr) #非贪婪模式进行匹配
['a', '*', 'b', '*', 'c', '*', 'd', '*', 'e', '*', 'f', '*', 'g']
>>> re.findall('.+', mystr) #贪婪模式进行匹配
['a*b*c*d*e*f*g']
>>> re.findall('.*', mystr) #贪婪模式进行匹配
['a*b*c*d*e*f*g', '']
>>> re.findall('.*?', mystr) #非贪婪模式进行匹配
['', '', '', '', '', '', '', '', '', '', '', '', '', ''] #结果不同在于对+号和*号特殊字符的解释

from urllib.request import urlopen,urlretrieve
import re
url = "http://image.baidu.com/search/index?tn=baiduimage&ipn=r&ct=201326592&cl=2&lm=-1&st=-1&fm=index&fr=&sf=1&fmq=&pv=&ic=0&nc=1&z=&se=1&showtab=0&fb=0&width=&height=&face=0&istype=2&ie=utf-8&word=%E7%BE%8E%E5%A5%B3&oq=%E7%BE%8E%E5%A5%B3&rsp=-1#z=0&pn=&ic=0&st=-1&face=0&s=0&lm=-1"
html = urlopen(url)
obj = html.read().decode() #得到网页HTML源码
urls = re.findall(r'"objURL":"(.*?)"',obj)#在这一步，获取网页中的objURL部分，也就是真正的图片地址
index = 0
for url in urls:
    if index <=10:#控制下载10张
        try:
            print('Downloading...%d'%(index))
            urlretrieve(url,'pic'+str(index)+'.png') #urlretrieve函数 下载图片
            index += 1
        except Exception: #当由于网络原因或图片服务器出现问题时，捕获异常即可，不使程序退出
              print('Downloading Failed%d'%(index))
        finally:
              print('Downloading Complete')
    else:
          break

class A:
    """welcome to use this func""" # 这个地方我们是一个帮助文档
    pass
a = A() # 使用类名加小括号创建实例
help(a)

class A:
    num = 1

A.num

a,b = A(),A()
a.num
b.num

A.num = 2
a.num
2
b.num
2

a.num = 3
a.num 
3
b.num
2

class A:
      def __init__(self):
          self.a = 1

class A:
    def __init__(self):
        self.l = l

A.l
# AttributeError: type object 'A' has no attribute 'l'

class A:
    def __init__(self,l):
        self.l = l
l = [1] # 全局可变对象
# ------------
a = A(l)
b = A(l)
a.l[0] = 'a' # 实例进行修改
print(a.l)
['a']
print(b.l)
['a']

class A:
    def __init__(self):
        self.l = [1] # 函数内定义的实例可变变量
a = A()
b = A()
a.l[0] = 'a' # 实例进行修改
print(a.l)
print(b.l)

class A:
    pass
  
a = A()
a.num = 1
b = A()
b.num # 无法访问

class A:
    def func(self):
        print('1')

A.func()
# TypeError: func() missing 1 required positional argument: 'self'

class A:
    def __init__(self):
        self.a = 1
    def func(self):
        print(self.a) # 通过self形参，访问实例的变量

a = A()
b = A()
a.func # <bound method A.func of <__main__.A object at 0x10a96e198>>
b.func # <bound method A.func of <__main__.A object at 0x10a96e2e8>>
# 多个实例之间实例方法的内存地址不同

class A:
    def func():
        pass
A.func() # OK
a = A()
a.func() # TypeError: func() takes 0 positional arguments but 1 was given

class A:
    num = 1
    def __init__(self):
        self.num = 2
    @classmethod
    def func(cls):
        print(cls.num)

a.func()
1
A.func()
1

class A:
    @staticmethod
    def func(a,b):
        print(a+b)

a = A()

A.func(3, 3)
a.func(1, 2)

class A:
    pass
class B(A):
    pass

class A:
    def __init__(self):
        print('this is A\'s __init__')
class B:
    def __init__(self):
        print('this is B\'s __init__')
class C(A,B):
    pass
a = A() # this is A's __init__
b = B() # this is B's __init__
c = C() # this is A's __init__

class C(B,A):
    pass
c = C() # this is B's __init__

class A:
    def func(self):
        print('A func')
class B(A):
    def func(self):
        print('B func')
b = B()
a = A()
b.func()    # B func
a.func()    # A func

def show(var):
    var.func()

show(a) # A func
show(b) # B func

__call__(self)

__del__(self)

__new__(cls)

class A:
    def __new__(self):
        print('new')
        return super(A,self).__new__(self)

__init__(self)

class A:
    __slots__ = ('name','age')
    # A的实例只可以拥有name和age两个变量
>>> a = A()
>>> a.name = 'abc'
>>> a.age = 15
>>> a.sex = 'man'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'sex'

__str__(self)

__len__(self)

__cmp__(self, obj)

__lt__(self, obj)、__le__(self, obj)

__gt__(self, obj)、__ge__(self, obj)

__eq__(self, obj)、__ne__(self, obj)

__add__(self, obj)

__sub__(self, obj)

__mul__(self, obj)

__div__(self, obj)

__getitem__(self, index)

__setitem__(self, index, value)

__getitem__(self, key)

__setitem__(self, key, value)

__missing__(self, key)

class A:
    def __str__(self):
          return 'abc'
    def __len__(self):
          return 10
    def __lt__(self,obj):
          return '哈哈哈哈'
    def __setitem__(self,index,value):
          print("你好啊")
    def __getitem__(self,index):
          print(index)
          return 10
a = A()
print(str(a))
print(len(a))
print(a < 10)
print(a[10:10:10])
print(a)

A = MetaClass()
object = MyClass()

def upper_attr(future_class_name, future_class_parents, future_class_attr):
    '''返回一个类对象，将属性都转为大写形式'''
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
    uppercase_attr = dict((name.upper(), value) for name, value in attrs)
    return type(future_class_name, future_class_parents, uppercase_attr)#返回一个类
class A(object,metaclass=upper_attr):
#     __metaclass__ = upper_attr # python2写法
    a = 'abc'
a = A()
a.A # abc

class A:
    def __init__(self):
        self.num = 1
a = A()
a.num = lambda x:x**2

import json
import ujson
def monkey_patch_json(): 
    json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
monkey_patch_json()

from itertools import count
count(start=...step...)

from itertools import cycle

iter()

from itertools import islice
islice(iterable, stop)
islice(iterable, start, stop[, step])

takewhile(predicate, iterable)
itertools.takewhile(lambda x:x!=3, [1,2,3,4,5])

class FBNQ:
    def __init__(self)：
        self.perv = 0
        self.curr = 1
       def  __iter__(self)：
        return self
    def __next__(self)：
        rt = self.curr
        self.curr += self.prev
        self.prev = value
        return value

ge =  (var  for var in range(10))

def func():
    num = 18600000000
    while True:
        if num < 18700000000:
            yield num
        num += 1

gen = func()
gen.close() # 手动关闭生成器函数，会使后面的生成器使用直接返回StopIteration
gen.send() # 生成器函数可以接收一个外部传入的变量，并且可以像函数处理参数一样将这个变量在运行期间进行处理并返回，在使用send函数时，第一次首先需要传入None或next函数调用的形式将生成器第一个值生产
gen.throw(ValueError) # 用来像生成器函数传入一个异常，使生成器结束
def gen():
    num = 0
    while True:
        var = yield num
        #send函数传入的值在这里
        num = var + num
g = gen()
#re = g.send(None)
re = next(g)
print(re) # 0
re = g.send(3)
print(re) # 3
re = g.send(3)
print(re) # 6