python （pycharm）第五章 面向函数

一、匿名函数

和函数的作用一致，都是进行代码逻辑的封装，

区别1 在定义时，匿名函数可以不指定函数的名字

区别2 匿名函数执行实现简单的计算

区别3 匿名函数会自动将计算的结果返回

定义格式

#lambda 参数1,参数2...:计算逻辑(参数的处理逻辑)

# 匿名函数的使用
# 加法计算功能
def add(a,b):
    data = a+b
    return data

res = add(12,15)
print(res)

# 使用匿名函数实现
# 定义匿名函数时，需要指定一个变量接收
f = lambda a,b:a+b

# 使用变量调用匿名函数
print(type(f))
res2 = f(20,30)
print(res2)

使用场景

• 1-进行简单的数据计算

• 2-匿名函数当成参数进行传递，实现对数据的处理

  匿名函数成参数使用

  rdd = [1,2,3,4,5,6]

  def reduce(f): # f = lambda a,b:a+b
  # f参数 接收一个累加计算的函数计算的函数
  # 实现数据的遍历过程
  init = 0
  for i in rdd:
  # 遍历数据时进行数据的sum求和
  # 实际的pyspark开发中，sum求和的计算不在reduce中实现，由开发人员自己编写计算逻辑
  # init = init+i
  init= f(init,i)
  return init

  开发人员在调用reduce函数编写数据的累加计算逻辑

  res= reduce(lambda a,b:a+b)
  print(res)

二、面向对象介绍

面向对象开发的三大特性

• 封装

  • 对问题的归纳总结，封装为一个类

• 继承

  • 对已经封装的类进行继承，在原来类的基础上可以再次增加新的内容

  • 人类的操作

    • 性别，年龄，地址。。

    • 上班

    • 学习

    • 吃饭

  • 继承人类 原来的数据和行为都会被继承下来

    • 性别，年龄，地址,手机号，收入

    • 上班

    • 学习

    • 吃饭

    • 睡觉

    • 玩游戏

• 多态

  • 同一个方法实现不同的操作

  • 吃饭

    • 吃炒饭

    • 吃炒面

    • 吃盖浇饭

面向对象的特性中，主要使用的是封装

继承和多态可以根据实际需求选择使用

三、类的构成

格式

• 关键字 class

  class 类名:
  属性
  name = '张三'

    方法
    def eat(self):
        
    def paly_game(self):
  

  调用类创建对象

  object = 类名() # 当前对象就是张三

  执行某个行为

  object.eat()

  object.paly_game()

  类的定义

  原来类的定义方式

  class Student:
  # 类属性
  name = None
  age = None

    # 方法
    def func(self):
        print('方法')
        # 处理属性数据
        print(self.name)
        print(self.age)
  

  使用类创建对象

  s_obj = Student()

  使用对象对数据进行赋值

  s_obj.name = '张三'
  s_obj.age = 20

  创建多个对象

  s_obj2 = Student()
  s_obj2.name = '李四'
  s_obj2.age = 20

  使用类的方法进行数据处理

  s_obj.func()

  s_obj2.func()

四、面向开发的基本使用

根据需求定义类

• 关键字class

• 属性

  • 变量

• 方法

  • 函数

  • 默认函数中必须有个self参数

  • self(自己)代表当前对象

如何将一项物品放入一个空间内?

# 使用面向对象方式开发程序

class Loading:
    # 属性
    name = None
    container = None

    # 方法
    def open_func(self):
        print(f'打开{self.container}')

    def load_func(self):
        print(f'把{self.name}放入{self.container}中')

    def close_func(self):
        print(f'关闭{self.container}')


l = Loading()
# 指定数据
l.name = '大象'
l.container = '冰箱'
# 执行数据处理方法
l.open_func()
l.load_func()
l.close_func()

# 如何把老虎关进笼子？
l2 = Loading()
l2.name='老虎'
l2.container='笼子'
# 执行数据处理方法
l2.open_func()
l2.load_func()
l2.close_func()

五、类中的属性

5-1 属性分类

类属性

class 类名:
    # 类属性定义   name就是一个类属性
    name = None

对象属性

class 类名:
    # 类属性定义   name就是一个类属性
    name = None
    
    def func(self):
        # age是对象属性
        self.age = None

两种属性的区别

# 类中属性使用区别
class A:
    # 类属性 
    name = '张三'

    def func(self):
        # 对象属性
        self.age = 20



# 使用类创建对象
a = A()
# 使用对象获取类属性值和对象属性值
print(a.name)
a.func() # 执行方法定义对象属性
print(a.age)

# 直接使用类名字获取属性值

print(A.name)
print(A.age)# 类名不能直接获取对象数据的值

5-2 属性值的获取

类的外部获取

# 类中属性使用区别
class A:
    # 类属性 
    name = '张三'

    def func(self):
        # 对象属性
        self.age = 20



# 使用类创建对象
a = A()
# 使用对象获取类属性值和对象属性值
print(a.name)
a.func() # 执行方法定义对象属性
print(a.age)

# 直接使用类名字获取属性值

print(A.name)
print(A.age)# 类名不能直接获取对象数据的值

类的内部获取

使用self获取属性值进行操作

# 类的属性值获取
class A:
    # 类属性定义
    stu = {}

    # 在类的方法中操作属性数据
    def func(self):
        self.age = 20


    def func2(self):
        # 操作类属性
        self.stu['address'] = '北京'
        # 操作对象属性
        self.age = 25



# 使用类创建对象
a = A()
# 类的外部获取属性值
print(a.stu)
# 类的外部修改属性值
a.stu['name'] = '张三'
a.stu['gender'] = '男'
del a.stu['name']
# 再次获取属性
print(a.stu)
 
# 外部获取对象属性值
a.func()
print(a.age)

print('--------------')
# 调用方法2在类的内部处理属性值
a.func2()
print(a.stu)
print(a.age)

六、self的说明

# self 的说明
class Student:
    name = None
    age = None

    def comment(self):
        """
            自我介绍方法
        :return:
        """
        # 使用self来确认当前对象是谁
        print(f'我叫{self.name},年龄{self.age}岁')
        print(self)

# 使用类创建对象
s1 = Student()
s1.name = '张三'
s1.age = 20

s2 = Student()
s2.name = '李四'
s2.age = 25

# 两个对象调用相同方法
s1.comment() # s1对象调用方法 那么方法中slef就是s1对象
s2.comment() # s2对象调用方法 那么方法中slef就是s2对象

七、类的方法

• 魔法方法

  • 类中自带的方法

  • __init__()

    • 在创建类对象时会调用的方法

  • __str__()

    • 在对对象进行print输出时调用

  • __del__()

    • 在删除对象时会被调用

  • ......

• 自定义方法

  • 用户自己编写的方法

    init魔法方法的使用

    class A:

    # 魔法方法
    def __init__(self):
        print('创建对象调用')
    
    # 自定义方法
    def func(self):
        print('自定义方法，需要创建对象后，使用对象调用才会执行')
    

    创建对象会调用init方法

    a1 = A()

    使用对象调用func方法

    a1.func()

7-1 魔法方法使用

# 类中的魔法方法
class A:
    # 类属性
    name = None

    # 使用魔法方法 格式是固定的
    # init 初始化方法 创建对象时会被自动执行
    def __init__(self):
        print('init被调用执行')


    def __del__(self):
        # 对象被销毁删除时会被自动执行
        print('del被调用执行')


    def __str__(self):
        # 当对象被print输出时，会将str中返回值进行输出
        return self.name


# 创建对象
a = A()
# 手动删除对象
# del a
# 输出对象
a.name = '张三'
# print时会自动调用str方法，获取返回值
print(a)
# 程序结束 对象会被自动删除
print('程序结束')

7-2 init魔法方法的传参

# init方法的传参

class A:
    # name = None

    # 可以使用init方法，在创建对象时给属性赋值
    # 通过init的参数赋值
    def __init__(self,name,age,gender='男'):
        # 定义对象属性
        self.name = name
        self.age = age
        self.gender = gender

# 使用类创建对象,在括号内传递init的参数数据
a = A('李四',20,'男')
# 在生成对象后才对属性赋值
# a.name = '张三'

# 直接获取属性值
print(a.name)
print(a.age)
print(a.gender)

a1 = A(name='王五',gender='男',age=22)
print(a1.name)