Python基础

目录

1.数据类型

2.类型转化

3.输入

4.格式化输出

5.逻辑运算符

 if else 结构

if elif else 结构 

 6.循环

7.容器 

1字符串

1下标

 2切⽚

3字符串的查找⽅法 find 

 4字符串的替换⽅法 replace

5字符串的拆分 split 

6字符串的链接 join 

8列表 

 1列表⽀持下标和切⽚, ⻓度

 2查找 - 查找列表中数据下标的⽅法

3查找 - 判断是否存在 

4查找 - 统计出现的次数 

 5添加数据的⽅法

6指定下标位置添加 

7列表合并 

8修改操作

9删除操作 

1根据下标删除

2根据数据值删除

3列表的反转(倒置)

4列表的排序

10列表去重 

9元组

1常⽤⽅法： 

 10字典

1增加和修改操作 

2 删除

3查询- 根据键获取对应的值 

 4字典的遍历

1对 字典的键 进⾏遍历

2对 字典的值 进⾏遍历

3对 字典的键值对 进⾏遍历 

11函数

1交换两个变量的值 

2拆包和组包

  3局部变量和全局变量

1局部变量

2全局变量 

4返回值- 函数返回多个数据值 

 11函数参数

1函数传参的⽅式

2Print 函数的解析 

---

---

1.数据类型

2.类型转化

3.输入

使⽤的函数是 input() 变量 = input('提示的信息')

1. 代码从上到下执⾏, 遇到 input 函数之后,会暂停执⾏,等待 ⽤户的输⼊, r如果不输⼊会⼀直等待

2. 在输⼊的过程中,遇到回⻋,代表本次输⼊结束

3. 会将你输⼊的内容 保存到等号左边的变量中, 并且 变量的数 据类型 ⼀定是 str

4.格式化输出

1.%d 占位, 填充 整型数据 digit  2.%f 占位. 填充 浮点型数据 float 3.%s 占位, 填充 字符串数据 string

# 定义变量 姓名 年龄 身⾼
name = '⼩明' # 可以使⽤ input 输⼊
age = 18 # 可以使⽤ input 输⼊
height = 1.71 # 可以使⽤ input 输⼊
 
# 要求按照以下个数输出个⼈信息
# 我的名字是 xx, 年龄是 xx, 身⾼是 xx m
# 使⽤格式化输出实现
# print('我的名字是 name, 年龄是 age, 身⾼是 height 
m')
print('我的名字是 %s, 年龄是 %d, 身⾼是 %f m' % 
(name, age, height))
# ⼩数默认显示 6 位, 如果想要指定显示⼩数点后⼏位, 
%.nf , n 需要换成具体的整数数字,即保留⼩数的位置
print('我的名字是 %s, 年龄是 %d, 身⾼是 %.2f m' % 
(name, age, height)) # 两位⼩数
print('我的名字是 %s, 年龄是 %d, 身⾼是 %.1f m' % 
(name, age, height)) # ⼀位⼩数
 
# 补充
stu_num = 1 # 学号
# 我的学号是 000001
print('我的学号是%d' % stu_num)
# %0nd n 需要换成具体的整数数字, 表示整数⼀共占⼏位
print('我的学号是%06d' % stu_num)
 
num = 90 # 考试的及格率
# 某次考试的及格率为 90%, 如果在 格式化中需要显示%, 
在书写的使⽤ 需要使⽤ 两个 %% 才可以
print('某次考试的及格率为 %d%%' % num)

F-string( f字符串的格式化⽅法) 

name = '⼩明' # 可以使⽤ input 输⼊
age = 18 # 可以使⽤ input 输⼊
height = 1.71 # 可以使⽤ input 输⼊
stu_num = 1 # 学号
num = 90 # 及格率
 
# print('我的名字是 xx, 年龄是 xx, 身⾼是 xx m, 学号 
xx, 本次考试的及格率为 xx%')
print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是 
{height} m, 学号 {stu_num}, 本次考试的及格率为 
{num}%')
# ⼀般不会有这样的需求
print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是 
{height:.3f} m, 学号 {stu_num:06d}, 本次考试的及格
率为 {num}%')
 
# 在字符串中想要输出换⾏ \n (转义字符)
print(f'我的名字是 {name}, 年龄是 {age}, 身⾼是 
{height:.3f} m, 学号 {stu_num:06d},\n本次考试的及格
率为 {num}%')

5.逻辑运算符

and  逻辑与 和,并且  and 连接两个条件,都必须为 True, 整体结果才为 True, 即一假为假 (当第一个条件为 False 的时候,第二个条件就不再判断) or  逻辑或  或者    or 连接的两个条件, 只要有一个条件为 True , 整体结果就为 True, 即 一真为真 (当第 一个条件为 True的时候,第二个条件就不再判断) not 逻辑非  取反    not 后边的条件, 如果本来是 True,变为 False, 本来是 False,变为 True 

6.if 的基本结构

if 判断条件:    

  书写条件成立(真),执行的代码   

  书写条件成立(真),执行的代码

if int(age) >= 18:  # 字符串和 int 类型不能比大小, 先类型转换,再比大小
    # 3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲为了'
    print('满 18 岁了,可以进入网吧为所欲为了')

 if else 结构

# 1. 使用 input 获取用户的年龄, 类型是 str
age = input('请输入你的年龄:')
# 2. 判断年龄是否满足 18 岁
if int(age) >= 18:  # 字符串和 int 类型不能比大小, 先类型转换,再比大小
    # 3. 如果年龄大于等于(满足)18 岁, 输出 '满 18 岁了,可以进入网吧为所欲为了'
    print('满 18 岁了,可以进入网吧为所欲为了')
# 4. 如果不满足, 输出 '不满 18 岁,回去写作业吧'
else:
    print('不满 18 岁,回去写作业吧')

if elif else 结构 

 6.循环

for 变量 in range(n):
 重复执⾏的代码
 
# 1, range() 是 Python 中的函数, 作⽤使⽤可以⽣成 
[0, n) 之间的整数, 不包含 n 的 , ⼀个有 n 个数字, 所
以这个循环循环 n 次
# 2, 想让 for 循环循环多少次,n 就写⼏
# 3, 变量的值 也是每次循环从 [0, n) 取出⼀个值, 第⼀
次取得是 0 ,最后⼀次取得是 n-1



# 需求: 使⽤ for 循环获取 5 到 10 之间的数字
for 变量 in range(a, b):
 重复的代码
 
# range(a, b) 作⽤是⽣成 [a, b) 之间的整数数字, 不
包含 b

7.容器 

1字符串

定义: 使⽤引号(单引号, 双引号, 三引号)引起来的内容就是字 符串

1下标

下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是 下标 这个编号⼀般来说都是从左到右进⾏编号的, 从 0 开始的 (Python 中⽀持负数下标,从右到左进⾏编号的, 从-1 开始)

str1 = 'abcdefg'
 
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a
 
# 2. 打印最后⼀个位置的数据
print(str1[-1]) # g
 
# 3. 打印倒数第⼆个位置的字符
print(str1[-2]) # f

 2切⽚

语法: 字符串[start:end:step]

start 是开始位置的下标, end 是结束位置的下标(注意,不能取 到这个位置的字符) step 步⻓,等差数列的差值, 所取的相邻字 符下标之间的差值,默认是 1, 可以不写

# 切⽚会得到⼀个字符串, 即可以获取字符串中的多个字符
 
str1 = 'abcdefg'
 
# 1. 获取 abc 字符
print(str1[0:3:1]) # abc
# 1.1 如果步⻓是 1 可以不写, 最后⼀个冒号也不写
print(str1[0:3]) # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3]) # abc
 
# 2. 获取 efg 字符
print(str1[4:7]) # efg
print(str1[-3:7]) # efg
# 2.1 如果最后⼀个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:]) # abcdefg
 
# 3. 获取 aceg # 0 2 4 6, 所以步⻓为 2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
 
 
# 4. 特殊应⽤, 步⻓为负数, 开始和结束不写,意思全变, ⼀般
不⽤管,只有⼀种使⽤场景
# 反转(逆置) 字符串 字符串[::-1]
print(str1[::-1]) # gfedcba

3字符串的查找⽅法 find 

str1 = "and itcast and itheima and Python"
 
# 在字符串中查找 and
num = str1.find('and')
print(num) # 0
 
# 在字符串中查找 第⼆个 and 出现的下标, 从第⼀次出现的后⼀位开始找
num1 = str1.find('and', num+1)
print(num1) # 11
 
# 在字符串中查找 第三个 and 出现的下标, 从第⼆次出现的后⼀位开始找
num2 = str1.find('and', num1+1)
print(num2) # 23
 
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后⼀位开始找
num3 = str1.find('and', num2+1)
print(num3) # -1

 4字符串的替换⽅法 replace

str1 = 'good good study'
 
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study
# 2. 将 str1 中第⼀个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
 
# 3. 将 str1 中第⼆个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第⼀个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study

5字符串的拆分 split 

str1 = "hello world and itcast and itheima and Python"
# 1. 将 str1 按照 and 字符进⾏拆分
result1 = str1.split('and')
print(result1) # ['hello world ', ' itcast ', ' 
itheima ', ' Python']
 
# 2, 将 str1 按照 and 字符进⾏拆分, 拆分⼀次
result2 = str1.split('and', 1)
print(result2) # ['hello world ', ' itcast and 
itheima and Python']
 
# 3. 按照空⽩字符进⾏切割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and', 
'itcast', 'and', 'itheima', 'and', 'Python']
 
# 4. 按照空⽩字符进⾏切割, 拆分⼀次
result4 = str1.split(maxsplit=1)
print(result4)

6字符串的链接 join 

 

list1 = ['good', 'good', 'study']
 
# 1. 将 列表中的字符串使⽤空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
 
# 2. 将 列表中的字符串使⽤ and 连起来
str2 = ' and '.join(list1)
print(str2) # good and good and study

8列表 

列表 list, 是使⽤最多的⼀种容器(数据类型)

列表中可以存储多个数据, 每个数据之间使⽤逗号隔开

列表中可以存放任意类型的数据

# 1. 类实例化的⽅式(不常⽤)
# 1.1 定义空列表(没有任何数据的列表)
# 变量 = list()
list1 = list()
print(type(list1), list1) #  []
 
# 1.2 类型转换 list(容器) 将其他的容器转换为列表
# 转换字符串会将字符串中的每个字符作为⼀个数据存⼊到列表
中
list2 = list('hello')
print(type(list2), list2) #  ['h', 'e', 'l', 'l', 'o']
 
# 2, 直接使⽤ [] 进⾏定义(常⽤)
# 2.1 定义空列表
my_list = []
print(my_list) # []
 
# 2.2 定义⾮空列表
my_list1 = [1, '⼩明', 3.14, False]
print(my_list1) # [1, '⼩明', 3.14, False]

 1列表⽀持下标和切⽚, ⻓度

列表⽀持下标和切⽚操作, 使⽤⽅法和字符串中的使⽤⽅法⼀致 区别: 列表的切⽚得到的是列表

list1 = ['⼩明', 18, 1.71, True]
 
# 获取第⼀个数据,名字
print(list1[0])
 
# 获取最后⼀个数据
print(list1[-1])
 
# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]
 
# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 4 

 2查找 - 查找列表中数据下标的⽅法

3查找 - 判断是否存在 

4查找 - 统计出现的次数 

统计出现的次数,使⽤的是 count() ⽅法 列表.count(数据) # 返回 数据出现的次数

my_list = [1, 3, 5, 7, 2, 3]
# 找 数据 3 出现的下标
num = my_list.index(3)
print(num) # 1
 
# 找 数据 4 出现的下标
# num1 = my_list.index(4) # 代码会报错
if 4 in my_list:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')
 
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')

 5添加数据的⽅法

6指定下标位置添加 

7列表合并 

my_list = []
print(my_list) # []
 
# 1. 想列表中添加数据 郭德纲
my_list.append('郭德纲')
No. 22 / 24
更多资源，百度“黑马软件测试学习路线图” bbs.itheima.com/thread-405757-1-1.htmlprint(my_list) # ['郭德纲']
 
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']
 
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list) # ['郭德纲', '岳岳', '郭麒麟']
 
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟']
 
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟', 
'孙越', '烧饼']
 
# 将 list1 作为⼀个整体添加到 my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟', 
'孙越', '烧饼', ['孙越', '烧饼']]

8修改操作

# 定义列表
my_list = [1, 3, 5, 7]
 
# 1. 想要将下标为 1 的数据修改为 22
my_list[1] = 22
print(my_list) # [1, 22, 5, 7]
 
# 修改最后⼀个位置的数据, 改为 'hello'
my_list[-1] = 'hello'
print(my_list) # [1, 22, 5, 'hello']
 
# 2. 如果指定的下标不存在, 会报错的
# my_list[10] = 10 # 代码会报错

9删除操作 

1根据下标删除

2根据数据值删除

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 1. 删除最后⼀个位置的数据
num = my_list.pop()
print('删除的数据为:', num)
print(my_list) # [1, 3, 5, 7, 9, 2, 4, 6, 8]
 
# 2. 删除下标为 1 的数据 3
my_list.pop(1)
print(my_list) # [1, 5, 7, 9, 2, 4, 6, 8]
 
# 3. 删除数据为 7 的数据
my_list.remove(7) # 注意, 如果列表中有多个 7, 只能删除
第⼀个, 如果数据不存在,会报错的
print(my_list) # [1, 5, 9, 2, 4, 6, 8]

3列表的反转(倒置)

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 使⽤切⽚的⽅法反转, 会得到⼀个新列表
 
list1 = my_list[::-1]
print('my_list:', my_list)
print('list1 :', list1)
 
# 使⽤ reverse ⽅法, 直接修改原列表
my_list.reverse()
print('my_list:', my_list)

4列表的排序

my_list = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
 
# 升序排序
my_list.sort()
print(my_list)
 
# 降序排序
my_list.sort(reverse=True)
 
print(my_list)

10列表去重 

my_list = [3, 2, 4, 1, 2, 3, 3, 2, 1, 2, 3, 1]
# print(list(set(my_list)))
#
# new_list = list(set(my_list))
# print(new_list)
 
new_list = []
# for i in my_list:
# # 判断新列表中是否存在 i
# if i in new_list:
# # 存在
# pass # continue
# else:
# new_list.append(i)
 
for i in my_list:
 if i not in new_list:
 new_list.append(i)
 
print(new_list)

9元组

1常⽤⽅法： 

# 1, 类实例化的⽅式
# 1.1 定义空元祖(不会使⽤的)
my_tuple1 = tuple()
print(type(my_tuple1), my_tuple1) #  
()
# 1.2 类型转换
# 可以将列表转换为元组, 只需要将 [], 变为 (), 同时 可以
将元组转换列表 , 将() 变为 []
my_tuple2 = tuple([1, 2, 3])
print(my_tuple2) # (1, 2, 3)
# 转换字符串, 和列表中⼀样,只是将列表的[] 变为()
my_tuple3 = tuple('hello')
print(my_tuple3) # ('h', 'e', 'l', 'l', 'o')
 
# 2. 直接使⽤ () 定义
my_tuple4 = (1, "⼩王", 3.14, False)
print(my_tuple4)
# 3. 特殊点, 定义只有⼀个数据的元组时, 数据后边必须有⼀
个逗号
my_tuple5 = (1,)
print(my_tuple5) # (1,)
 
print(my_tuple4[1]) # ⼩王

 10字典

# 2. 直接使⽤{} 定义
# 2.1 空字典
my_dict1 = {}
print(type(my_dict1), my_dict1) #  {}
 
# 2.2 ⾮空字典, ⼩明('name') 18('age') 1.71('height') 
True(is_men) 抽烟 喝酒 烫头('like')
my_dict2 = {"name": "⼩明", "age": 18, "height": 
1.71, "is_men": True, "like": ["抽烟", "喝酒", "烫
头"]}
 
print(my_dict2)
print(len(my_dict2)) # 5

1增加和修改操作 

 

# 定义字典 ⼩明 18 爱好
my_dict = {"name": "⼩明", "age": 18, "like": ['抽烟', '喝酒', '烫头']}
 
print(my_dict) # {'name': '⼩明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头']}
# 1. 添加性别信息 sex
my_dict['sex'] = '男'
print(my_dict) # {'name': '⼩明', 'age': 18, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
 
# 2. 修改年龄为 19
my_dict['age'] = 19
print(my_dict) # {'name': '⼩明', 'age': 19, 'like': ['抽烟', '喝酒', '烫头'], 'sex': '男'}
 
# 3. 添加⼀个爱好, 学习--> 本质是向列表中添加⼀个数据
my_dict['like'].append('学习')
print(my_dict) # {'name': '⼩明', 'age': 19, 
'like': ['抽烟', '喝酒', '烫头', '学习'], 'sex': '男'}

2 删除

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽
烟', '喝酒', '烫头', '学习'], 'sex': '男'}
 
# 删除 sex 键值对
del my_dict['sex']
print(my_dict) # {'name': '⼩明', 'age': 19, 
'like': ['抽烟', '喝酒', '烫头', '学习']}
 
# 字典.pop('键')
my_dict.pop('age')
print(my_dict) # {'name': '⼩明', 'like': ['抽烟', 
'喝酒', '烫头', '学习']}
 
# 删除抽烟的爱好 ---> 本质操作是在列表中删除 数据值
# my_dict['like'].pop(0)

3查询- 根据键获取对应的值 

my_dict = {'name': '⼩明', 'age': 19, 'like': ['抽
烟', '喝酒', '烫头', '学习']}
 
# 1. 获取 名字
print(my_dict['name']) # ⼩明
print(my_dict.get('name')) # ⼩明
print(my_dict.get('name', 'zzz')) # ⼩明
 
# 2. 获取 sex 性别
# print(my_dict['sex']) # 代码会报错, 原因 key 不存
在
 
print(my_dict.get('sex')) # None
print(my_dict.get('sex', '保密')) # 保密
 
# 3. 获取 第⼆个爱好
print(my_dict['like'][1]) # 喝酒
print(my_dict.get('like')[1]) # 喝酒

 4字典的遍历

1对 字典的键 进⾏遍历

2对 字典的值 进⾏遍历

3对 字典的键值对 进⾏遍历 

# 定义字典
my_dict = {'name': '⼩明', 'age': 18, 'sex': '男'}
 
# 1. 遍历字典的键
for k in my_dict:
 print(k)
 
for k in my_dict.keys():
 print(k)
 
print('-' * 30)
 
# 2. 遍历字典的值
for v in my_dict.values():
 print(v)
 
print('*' * 30)
 
# 3. 遍历键值
for k, v in my_dict.items():
print(k, v)

11函数

1交换两个变量的值 

a = 10
b = 20
# ⽅法⼀: 常规⽅法 引⼊第三个变量
# c = a # 将 变量 a 中的值先保存起来 10
# a = b # 将变量 b 中的值 给 a
# b = c # 将变量 c中的值(即最开始 a 的值) 10 给 b
# print(a, b)
 
# ⽅法⼆, 不使⽤第三个变量, 使⽤数学中的⽅法
# a = a + b # a 的值 30
# b = a - b # 30 - 20 ===> 10
# a = a - b # 30 - 10 ===> 20
# print(a, b)
 
# ⽅法三, 重点掌握, Python 特有
a, b = b, a
print(a, b)

2拆包和组包

# 组包
c = b, a # 组包
print(type(c), c) #  (10, 20)
 
# 拆包
a, b = c
print(a, b)
 
x, y, z = [1, 2, 3]
print(x, y, z)

  3局部变量和全局变量

1局部变量

 

def func1():
 num = 10 # num 就是局部变量
 print(f"func1 函数中 {num}")
def func2():
 num = 100 # 可以在不同函数中定义名字相同的局部变
量,没有影响
 print(f"func2 函数中 {num}")
 
 
func1() # 10
func2() # 100
func1() # 10

2全局变量 

 

g_num = 10 # 全局变量
def func1():
 print(f'func1 中 {g_num}') # 在函数中可以读取全局
变量的值
 
 
def func2():
 g_num = 20 # 定义局部变量, 不会影响全局变量
 print(f'func2 中 {g_num}')
 
 
def func3():
 global g_num # 这个函数中使⽤的 g_num 都是全局变
量, 写在函数的第⼀⾏
 g_num = 30 # 修改了全局变量
 print(f'func3 中 {g_num}')
 
 
# func1() # 10
# func2() # 20
# func1() # 10
# func3() # 30
# func1() # 30
print(g_num)

4返回值- 函数返回多个数据值 

 

def calc(a, b):
 num = a + b
 num1 = a - b
 return num, num1
 
 
# 写法⼀
result = calc(10, 5)
print(result, result[0], result[1])
 
# 写法⼆, 直接拆包
x, y = calc(20, 10)
print(x, y)

 12函数参数

1函数传参的⽅式

def func(a, b, c):
 print(f'a: {a}, b: {b}, c: {c}')
 
 
# 位置传参
func(1, 2, 3)
 
# 关键字传参
func(a=2, b=3, c=1)
 
# 混合使⽤
func(1, 3, c=5)

2Print 函数的解析 

# print()
# sep=' ', 多个位置参数之间的间隔
# end='\n' 每⼀个 print 函数结束, 都会打印的内容 结束符
print(1, end=' ')
print(2, end=' ')
print(3)
 
print(1, 2, 3, 4, 5, 6, sep='_')
print(1, 2, 3, 4, 5, 6, sep='_*_')

3匿名函数

 

# 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))

13面向对象

类和对象

class 类名:
 # 在缩进中书写的内容,都是类中的代码
 def ⽅法名(self): # 就是⼀个⽅法
 pass 

对象

类名() # 创建⼀个对象, 这个对象在后续不能使⽤
# 创建的对象想要在后续的代码中继续使⽤, 需要使⽤⼀个变量,
将这个对象保存起来
变量 = 类名() # 这个变量中保存的是对象的地址, ⼀般可以
成为这个变量为对象
 
# ⼀个类可以创建多个对象, 只要出现 类名() 就是创建⼀个对
象,每个对象的地址是不⼀样的

调⽤⽅法

案例

需求:⼩猫爱吃⻥，⼩猫要喝⽔
类名: 猫类 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(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

14魔法⽅法 

 python 中有⼀类⽅法, 以两个下划线开头,两个下划线结尾,并 且在满⾜某个条件的情况下, 会⾃动调⽤, 这类⽅法称为 魔法⽅ 法

 

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)

 

案例

 

类名: ⼈类 Person 属性: 姓名 name, 体重 weight ⽅法: 跑步 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} 跑步 5 km, 体重减少了')
 # 减体重, 即修改属性
 self.weight -= 0.5
 
 def eat(self):
 print(f'{self.name} ⼤餐⼀顿, 体重增加了')
 # 修改体重
 self.weight += 1
xm = Person('⼩明', 75.0)
print(xm)
xm.run()
print(xm)
xm.eat()
print(xm)