Python基础
前言
博主本人之前学习的方向是Java后端开发,因为一些原因,打算从转到测试方向,由于Python
在测试方向上的广泛应用,于是开始学习Python
,此贴作为和大家的一个交流,如果有错误之处,请多多指教。
1.python语法
先来个经典开局:输出hello the world !
print("hello the world")
再将它多元化一点
class Greeting:
message = "Hello, the world" # 类变量
def say_hello(self):
print(self.message) # 输出消息
由上面两个例子可以看出,python的语法和C/C++、Java最明显的不同的一点就是,python使用缩进来替代大括号表示代码块,强调了代码的可读性。
同时,python和Java一样,是一门强类型的语言,不同的是python不需要显示的声明变量的数据类型。
并且,python是一门解释性语言,代码不需要显示编译,可以直接运行。
2.注释和标识符
1)单行注释
单行注释使用 # 作为标识
如果单行注释在当前行代码后,需要间隔两个空格位置
# 这是一个单行注释
print('大吉大利,今晚吃鸡') # 这是一个单行注释
2)多行注释
多行注释使用 ‘’’ ‘’’ 作为标识
'''
这是一个多行注释
这是一个多行注释
这是一个多行注释
'''
3)标识符
python中的标识符,仅允许使用英文、数字、下划线、中文(不推荐使用中文)
必须以字母、下划线开头,不允许数字开头,同时不允许使用python的保留字作为标识符
# 合规的标识符
my_variable = 42
user_name = "Alice"
MAX_SIZE = 100
ClassA = "Hello"
# 不合规的标识符
my_variable = 42
user_name = "Alice"
MAX_SIZE = 100
ClassA = "Hello"
3.变量、运算符、数据类型、数据类型转换
1)变量
变量的定义
变量是用于存储数据的标识符。在Python中,不需要显式声明变量的类型,它们会根据赋予的值自动确定数据类型。
# 定义一个变量 ---> 变量名 = 变量值
name = 'kunkun'
age = 25
2)运算符
''' 数学运算符 '''
# 加法运算符
result = 5 + 3 # 结果为8
# 减法运算符
result = 7 - 2 # 结果为5
# 乘法运算符
result = 4 * 6 # 结果为24
# 除法运算符
result = 10 / 3 # 结果为3.3333333333333335
# 取模运算符
result = 10 % 3 # 结果为1
# 整除运算符
result = 10 // 3 # 结果为3
# 幂运算符
result = 2 ** 3 # 结果为8
''' 比较运算符 '''
# 等于运算符
result = 5 == 5 # 结果为True
# 不等于运算符
result = 7 != 3 # 结果为True
# 小于运算符
result = 4 < 7 # 结果为True
# 大于运算符
result = 8 > 6 # 结果为True
# 小于等于运算符
result = 5 <= 5 # 结果为True
# 大于等于运算符
result = 7 >= 8 # 结果为False
''' 逻辑运算符 '''
# 逻辑与运算符
result = True and False # 结果为False
# 逻辑或运算符
result = True or False # 结果为True
# 逻辑非运算符
result = not True # 结果为False
''' 位运算符 '''
# 按位与运算符
result = 0b1100 & 0b1010 # 结果为0b1000(8)
# 按位或运算符
result = 0b1100 | 0b1010 # 结果为0b1110(14)
# 按位异或运算符
result = 0b1100 ^ 0b1010 # 结果为0b0110(6)
# 按位取反运算符
result = ~0b1100 # 结果为-13
# 左移位运算符
result = 5 << 2 # 结果为20
# 右移位运算符
result = 20 >> 2 # 结果为5
''' 赋值运算符 '''
# 赋值运算符
x = 5
# 复合赋值运算符
x += 3 # 等同于 x = x + 3,结果为8
''' 特殊运算符 '''
# 身份运算符(is)
a = [1, 2, 3]
b = a
result = a is b # 结果为True
# 不是身份运算符(is not)
c = [1, 2, 3]
result = a is not c # 结果为True
3)数据类型
- 整数(int):用于表示整数值,例如:-1、0、1、100等。
- 浮点数(float):用于表示浮点数,即带小数点的数字,例如:3.14、-0.5、1.0等。
- 字符串(str):用于表示文本数据,由字符组成,例如:“Hello, World”、'Python’等。
- 布尔值(bool):用于表示真值或假值,只有两个可能的值:True和False。
- 列表(list):用于存储一组有序的数据,可以包含不同类型的元素,例如:[1, “apple”, 3.14, True]。
- 元组(tuple):类似于列表,但是不可变的,用圆括号表示,例如:(1, “apple”, 3.14, True)。
- 集合(set):用于存储一组唯一的元素,不包含重复值,例如:{1, 2, 3}。
- 字典(dictionary):用于存储键-值对的映射关系,类似于关联数组,例如:{‘name’: ‘Alice’, ‘age’: 30}。
- 字节串(bytes):用于表示字节数据,常用于处理二进制数据。
- 字节数组(bytearray):类似于字节串,但是可变的。
- 复数(complex):用于表示复数,例如:3 + 4j。
- 空值(None):表示一个特殊的空值或缺失值。
- 自定义类(class):您可以创建自定义类来定义自己的数据类型,包括属性和方法。
其中,int、float、str、bool、bytes属于基本数据类型,也是最常用的数据类型
list、tuple、set、dictionary、bytearray属于基本数据结构,详细讲解可以跳到序列讲解
complex、none、class暂时不讲,后面再详细展开
4)数据类型转换
- 整数转换(int()):将其他数据类型转换为整数。
pythonCopy codefloat_num = 3.14
int_num = int(float_num) # 将浮点数转换为整数,结果为3
- 浮点数转换(float()):将其他数据类型转换为浮点数。
pythonCopy codeint_num = 5
float_num = float(int_num) # 将整数转换为浮点数,结果为5.0
- 字符串转换(str()):将其他数据类型转换为字符串。
pythonCopy codenumber = 42
string_num = str(number) # 将整数转换为字符串,结果为'42'
- 布尔值转换(bool()):将其他数据类型转换为布尔值。
pythonCopy codezero = 0
non_zero = 42
bool_zero = bool(zero) # 将整数0转换为False
bool_non_zero = bool(non_zero) # 将非零整数转换为True
4.输入和输出
1)输入
python中提供了input函数获取用户的输入,返回值默认是字符串类型,需要根据需要转换为其它类型
name = input("请输入您的姓名:")
age = input("请输入您的年龄:")
age = (int)age
2)输出
python中提供了print函数将内容输出到控制台或标准输出
# 格式化输出
# 方式1
print("My name is %s and I am %d years old." % (name, age))
# 方式2 :python3.6及更高版本支持
print(f"My name is {name} and I am {age} years old.")
# 输出到文件
with open("output.txt", "w") as file:
print("Hello, World!", file=file)
5.序列(数据容器)
Python中的序列有6种,分别为列表、元祖、集合、字典、字符串、字节数组
1)列表list
列表的定义
my_list = [0,1,2,3,4] # 定义一个列表
my_list1 = [] # 定义一个空列表
my_list = list() # 定义一个空列表
列表的索引
列表的索引是从0开始的,并且支持反向索引,反向索引从-1开始
列表存储的数据类型
列表存储的数据的类型可以不一样,并且支持列表间的嵌套
列表的常用方法
my_list = [0,1,2,3,4,5]
# 取出数据
print(my_list[0]) # 取出下标为0的数据
print(my_list[-1]) # 取出下标为-1的数据(倒数第一个数据)
# 追加数据
my_list.append(6) # 追加方式1
my_list.append(["a","b","c"]) # 追加方式2
# 删除
# 方式1:删除下标为2的元素,结果为[0,1,3,4,5]
del my_list[2]
# 方式2:删除值为2的元素,返回删除后的列表,结果为[0,1,3,4,5]
res = my_list.remove(2)
# 方式3:删除下标2为的元素,并将其返回,结果为[0,1,3,4,5]
res = my_list.pop(2)
res = my_list.pop() # 空参则移除列表最后一个元素
2)元祖 tuple
元祖的定义
元祖是一个有序、不可变的数据结构。
元祖中的元素可以是不同的数据类型
元祖支持嵌套
my_tuple = (1,2,3) # 定义一个元祖
empty_tuple = () # 定义一个空元祖
single_tupel = (1,) # 定义一个单个数据的元祖
nums_tuple = (1,2,3,"a","b","c") # 定义一个含有不同数据类型的元祖
nested_tuple = ((1, 2), (3, 4), (5, 6)) # 定义一个嵌套的元祖
元祖的索引
元祖的索引从0开始,并且支持反向索引,反向索引从-1开始
my_tuple = (1,2,3,"a","b","c")
print(f"第1个索引对应的值为:{nums_tuple[0]}")
print(f"最后1个索引对应的值为:{nums_tuple[-1]}")
元祖的常用方法
# count(value):返回指定元素在元组中出现的次数。
fruits = ("apple", "banana", "orange", "apple")
count = fruits.count("apple")
print(count) # 输出: 2
# index(value):返回指定元素在元组中首次出现的索引。
fruits = ("apple", "banana", "orange", "apple")
index = fruits.index("banana")
print(index) # 输出: 1
# list(),转换为列表。tuple(),转换为元祖
fruits = ("apple", "banana", "orange")
fruits_list = list(fruits) # 转换为列表
fruits_list.append("pear") # 修改列表,添加新元素
fruits = tuple(fruits_list) # 转换回元组
print(fruits) # 输出: ("apple", "banana", "orange", "pear")
3)集合set
集合的定义
集合是一组无序、不重复的的数据集合
集合中的元素是唯一的
集合中的元素的数据类型可以不同,但必须是可哈希的数据类型
empty_set1 = {} # 定于一个空集合,实际上创建的是一个空字典
empty_set2 = set() # 定义一个空集合
my_set1 = {1, 2, 3, "a", "b", "c"} # 定义一个集合
my_set2 = set([1, 2, 3, "a", "b", "C"]) # 定义一个集合
try:
error_set = {[1, 2], [3, 4], [5, 6]} # 集合中元素的类型必须是可哈希的,不然会报TypeError。列表list是不可哈希的数据类型
except TypeError:
print("捕获到TypeError")
集合的常用方法
# 添加元素
my_set.add(4)
# 删除元素:使用 remove() 方法删除集合中的元素。如果元素不存在,会引发 KeyError。如果希望避免引发异常,可以使用 discard() 方法
my_set.remove(3)
my_set.discard(5)
# 清空集合:使用 clear() 方法清空集合中的所有元素
my_set.clear()
# 集合支持各种集合操作,如并集、交集和差集。这些操作可以使用方法或运算符进行。
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2) # 并集
union_set = set1 | set2 # 或者使用运算符
intersection_set = set1.intersection(set2) # 交集
intersection_set = set1 & set2 # 或者使用运算符
difference_set = set1.difference(set2) # 差集
difference_set = set1 - set2 # 或者使用运算符
4)字典dictionary
字典的定义
字典是一种以键-值对的方式存储元素的数据结构
字典的元素是无序的
字典的键值是唯一的
字典的键值是不可变的,通常为字符串,数字、元祖
字典支持嵌套
# 创建一个字典:使用{},键值对之间使用冒号分隔
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
# 创建一个字典:使用dict()方法
another_dict = dict(name='Bob', age=25, city='San Francisco')
# 创建一个字典:嵌套
person = {
'name': 'Alice',
'address': {
'street': '123 Main St',
'city': 'New York'
}
}
访问字典中的元素
# 可以使用键值来访问字典中的元素
name = my_dict['name']
age = my_dict['age']
# 如果键值不存在,则会引发KeyError异常,可以使用get()方法避免
name = my_dict.get('name', 'unknown') # 如果键不存在,返回unknown
字典的常用操作
''' 增删改 '''
# 添加数据
my_dict['hobby'] = 'basketball'
# 删除数据
del my_dict['name'] # 使用del
my_dict.pop('name') # 使用pop()
# 修改数据
my_dict['name'] = 'kunkun'
''' 常用方法 '''
# keys() 返回字典所有键
keys = my_dict.keys()
# values() 返回字典所有值
values = my_dict.values()
# items() 返回字典所有键值对(以元祖tuple的形式)
items = my_dict.items()
# update() 将一个字典的键值对合并到另一个字典中
my_dict.update(another_dict)
# clear() 清除字典中的所有元素
my_dict.clear()
5)字符串strings
字符串的定义
字符串是python中的一种基本数据类型
字符串是不可变,如果需要修改字符串,则必须创建一个新的字符串
# 使用单引号创建字符串
my_string = 'Hello, World!'
# 使用双引号创建字符串
another_string = "Python is great!"
# 使用三重引号创建多行字符串
multi_line_string = '''This is a
multi-line
string.'''
字符串的索引和切片
字符串支持索引访问和切片操作
# 使用索引
my_string = 'Python'
first_char = my_string[0] # 结果为 'P'
# 使用切片
sub_string = my_string[2:4] # 结果为 'th'
字符串的常用操作
# 字符串的连接
greeting = 'Hello, '
name = 'Alice'
message = greeting + name # 结果为 'Hello, Alice'
# 字符串的重复
repeat_string = 'abc' * 3 # 结果为 'abcabcabc'
# 字符串的方法
text = 'Python is a powerful programming language.'
text.lower() # 转换为小写
text.upper() # 转换为大写
text.find('is') # 查找子字符串的位置
text.replace('Python', 'Java') # 替换文本
# 字符串的格式化
name = 'Alice'
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
6)字节数组byte-array
字节数组的定义
字节数组是一个存储字节数据的数据结构,元素是字节(0-255的整数)
字节数组是一个可变的序列,允许修改
字节数组常用于存储二进制数据,例如图形、音频、网络通信、文件操作
# 创建字节数组
my_bytearray = bytearray()
data = bytearray(b'hello')
字节数组的访问
my_bytearray = bytearray(b'hello')
first_byte = my_bytearray[0] # 获取第一个字节
字节数组的常用操作
''' 增删改 '''
# 修改元素
my_bytearray[1] = 101 # 修改第二个字节为101
# 添加元素
my_bytearray.append(111) # 在末尾添加字节111
# 删除元素
del my_bytearray[2] # 删除第三个字节
''' 常用方法 '''
my_bytearray.find(b'lo') # 查找子字节数组的位置
my_bytearray.replace(b'hello', b'world') # 替换字节数组中的内容
my_bytearray[:3] # 切片字节数组
''' 字节数组和字符串之间的转换 '''
my_bytearray.decode('utf-8') # 将字节数组转换为字符串
'hello'.encode('utf-8') # 将字符串转换为字节数组
总结
- list集合,多类型、可变、可嵌套、有序、不唯一
- set集合,多类型、可变、可嵌套、无序、唯一、必须可哈希
- tuple元祖,多类型、不可变、可嵌套、有序、不唯一
- dictionary字典,多类型、键值对、可变、可嵌套、无序、键值唯一且不可变
- strings字符串,单类型、字符、不可变
- bytearray字节数组,单类型、字节、可变
6.代码结构
python常见的代码结构通常包括模块Module、函数Function、条件语句Conditional Statements、循环语句Loop Statements、异常处理Exception Handling
1)模块Module
模块的定义
模块就是一个python文件,包含一组相关的函数、变量和类。
模块可以被导入到其它python文件中,便于重复使用代码
# 模块示例(module_example.py)
def add(x, y):
return x + y
def subtract(x, y):
return x - y
if __name__ == "__main__":
# 在模块中编写的测试代码
result = add(5, 3)
print(result)
补充:
if __name__ == '__main__':
是一个常见的Python编程约定,用于确定一个脚本文件是否正在直接运行,还是被作为模块导入到其他脚本中。这个约定通常用于在一个Python文件中定义可执行代码和模块导入时执行的代码,以便将脚本文件和模块导入分开。当一个Python脚本文件被执行时,Python解释器会设置特殊变量
__name__
的值。如果脚本文件是直接执行的,__name__
的值将被设置为'__main__'
。如果脚本文件被导入为一个模块,__name__
的值将被设置为模块的名称。因此,
if __name__ == '__main__':
的目的是检查__name__
的值是否等于'__main__'
,如果条件成立,就执行其后的代码块。这意味着这部分代码仅在脚本文件直接运行时才会执行,而在被导入为模块时不会执行。
2)函数Function
函数的定义
函数是一段可重复使用的代码块,接受参数并执行特定任务。函数通常用于模块化代码,提高可读性和维护性。
函数的接收参数,可以是固定的,也可以是动态的。
def greet(name):
print(f"Hello, {name}!")
def dynamic_greet(*names):
for name in names:
print(f"{name}")
# 调用函数
greet("Alice")
my_list = ['ikun01', 'ikun02', 'ikun03']
dynamic_greet(*my_list)
匿名函数
也称为lambda函数,是一种在Python中创建小型、无需显式命名的函数的方式。
# 基本语法
lambda [函数参数]:[函数的返回值]
# 例子
add = lambda x,y: x + y
print(add(1,2)) # 结果为3
# lambda函数作为列表排序的键函数
students = [
{"name": "Alice", "age": 25},
{"name": "Bob", "age": 22},
{"name": "Charlie", "age": 30}
]
students.sort(key=lambda student: student["age"])
3)条件语句Conditional Statements
条件语句的定义
条件语句用于根据条件执行不同的代码块,从而控制程序的流程。
''' 模板
if condition:
# 当条件为True时执行
pass
elif another_condition:
# 当第一个条件为False,但第二个条件为True时执行
pass
else:
# 当所有条件都为False时执行
pass
'''
''' 示例如下:猜数字游戏。设定一个答案,根据输入的数字和答案对比,打印不同的结果 '''
res = 10
num = input('请输入你的数字:')
num = int(num) # 是否记得前面提过的,input()函数接收的数据类型默认是str,想要进行比较的话,需要转为int类型噢
if num > 10:
print('你输入的数字比答案大了')
elif num < 10:
print('你输入的数字比答案小了')
else:
print('恭喜你,答案正确')
4)循环语句Loop Statements
循环语句的定义
循环语句用于多次执行一段代码块
python
中循环有两种结构,for循环和while循环
for
循环常用于迭代(遍历)可迭代对象(list、set、tuple、dictionary、str等)。工作原理是依次将可迭代对象中的每个元素赋值给循环变量,直至遍历完可迭代对象中的所有元素。循环遍历过程中,可以通过break和continue两种方式来控制循环的行为。break是结束整个for循环,continue是跳过当前for循环的这一次迭代
while
循环是一种条件控制的循环结构,它会反复执行一组语句,直到条件变为False
。常用于需要动态循环次数的的迭代。迭代过程中,也可以像for
循环一样,使用break和continue语句来控制循环行为。
''' for循环 '''
fans = ['ikun01', 'ikun02', 'ikun03']
for fan in fans:
print(fan)
# 运行结果是依次打印ikun01,ikun02,ikun03
for fan in fans:
if fan == 'ikun02':
break # 结束当前for循环
else:
print(fan)
# 运行结果为仅打印ikun01。因为当if条件成立后,for循环结束了
for fan in fans:
if fan == 'ikun02':
continue # 跳过当前这一次迭代,进入下一次迭代
else:
print(fan)
# 运行结果为依次打印ikun01,ikun03。因为当迭代到fan = ikun02时,触发了if条件,跳过了本次迭代。
''' while循环 '''
count = 0
while count < 5:
print(count)
count += 1
# 运行结果为01234
5)异常处理Exception Handling
异常处理的定义
异常处理用于处理代码执行中可能出现的异常情况。
try
、except
、finally
关键字用于捕获和处理异常。
try
代码块是可能出现的异常,except
代码块是指定try
代码块中出现的某一异常的处理逻辑,finally
代码块是必然执行的逻辑,不论try
代码块中是否出现异常
try:
result = 10 / 0 # 会引发ZeroDivisionError异常
except ZeroDivisionError:
print("除数不允许为0")
finally:
print("异常结束")
7.文件操作
1)打开文件
python
提供了一个内置的open()
函数,通过传入文件名参数
和打开模式参数
。
文件名参数
可以包括文件的相对路径或绝对路径,如果仅传入文件名,默认从当前项目路径寻找。
打开模式参数
包括6种。分别为
"r"
:读取模式(默认)。用于打开文件以供读取,如果文件不存在会引发异常。"w"
:写入模式。用于打开文件以供写入,如果文件存在,会截断文件内容;如果文件不存在,会创建新文件。"a"
:追加模式。用于打开文件以供追加数据,如果文件不存在,会创建新文件。"x"
:独占创建模式。用于创建新文件,如果文件已存在,则引发错误。"b"
:二进制模式。用于以二进制模式打开文件,例如读取或写入二进制数据。"t"
:文本模式(默认)。用于以文本模式打开文件,适用于读取或写入文本数据。
# 打开一个文本文件进行读取
file = open("example.txt", "r")
# 打开一个文本文件进行写入(如果文件不存在,则创建)
file = open("example.txt", "w")
python
中的标准库提供了一个os模块,可以使用这个模块中的功能来检查文件是否存在
import os # 引入os模块
# 查看当前文件目录
cur_directory = os.getcwd()
print(f"cur_directory is {cur_directory}")
# 检查文件是否存在
if os.path.exists("file_to_check.txt"):
print("文件存在")
else:
print("文件不存在")
2)读取文件
python
提供了3个内置的函数来读取文件内容,分别是
- read():一次性读取整个文件的内容,并将其存储为一个字符串
- readLine():逐行读取文件的内容,以字符串返回,每次调用会返回文件中的下一行
- readLines():将文件中的每一行以字符串返回,然后存储在一个列表中
# read()
with open("example.txt", "r") as file:
file_content = file.read()
print(file_content)
# readLine()
with open("example.txt", "r") as file:
line = file.readline()
while line:
print(line)
line = file.readline()
# readLines()
with open("example.txt", "r") as file:
lines = file.readlines()
for line in lines:
print(line)
3)写入文件
python
提供了两个函数来写入,传入参数为写入内容
write()
:写入指定的传入的数据writelines()
:一次性写入多行数据,传入参数为一个list集合
# write()
with open("output.txt", "w") as file:
file.write("Hello, World!")
# writes()
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("output.txt", "w") as file:
file.writelines(lines)
4)关闭文件
python
中,打开文件执行完文件操作后需要关闭已打开的文件,有两种方式
- 使用显示调用
close()
方法来关闭文件 - 使用
with
语句,在代码块中完成对文件的操作,最后隐式调用close()
方法
# 显示调用close()
file = open("example.txt", "r")
content = file.read()
file.close() # 手动关闭文件
# 使用with,隐式调用close()
with open("example.txt", "r") as file:
content = file.read()
补充
在使用
with
语句时,无需显式调用close()
,这是因为with
语句会自动处理关闭文件的操作,即使在发生异常时也会执行。这有助于确保文件被正确关闭,不会产生资源泄漏。最佳实践是在需要打开文件时始终使用with
语句。
5)复制、删除、重命名文件
对于复制、删除、重命名三个文件操作,可以使用python
标准库中的shutil
模块来实现
import shutil # 引入shutil模块
# 复制文件
shutil.copy("source.txt", "destination.txt")
# 删除文件
os.remove("file_to_delete.txt")
# 重命名文件
os.rename("old_name.txt", "new_name.txt")
补充
在执行这些操作时,出现异常的可能性较大,例如文件不存在或文件权限不足等。因此在执行这些操作时,最好提前进行错误处理
8.面向对象
在Python
中,面向对象编程(Object-Oriented Programming,OOP)
是一种重要的编程范例,它允许您将数据和行为封装到对象中,以更好地组织和管理代码。
1)类和对象
- 类(Class):类是定义对象的模板或蓝图。它包含了对象的属性(也称为数据成员)和方法(也称为函数成员)。
- 对象(Object):对象是类的实例,它具有类定义的属性和方法。您可以创建多个对象来表示不同的实体。
''' 定义类
class 类名:
# 属性
属性名 = 属性值
...
# 方法
def 方法名(参数):
return "sing" # 返回值
...
'''
class Person:
# 属性
name = 'kun'
age = 25
# 方法
def sing(self):
return "sing"
def jump(self):
return "jump"
def rap(self):
return "rap"
def basketball(self):
return "basketball"
# 类可以定义一个初始化方法__init__(),完成创建对象时对某些参数进行初始化
class Person_init:
# 初始化方法
def __init__(self, name, age):
self.name = name
self.age = age
# 方法
def sing(self):
return "sing"
def jump(self):
return "jump"
def rap(self):
return "rap"
def basketball(self):
return "basketball"
''' 创建对象 '''
person1 = person()
person2: Person = Person() # 指定创建的person类型为Person
person2 = person_init("ikun", 250)
# 通过创建的对象,可以方法对象的属性和方法
print(person1.name)
print(person1.sing())
补充
在
python
中,类中的属性和方法默认是公开的,如果想要指定某个方法或属性为私有,可以将属性名或方法名以__
开头,这样就能设置为私有
2)继承和多态
继承(重写)
继承是面向对象编程中的核心概念,它允许一个类(子类)继承另一个类(父类)的属性和方法。子类可以重用父类的功能,并且还可以添加自己的属性和方法。
class Animal:
def speak(self):
return "Animal speaks"
class Dog(Animal):
def speak(self):
return "Dog barks"
dog = Dog()
print(dog.speak()) # 输出: "Dog barks"
在这个示例中,Dog
类继承了 Animal
类,并重写了 speak
方法以提供不同的实现。这是继承的一个示例,其中子类继承了父类的方法并重写,进行了定制。
多态
多态是面向对象编程中的另一个关键概念,它允许不同类的对象使用相同的方法名称,从而实现更灵活的代码。不同的对象可以根据其类型调用相同名称的方法,这称为动态绑定。
同时,多态的存在,可以使用父类的引用来引用子类的对象
class Animal:
def speak(self):
return "Animal speaks"
class Dog(Animal):
def speak(self):
return "Dog barks"
def animal_speak(animal):
return animal.speak()
animal: Animal = Animal()
dog: Dog = Dog()
print(animal_speak(animal)) # 输出: "Animal speaks"
print(animal_speak(dog)) # 输出: "Dog barks"
抽象类
在Python中,可以使用抽象基类(Abstract Base Class,简称ABC)来定义抽象类。抽象类是不能实例化的类,通常用作其他类的基类,用于定义规范和接口,要求其子类实现特定的方法。Python的
abc
模块提供了抽象基类的支持。
from abc import ABC, abstractmethod # 从abc模块导入ABC类和abstractmethod方法
class Animal(ABC):
@abstractmethod
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "Dog barks"
# 无法实例化抽象类
# animal = Animal() # 这将引发TypeError
dog = Dog()
print(dog.speak()) # 输出: "Dog barks"
- 抽象类使用
ABC
类作为基类。 @abstractmethod
装饰器用于标记抽象方法,告诉子类它必须实现该方法。- 抽象类不能实例化,但可以用作其他类的基类。
- 子类必须实现抽象类中定义的抽象方法。
- 抽象类可以有普通方法,普通方法可以被子类继承或重写
3)方法的重载、重写
重载
重载的意思就是,在一个类中,可以有多个方法名相同但参数列表不同的方法。
python和Java等语言不同,python不支持方法的重载。因为Python是一种动态类型语言,方法的参数类型和数量可以在运行时发生变化。
但是,python提供了一种替代方案,即使用默认参数值和可变参数来模拟方法的重载
# 模拟重载
class MathOperations:
def add(self, a, b, c=0):
return a + b + c
# 创建一个对象
math_obj = MathOperations()
# 调用方法,可以接受不同数量的参数
result1 = math_obj.add(1, 2)
result2 = math_obj.add(1, 2, 3)
print(result1) # 输出: 3
print(result2) # 输出: 6
在上面的示例中,add
方法接受一个到三个参数,并根据参数的数量来执行不同的操作。这种方法可以模拟方法的重载,但实际上只是一个方法,根据传递的参数自动调整行为。
重写
重写的意思就是,子类对父类方法的重新编写
class Animal:
def speak(self):
return "Animal speaks"
class Dog(Animal):
def speak(self):
return "Dog barks"
dog = Dog()
print(dog.speak()) # 输出: "Dog barks"