python基础笔试题

1.
    """
    补充缺失的代码
        def print_directory_contents(sPath):
        这个函数接收文件夹的名称作为输入参数
        返回该文件夹中文件的路径
        以及其包含文件夹中文件的路径
    """

    import os


    def print_directory_contents(sPath):
        for child_path in os.listdir(sPath):#遍历sPath下的所有文件
            child_path = os.path.join(sPath, child_path)#改成完整路径
            if os.path.isdir(child_path):#判断是否是文件夹
                print_directory_contents(child_path)#递归调用
            else:
                print(child_path)#不是 打印文件名

                
2.
    """"
    输入日期， 判断这一天是这一年的第几天？
    """

    import datetime


    def dayofyear():
        year = int(input("year:"))
        month = int(input("month:"))
        day = int(input("day:"))
        date1 = datetime.date(year=year, month=month, day=day)  # 今天的日期
        date2 = datetime.date(year=year, month=1, day=1)  # 今年的第一天日期
        return (date1 - date2).days + 1  # 日期相减

3.
    """"
    打乱一个排好序的list对象alist？
    """

    import random

    alist = [1, 2, 3, 4, 5, 6, 7]
    random.shuffle(alist)
    print(alist)

    
4.
    """
    现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
    """
  

  d = {'a': 24, 'g': 52, 'i': 12, 'k': 33}
    new_d = sorted(d.items(), key=lambda x: x[1])
    print(new_d)

    """
    这里的d.items()实际上是将d转换为可迭代对象，迭代对象的元素为 （‘a’,24）、（‘g’,252）、（‘i’,12）、
    （‘k’,33），items()方法将字典的元素 转化为了元组，而这里key参数对应的lambda表达式的意思则是选取元组中的第二个元素作
    为比较参数（如果写作key=lambda item:item[0]的话则是选取第一个元素作为比较对象，也就是key值作为比较对象。
    lambda x:y中x表示输出参数，y表示lambda 函数的返回值），所以采用这种方法可以对字典的value进行排序。注意排序后的返回值是一个list，
    而原字典中的名值对被转换为了list中的元组。"""

5.
    """
    给一个可迭代对象 例如alist = [("a", 1), ("b", 2), ("c", 3)]
    生成字典
    """
  

 alist = [("a", 1), ("b", 2), ("c", 3)]
    dict1 = {k: v for (k, v) in alist}
    print(dict1)

    
6.
"""
    请反转字符串 "aStr"?
    """

    str1 = "aStr"
    str1 = str1[::-1]
    print(str1)

    
7.
    """
    将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
    """

  

 str1 = "k:1 |k1:2|k2:3|k3:4"
    dict = {}
    for item in str1.split("|"):
        item = item.strip()
        k, v = item.split(":")
        dict[k] = v
    print(dict)

8.
    """
    请按alist中元素的age由大到小排序
    alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
    """
    此题和第四题类似
    
    

alist = [{'name': 'a', 'age': 20}, {'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}]
    new = sorted(alist, key=lambda x: x["age"], reverse=True)  # reverse 逆序排列
    print(new)

9.
    下面代码的输出结果将是什么？
    list = ['a','b','c','d','e']
    print(list[10:])
    代码将输出[],不会产生IndexError错误，就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。例如，尝试获取list[10]和之后的成员，会导致IndexError。然而，尝试获取列表的切片，开始的index超过了成员个数不会产生IndexError，而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致Bug很难被追踪到。

10.
    写一个列表生成式，产生一个公差为11的等差数列
    
    两种思路:
    第一种
        alist = [i for i in range(0, 100, 11)]
    第二种:
        alist = [i*11 for i in range(0, 10)]

11.
    """
    给定两个列表，怎么找出他们相同的元素和不同的元素？
    a = [1,2,3]
    b = [2,3,5]
    """
    #先把列表改成集合,在取交集 差集
  

  a = [1, 2, 3]
    b = [2, 3, 4]
    c = set(a) & set(b)
    d = set(a) ^ set(b)
    print(c)
    print(d)

12.
    """
    请写出一段python代码实现删除list里面的重复元素？
    l1 = ['b','c','d','c','a','a']
    """

    l1 = ['b', 'c', 'd', 'c', 'a', 'a']
    print(list(set(l1)))

13.
    python中内置的数据结构有几种？
    a. 整型 int、 长整型 long、浮点型 float、 复数 complex

    b. 字符串 str、 列表 list、 元祖 tuple

    c. 字典 dict 、 集合 set

    d. Python3 中没有 long，只有无限精度的 int

14.
    python新式类和经典类的区别？
    a. 在python里凡是继承了object的类，都是新式类

    b. Python3里只有新式类

    c. Python2里面继承object的是新式类，没有写父类的是经典类

    d. 经典类目前在Python里基本没有应用

    e.经典类的MRO是深度优先搜索，新式类的MRO是广度优先搜索
    
15.
    第一种方法:使用装饰器

    def singleton(cls):
        instances = {}
        def wrapper(*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]
        return wrapper
        
        
    @singleton
    class Foo(object):
        pass
    foo1 = Foo()
    foo2 = Foo()
    print(foo1 is foo2)  # True

    第二种方法：使用基类 New 是真正创建实例对象的方法，所以重写基类的new 方法，以此保证创建对象的时候只生成一个实例  

 class Singleton(object):
        def __new__(cls, *args, **kwargs):
            if not hasattr(cls, '_instance'):
                cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
            return cls._instance
        
        
    class Foo(Singleton):
        pass

    foo1 = Foo()
    foo2 = Foo()

    print(foo1 is foo2)  # True

    第三种方法：元类，元类是用于创建类对象的类，类对象创建实例对象时一定要调用call方法，因此在调用call时候保证始终只创建一个实例即可，type是python的元类    

class Singleton(type):
        def __call__(cls, *args, **kwargs):
            if not hasattr(cls, '_instance'):
                cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
            return cls._instance


    # Python2
    class Foo(object):
        __metaclass__ = Singleton

    # Python3
    class Foo(metaclass=Singleton):
        pass

    foo1 = Foo()
    foo2 = Foo()
    print(foo1 is foo2)  # True

    
16.
    """
    反转一个整数，例如-123 --> -321
    """

  

 def num_reverse(num):
        if -10 < num < 10:
            return num
        num = str(num)
        if num.startswith("-"):
            return num[0] + num[:0:-1]
        return num[::-1]

        
17.
    
    设计实现遍历目录与子目录，抓取.pyc文件
    import os

 

    def get_pyc(path):
        for child in os.listdir(path):
            child = os.path.join(path, child)
            if os.path.isdir(child):
                get_pyc(child)
            elif os.path.splitext(child)[1] == ".pyc":
                print(child)

18.
    一行代码实现1-100之和
  

 res = sum(range(1, 100))
    print(res)

    
19.
    Python-遍历列表时删除元素的正确做法
    遍历在新在列表操作，删除时在原来的列表操作
    第一种方法
      

 a = [1, 2, 3, 4, 5, 6, 7, 8]
        for i in a[:]:
            if i <= 5:
                a.remove(i)
        print(a)

    第二种方法
      

  res = filter(lambda x: x > 5, a)
        print(list(res))

    第三种方法
     

   b = [i for i in a if a > 5]

20.
    字符串的操作题目
    全字母短句 PANGRAM 是包含所有英文字母的句子，比如：A QUICK BROWN FOX JUMPS OVER THE LAZY DOG. 定义并实现一个方法 get_missing_letter, 传入一个字符串采纳数，返回参数字符串变成一个 PANGRAM 中所缺失的字符。应该忽略传入字符串参数中的大小写，返回应该都是小写字符并按字母顺序排序（请忽略所有非 ACSII 字符）

    下面示例是用来解释，双引号不需要考虑:

    (0)输入: "A quick brown for jumps over the lazy dog"

    返回： ""

    (1)输入: "A slow yellow fox crawls under the proactive dog"

    返回: "bjkmqz"

    (2)输入: "Lions, and tigers, and bears, oh my!"

    返回: "cfjkpquvwxz"

    (3)输入: ""

    返回："abcdefghijklmnopqrstuvwxyz"
    
    

    def get_missing_letter(value):
    s1 = set("abcdefghijklmnopqrstuvwxyz")
    s2 = set(value.lower())
    res = "".join(sorted(s1-s2))
    print(res)

    
21.
    求出列表所有奇数并构造新列表

    a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    b = [i for i in a if i % 2 == 1]

    
22.
    is和==有什么区别？
    is：比较的是两个对象的id值是否相等，也就是比较俩对象是否为同一个实例对象。是否指向同一个内存地址

    == ： 比较的两个对象的内容/值是否相等，默认会调用对象的eq()方法
    
23.
    可变类型和不可变类型
    1,可变类型有list,dict.不可变类型有string，number,tuple.

    2,当进行修改操作时，可变类型传递的是内存中的地址，也就是说，直接修改内存中的值，并没有开辟新的内存。

    3,不可变类型被改变时，并没有改变原内存地址中的值，而是开辟一块新的内存，将原地址中的值复制过去，对这块新开辟的内存中的值进行操作。
    
24.
    """
    用一行python代码写出1+2+3+10248
    """
    from functools import reduce
    第一种方法
      

  res1 = sum([1, 2, 3, 10248])

    第二种方法

        res2 = reduce(lambda x,y: x + y, [1, 2, 3, 10248])

        
25.
    字符串 "123" 转换成 123，不使用内置api，例如 int()
    
    第一种方法
        

def transfer(str1):
        num = 0
        for i in str1:
            for j in range(10):
                if i == str(j):
                    num = num * 10 + j
        return num
    num = transfer("123")
    print(num)

26.
    Given an array of integers
    给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。示例:给定nums = [2, 7, 11, 15], target=9 因为 nums[0] + nums[1] = 2 + 7 = 9,所以返回 [0, 1]
 

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


    def get_array(alist, num):
        for i in alist:
            for j in alist[alist.index(i):]:
                if i + j == num:
                    return [alist.index(i), alist.index(j)]


    print(get_array(alist=alist, num=5))

    
27.
    统计一个文本中单词频次最高的10个单词？
    方法一:
      

  import re

        with open("text", "r", encoding="utf-8")as f:
            data = f.read()
            words = re.findall("\w+", data)
            dict = {}
            for each in words:
                if each in dict.keys():
                    dict[each] += 1
                else:
                    dict[each] = 1
        res = sorted(dict.items(), key=lambda x: x[1], reverse=True)[:10]
        counter = [each[0]for each in res]
        print(counter)

        
28.
    """"
    请写出一个函数满足以下条件
    该函数的输入是一个仅包含数字的list,输出一个新的list，其中每一个元素要满足以下条件：

    1、该元素是偶数    2、该元素在原list中是在偶数的位置(index是偶数)
    """
 

   a = [1, 3, 4, 5, 7, 8, 11, 32, 55, 65, 78, 100]

    new_list = [i for i in a if i % 2 == 0 and a.index(i) % 2 == 0]
    print(new_list)

29.
    """
    使用单一的列表生成式来产生一个新的列表
    该列表只包含满足以下条件的值，元素为原始列表中偶数切片
    """

    list_data = [1, 2, 5, 8, 10, 3, 18, 6, 20]
    alist = [i for i in list_data[::2] if i % 2 == 0]
    print(alist)

30.
    """"
    用一行代码生成[1,4,9,16,25,36,49,64,81,100]
    """

  

  alist = [i * i for i in range(1, 11)]
    print(alist)

    
    
31.
    """"
    两个有序列表，l1,l2，对这两个列表进行合并不可使用extend
    """
    归并排序会用到此方法

  

 l1 = sorted([2, 3, 5, 6, 7, 81, 131, 555])
    l2 = sorted([0, 9, 18, 338, 13, 333, 200])
    new_list = []
    while len(l1) > 0 and len(l2) > 0:
        if l1[0] < l2[0]:
            new_list.append(l1[0])
            del l1[0]
        else:
            new_list.append(l2[0])
            del l2[0]
    while len(l1) > 0:
        new_list.append(l1[0])
        del l1[0]
    while len(l2) > 0:
        new_list.append(l2[0])
        del l2[0]
    print(new_list)

32.
    """
    给定一个任意长度数组，实现一个函数
    让所有奇数都在偶数前面，而且奇数升序排列，偶数降序排序，如字符串'1982376455',变成'1355798642'
    """
    方法一:
        

num_str = "1982376455"
        odd = []
        even = []

        for i in num_str:
            if int(i) % 2 == 0:
                odd.append(i)
            else:
                even.append(i)
        odd = sorted(odd, reverse=True)
        even = sorted(even, reverse=False)
        new_list = even + odd
        new_str = "".join(new_list)
        print(new_str)

        
    方法二:
      

  test_str = '1982376455'
        def func(l):
            print("".join(sorted(l, key=lambda x: int(x) % 2 == 0 and 20 - int(x) or int(x))))
        func(test_str)

        
33.
    """
    写一个函数找出一个整数数组中，第二大的数
    """
    方法一:
  

     a = [2, 3, 11, 13, 0, 100, 897, 13]
        first = a[0]
        second = a[0]
        for i in range(1, len(a)):
            if a[i] > first:
                second = first
                first = a[i]
            elif a[i] > second:
                second = a[i]
        print(second)

        
    方法二:
  

     a = [2, 3, 11, 13, 0, 100, 897, 13]
        second = sorted(a,reverse=True)[1]
        print(second)
    

    方法三:

34.
    阅读一下代码他们的输出结果是什么？
    

def multi():
        return [lambda x : i*x for i in range(4)]
    print([m(3) for m in multi()])

    正确答案是[9,9,9,9]，而不是[0,3,6,9]产生的原因是Python的闭包的后期绑定导致的，这意味着在闭包中的变量是在内部函数被调用的时候被查找的，因为，最后函数被调用的时候，for循环已经完成, i 的值最后是3,因此每一个返回值的i都是3,所以最后的结果是[9,9,9,9]

35.
    统计一段字符串中字符出现的次数
    类似于第27题

 

36.
    """
    遍历一个object的所有属性，并print每一个属性名？
    """
  

  class Car:
        def __init__(self, name, loss):  # loss [价格，油耗，公里数]
            self.name = name
            self.loss = loss

        def getName(self):
            return self.name

        def getPrice(self):
            # 获取汽车价格
            return self.loss[0]

        def getLoss(self):
            # 获取汽车损耗值
            return self.loss[1] * self.loss[2]
    car = Car("BMW",[20,30,100])
    print(dir(car))

    ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'getLoss', 'getName', 'getPrice', 'loss', 'name']
    
    
37.
    简述read、readline、readlines的区别？
    read 读取整个文件

    readline 读取下一行

    readlines 读取整个文件到一个迭代器以供我们遍历
    
38.
    什么是Hash（散列函数）？
    散列函数（英语：Hash function）又称散列算法、哈希函数，是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做散列值（hash values，hash codes，hash sums，或hashes）的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表39.
    手写一个判断时间的装饰器
    

import datetime


    class TimeException(Exception):
        def __init__(self, expection_info):
            super().__init__()
            self.info = expection_info

        def __str__(self):
            return self.info


    def timecheck(func):
        def wrapper(*args, **kwargs):
            if datetime.datetime.now().year == 2019:
                func(*args, **kwargs)
            else:
                raise TimeException("函数已超时")
        return wrapper
    @timecheck
    def time_now(name):
        print("hello {} today is 2019".format(name))

    if __name__ == '__main__':
        time_now("shan")

40.
    使用Python内置的filter()方法来过滤1到100的偶数？

    res = list(filter(lambda x: x % 2 == 0, range(1, 101)))
    print(res)

41.
    函数调用参数的传递方式是值传递还是引用传递？
    Python的参数传递有：位置参数、默认参数、可变参数、关键字参数。

    函数的传值到底是值传递还是引用传递、要分情况：

    不可变参数用值传递：像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变不可变对象。

    可变参数是引用传递：比如像列表，字典这样的对象是通过引用传递、和C语言里面的用指针传递数组很相似，可变对象能在函数内部改变。
    
42.
    如何在function里面设置一个全局变量
    globals() # 返回包含当前作用余全局变量的字典。
    global 变量 设置使用全局变量
    
43.
    有这样一段代码，print c会输出什么，为什么？
    

a = 10
    b = 20
    c = [a]
    a = 15
    
    c = [10]

    
44.
    map(lambda x:x*x，[y for y in range(3)])的输出？
    [0,1,4]
    
45.
    手写一个装饰器计时器
    
  

  import time


    def timmer(func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            func()
            end_time = time.time()
            print(end_time-start_time)
        return wrapper


    @timmer
    def func():
        total = 0
        for i in range(10000000):
            total += i
    func()

    
46.
    hasattr() getattr() setattr() 函数使用详解？
    hasattr(object,name)函数:    判断一个对象里面是否有name属性或者name方法，返回bool值，有name属性（方法）返回True，否则返回False。

    class function_demo(object):
    name = 'demo'

    def run(self):
        return "hello function"


    functiondemo = function_demo()
    res1 = hasattr(functiondemo, "name")  # 判断对象是否有name属性，True
    res2 = hasattr(functiondemo, "run")  # 判断对象是否有run方法，True
    res3 = hasattr(functiondemo, "age")  # 判断对象是否有age属性，False

    print(res1)
    print(res2)
    print(res3)

    
    setattr(object, name, values)函数：    给对象的属性赋值，若属性不存在，先创建再赋值
    

class function_demo(object):
    name = "demo"

    def run(self):
        return "hello function"


    functiondemo = function_demo()
    res = hasattr(functiondemo, "age")  # 判断age属性是否存在，False
    print(res)
    setattr(functiondemo, "age", 18)  # 对age属性进行赋值，无返回值
    res1 = hasattr(functiondemo, "age")  # 再次判断属性是否存在，True
    print(res1)

    
    getattr(object, name[,default])函数：    获取对象object的属性或者方法，如果存在则打印出来，如果不存在，打印默认值，默认值可选。注意：如果返回的是对象的方法，则打印结果是：方法的内存地址，如果需要运行这个方法，可以在后面添加括号().
  

 class function_demo(object):
    name = "demo"

    def run(self):
        print("hello function")


    functiondemo = function_demo()
    getattr(functiondemo, "name")  # 如果有name属性则返回name的值
    getattr(functiondemo, "run")  # 如果有fun的属性则返回run的内存地址,要调用的话在后面加上括号调用
    getattr(functiondemo, "age")  # 获取不存在的属性，报错
    getattr(functiondemo, "age", 20)  # 获取不存在的属性，返回一个默认的值,也可以写个函数来调用

    
    综合使用
    
  

  class function_demo(object):
    name = "demo"

    def run(self):
        return "hello function"


    functiondemo = function_demo()
    res = hasattr(functiondemo, "addr")  # 先判断是否存在
    if res:
        addr = getattr(functiondemo, "addr")
        print(addr)
    else:
        addr = getattr(functiondemo, "addr", setattr(functiondemo, "addr", "北京首都"))
        print(addr)

47.
    """
    一句话解决阶乘函数？
    """

    from functools import reduce


    def factorial(n):
        return reduce(lambda x, y: x * y, range(1, n + 1))

48.
    什么是lambda函数？ 有什么好处？
    lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数

    1.lambda函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，连名字都很随意的情况下

    2.匿名函数，一般用来给filter，map这样的函数式编程服务

    3.作为回调函数，传递给某些应用，比如消息处理
    
    
49.
    递归函数停止的条件？
    递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择是继续调用自身，还是return，，返回终止递归。

    终止的条件：判断递归的次数是否达到某一限定值

    2.判断运算的结果是否达到某个范围等，根据设计的目的来选择
    
    
47.
    """"
    下面这段代码的输出结果将是什么？请解释。
    """

    def multipliers():
        return [lambda x: i * x for i in range(4)]


    print([m(2) for m in multipliers()])

    
    输出[6,6,6,6]
    这个是python的闭包延迟的绑定,因为匿名函数是在for循环之后调用,当匿名函数调用时查找的i是最后生成的3,所以最后生成[6,6,6,6]而不是[0,2,4,6]
    怎么修改才能成为[0,2,4,6]
    为了达成这个效果,则目的是循环一个弹出数值,那yield可以满足需求
    方法一
      

  def multipliers():
            for i in range(4):
                yield lambda x: x * i


        print([m(2) for m in multipliers()])

        
    方法二
      

 def multipliers():
            return [lambda x, i=i: x * i for i in range(4)]


        print([m(2) for m in multipliers()])
    

48.
    """
    什么是lambda函数？它有什么好处？写一个匿名函数求两个数的和
    """
    lambda函数是匿名函数，使用lambda函数能创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤
  

  from functools import reduce

    res = reduce(lambda x, y: x + y, [1, 2])
    print(res)

    
49.
    单例模式的应用场景有那些？
    单例模式应用的场景一般发现在以下条件下： 资源共享的情况下，避免由于资源操作时导致的性能或损耗等，如日志文件，应用配置。 控制资源的情况下，方便资源之间的互相通信。如线程池等，1,网站的计数器 2,应用配置 3.多线程池 4数据库配置 数据库连接池 5.应用程序的日志应用...

50.
    解释以下什么是闭包？
    在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包。
    
51.
    生成器，迭代器的区别？
    迭代器是遵循迭代协议的对象。用户可以使用 iter() 以从任何序列得到迭代器（如 list, tuple, dictionary, set 等）。另一个方法则是创建一个另一种形式的迭代器 —— generator 。要获取下一个元素，则使用成员函数 next()（Python 2）或函数 next() function （Python 3） 。当没有元素时，则引发 StopIteration 此例外。若要实现自己的迭代器，则只要实现 next()（Python 2）或 __next__()（ Python 3）

    生成器（Generator），只是在需要返回数据的时候使用yield语句。每次next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行的位置和所有的数据值）

    区别： 生成器能做到迭代器能做的所有事，而且因为自动创建iter()和next()方法，生成器显得特别简洁，而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法，当发生器终结时，还会自动抛出StopIteration异常。

52.
    X是什么类型?
    X= (i for i in range(10))
    X是 generator类型

53.
    请用一行代码 实现将1-N 的整数列表以3为单位分组
    res = [[j for j in range(1, 100)][i:i + 3] for i in range(1, 100, 3)]
    先找到所有以数字3为间隔的数字,然后通过3来进行列表的切片.
    
54.
    Python的魔法方法
    魔法方法就是可以给你的类增加魔力的特殊方法，如果你的对象实现（重载）了这些方法中的某一个，那么这个方法就会在特殊的情况下被Python所调用，你可以定义自己想要的行为，而这一切都是自动发生的，它们经常是两个下划线包围来命名的（比如__init___,__len__),Python的魔法方法是非常强大的所以了解其使用方法也变得尤为重要!

    __init__构造器，当一个实例被创建的时候初始化的方法，但是它并不是实例化调用的第一个方法。

    __new__才是实例化对象调用的第一个方法，它只取下cls参数，并把其他参数传给__init___.

    ___new__很少使用，但是也有它适合的场景，尤其是当类继承自一个像元祖或者字符串这样不经常改变的类型的时候。

    __call__让一个类的实例像函数一样被调用

    __getitem__定义获取容器中指定元素的行为，相当于self[key]

    __getattr__定义当用户试图访问一个不存在属性的时候的行为。

    __setattr__定义当一个属性被设置的时候的行为

    __getattribute___定义当一个属性被访问的时候的行为

55.
    面向对象中怎么实现只读属性?
    将对象私有化，通过共有方法提供一个读取数据的接口
    第一种方法
      

 class person:
            def __init__(self, x):
                self.__age = 10
            def age(self):
                return self.__age
        t = person(22)
        t.__age =100
        print(t.age())

    第二种方法(最好):
      

  class MyCls(object):
        __weight = 50
        
        @property
        def weight(self):
            return self.__weight

        当你在外部修改私有属性时修改不了
        但是这个方法不是安全的,你可以调用print(dir(t))查看到实例t的所有属性,包括私有属性,_person__age,
        这时你把_person__age=20,则私有属性被修改了
    
56.
    a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？
  

  a = "abbbccc"
    import re
    print(re.sub("b+","b",a))