python：函数和面向对象基础

函数

---

不定长参数补充-函数调用时的拆包

def my_sum(*args, **kwargs):
    num = 0 # 定义变量,保存求和的结果
    for i in args:
        num += i

    for j in kwargs.values():
        num += j

    print(num)

# 需求, my_list = [1, 2, 3, 4] 字典 my_dict = {'a':1, 'b': 2, 'c': 3, 'd': 4}
my_list = [1, 2, 3, 4]
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 将字典和列表中的数据使⽤ my_sum 函数进⾏求和, 改如何传参的问题
# my_sum(1, 2, 3, 4)
# my_sum(a=1, b=2, c=3, d=4)
# 想要将列表(元组)中的数据 分别作为位置参数,进⾏传参,需要对列表进⾏拆包操作
# my_sum(*my_list) # my_sum(1, 2, 3, 4)

# 想要将字典中的数据, 作为关键字传参,, 需要使⽤ 使⽤ **对字典进⾏拆包
my_sum(**my_dict) # my_sum(a=1, b=2, c=3, d=4)

匿名函数

匿名函数：就是使用   lambda 关键字定义的函数

⼀般称为使用 def 关键字定义的函数为，标准函数

匿名函数只能书写⼀行代码

匿名函数的返回值不需要 return ，⼀行代码（表达式）的结果就是返回值

使用场景： 作为函数的参数，这个函数比较简单，值使用⼀次，没有必要使用  def 定义

• 语法

lambda 参数 ： ⼀行代码 # 这⼀行代码， 称为是表达式

# 匿名函数⼀般不需要我们主动的调用， ⼀般作为函数的参数 使用的

# 我们在学习阶段为了查看匿名函数定义的是否正确， 可以调用

# 1.  在定义的时候， 将匿名函数的引用保存到⼀个变量中

变量 = lambda 参数 ： ⼀行代码

# 2. 使用变量进行调用

变量 ( )

• 代码

# 1. ⽆参⽆返回值
def func1():
    print('hello world')

func1()
# lambda : print('hello lambda') # 匿名函数的定义
func11 = lambda: print('hello lambda')
func11()

# 2. ⽆参有返回值
def func2():
    return 10

print(func2())
func22 = lambda: 10
print(func22())

# 3. 有参⽆返回值
def my_sum(a, b):
    print(a + b)

my_sum(1, 2)
my_sum11 = lambda a, b: print(a+b)
my_sum11(10, 20)

# 4. 有参有返回值
def func4(a, b):
    return a + b
print(func4(1, 2)) # num = func4(1, 2) 
print(num)
func44 = lambda a, b: a+b

print(func44(10, 20))

• 匿名函数作为函数的参数 - 列表中的字典排序

user_list = [

{ "name" : "zhangsan" , "age" : 18 } , { "name" : "lisi" , "age" : 19 } , { "name" : "wangwu" , "age" : 17 }

]

列表排序 （ 列表中的数字 ） ：

列表 . sort ( ) # 升序

列表 . sort ( reverse = True ) # 降序

列表中的内容都是字典 ， 想要排序 ?

user_list = [
    {"name": "zhangsan", "age": 18},
    {"name": "lisi", "age": 19},
    {"name": "wangwu", "age": 17}
]

# user_list.sort()
# 列表的排序, 默认是对列表中的数据进⾏⽐⼤⼩的, 可以对数字类型和字符串进⾏⽐⼤⼩
# 但是对于字典来说,就不知道该怎么⽐⼤⼩,此时,我们需要使⽤sort函数中的key这个参数, 来指定字典⽐⼤⼩的⽅法
# key 这个参数,需要传递⼀个函数,⼀般是匿名函数, 字典的排序,其实要指定根据字典的什么键进⾏排序, 我们只需要使⽤
# 匿名函数返回字典的这个键对应的值即可
# 列表.sort(key=lambda x: x['键'])
# 根据年龄排序
# user_list.sort(key=lambda x: x['age'])
user_list.sort(key=lambda x: x['age'], reverse=True)
print(user_list)

# user_list.sort(key=lambda x: x['age'])
# 说明: 匿名函数中的参数是 列表中的数据, 在 sort 函数内部,会调⽤ key 这个函数(将列表中每个数据作为实参传递给形参)
# 从列表中的获取函数的返回值, 对返回值进⾏⽐⼤⼩操作(<)

def get_value(x):
    return x['age']
user_list.sort(key=get_value)

• 字符串比大小

字符比大小 ， 是比较字符对应的 ASCII 码值

A < Z < a < z

ord ( 字符 ) # 获取字符对应的 ASCII 的值

chr ( ASCII 值 ) # 获取对应的 字符

字符串比大小：

对应下标位置字符的大小，直到比出大小，如果全部比完了，还没有比出大小，就是相等

 面向对象

---

基本的介绍

面向对象是⼀个编程思想 （ 写代码的套路 ）

编程思想：

1. 面向过程

2. 面向对象

以上两种都属于写代码的套路（方法），最终目的都是为了将代码书写出来，只不过过程和思考方法不太⼀样

• 面向过程
  • 关注的是具体步骤的实现，所有的功能都自己书写
  • 亲力亲为
  • 定义⼀个个函数，最终按照顺序调用函数
• 面向对象
  • 关注的是结果，谁（对象）能帮我做这件事
  • 偷懒
  • 找⼀个对象（），让对象去做

 类和对象

面向对象的 核心思想 是找⼀个对象去帮我们处理事情

在程序代码中 对象是由 类 创建的

类和对象，是面向对象编程思想中非常重要的两个概念

• 类
  • 抽象的概念，对 多个 特征和行为相同或者相似事物的统称
  • 泛指的（指代多个，而不是具体的⼀个）
• 对象
  • 具体存在的⼀个事物，看得见摸得着的
  • 特指的，（指代⼀个）

苹果 ---> 类

红苹果 ----> 类

张三嘴⾥正在吃的那个苹果 ---> 对象

 类的组成

1. 类名（给这多个事物起⼀个名字，在代码中满足大驼峰命名法（每个单词的首字母大写））
2. 属性（事物的特征，即有什么，⼀般文字中的名词）
3. 方法（事物的行为，即做什么事，⼀般是动词）

类的抽象（类的设计）

类的抽象，其实就是找到 类的 类名，属性 和方法

类名 ： ⼈类 ( Person , People )

属性 ： 名字 ( name ) , 年龄 ( age ) , 身高 ( height )

方法 ： 跑步 ( run ) 吃 ( eat )

面向代码的步骤

1. 定义类，在定义类之前先设计类
2. 创建对象，使用第⼀步定义的类创建对象
3. 通过对象调用方法

面向对象基本代码的书写

1.定义类

先定义简单的类，不包含属性，在 python 中定义类需要使用关键字 class

方法：方法的本质是在类中定义的函数，只不过，第⼀个参数是 self

class 类名:

        # 在缩进中书写的内容,都是类中的代码

         def 方法名( self): # 就是⼀个⽅法

                 pass

2.创建对象

创建对象是使用类名 () 进行创建 ， 即

类名 () # 创建⼀个对象， 这个对象在后续不能使用

# 创建的对象想要在后续的代码中继续使用， 需要使用⼀个变量 , 将这个对象保存起来

变量 = 类名 ()         # 这个变量中保存的是对象的地址， ⼀般可以成为这个变量为对象

# ⼀个类可以创建多个对象， 只要出现 类名 () 就是创建⼀个对象， 每个对象的地址是不⼀样的

3.调用方法 

对象 .方 法名 ()

列表 . sort ()

列表 . append ()

self 的说明

class Cat :

        # 在缩进中书写 方法

        def eat ( self ) : # self 会自动出现 ， 暂不管

                print ( '小 猫爱吃鱼 ... ' )

black_cat . eat ()

1. 从函数的语法上讲 ， self 是形参 ， 就可以是任意的变量名 ， 只不过我们习惯性将这个形参写作 self

2. self 是普通的形参 ， 但是在调⽤的时候没有传递实参值 ， 原因是 ， Python 解释器在执行代码的时候 ， 自 动的将调用这个方法的对象传递给了 self ， 即 self 的本质是对象

3. 验证 ， 只需要确定通过哪个对象调用 ， 对象的引⽤和 self 的引⽤是⼀样的

4. self 是函数中的局部变量 ， 直接创建的对象是全局变量

#1.需求:⼩猫爱吃⻥，⼩猫要喝⽔, 定义不带属性的类

class Cat:
    # 在缩进中书写 ⽅法
    def eat(self): # self 会⾃动出现,暂不管
        print(f'{id(self)}, self')
        print('⼩猫爱吃⻥...')

# 2. 创建对象
blue_cat = Cat()
print(f'{id(blue_cat)}, blue_cat')
# 3. 通过对象调⽤类中的⽅法
blue_cat.eat() # blue_cat 对象调⽤ eat ⽅法, 解释器就会将 blue_cat 对象传给 self
print('_*_' * 30)
# 创建对象
black_cat = Cat()
print(f"{id(black_cat)}, black_cat")
black_cat.eat() # black_cat 对象调⽤ eat ⽅法, 解释器就会将 black_cat 对象传给 self

对象的属性操作

添加属性

对象 . 属性名 = 属性值

• 类内部添加

在内部⽅法中 ， self 是对象

self . 属性名 = 属性值

# 在类中添加属性⼀般写在 _ _init __ ⽅法中

• 类外部添加 

 对象.属性名 = 属性值 # ⼀般不使用

获取属性

对象 . 属性名

类内部

在内部方法中 ， self 是对象

self . 属性名

类外部

对象 . 属性名 # ⼀般很少使用

 

class Cat:
    # 在缩进中书写 ⽅法
    def eat(self): # self 会⾃动出现,暂不管
        print(f'{id(self)}, self')
        print(f'⼩猫{self.name} 爱吃⻥...')

# 2. 创建对象
blue_cat = Cat()
print(f'{id(blue_cat)}, blue_cat')
# 给 蓝猫添加 name 属性
blue_cat.name = '蓝猫'
# 3. 通过对象调⽤类中的⽅法
blue_cat.eat() # blue_cat 对象调⽤ eat ⽅法, 解释器就会将 blue_cat 对象传给 self
print('_*_' * 30)
# # 创建对象
black_cat = Cat()
black_cat.name = '⿊猫'
print(f"{id(black_cat)}, black_cat")
black_cat.eat() # black_cat 对象调⽤ eat ⽅法, 解释器就会将 black_cat 对象传给 self