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
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__方法