自学python所记（十）

14.20、函数传参中的拆包

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(*my_list)  # my_sum(1,2,3,4)

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

14.21、匿名函数

匿名函数：使用lambda关键字定义的函数
一般成为使用def关键字定义的函数为 标准函数

匿名函数只能书写一行代码
匿名函数返回值不需要return，一行代码(表达式)的结果就是返回值

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

• 语法

  lambda参数：  #这一行代码，称为是表达式
  
  # 匿名函数一般不需要我们主动的调用，一般作为函数的参数使用
  #学习阶段为了查看匿名函数定义的是否正确，可以调用
  # 在定义的时候，将匿名函数的引用保存到一个变量中
  变量 = lambda 参数：一行代码
  # 使用变量进行调用
  变量（）
  

# 1、无参无返回值
def func1():
    print('hello world')


func1()

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


# 2、无参有返回值
def func2():
    return 10


print(func2())

func22 = lambda: 10
print(func22())


# 3、有参无返回值
def sum3(a, b):
    print(a + b)


sum3(1, 2)

sum33 = lambda a, b: print(a + b)
sum33(10, 20)


# 4、有参有返回值
def func4(a, b):
    return a + b


print(func4(2, 3))

func44 = lambda a, b: a + b
print(func44(5, 6))

# 1.定义一个匿名函数可以求两个数的乘积（
#  参数需要两个
func1 = lambda a, b: a * b

print(func1(5, 6))

# 2.定义一个匿名函数，参数为字典，返回字典中键为age的值
# 参数只是一个占位的作用，定义的时候 没有具体的数据值，形参的值实在调用的时候进行传递，此时，形参才有数据
# 形参的类型由实参决定。函数定义时，形参只是一个符号，些什么都可以，想让其时字典类型，只需要保证 实参是字典
func2 = lambda x: x.get('age')
func3 = lambda x: x['age']

my_dict = {'name': '李白', 'age': 12}
print(func2(my_dict))
print(func2(my_dict))

14.22、匿名函数的应用

匿名函数作为函数参数------列表排序

list1=[{'name'：'jh','age':16},{'name'：'js','age':15},{'name'：'jl','age':19}]

list1=[{'name':'jh','age':16},{'name':'js','age':15},{'name':'jl','age':19}]

# 列表的排序，默认是对列表中数据进行比大小，可以对 数字类型和字符串进行比较大小
# 不能对字典进行比较大小，需要使用sort函数中的key这个参数，来指定字典比大小的方法
# key 这个参数，需要传递一个函数，一般是匿名函数，字典的排序，要根据字典的键进行排序
# 匿名函数返回字典的这个键对应的值

列表.sort(key=lambda x:x['键'])

# 根据年龄排序
# list1.sort(key=lambda x:x['age']

list1.sort(key=lambda x:x['age'],reverse=True)
print(list1)

# 说明：匿名函数中的参数是 列表中的数据 在sort函数内部，会调用key这个函数（将列表中每个数据作为实参传递给形参），
# 从列表中的获取函数的返回值，对返回值进行比大小操作（<）

列表.sort(key=lambda x:x['键'])

字符串比大小

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

A < Z < a < z

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

十五、面向对象

15.1、基本介绍

面向对象一种编程思想
1.面向过程
2.面向对象

• 面向过程

  • 关注的是具体步骤的实现，所有功能都自己书写
  • 亲力亲为
  • 定义一个个函数，最终按照顺序调用函数

• 面向对象

  • 关注结果
  • 偷懒
  • 找一个对象（），让对象去处理

15.2、类和对象

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

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

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

• 类

  • 抽象的概念 ， 对 多个 特征和行为相同或相似事物的统称
  • 泛指的（指代多个，而不是具体的一个）

• 对象

  • 具体存在的一个事物，看到见摸得着的

  • 特指的（指代一个）

15.3、类的组成

1.类名（给多个事物起一个名字，在代码中 满足大驼峰命名法（每个单词的首字母大写）

2.属性（事物的特征，即有什么，一般文字中的名词）

3.方法（事物的行为，即做什么事，一般是动词）

15.4、类的抽象（类的设计）

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

需求：小明今年8岁，身高1.58，每天早晨跑完步，会去吃东西

​ 小美今年17岁，身高1.66，小美不跑步，小妹喜欢吃东西

类名：人类（person,people)

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

方法： 跑步（run)  ，吃（eat）

15.5、面向代码的步骤

1.定义类，在定义类之前先设计类

2.创建对象，使用第一步定义的类创建对象

3.通过对象调用方法

15.6、面向对象基本代码的书写

1.定义类

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

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

class 类名：
	# 在缩进中书写的内容，都是类中的代码
	def 方法名（self）  # 就是一个方法
		pass

2.创建对象

创建对象是使用 类名（） 进行创建，即

类名（）  # 创建一个对象，这个对象在后续不能使用
# 创建的对象想要在后续的代码中继续使用，需要使用一个变量，将这个对象保存起来
变量 = 类名（）   # 这个变量保存的是对象的地址，一般可以称为这个变量为对象

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

3.调用方法

对象.方法名（）

例：

列表.sort()
列表.append()

4.案例实现

需求：小猫爱吃鱼，小猫爱喝水
类名：猫类（Cat）
属性：暂无
方法：吃鱼（eat）喝水（drink）

# 需求：小猫爱吃鱼，小猫爱喝水，定义不带属性的类

class Cat:
    #在缩进中书写方法
    def eat(self):  #self 会自动出现，暂不管
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫要喝水')

# 2. 创建对象
blue_cat = Cat()

# 3.通过对象调用类中的方法
blue_cat.eat()
blue_cat.drink()

# 创建对象
black_cat=Cat()
black_cat.eat()
black_cat.drink()

15.7、self的说明

class Cat:
    #在缩进中书写方法
    def eat(self):  #self 会自动出现，暂不管
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫要喝水')
        
1.从函数的语法上讲，self是形参，就可以是任意的变量名，习惯将这个形参写成self
2.self是普通的形参，但在调用的时候没有传递实参值，原因是，python解释器在执行代码的时候，自动将调用的这个方法的对象 传递给了self, 即self 的本质是对象

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

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

class Cat:
    #在缩进中书写方法
    def eat(self):  #self 会自动出现，暂不管
        print(f"{id(self)},self")
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫要喝水')

# 2. 创建对象
blue_cat = Cat()
print(f"{id(blue_cat)},blue_cat")

# 3.通过对象调用类中的方法
blue_cat.eat()
blue_cat.drink()

输出：
2092055696368,blue_cat
2092055696368,self
小猫爱吃鱼
小猫要喝水

15.8、对象的属性操作

添加属性

对象.属性名 = 属性值

• 类内部添加

  在内部方法中，self是对象
  self.属性名 = 属性值
  # 在类中添加属性一般写作 _init_ 方法中
  

  ​

• 类外部添加

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

获取属性

对象.属性名

• 类内部

  在内部方法，self是对象
  self.属性名
  

• 类外部

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

class Cat:
    #在缩进中书写方法
    def eat(self):  #self 会自动出现，暂不管
        print(f"{id(self)},self")

        print(f'小猫{self.name} 爱吃鱼')
        
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫要喝水')

# 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
blue_cat.drink()


# 1852769932272,blue_cat
# 1852769932272,self
# 小猫蓝猫 爱吃鱼
# 小猫要喝水

15.9、魔法方法

 python中有一类方法，以两个下划线开题偶，两个下划线结尾，并且在满足某个条件的情况下，会自动调用，这类方法称为 魔法方法

学习：
1.什么情况下自动调用
2.有什么用，用在哪
3.书写的注意事项

init 方法 **

1.创建对象后自动调用
2.1）给对象添加属性的（初始化方法，构造方法； 
  2）某些代码每次创建代码后，都要执行，就可以将这行代码写在__int__方法
3.注意事项
  1）不要写错
  2）如果init方法中，存在除了self之外的参数，在创建对象的时候必须传实参值

• 不带参数

'''
    猫类，属性 name age showa-info(输出属性信息）

'''

class Cat:

    # 定义添加属性的方法

    def __init__(self):
        self.name = '蓝猫'  # 给对象添加name属性
        self.age = 2   # 给对象添加age属性

    # 下方代码只是为了验证该方法调用，实际代码不要书写

        print('我是__init__，我被调用了')
    #输出属性信息
    def show_info(self):
        print(f'小猫的名字是：{self.name},年龄是：{self.age}')

# 创建对象，不要在自己类缩进中创建

blue_cat  = Cat()
blue = blue_cat  # 不是创建对象
blue.show_info()

• 带参数

'''
    猫类，属性 name age showa-info(输出属性信息）
'''

class Cat:
    # 定义添加属性的方法
    def __init__(self,name,age): # 创建对象后调用
        self.name = name  # 给对象添加name属性
        self.age = age   # 给对象添加age属性

    #输出属性信息
    def show_info(self):
        print(f'小猫的名字是：{self.name},年龄是：{self.age}')

# 创建对象，不要在自己类缩进中创建
blue_cat  = Cat('蓝猫',2)
blue = blue_cat  # 不是创建对象
blue.show_info()

# 创建黑猫
black_cat = Cat('黑猫',3) # 创建对象
black_cat.show_info()

# 小猫的名字是：蓝猫,年龄是：2
# 小猫的名字是：黑猫,年龄是：3

str 方法 *

1。什么情况下调用
 > 使用print（对象）  打印对象的时候 会自动调用
2.有什么用，用在哪
 > 在这个方法中一般书写对象的 属性信息的，即打印对象的时候想要查看什么信息，在这个方法中进行定义
3.书写的注意事项
 > 这个方法必须返回 一个字符串

就是输出信息的

'''
    猫类，属性 name age showa-info(输出属性信息）
'''

class Cat:
    # 定义添加属性的方法
    def __init__(self,name,age):
        self.name = name  # 给对象添加name属性
        self.age = age   # 给对象添加age属性


    def __str__(self):
        # 必须返回一个字符串
        return f'小猫的名字是：{self.name},年龄是：{self.age}'  # 当print时想返回啥就写出啥
# 创建对象，不要在自己类缩进中创建
blue_cat  = Cat('蓝猫',2)
print(blue_cat)

del 方法 0颗*

init__方法，创建对象之后，会自动调用

__del__方法，对象被销毁时，自动调用

调用场景：
1.调用场景，程序代码运行结束 所有对象都被销毁
2.调用场景:直接使用del删除对象（如果对象有多个名字或者多个对象引用引用一个对象，需要把所有的对象都删除

class Demo:
    def __init__(self,name):
        print('我是__init__,我被调用')
        self.name=name
    def __del__(self):
        print(f'{self.name}没了，给他处理后事')

Demo('a')

a = Demo('a')

b= Demo('b')

del a  # 删除销毁 对象
print('代码运行结束')

# 我是__init__,我被调用
# a没了，给他处理后事
# 我是__init__,我被调用
# 我是__init__,我被调用
# a没了，给他处理后事
# 代码运行结束
# b没了，给他处理后事

15.10、案例

• 案例一：

需求：

1.小明体重85.0公斤

2.小名每次跑步会减肥0.5公斤

3.小明每次吃东西体重会增加1公斤

类名：人类（person
属性：姓名（name) 体重（height)
方法:跑步（run) 
    吃东西（eat) 
    添加属性__init__
    属性信息__str__

class Person:
    def __init__(self,name,weight):
        self.name =name
        self.weight=weight

    def __str__(self):
        return f"姓名：{self.name},体重：{self.weight}kg"

    def run(self):
        print(f'{self.name}跑步5km,体重减少')
        # 减体重，即修改属性
        self.weight-=0.5

    def eat(self):
        print(f'{self.weight}体重增加了')
        self.weight+=1

xm = Person('小明',75)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)

输出：
    姓名：小明,体重：75kg
    小明跑步5km,体重减少
    姓名：小明,体重：74.5kg
    74.5体重增加了
    姓名：小明,体重：75.5kg