一、闭包
1.定义
闭包是一个函数内部定义的内部函数，且可以访问外部函数的变量。常用与数据隐藏和信息封装。
def hello():
username = '小小奇'
def voi(): //内部函数变量
return username
return voi2.数据隐藏
将变量封装在内部函数中，防止外部访问和修改，实现数据私有化。
def hello():
username = '小小奇'
def voi():
return username
return voi
word = hello()
print(word()) 用闭包操作实现，username为局部变量，私有属性用户无法更改，只能获取。
3.保持状态
保存函数当前状态，可以重复使用，但占用内存。
def hello(username):
def voi(stu):
return username+stu
return voi
word1 = hello('小小奇')
word2 = hello ('派大星')
print(word1('吃饭')) //小小奇吃饭
print(word1('喝水')) 小小奇喝水
print(word2('喝水')) 派大星喝水调用word1期间，所有username都是小小奇状态保持不变，调用word2期间，所有username都是派大星保持不变，存在内存中。
3.添加功能
装饰器
4.变量名隔离
同一文件下，不同内部函数可以给相同变量名取不同值，相互不影响。
def hello():
username = '小小奇'
def voi():
return username
return voi
def word():
username = '派大星'
def voi():
return username
return voi二、常用函数
1.sorted() 排序
lists = [2,5,3,6,1,4]
print(sorted (lists)) //[1,2,3,4,5,6]
print(sorted (lists,reverse=True)) //[6,5,4,3,2,1]2.filter() 过滤
def get_data(x):
return x%2==0 //布尔型数据
print(list(filter (get_data,range(1,101))))3.reduce() 累积操作
from functools import reduce
reduce(函数, 操作对象（可选初始值）)
def get_data(x,y):
return x+y
print(list(reduce (get_data,range(1,101)))) //累加值4. map() 队列
map(函数, 操作对象) 将函数应用于每一个操作对象
def get_data(x):
return x**3 //x的3次方
print(list(map(get_data,[1,2,3]))) //[1,8,27]5.reversed() 反转顺序
lists = [1,2,3,4,5]
print(list(reversed(lists))) //[5,4,3,2,1]6.lambda 匿名函数
get_data = lambda x:x**3
print(get_data(3)) product = reduce(lambda x, y: x + y, range(1,101))
print(product) numbers = [1, 2, 3]
product = map(lambda x: x**3, numbers)
print(list(product)) 三、类和实例
1.类的定义
class Student(object):2.类的属性
没有继承其他类的时候object可以省略
class Student(object): //Studunt类
name = '小小奇' //类属性user
def __init__(self,play): //构造函数
self.play = play //实例属性play
stu1 = Student('吃饭') //类的实例化
stu2 = Student('喝水') //实例stu与self绑定
print(stu1.name,stu1.play) //小小奇 吃饭
print(stu2.name,stu2.play) //小小奇 喝水
print(Student.name) //小小奇类只能调用类属性，实例可以调用实例和类属性
1.查看属性和方法
dir（）
my_list = [1, 2, 3]
print(dir(my_list)) //查看my_list的所有属性和方法2.获取/设置/判断属性
getattr/setattr/hasattr
class Animal:
def run(self):
print('runing')
def __init__(self):
self.name = '狗'
self.age = '2'
class Dog(Animal):
pass
dog = Dog()
print(getattr(dog,'name')) //获取name属性值
setattr(dog,'age','3') //设置age属性值为3
print(getattr(dog,'age'))
print(hasattr(dog,'name')) //判断是否拥有name属性
print(getattr(dog,'area','beijing')) //如果获取不到area属性值，返回beijing3.方法
1.实例方法
构造方法 __init__
class Student(object):
name = '小小奇'
def __init__(self,play):
self.play = play
def say(self): //实例方法
print('{}要适量'.format(self.play))
stu1 = Student('吃饭')
stu2 = Student('喝水')
stu1.say() //吃饭 要适量
stu2.say() //喝水 要适量2.类方法
实例可调用 ：stu1.say()
class Student(object):
name = '小小奇'
@classmethod
def say(cls): //cls是类本身
print('吃饭')
Student.say()
3.静态方法
实例可调用 ：stu1.say()
class Student(object):
name = '小小奇'
@staticmethod
def say(): //没有参数
print('吃饭')
Student.say() //吃饭4.封装
1.修改属性值
stu1 = Student('吃饭')
print(stu1.play)
stu1.play = '跳舞'2私有属性
类的内部函数可以调用，外部无法直接访问，无法继承。
class Student(object):
name = '小小奇'
def __init__(self,play):
self.__play = play
self.__say =say1.调用
此时外部调用名被更改为Student.__play,所以用__play无法调用，更改变量名仍可以调用，所以并不是真正的私有。
class Student(object):
name = '小小奇'
def __init__(self,play):
self.__play = play
self.__say =say
stu = Student('吃饭')
print(stu.Student__play) //更改变量名调用2.更改私有属性值
class Student(object):
name = '小小奇'
def __init__(self,play):
self.__play = play
self.__say =say
stu = Student('吃饭')
stu._Student__play = '喝水' //更改私有属性变量值
print(stu.Student__play) 5.继承和多态
1.继承
class Animal: //父类
def run(self):
print('runing')
def __init__(self,name):
self.__name = name //私有属性，子类无法访问和继承
class Dog(Animal): //Dog类继承自Animal类
pass
dog = Dog()
dog.run() 2.多重继承
class Animal:
@staticmethod
def cs():
return '胎生'
class Run:
@staticmethod
def run():
return '能跑'
class Dog(Animal, Run): //继承了Animal类和Run类
def ms(self):
print('狗是{}并且{}'.format(self.cs(), self.run()))
dog = Dog()
dog.ms()
3.多态
子类方法与父类相同时，调用子类方法，覆盖父类方法。
函数不变，通过直接添加子类来增加内容，类中方法不变。
class Animal: //父类
def run(self):
print('runing')
class Dog(Animal): //Dog类继承自Animal类
def run(self):
print('Dog is runing')
class Cat(Animal): //Cat类继承自Animal类
def run(self):
print('Cat is runing')
def runclass(obj):
obj.run()
runclass(Animal()) //runing
runclass(Dog()) //Dog is runing
runclass(Cat()) //Cat is runing
6.实例判断
1.type 数据类型
print(type(5)) //<class 'int'>2.isinstance() 继承关系
class Animal:
def run(self):
print('runing')
class Dog(Animal):
pass
dog = Dog()
print(isinstance(dog,Dog)) //判断dog类是否属于Dog类 True
print(isinstance(dog,Animal))