string = 'life is short, I use python'
# 返回的為0或正數(shù)時(shí)，為其索引號(hào)
>>> string.find('life')
string.replace('short','long')
# replace 將short替換為long
>>> life is long, I use python

# random模塊中的shuffle(洗牌函數(shù))  
    import random  
    list = [1, 2, 3, 4]  
    random.shuffle(list)     
    print(list)

import time
from functools import wraps

def timethis(func):
    '''
    Decorator that reports the execution time.
    '''
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end-start)
        return result
    return wrapper
@timethis
def countdown(n):
     '''
    Counts down
     '''
     while n > 0:
         n -= 1

>>> countdown(100000)
countdown 0.008917808532714844
>>> countdown(10000000)
countdown 0.87188299392912”

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
# 參數(shù)3為最大的3個(gè)值(最小的3個(gè)值)
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
# 上面代碼在對(duì)每個(gè)元素進(jìn)行對(duì)比的時(shí)候，會(huì)以price的值進(jìn)行比較。

#方法1,實(shí)現(xiàn)__new__方法  
    #并在將一個(gè)類的實(shí)例綁定到類變量_instance上,  
    #如果cls._instance為None說(shuō)明該類還沒(méi)有實(shí)例化過(guò),實(shí)例化該類,并返回  
    #如果cls._instance不為None,直接返回cls._instance  
  class Singleton(object):  
      def __new__(cls, *args, **kw):  
          if not hasattr(cls, '_instance'):  
              orig = super(Singleton, cls)  
              cls._instance = orig.__new__(cls, *args, **kw)  
          return cls._instance  

  class MyClass(Singleton):  
      a = 1  

  one = MyClass()  
  two = MyClass()  

  two.a = 3  
  print(one.a)  
  #3  
  #one和two完全相同,可以用id(), ==, is檢測(cè)  
  print(id(one))  
  #29097904  
  print(id(two))  
  #29097904  
  print(one == two)
  #True  
  print(one is two)  
  #True  

  print('----------------------方法2--------------------------') 
  #方法2,共享屬性;所謂單例就是所有引用(實(shí)例、對(duì)象)擁有相同的狀態(tài)(屬性)和行為(方法)  
  #同一個(gè)類的所有實(shí)例天然擁有相同的行為(方法),  
  #只需要保證同一個(gè)類的所有實(shí)例具有相同的狀態(tài)(屬性)即可  
  #所有實(shí)例共享屬性的最簡(jiǎn)單最直接的方法就是__dict__屬性指向(引用)同一個(gè)字典(dict)  
  #可參看:http://code.activestate.com/recipes/66531/  
  class Borg(object):  
      _state = {}  
      def __new__(cls, *args, **kw):  
          ob = super(Borg, cls).__new__(cls, *args, **kw)  
          ob.__dict__ = cls._state  
          return ob  

  class MyClass2(Borg):  
      a = 1  

  one = MyClass2()  
  two = MyClass2()  

  #one和two是兩個(gè)不同的對(duì)象,id, ==, is對(duì)比結(jié)果可看出  
  two.a = 3  
  print(one.a)
  #3  
  print(id(one))  
  #28873680  
  print(id(two))  
  #28873712  
  print(one == two)
  #False  
  print(one is two)  
  #False  
  #但是one和two具有相同的（同一個(gè)__dict__屬性）,見(jiàn):  
  print(id(one.__dict__)) 
  #30104000  
  print(id(two.__dict__))  
  #30104000  

  print '----------------------方法3--------------------------'  
  #方法3:本質(zhì)上是方法1的升級(jí)（或者說(shuō)高級(jí)）版  
  #使用__metaclass__（元類）的高級(jí)python用法  
  class Singleton2(type):  
      def __init__(cls, name, bases, dict):  
          super(Singleton2, cls).__init__(name, bases, dict)  
          if not hasattr(cls, '_instance'):
           cls._instance = None
      def __call__(cls, *args, **kw):  
          if cls._instance is None:  
              cls._instance = super(Singleton2, cls).__call__(*args, **kw)  
          return cls._instance  

  class MyClass3(object):  
      __metaclass__ = Singleton2  

  one = MyClass3()  
  two = MyClass3()  

  two.a = 3  
  print(one.a)  
  #3  
  print(id(one))  
  #31495472  
  print(id(two))  
  #31495472  
  print(one == two)  
  #True  
  print(one is two)  
  #True  

  print '----------------------方法4--------------------------'  
  #方法4:也是方法1的升級(jí)（高級(jí)）版本,  
  #使用裝飾器(decorator),  
  #這是一種更pythonic,更elegant的方法,  
  #單例類本身根本不知道自己是單例的,因?yàn)樗旧?自己的代碼)并不是單例的  
  def singleton(cls, *args, **kw):  
      instances = {}  
      def _singleton():  
          if cls not in instances:  
              instances[cls] = cls(*args, **kw)  
          return instances[cls]  
      return _singleton  

  @singleton  
  class MyClass4(object):  
      a = 1  
      def __init__(self, x=0):  
          self.x = x  

  one = MyClass4()  
  two = MyClass4()  

  two.a = 3  
  print(one.a)  
  #3  
  print(id(one)) 
  #29660784  
  print(id(two))  
  #29660784  
  print(one == two)  
  #True  
  print(one is two)  
  #True  
  one.x = 1  
  print(one.x) 
  #1  
  print(two.x)
  #1 

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a

def main():
    for val in fib(20):
        print(val)
if __name__ == '__main__':
    main()

import os
import time

def main():
    content = '曹查理的python面試集-基礎(chǔ)篇'
    while True:
        # 清理屏幕上的輸出
        os.system('cls')  # os.system('clear')
        print(content)
        # 休眠200毫秒
        time.sleep(0.2)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()

def get_suffix(filename, has_dot=False):
    """
    獲取文件名的后綴名

    :param filename: 文件名
    :param has_dot: 返回的后綴名是否需要帶點(diǎn)

    :return: 文件的后綴名
    """
    pos = filename.rfind('.')
    if 0 < pos < len(filename) - 1:
        index = pos if has_dot else pos + 1
        return filename[index:]
    else:
        return ''