函数
不定长参数补充-函数调用时的拆包
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))
-
练习
1. 定义一个匿名函数可以求两个数的乘积
2. 定义一个匿名函数, 参数为字典,返回字典中键为 age 的值
# 1. 定义一个匿名函数可以求两个数的乘积 (参数需要两个, )
func1 = lambda a, b: a * b
# 2. 定义一个匿名函数, 参数为字典,返回字典中键为 age 的值
# 参数只是一个占位的作用,定义的时候没有具体的数据值, 形参的值是在调用的时候进行传递,此时,形参才有数据值形参的类型就是由实参来决定的, 在函数定义的时候,参数只是一个符号,写什么都可以, 想让其是字典类型,只需要保证
# 实参是字典即可
func2 = lambda x: x.get('age')func3 = lambda x: x['age']
print(func1(1, 2))
print(func1(3, 2))
my_dict = {'name': '张三', 'age': 18}print(func2(my_dict))
print(func3(my_dict))
-
匿名函数作为函数的参数 - 列表中的字典排序
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)
类名: 狗类(Dog)
属性: 颜色(color) , 名字(name)
方法: 汪汪叫 (bark), 摇尾巴(shake)
面向代码的步骤
1. 定义类, 在定义类之前先设计类
2. 创建对象, 使用第一步定义的类创建对象
3. 通过对象调用方法
面向对象基本代码的书写
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()
Cat() # 是
a = black_cat # 不是
b = Cat # 不是
self 的说明
class Cat:
# 在缩进中书写 方法
def eat(self): # self 会自动出现,暂不管
print('小猫爱吃鱼...')
black_cat.eat()
1. 从函数的语法上讲, self是形参, 就可以是任意的变量名, 只不过我们习惯性将这个形参写作 self
2. self 是普通的形参, 但是在调用的时候没有传递实参值, 原因是, Python 解释器在执行代码的时候, 自动的将调用这个方法的对象 传递给了 self, 即 self 的本质是对象
3. 验证, 只需要确定 通过哪个对象调用, 对象的引用和 self 的引用是一样的
4. self 是函数中的局部变量, 直接创建的对象是全局变量
"""
需求:小猫爱吃鱼，小猫要喝水, 定义不带属性的类
"""
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
魔法方法
python 中有一类方法, 以两个下划线开头,两个下划线结尾,并且在满足某个条件的情况下, 会自动调用, 这类方法称为 魔法方法
学习:
1. 什么情况下自动调用
2. 有什么用, 用在哪
3. 书写的注意事项
__init__ 方法 **
1. 什么情况下自动调用
> 创建对象之后会自动调用
2. 有什么用, 用在哪
> 1. 给对象添加属性的, (初始化方法, 构造方法) 2. 某些代码, 在每次创建对象之后, 都要执行,就可以将这行代码写在 __init__ 方法
3. 书写的注意事项
> 1. 不要写错了 2. 如果 init 方法中,存在出了 self 之外的参数, 在创建对象的时候必须传参
"""
猫类, 属性 name, age , show_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}')
# 创建对象,不要在自己类缩进中创建
# Cat() # 创建对象 ,会输出
blue_cat = Cat('蓝猫', 2)
blue = blue_cat
blue.show_info()
# 创建黑猫
black_cat = Cat('黑猫', 3)
black_cat.show_info()
__str__ 方法 *
1. 什么情况下自动调用
> 使用 print(对象) 打印对象的时候 会自动调用
2. 有什么用, 用在哪
> 在这个方法中一般书写对象的 属性信息的, 即打印对象的时候想要查看什么信息,在这个方法中进行定义的
> 如果类中没有定义 __str__ 方法, print(对象) ,默认输出对象的引用地址
3. 书写的注意事项
> 这个方法必须返回 一个字符串
class Cat:
# 定义添加属性的方法
def __init__(self, n, age): # 这个方法是创建对象之后调用
self.name = n # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
def __str__(self):
# 方法必须返回一个字符串, 只要是字符串就行,
return f'小猫的名字是: {self.name}, 年龄是: {self.age}'
# 创建对象,不要在自己类缩进中创建
# Cat() # 创建对象 ,会输出
blue_cat = Cat('蓝猫', 2)
print(blue_cat)
# 创建黑猫
black_cat = Cat('黑猫', 3)
print(black_cat)
__del__ 方法 [了解]
__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('代码运行结束')