re.match()  #从str的起始位置匹配模式，匹配不成功返回none,使用s.group() or s.groups()获取返回内容。
re.search() #扫描字符串，找到这个 RE 匹配的位置
re.findall() #找到 RE 匹配的所有子串，并把它们作为一个列表返回
re.finditer() #找到 RE 匹配的所有子串，并把它们作为一个迭代器返回

# 正则语法
re.match(pattern, string, flags=0)

pattern '匹配的正则表达式'
string  '要匹配的字符串'
flags   '标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等'

# 返回匹配对象
group(num=0) #匹配的整个表达式的字符串，
group()      #可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()     #返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

In [1]: import re

In [2]: s = 'abc,234,dwd,dwd'

In [3]: m = re.match('abc',s,2)

In [7]: m.group()
Out[7]: 'abc'

def clac(n):
    print(n)
    if n/2 > 1:
        res = clac(n/2)
        #print('res',res)   #res接受returen的返回值
    print('N',n)            #每退出一层n跟随每层的变化
    return n   #return返回给res

clac(10)

def login(arg1):   #1.python由上往下解释代码;4进入函数(sqlAPI被arg1传入)
    def outer(arg): #5.进入函数内部;7进入函数arg带入sqlAPI函数的参数
         print('outer') #8.执行函数内部代码块
         arg1(arg) #9.执行sqlAPI函数
    return outer  #6.直接把函数return回去 

def home(name):    #2.遇到函数做标记
    print('Welcome [%s] to home page'%name)

@login  #3.遇到@符装饰器 回到装饰器
def sqlAPI(name): 
    print('Welcome [%s] to sqlApi'%name) #10.跳过函数头直接执行函数内部代码块



sqlAPI('Peter')   #6调用函数

def login(user,password):
    def outer(sqlAPI):
        def wrapper(name): #执行主体函数和处理装饰器传递的参数
            print('username: [%s], password: [%s]'%(user,password))
            sqlAPI(name)
        return wrapper
    return outer


@login('afei','123')  #可以传递任意数量和形式的参数包括函数也可以被传递
def sqlAPI(name):
    print('Welcome [%s] to sqlApi'%name)

sqlAPI('peter')

In [1]: names = iter(['Peter','Alex','Jack'])  #使用工厂函数iter生成一个迭代器

In [2]: names.__next__()  #python2.7中是names.next()方法
Out[2]: 'Peter'

In [3]: names.__next__()
Out[3]: 'Alex'

In [4]: names.__next__()
Out[4]: 'Jack'

In [5]: names.__next__()   #迭代器为空时抛出StopIteration:异常
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-5-317938fc3664> in <module>()
----> 1 names.__next__()

StopIteration:

f = open('test.log','r')
for i in f:
    print(i)

------
In [6]: l = (1, 2, 3, 4)

In [7]: for i in l:
   ...:     print(i)
      ...:
      1
      2
      3
      4

In [1]: import time

In [3]: def con(arg):
    print('准备生产杯子啦')
    while True:
        arg = yield
        print('生产了 [%s] 个杯子，被[%s]个人买走了'%(arg1,arg2)]


In [4]: def producer(arg1,arg2):
   ...:     c = con(arg1)
   ...:     c2 = con(arg2)
   ...:     c.__next__()
   ...:     c2.__next__()
   ...:     print('开始生产杯子啦')
   ...:     for i in range(10):
   ...:         time.sleep(1)
   ...:         print('生产了 [%s] 个杯子'%i)
   ...:         c.send(i)
   ...:         c2.send(i)
   ...:

In [5]: producer('xxx','aaa')
准备生产杯子啦
开始生产杯子啦
生产了 [0] 个杯子
生产了 [xxx] 个杯子，被[0]个人买走了
生产了 [aaa] 个杯子，被[0]个人买走了
生产了 [1] 个杯子
生产了 [xxx] 个杯子，被[1]个人买走了
生产了 [aaa] 个杯子，被[1]个人买走了
生产了 [2] 个杯子
生产了 [xxx] 个杯子，被[2]个人买走了
生产了 [aaa] 个杯子，被[2]个人买走了
生产了 [3] 个杯子
生产了 [xxx] 个杯子，被[3]个人买走了
生产了 [aaa] 个杯子，被[3]个人买走了

In [7]: def cas(mo):
    while mo >0:
        mo -= 10
        yield 10
        print('--------'
   ...:
   ...:
   ...:
   ...:         )
   ...:

In [8]: a = cas(50)

In [9]: for i in a:
   ...:     print(9)
   ...:
9
--------
9
--------
9
--------
9
--------
9
--------

# 创建一个队列,指定长度为2,长度小于0为不限制长度
>>> import Queue
>>> s = Queue.Queue(maxsize = 2)
>>>

>>> s.put(1,block=False)
>>> s.put(2,block=False)
>>> s.put(3,block=False)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "/usr/lib/python2.7/Queue.py", line 123, in put
    raise Full
Full
>>>

>>> s.put(1,block=True)
>>> s.put(2,block=True)
>>> s.put(3,block=True)

>>> s.put(1,timeout=2)
>>> s.put(2,timeout=2)
>>> s.put(3,timeout=2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "/usr/lib/python2.7/Queue.py", line 134, in put
    raise Full
Full
>>>

>>> s.get()
1
>>> s.get()
2
>>> s.get(block=False)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "/usr/lib/python2.7/Queue.py", line 165, in get
    raise Empty
Empty
>>> s.get(timeout=2)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "/usr/lib/python2.7/Queue.py", line 176, in get
    raise Empty
Empty
>>>

>>> s.qsize()
0

>>> s.empty()
True

>>> s.full()
False

>>> s2 = Queue.LifoQueue(maxsize=2)
>>> s2.put(1)
>>> s2.put(2)
>>> s2.put(3,block=False)
Traceback (most recent call last):
    File "<input>", line 1, in <module>
    File "/usr/lib/python2.7/Queue.py", line 123, in put
        raise Full
Full

#注意取值和存值的顺序
>>> s2.get()
2
>>> s2.get()
1
>>>

#再观察先进先出的取值和存值
>>> s = Queue.Queue(maxsize=2)
>>> s.put(1)
>>> s.put(2)
>>> s2 = Queue.LifoQueue(maxsize=2)
>>> s2.put(1)
>>> s2.put(2)
>>> s.get()
1
>>> s.get()
2
>>> s2.get()
2
>>> s2.get()
1
>>>

In [1]: import queue

In [2]: s = queue.Queue(maxsize=2)

In [3]: s.
s.all_tasks_done    s.get_nowait        s.not_empty         s.qsize
s.empty             s.join              s.not_full          s.queue
s.full              s.maxsize           s.put               s.task_done
s.get               s.mutex             s.put_nowait        s.unfinished_tasks

In [3]: s.put(1)

In [4]: s.put(2)

In [5]: s.put(3,block=False)
---------------------------------------------------------------------------
Full                                      Traceback (most recent call last)
<ipython-input-5-8ebc2086f968> in <module>()
----> 1 s.put(3,block=False)

/usr/lib/python3.4/queue.py in put(self, item, block, timeout)
    131                 if not block:
    132                     if self._qsize() >= self.maxsize:
--> 133                         raise Full
    134                 elif timeout is None:
    135                     while self._qsize() >= self.maxsize:

Full:

>>> a = collections.deque([])   #创建空列表
>>> a.append(1)                 #从后添加
>>> a
deque([1])
>>> a.append(2)
>>> a.append('a')
>>> a
deque([1, 2, 'a'])
>>> a.appendleft('b')           #从头添加
>>> a
deque(['b', 1, 2, 'a'])
>>>

>>> a.pop()                     #从后取
'a'
>>> a
deque(['b', 1, 2])
>>> a.popleft()                 #从前取
'b'
>>> a
deque([1, 2])
>>>

>>> a.remove(2)                 #删除指定元素
>>> a
deque([1])
>>>

>>> a.extend(['b', 1, 2, 'a'])  #从前扩展队列
>>> a
deque([1, 'b', 1, 2, 'a'])
>>> a.extendleft(['d', 1, 2, 'd']) #从后扩展队列
>>> a
deque(['d', 2, 1, 'd', 1, 'b', 1, 2, 'a'])
>>>

>>> a.reverse()                    #反转队列
>>> a
deque(['a', 2, 1, 'b', 1, 'd', 1, 2, 'd'])
>>>

a.clear()       #清空队列
a.count(n)      #在队列中统计元素的个数，n表示统计的元素
a.rotate(n)      #旋转队列，默认时值为1，由右边开始旋转，负值代表左边旋转，n代表从队列的第一个元素开始，n从1开始计数

# 2.set.clear     #添加元素
In [51]: s = set([1,2,3,4,'s'])

In [52]: s.add('d')

In [53]: s
Out[53]: {1, 2, 3, 4, 's', 'd'}

# 2.set.clear     #从set中移除所有元素
In [54]: s.clear()

In [55]: s
Out[55]: set()

    #3.set.copy      #返回set的浅拷贝

#4.set.difference            #返回由两个或多个set中不同的元素（差集)组成一个新set
In [56]: s1 = set([1,2,3,4,5,6])

In [57]: s2 = set(['a','b','c','d'])

In [58]: s1.dif
s1.difference         s1.difference_update

In [60]: s3 = s1.difference(s2)

In [61]: s3
Out[61]: {1, 2, 3, 4, 5, 6}

In [63]: s2
Out[63]: {'a', 'b', 'c', 'd'}

# 上面s1里面的元素在s2中没有，所以s3得到的元素为s1本身
In [64]: s4 = s2.difference(s1)

In [65]: s4
Out[65]: {'a', 'b', 'c', 'd'}
# s4 用s2得到和s3相反的结果

   #5.set.difference_update     #从当前set中移除其它set中所有所有元素。
   In [66]: s4.difference_update(s1)

   In [67]: s4
   Out[67]: {'a', 'b', 'c', 'd'}

   In [68]: s4.difference_update(s2)

   In [69]: s4
   Out[69]: set()

#6.set.discard               #从set中删除一个元素，如果set中存在该元素
In [70]: s3
Out[70]: {1, 2, 3, 4, 5, 6}

In [71]: s3.discard('a')

In [72]: s3
Out[72]: {1, 2, 3, 4, 5, 6}

In [73]: s3.discard(4)

In [74]: s3
Out[74]: {1, 2, 3, 5, 6}

#7.set.intersection          #返回两个或多个set的交集，即两个或多个set中都存在的元素
In [91]: s1
Out[91]: {1, 2, 3, 4, 5, 6, 'b', 'a'}

In [92]: s2
Out[92]: {'a', 'b', 'c', 'd'}

In [94]: s3 = s1.intersection(s2)

In [95]: s3
Out[95]: {'a', 'b'}

#8.set.intersection_update   #更新当前set，只保留那些在当前set和其他set中都存在的
In [106]: s1
Out[106]: {1, 2, 3, 4, 5, 6, 'b', 'a'}

In [107]: s2
Out[107]: {'a', 'b', 'c', 'd'}

In [108]: s1.intersection_update(s2)

In [109]: s1
Out[109]: {'a', 'b'}

#9.set.isdisjoint            #如果两个set没有交集，返回true
In [111]: s1
Out[111]: {'a', 'b'}

In [112]: s2
Out[112]: {'a', 'b', 'c', 'd'}

In [113]: s2.isdisjoint(s1)
Out[113]: False

---------

In [115]: s2
Out[115]: {'a', 'b', 'c', 'd'}

In [116]: s3
Out[116]: {1, 2, 3, 4, 5}

In [117]: s3.isdisjoint(s2)
Out[117]: True

10.set.issubset             #判断是否另外一个set包含当前set。
In [118]: s2
Out[118]: {'a', 'b', 'c', 'd'}

In [119]: s3
Out[119]: {1, 2, 3, 4, 5}

In [120]: s2.issu
s2.issubset    s2.issuperset

In [120]: s2.issubset(s3)
Out[120]: False

--------

In [125]: s2
Out[125]: {'a', 'b', 'c', 'd'}

In [126]: s4
Out[126]: {'a', 'b'}

In [127]: s4.issubset(s2)
Out[127]: True

In [128]: s2.issubset(s4)
Out[128]: False

def trset():
    '''
     -- set ---
    set练习 将下面两个字典的key来用set来做比较，找出交集，差集，
    1. 要删除   #  new里面没有old里面有的删除
    2. 要更新   #  new里面没有old里面有的增加
    3. 要添加   #  new 和old都有的更新
    '''

    old_dict = {
        "#1":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80  },
        "#2":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80  },
        "#3":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80  },
    }

    new_dict = {
        "#1":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 800 },
        "#3":{ 'hostname':"c1", 'cpu_count': 2, 'mem_capicity': 80 },
        "#4":{ 'hostname':"c2", 'cpu_count': 2, 'mem_capicity': 80 },
    }

    old = set(old_dict.keys())
    new = set(new_dict.keys())

    update_set = old.intersection(new)
    delete_set = old.difference(new)
    add_set = new.difference(old)

    print('update:',update_set)
    print('delte:',delete_set)
    print('add:',add_set)

In [1]: def show():
   ...:     print('a')
   ...:

In [2]:  show()
a

In [3]: def show(arg):
   ...:         print(arg)
   ...:

In [4]: show('hello')
hello

In [5]: def show(arg0,arg1):
   ...:         print(arg0,arg1)
   ...:

In [6]: show('hello','world')
hello world

In [7]: def show(arg,arg0='88'):
   ...:         # 默认的参数必须放在最后
   ...:         print(arg,arg0)
   ...:

In [8]: show('dd')
dd 88

In [9]: show('dd','aa')
dd aa

In [10]: def show(arg,arg0,arg1):
   ....:         print(arg,arg0,arg1)
   ....:

In [11]: show('a','b','c')
a b c

In [12]: show(arg1='a',arg0='b',arg='c')
c b a

In [29]: def show(*arg): #参数转换为元组
   ....:         print(arg,type(arg))
   ....:

In [30]: show('a')
('a',) <class 'tuple'>

In [31]: show(1,23,4,'sdf')
(1, 23, 4, 'sdf') <class 'tuple'>

In [37]: def show(**arg): #参数转换为字典
        pass
        print(arg,type(arg))
   ....:

In [38]: show(a='v')
{'a': 'v'} <class 'dict'>

In [39]: show(a='v',k1='v1',k2='v2')
{'a': 'v', 'k1': 'v1', 'k2': 'v2'} <class 'dict'>

#传参形式1
In [45]: def show(*args,**kwargs):
        pass
        print(args,type(args))
        print(kwargs,type(kwargs))
   ....:

In [46]: show(2,3,4,5,'a','d',k1='v1',k2='v2')
(2, 3, 4, 5, 'a', 'd') <class 'tuple'>
{'k1': 'v1', 'k2': 'v2'} <class 'dict'>


传参形式2
In [47]: li = [2,3,4,5,'a']

In [48]: d = {'k1':'v1','k2':'v2'}

In [49]:

In [49]: show(li,d)
([2, 3, 4, 5, 'a'], {'k1': 'v1', 'k2': 'v2'}) <class 'tuple'>
{} <class 'dict'>


#传参形式3
In [50]: show(*li,**d)
(2, 3, 4, 5, 'a') <class 'tuple'>
{'k1': 'v1', 'k2': 'v2'} <class 'dict'>

dict.clear        #删除dictionary中的所有key-value对

>>> a = {'k1':'v1'}
>>> a
{'k1': 'v1'}
>>> a.clear()

dict.copy         #浅拷贝dictionary

>>> b = a.copy()
>>> b
{'k1': 'v1'}

dict.fromkeys     #返回一个新的dictionary，key由iterable的元素组成，value等于value

>>> a = dict.fromkeys(['k1','k2','k3'],'vvv')
>>> a
{'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'}

dict.get          #返回dictionary中key为指定值k对应的value，

>>> a.get('k3')
'vvv'

>>> b = {'k1':a}
>>> b
{'k1': {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'}}
>>> b.get('k1')['k3']
'vvv'
>>>

dict.items        #返回dictionary所有key-value对组成的集合

>>> b.items()
[('k1', {'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'})]

dict.keys         #返回dictionary所有key组成的集合

>>> b.keys()
['k1']

dict.pop          #从dictionary中删除指定key，返回指定key对应的value。如果dictionary中不存在指定key，如果指定了d，返回d，否则抛出例外

>>> c = b.pop('k1')
>>> c
{'k3': 'vvv', 'k2': 'vvv', 'k1': 'vvv'}
>>> b
{}
>>>

dict.popitem      #删除并返回key-value对(key, value)作为2-tuple，如果dictionary为空，抛出例外

>>> e = c.popitem()
>>> e
('k3', 'vvv')
>>> c
{'k2': 'vvv', 'k1': 'vvv'}
>>>

dict.setdefault   #如果dictionary中不存在k，设置D[k]=d


>>> c
{'k2': 'vvv', 'k1': 'vvv'}
>>> c.setdefault('k1','v1')
'vvv'
>>> c
{'k2': 'vvv', 'k1': 'vvv'}
>>> c.setdefault('k4','v4')
'v4'
>>> c
{'k2': 'vvv', 'k1': 'vvv', 'k4': 'v4'}
>>>

dict.update      #使用E(dict/iterable)和F的数据更新dicti

>>> a = {'ak1':'av1'}
>>> b = {'bk1':'bv1'}
>>> b.update(a)
>>> b
{'ak1': 'av1', 'bk1': 'bv1'}

dict.values      #返回dictionary所有value组成的集合
>>> b.values()
['av1', 'bv1']
>>>

list.append           #附加一个对象到list

>>> a = ['a','b',1,3,4]
>>> a
['a', 'b', 1, 3, 4]
>>> a.append('d')
>>> a
['a', 'b', 1, 3, 4, 'd']

list.clear            #删除list中的所有元素

>>> a.clear()
>>> a
[]

list.copy             #浅拷贝list

>>> a = ['a','b',1,3,4]
>>> a
['a', 'b', 1, 3, 4]
>>> b = a.copy()
>>> b
['a', 'b', 1, 3, 4]

list.count            #返回指定参数在list中出现的次数

>>> a.count('b')
1

list.extend           #附加指定iterable中的元素到list

>>> b = [6,6,5,4,2,4]
>>> a.extend(b)
>>> a
['a', 'b', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4]
>>>

list.index            #返回指定值在list中第一次出现的位置，如果list上存在指

>>> a
['a', 'b', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4]
>>> a.index(1)
2

list.insert           #在list的指定位置index插入object

>>> a.insert(2,'sddsds')
>>> a
['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4]

list.pop              #删除并返回指定位置index的元素，默认为最后位置,如果index超过范围或list为空，抛出错误

>>> a
['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2, 4]
>>> b = a.pop()
>>> b
4
>>> a
['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2]
>>>

list.remove           #从list中删除第一次出现的指定值，如果指定值不存在，抛出例外

>>> a
['a', 'b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2]
>>> a.remove('a')
>>> a
['b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2]

list.reverse         #反转list中的元素

>>> a
['b', 'sddsds', 1, 3, 4, 'd', 6, 6, 5, 4, 2]
>>> a.reverse()
>>> a
[2, 4, 5, 6, 6, 'd', 4, 3, 1, 'sddsds', 'b']

list.sort            #对list进行排序

>>> a
[2, 4, 5, 6, 6, 'd', 4, 3, 1, 'sddsds', 'b']
>>> a.sort()
>>> a
[1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds']
>>>

tuple.count       #返回指定参数在tuple中出现的次数

>>> b
(1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds')
>>> b.count(4)
2 

tuple.index       #返回指定值在tuple中第一次出现的位置，如果tuple中不

>>> b
(1, 2, 3, 4, 4, 5, 6, 6, 'b', 'd', 'sddsds')
>>> b.count(4)
2
>>> b.index(2)
1
>>> b.index(1)
0
>>>

str.capitalize    #返回首字母大写，其他字母小写的字符串
>>> a = 'peter'
>>> a.capitalize()
'Peter'
>>>

str.casefold      #字符串转换成小写，用于不区分大小写的字符串比较

>>> a = 'peter'
>>> b = a.capitalize()
>>> b
'Peter'
>>> b.casefold()
'peter'

str.center        #返回指定长度的字符串，字符串内容居中，并使用指定字符填充

>>> b.center(40,'-')
'-----------------Peter------------------'

str.count         #返回子字符串在字符串中出现的次数
>>> b.count('a')
0
>>> b.count('e')
2
>>> b
'Peter'

str.encode        #对字符串进行编码，返回字节对象
>>> b.encode('gbk')
b'Peter'

str.endswith      #判断字符串是否以指定的后缀结尾
>>> b
'Peter'
>>> b.endswith('r')
True
>>> b.endswith('d')
False

str.expandtabs    #使用空格替换tab

>>> str.expandtabs('hello\tworld')
'hello   world'

str.find          #返回子字符串在字符串中第一次出现的位置；如没找到，返回-1
>>> c.find('wo')
8
>>> c
'hello   world'

str.format        #执行字符串格式化操作，替换字段使用{}分隔，替换字段可以是表
>>> str.format('hello {}','world')
'hello world'

str.format_map   #执行字符串格式化操作，替换字段使用{}分隔，同str.for

str.index        #同find()，但如果在字符串中没找到子字符串，会抛出错误
>>> a = 'peter'
>>> a.index('e')
1
>>> a.index('a')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  ValueError: substring not found

12.str.isalnum      #判断字符串中是否至少有一个字符，并且所有字符都是字母或数字
   In [202]: a = 'asf23234d'

   In [203]: a.isalnum()
   Out[203]: True

   In [204]: b = 'asf'

   In [205]: b.isalnum()
   Out[205]: True

   In [206]: c = 'a*sf32'

   In [207]: c.isalnum()
   Out[207]: False

   In [208]: d = ''

   In [209]: d.isalnum()
   Out[209]: False

13.str.isalpha      #判断字符串中是否至少有一个字符，并且所有字符都是字母
    In [194]: a
    Out[194]: '123'

    In [195]: a.isa
    a.isalnum  a.isalpha

    In [195]: a.isalpha()
    Out[195]: False

    In [196]: b
    Out[196]: '1a'

    In [197]: b.isa
    b.isalnum  b.isalpha

    In [197]: b.isalpha()
    Out[197]: False

    In [198]: c
    Out[198]: ''

    In [199]: c.isalpha()
    Out[199]: False

    In [200]: d = 'adsf'

    In [201]: d.isalpha()
    Out[201]: True

14.str.isdecimal    #判断字符串中是否至少有一个字符，并且所有字符都是十进制数字
    In [183]: a = '123'

    In [184]: b = '1a'

    In [185]: c = ''

    In [189]: e = '1.3'

    In [190]: a.isdecimal()
    Out[190]: True

    In [191]: b.isdecimal()
    Out[191]: False

    In [192]: c.isdecimal()
    Out[192]: False

    In [193]: e.isdecimal()
    Out[193]: False

15.str.isdigit      #判断字符串中是否至少有一个字符，并且所有字符都是数字
   In [183]: a = '123'

   In [184]: b = '1a'

   In [185]: c = ''

   In [186]: a.isdigit()
   Out[186]: True

   In [187]: b.isdigit()
   Out[187]: False

   In [188]: c.isdigit()
   Out[188]: False

16.str.isidentifier #判断字符串中是否是有效标识符
    In [172]: a
    Out[172]: 'peter'

    In [173]: b
    Out[173]: 'ASDF'

    In [174]: a
    Out[174]: 'peter'

    In [175]: b = '12'

    In [176]: c = ''

    In [178]: d = '*'

    In [179]: a.isidentifier()
    Out[179]: True

    In [180]: b.isidentifier()
    Out[180]: False

    In [181]: c.isidentifier()
    Out[181]: False

    In [182]: b.isidentifier()
    Out[182]: False

17.str.islower      #判断字符串中是否小字并且至少有一个字符
       In [166]: a = 'peter'

       In [167]: b = 'ASDF'

       In [168]: c = ''

       In [169]: a.islower()
       Out[169]: True

       In [170]: b.islower()
       Out[170]: False

       In [171]: c.islower()
       Out[171]: False

18.str.isnumeric    #判断字符串中是否至少有一个字符，并且所有字符都是数字字符
      In [159]: a = '124'

      In [160]: b = 'as234'

      In [161]: c = ''

      In [162]: a.isnumeric()
      Out[162]: True

      In [163]: b.isnumeric()
      Out[163]: False

      In [164]: c.isnumeric()
      Out[164]: False

19.str.isprintable  #判断字符串的所有字符都是可打印字符或字符串为空
       In [151]: a = "\tPuppy"

       In [152]: b = "PUPPY\a"

       In [153]: c = "puppy"

       In [154]: d = "a puppy\b"

       In [155]: a.isprintable()
       Out[155]: False

       In [156]: b.isprintable()
       Out[156]: False

       In [157]: c.isprintable()
       Out[157]: True

       In [158]: d.isprintable()
       Out[158]: False

20.str.isspace      #判断字符串中是否至少有一个字符，并且所有字符都是空白字符
    In [144]: t2
    Out[144]: ''

    In [145]: t2.isspace()
    Out[145]: False

    In [146]: t3 = '  '

    In [147]: t3.isspace()
    Out[147]: True


    In [149]: t
    Out[149]: 'peter is a student'

    In [150]: t.isspace()
    Out[150]: False

21.str.istitle      #判断字符串中是否至少有一个字符，并且所有字符都是titlecase字符
    In [135]: t = 'peter is a student'

    In [137]: t1 = t.title()

    In [138]: t.istitle()
    Out[138]: False

    In [139]: t1.istitle()
    Out[139]: True

    In [142]: t2 = ''

    In [143]: t2.istitle()
    Out[143]: False

22.str.isupper      #判断字符串中是否全部是大写字母,空字符串为false
   In [124]: a = 'Peter'

   In [125]: a.isupper()
   Out[125]: False

   In [126]: a = 'PETER'

   In [127]: a.isupper()
   Out[127]: True

   In [128]: b = ''

   In [129]: b.isupper()
   Out[129]: False

23.str.join         #使用字符串作为分隔符串连多个数据为一个字符串
    In [116]: a
    Out[116]: 'peter'

    In [117]: e = ['a','b','c','d']

    In [118]: ''.join(e)
    Out[118]: 'abcd'

    In [119]: '*'.join(e)
    Out[119]: 'a*b*c*d'

    In [120]: '*'.join(a)
    Out[120]: 'p*e*t*e*r'

    In [121]: ''.join(a)
    Out[121]: 'peter'

24.str.ljust        #返回指定长度的字符串，字符串内容居左，并使用指定字符填充
   In [88]: a.ljust(10,'-')
   Out[88]: 'peter-----'

   In [89]: a.ljust(1,'-')
   Out[89]: 'peter'

   In [90]: a.ljust(6,'0')
   Out[90]: 'peter0'

25.str.lower        #字符串转换成小写
    In [81]: a = 'peter'

    In [82]: a.upper()
    Out[82]: 'PETER'

    In [83]: b = a.upper()

    In [84]: b
    Out[84]: 'PETER'

    In [85]: b.lower()
    Out[85]: 'peter'

26.str.lstrip       #去掉字符串前面的空格，或参数中的字符

str.translate    #根据table表的映射关系，将字符串中的每个字符转换成另一个#返回一个转换表
   In [32]: m = str.maketrans('e','b')

   In [33]: a.translate(m)
   Out[33]: 'pbtbr'

28.str.partition    #返回包含字符串中分隔符之前、分隔符、分隔符之后的子字符串的tuple
                    #指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
    In [77]: g = 'www.google.com'
    In [79]: g.partition('.')
    Out[79]: ('www', '.', 'google.com')

    In [80]: g.partition('g')
    Out[80]: ('www.', 'g', 'oogle.com')

29.str.replace      #替换字符串中所有的子字符串old为新的字符串new
>>> a.replace('e','A')
'pAtAr'
>>>

30.str.rfind        #返回子字符串在字符串中最后一次出现的位置；如没找到，返回-1
31.str.rindex       #同rfind()，但如果在字符串中没找到子字符串，会抛出错误
32.str.rjust        #返回指定长度的字符串，字符串内容居右，并使用指定字符填充
33.str.rpartition   #从后往前查找，返回包含字符串中分隔符之前、分隔符、分隔符之后
34.str.rsplit       #从后往前拆分字符串，返回一个列表
35.str.rstrip       #去掉字符串后面的空格，或参数中的字符

36.str.split        #拆分字符串，返回一个列表
   In [58]: a = '  peter is a student '

   In [59]: a.split()
   Out[59]: ['peter', 'is', 'a', 'student']

37.str.splitlines   #字符串以换行符为分隔符拆分，去掉换行符；如果keepends
   In [54]: a
   Out[54]: 'peter\n is \na student'

   In [55]: print(a)
   peter
    is
    a student

    In [56]: print(a.splitlines())
    ['peter', ' is ', 'a student']
    )

38.str.startswith   #判断字符串是否以指定的前缀开始
   In [47]: a
   Out[47]: '  peter is a student '

   In [48]: a.startswith(' ')
   Out[48]: True

   In [49]: a.startswith('a')
   Out[49]: False

39.str.strip        #去掉字符串前后的空格，或指定的所有字符
    In [41]: a = '  peter is a student '

    In [42]: a
    Out[42]: '  peter is a student '

    In [43]: a.strip()
    Out[43]: 'peter is a student'

40.str.swapcase     #大写字符转换成小写字符，小写字符转换成大写字符
   In [38]: b = a.title()

   In [39]: b
   Out[39]: 'Peter Is A Student'

   In [40]: b.swapcase()
   Out[40]: 'pETER iS a sTUDENT'

41.str.title        #每个单词的第一个字符转换成titlecase字符，其他字符转
    In [34]: a = 'peter is a student'

    In [35]: a.title()
    Out[35]: 'Peter Is A Student'

43.str.upper        #字符串转换成大写
   In [26]: a.upper()
   Out[26]: 'PETER'

44.str.zfill        #在字符串的左边填充0，不会截断字符串
    In [24]: a.zfill(10)
    Out[24]: '00000peter'

    In [25]: a.zfill(5)
    Out[25]: 'peter'

1.abs       #求绝对值
2.all       #判断迭代器中的所有数据是否都为true
3.any       #判断迭代器中的是否有一个数据为true
4.bin       #转换整数为一个二进制字符串
5.bool      #转换一个数据为布尔值
6.bytearray #将数据转换为字节数组
7.bytes     #将数据转换为字节数组
8.callable  #判断一个对象是否可调用
9.chr       #将整数转成字符
10.classmethod  #得到function的classmethod
11.compile      #编译source为code或AST对象
12.complex      #创建一个复数
13.delattr      #删除指定的属性
14.dict         #创建一个字典dictionary
15.dir          #返回对象的属性列表
16.divmod       #得到两个数字相除的结果和余数
17.enumerate    #得到一个枚举对象
18.eval         #执行一个表达式
19.exec         #动态执行Python代码
20.filter       #过滤数据得到一个迭代器
21.float        #将字符串或数字转为浮点数
22.format       #格式化数据
23.frozenset    #得到新的frozenset对象
24.getattr      #得到对象属性的值
25.globals      #得到当前模块的全局符号表的字典
26.hasattr      #判断对象是否存在属性
27.hash         #得到对象的哈希值
28.help         #显示帮助信息
29.hex          #整数转换为十六进制表示
30.id           #得到对象的id
31.input        #输出提示符，读取用户输入
32.int          #将数字或字符串转为整数
33.isinstance   #判断object是否是classinfo的实例
34.issubclass   #判断一个类是否是另一个类的父类
35.iter         #得到一个迭代器
36.len          #返回对象的长度或集合的数据个数
37.list         #创建一个列表
38.locals       #得到当前符号表字典
39.map          #更改迭代器中的每个数据得到一个新的迭代器
40.max          #得到迭代器中最大的或两个或多个参数中最大的
41.min          #得到迭代器中最小的或两个或多个参数中最小的
42.next         #得到迭代器的下一个数据
43.object       #得到object的实例
44.oct          #整数转换为八进制表示
45.open         #打开文件并返回一个流
46.ord          #得到字符的整数表示
47.pow          #乘方运算
48.print        #输出数据到流
49.property     #得到属性
50.range        #创建一个范围对象
51.repr         #得到对象的字符串表示
52.reversed     #反转序列得到一个迭代器
53.round        #浮点数按小数位数做舍入操作
54.set          #创建一个集合对象
55.setattr      #更改属性的值
56.slice        #得到分片对象
57.sorted       #排序可迭代的数据得到一个列表
58.staticmethod     #得到function的staticmethod
59.str      #得到对象的str版本
60.sum      #计算可迭代数据的合计
61.tuple    #创建一个元组
62.type     #返回对象的类型或创建一个新的类型对象
63.vars     #得到属性信息