Python基础面试20题

string = 'life is short, I use python'
# 返回的为0或正数时，为其索引号
>>> string.find('life')
string.replace('short','long')
# replace 将short替换为long
>>> life is long, I use python

# random模块中的shuffle(洗牌函数)  
    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}
]
# 参数3为最大的3个值(最小的3个值)
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
# 上面代码在对每个元素进行对比的时候，会以price的值进行比较。

#方法1,实现__new__方法  
    #并在将一个类的实例绑定到类变量_instance上,  
    #如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回  
    #如果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检测  
  print(id(one))  
  #29097904  
  print(id(two))  
  #29097904  
  print(one == two)
  #True  
  print(one is two)  
  #True  

  print('----------------------方法2--------------------------') 
  #方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)  
  #同一个类的所有实例天然拥有相同的行为(方法),  
  #只需要保证同一个类的所有实例具有相同的状态(属性)即可  
  #所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(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是两个不同的对象,id, ==, is对比结果可看出  
  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具有相同的（同一个__dict__属性）,见:  
  print(id(one.__dict__)) 
  #30104000  
  print(id(two.__dict__))  
  #30104000  

  print '----------------------方法3--------------------------'  
  #方法3:本质上是方法1的升级（或者说高级）版  
  #使用__metaclass__（元类）的高级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的升级（高级）版本,  
  #使用装饰器(decorator),  
  #这是一种更pythonic,更elegant的方法,  
  #单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的  
  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面试集-基础篇'
    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: 返回的后缀名是否需要带点

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