2024-06-06 闭包、常用函、类和实例

一、闭包

1.定义

闭包是一个函数内部定义的内部函数，且可以访问外部函数的变量。常用与数据隐藏和信息封装。

def hello():
    username = '小小奇'
    def voi():                  //内部函数变量
        return username
    return voi                  //外层函数返回内层函数

print(hello()())                //函数套函数返回username

2.数据隐藏

将变量封装在内部函数中，防止外部访问和修改，实现数据私有化。

def hello():
    username = '小小奇'
    def voi():                  
        return username
    return voi
      
print(hello()())             

用闭包操作实现，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 匿名函数

没有return

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属性值，返回beijing

3.方法

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.单例模式

__new__是Python中的特殊方法之一，用于在创建对象时分配内存空间。通常情况下，不需要重写，单例模式需要重写该方法。

4.封装

1.修改属性值

stu1 = Student('吃饭')
print(stu1.play)

stu1.play = '跳舞'

2私有属性

类的内部函数可以调用，外部无法直接访问，无法继承。

class Student(object):
    name = '小小奇'
    def __init__(self,play):
        self.__play = play
        self.__say =say

1.调用

此时外部调用名被更改为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))