列举字符串,列表，元组，字典每个常用的五个方法、map,zip,filter,sorted,reduce、面向对象中的__开头__结尾的方法及作用

1.列举字符串,列表，元组，字典每个常用的五个方法

字符串：repleace,strip,split,reverse,upper,lower,join

列表：append,pop,insert,remove,sort,count,index

元组：index,count,len(),dir(),cmp(tuple1, tuple2)：比较两个元组元素,max,min

字典：get,keys,values,pop,popitems,clear,update,items
2.描述下列常见内置函数的作用可用代码说明map,zip,filter,sorted,reduce

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

def f(x):
    return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
输出结果：
[1, 4, 9, 10, 25, 36, 49, 64, 81]
注意：map()函数不改变原有的 list，而是返回一个新的 list。

zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。

若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。

list1 = [1,2,3,4]
list2 = [5,6,7,8]
print zip(list1,list2) 
输出结果是   [(1, 5), (2, 6), (3, 7), (4, 8)]

str1 = "abcd"
str2 = "123456"
print zip(str1,str2)
输出结果是：[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

filter

1、循环帮你调用函数

2、帮你过滤你传入的参数，函数的结果返回的是true那就保存，返回false就不要，且返回的也是迭代器

sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。

>>> print sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]

>>> L = [5, 2, 3, 1, 4]
>>> L.sort()
>>> print L
[1, 2, 3, 4, 5]

3.列举你所知道的面向对象中的__开头__结尾的方法及作用，越多越好

内置的类方法和内置的函数之间有着千丝万缕的关系。

双下方法：__str__和__repr__  ---> str()和repr()

# str()
# repr()  # 内置函数，原封不动的输出你输入的内容
print(1)
print('1')
print(repr(1))
print(repr('1'))

__str__
定义__str__方法的时候，返回值必须是字符串格式的数据类型，否则报错。

class A:
    pass
a = A()
print(str(a)) # 以字符串类型打印出内存地址
# object 里有一个__str__，一旦调用，就返回调用这个方法的对象的内存地址

class B:
    def __str__(self):
        return '这是自己定义的__str___.'

b = B()
print(str(b))
print(b) # 打印一个对象的时候 默认就会调用  对象.__str__

print('%s:%s'%(b,a))  # %s str() print() 实际上都是调用__str__的方法

__repr__
调用__repr__的返回值必须是字符串的数据(str)类型,且repr()实际就是调用__repr__方法，格式化输出%r实际也是调用__repr__方法。

class Teacher:
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary

    def __str__(self):
        return "Teacher's object :%s"%self.name

    def __repr__(self):
        return '这是__repr__的返回值'

jerry = Teacher('Jerry',100)
print(jerry)
print(repr(jerry))
print('>>>%r'%jerry)

# 当类中没有定义__repr__方法的时候，会调用object里的__repr__方法
# 当类中没有定义__str__方法，但定义了__repr__方法时，会调用自己类中的__repr__方法，若没有__repr__方法，才会去找父类的__str__方法
# __repr__是__str__的备胎(但str不能做repr的备胎)，__str__不存在时会调用__repr__方法。
# 即如果没有__str__方法，会先找本类中的__repr__方法，若没找到，就找父类（object）中的__str__。
# repr(),只会找__repr__，如果没有就找父类的.

class Teacher:
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary

    # def __str__(self):
    #     return "Teacher's object :%s"%self.name

    def __repr__(self):
        return '这是__repr__的返回值'

jerry = Teacher('Jerry',100)
print(jerry)
print('调用的是str方法',str(jerry)) #  __repr__是__str__的备胎，__str__不存在时会调用__repr__方法。
print('>>>%r'%jerry)

__len__
并非所有的内置方法都存在于object父类中；我们知道len()实际调用的就是__len__方法，那么我们在类里自己定义一个__len__会怎么样？

class C:
    def __len__(self):
        return 10

c = C()
print(len(c))
# len 是否存在于object中
class D:
    pass
d = D()
# print(len(d))

# 需求，输出一个班级有多少学生
class Classes:
    def __init__(self,name):
        self.name = name
        self.student = []

    def __len__(self):
        return len(self.student)
classes = Classes('Python')
print(classes.name)
classes.student.append('Jerry')
classes.student.append('Tom')
print(classes.student)
print(len(classes.student))

__del__
析构方法：当对象在内存中被释放时，自动触发执行的

注：此方法一般无需定义，因为python是一门高级语言，程序员在使用时无需关系内存的分配和释放，因此工作都是交给python解释器来执行，所以析构函数的调用是由解释器在进行垃圾回收时自动触发的

class E:
    pass

e = E()
del e
# print(e)

class F:
    def __del__(self):
        print('执行了__del__')

f = F()
del f  # del 既执行了这个方法，又删除了变量 (先会调用类定义的__def__方法)
# print(f)

__call__
当类中使用了__call__方法后，实例化后的对象，加上括号 object() 就会调用__call__方法

class G:
    def __init__(self,name):pass
    def __call__(self):
        print('执行了__call__方法')

g = G('Jerry')
g()
# g = G('Jerry')() 代码简化的写法

item系列
__getitem__ __setitem__  __delitem__

主要作用就是操作类，可以像操作字典一样，相当于给类里的属性加上了索引。

class A:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __getitem__(self, item):
        if hasattr(self,item):
            return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value
        print(key,value)

    def __delitem__(self, key):
        print('你删除了属性：%s'%key)
        del self.__dict__[key]

a = A('Jerry',20,'男')
# 当对象+[]时 会自动查找类里的__getitem__方法
print(a['name'])
# 当对象+[key] = value 的时候回自动查找类来的的__setitem__方法
a['hobby'] = 'play'
print(a.hobby)
print(a['hobby'])

# 删除属性
# del a.hobby  # 调用了object父类的__delattr__方法
# 不支持一下删除方法，除非定义了__delitem__方法
del a['hobby']
# print(a.hobby)

__new__
__new__是一个构造方法：创建一个对象。

class B:
    def __init__(self):
        self.x = 1

    def __new__(cls, *args, **kwargs):
        print('这是__new__方法！')
        return object.__new__(cls,*args,**kwargs)

# 每实例化一个对象都会先调用__new__方法
b = B()

说到这个__new__就必须说一个经典的设计模式（共23种）------单例模式
单例模式：一个类始终只有一个实例；即当你第一次实例化一个类的时候，就创建一个实例化对象，后面再实例化同一个类的时候，都使用之前创建的对象。（属性相同的就覆盖，不同的就保留）

# 单例模式
class C:
    __instance = False
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if cls.__instance:
            return cls.__instance
        cls.__instance = object.__new__(cls) # 借助object父类中的__new__创建一个对象
        return cls.__instance

jerry = C('jerry',19)
tom = C('tom',20)
print(jerry)
print(tom)
print(jerry.name)
print(tom.name)
# 添加新的属性
jerry.sex = '男'  # 因为定义的属性sex不同，所以不会被覆盖
print(tom.sex)

__eq__
作用：当判断对象属性是否相同的时候会使用__eq__方法，即使用' == '做判断的时候会调用__eq__方法。

class D:
    def __init__(self,name):
        self.name = name

    def __eq__(self, other):
        if self.name == other.name:
            return True
        else:return False

ob1 = D('jerry')
ob2 = D('jerry')
print(ob1==ob2) # 所有的是否等于都是在对比内存地址，而非对象里的属性
# 让其相等，使用__eq__方法
ob3 = D('Tom')
print(ob2 == ob1)
print(ob1 == ob3)

__hash__
作用：让对象里属性相同的对象指向同一个哈希值。

class E:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

e =E('Jerry','man')
e1 = E('Jerry','man')
print(hash(e))
print(hash(e1))
# 需要让两个对象的属性若一样，则他们的哈希值是一样的,就会调用__hash__方法