- 声明：本文作为学习记录，如有侵权请联系本人进行删除
- 本文使用的IDE是PyCharm Community Edition 2022.1.3 下载地址
- 本文使用的Python版本python 3.10 下载地址
- 本文观看B站教学视频，跟着手打出来的。部分内容是复制其他链接上的。已给出参考链接。
- 观看教学视频链接地址
- 本人中出现错误的内容，请指正。
- Python入门常识
- 切片操作
- 创建列表及列表常用函数
- 创建元组及元组拆包
- 创建集合及常用函数
- 创建字典及常用函数
- 字符串
- 常用的转义符
- 普通字符串
- 原始字符换
- 长字符串
- 将字符串转换为数字
- 将数字转换为字符串
- 格式化字符串
- 使用占位符
- 格式化控制符
- 操作字符串
- 字符串查找及常用函数
- 字符串替换
- 字符串分割
- 去除字符串两边的空格 strip()
- 函数
- 定义函数
- 形参与实参
- 调用函数
- 使用位置参数调用函数
- 使用关键字参数调用函数
- 参数
- 参数的默认值
- 可变参数
- 基于元组的可变参数(*可变参数)
- 基于字典的可变参数(**可变参数)
- 函数中的变量作用域
- 全局变量 和 局部变量
- global 用法
- 函数类型
- 过滤函数filter
- 映射函数map
- lambda函数
- 创建对象
- 创建对象
- 类的成员
- 实例变量
- 构造方法：
- 实例方法
- 类变量
- 类方法
- 私有变量
- 私有方法
- 使用属性
- 继承性
- 继承
- 多继承
- 重写
- 多态性
- 继承与多态
- 异常捕获
- 捕获异常
- 多个except代码块
- 多重异常捕获
- try-except语句嵌套
- 使用finally代码块释放资源
- 使用finally代码块释放资源
- 语法：[start: end: step]
- 语法讲解：其中start是开始索引，end是结束索引，step是步长（切片时获取的元素的间隔，可以为正整数，也可以为负整数）。step就是去除等步长的元素
- 顾头不顾尾
- ==重点：==字符串、列表、元组可以进行切片。元组、集合不能进行切片操作。
list1 = [1, 2, 3, 4, 5, 6, 7] # 列表
list2 = {1, 2, 3, 4, 5, 6, 7} # 集合 因集合元素是无序的，所以不能用索引进行切片操作。
list3 = (1, 2, 3, 4, 5, 6, 7) # 元组
list4 = {"A": 1, "B": 2,"C": 3, "D": 4, "E": 5, "F": 6, "G": 7} # 字典
print(type(list1))
print(type(list2))
print(type(list3))
print(type(list4))
print(list1[1: 4: 2])
print(list1[1: 4])
# print(list2[1: 4: 2]) # 集合不能切片
# print(list2[1: 4])
print(list3[1: 4: 2])
print(list3[1: 4])
# print(list4[1: 4: 2]) # 字典不能切片
# print(list4[1: 4])
a = "hello"
print(a[1: 3: 2])
print(a[1: 3]) # 顾头不顾尾
创建列表及列表常用函数
# 创建方式
# 方式一：list(iterable)
a = list("HelloWord")
print(a)
# 方式二：[]
b = [] # 创建一个空列表
print(type(b))
c = [1, 2, 3, 4, 5, 6, 7]
print(c)
# 列表相关函数
print("列表相关函数:")
# 追加单个元素。append()
A = [4, 5, 6]
print(A)
A.append(7)
print(A)
# 追加多个元素。两个列表相加。 使用+ 或使用 extend()
B = [8, 9, 10]
C = [1, 2, 3]
A += B # 等价于：A = A + B
print(A)
C.extend(A)
print(C)
# 插入元素
# 方法：list.insert(i,x)
# 方法解释： i是索引的位置。在指定索引的前方插入。 x是具体的元素
print("")
print("列表C:" + str(C))
# 在列表C中的3，4之间插入"python"
C.insert(3, "python")
print(C)
# 替换元素
# 方法：list(i) = x
# 方法解释： i为索引，x为具体元素。
# 把集合C中的python替换成3.5
C[3] = 3.5
print(C)
# 删除元素
# 方法：list.remove(x)
# 方法解释: x为列表中的元素
# 把C列表中的3.5元素删除
C.remove(3.5)
print(C)
创建元组及元组拆包
# 创建元组方式 # 方式一：tuple(iterable) 函数 t1 = tuple([1, 2, 3, 4, 5]) # 列表作为参数 print(t1) print(type(t1)) # 方式二：() t2 = (6, 7, 8) print(t2) print(type(t2)) t3 = () # 创建一个空元组 print(t3) print(type(t3)) t4 = 9, 10, 11 # 小括号可省略 print(t4) print(type(t4)) # 元组拆包 s_id, s_name = (102, "张三") s_id1, s_name1 = 103, "李四" print(s_id) print(s_name) print(s_id1) print(s_name1)创建集合及常用函数
# 创建集合
# 集合是无序的。不能使用切片操作。
# 方式一：set(iterable) 函数。
set1 = set("hello") # 字符串
print(set1)
print(type(set1))
# 方式二： {}
set2 = {3, 2, 6, 4, 5}
print(set2)
print(type(set2))
# 创建空集合
set3 = set()
print(set3)
print(type(set3))
set4 = {} # 不能直接用{}创建空集合，{}为空字典
print(set4)
print(type(set4))
# 常用函数
# add(elem) ：添加元素，如果元素已经存在，则不能添加，不会抛出错误。
set5 = {4, 6, 8, 9, 1, 3, 5, 7, 2}
print(set5)
set5.add(10)
print(set5)
set5.add(10)
print(set5)
# remove(elem) ：删除元素，如果不存在，则抛出异常。
set5.remove(10)
print(set5)
# set5.remove(10)
print(set5) # KeyError: 10
# clear() : 清楚集合
set5.clear()
print(set5)
创建字典及常用函数
参考链接讲的很细
# 创建字典 dict
# 字典以键值对的形式存在。key : value 其中一个字典中key唯一不能重复，value可以重复。
# 方式一：dict()
# 方式二：{key1:value, key2: value2, ..., key_n: value_n}
# 参数是另一个字典{102 : "张三", 103 : "李四", 104: "王二麻子"}
dict1 = dict({102: "张三", 103: "李四", 104: "王二麻子"})
print(dict1)
print(type(dict1))
# 参数是元组((666, "66大顺"), (888, "88大发"), (999, "长长99")) :元组中套元组
dict2 = dict(((666, "66大顺"), (888, "88大发"), (999, "长长99")))
print(dict2)
print(type(dict2))
# 参数是列表[(102, "王五"), (103, "小李"), (104, "小明")] :列表中套元组
dict3 = dict([(102, "王五"), (103, "小李"), (104, "小明")])
print(dict3)
print(type(dict3))
# 用zip() 函数打包。 zip([666, 777, 888], ["六六大顺", "齐全齐美", "八仙过海"])
dict4 = dict(zip([666, 777, 888], ["六六大顺", "齐全齐美", "八仙过海"]))
print(dict4)
print(type(dict4))
# 创建空字典
dict5 = {}
dict6 = dict()
print(dict5)
print(dict6)
print(type(dict5))
print(type(dict6))
# 修改字典
# 方法：dict[key] = values_new
# 现有字典dict4 = {666: '六六大顺', 777: '齐全齐美', 888: '八仙过海'} 修改key=888的value为"七上八下"
print("现有字典dict4 = {666: '六六大顺', 777: '齐全齐美', 888: '八仙过海'} 修改key=888的value为”七上八下”")
dict4[888] = "七上八下"
print("dict4[888] = '七上八下'修改后的字典" + str(dict4))
# 删除键值对，返回删除的值
# 方法 ： dict.pop(key)
print("现有字典dict4 = {666: '六六大顺', 777: '齐全齐美', 888: '七上八下'} 删除key=888,并返回七上八下")
print(dict4.pop(888))
# 常用函数
# 参考链接http://c.biancheng.net/view/2212.html
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}
# 获取字典所有的key-value对，返回一个dict_items对象
ims = cars.items()
print(type(ims)) #
# 将dict_items转换成列表
print(list(ims)) # [('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]
# 访问第2个key-value对
print(list(ims)[1]) # ('BENS', 8.3)
# 获取字典所有的key，返回一个dict_keys对象
kys = cars.keys()
print(type(kys)) #
# 将dict_keys转换成列表
print(list(kys)) # ['BMW', 'BENS', 'AUDI']
# 访问第2个key
print(list(kys)[1]) # 'BENS'
# 获取字典所有的value，返回一个dict_values对象
vals = cars.values()
# 将dict_values转换成列表
print(type(vals)) # [8.5, 8.3, 7.9]
# 访问第2个value
print(list(vals)[1]) # 8.3
字符串
- 表示方式：普通字符串、原始字符串、长字符穿
| 字符表示 | Unicode编码 | 说明 |
|---|---|---|
| t | u0009 | 水平制表符 |
| n | u000a | 换行 |
| r | u000b | 回车 |
| " | u0022 | 双引号 |
| ’ | u0027 | 单引号 |
| \ | u005c | 反斜杠 |
- 用单引号(') 或 双引号(") 括起来的字符串
# 普通字符串：用单引号(') 或 双引号(") 括起来的字符串
a = 'Hello'
b = "Hello"
print(a + b)
原始字符换
- r :在字符串前面加r。表示原始字符串。
# 原始字符串 a = "Hellow n word" # n在普通字符串中表示换行 print(a) b = r"Hellow n word" # n在原始字符中表示 和 n 连个字符 print(b)长字符串
两种表是方式：
- 3个单引号表示 ： ‘’‘XXXXXXXXX’‘’
- 3个双引号表示 : “”“XXXXXXXX”“”
保留原有的格式
# 长字符串 ： 保留原有的格式
c = """
春晓
春眠不觉晓，处处闻啼鸟。
夜来风雨声，花落知多少。
—————— 作者：孟浩然
"""
d = '''
登鹳雀楼
王之涣 〔唐代〕
白日依山尽，黄河入海流。
欲穷千里目，更上一层楼。
'''
print(c)
print(d)
将字符串转换为数字
- int() 转换成功则返回数字(整数)，否则引发异常
- float() 转换成功则返回数字(浮点数)，否则引发异常
s = "90"
print(int(s))
d = "90.0"
# print(int(d)) 异常。int()不能转换浮点数
print(float(d))
print(int("AB", 16)) # 16进制也可以转换，不是16进制不能转换
# print(int("AB", 8)) 异常
# print(int("AB")) 异常
将数字转换为字符串
- str()函数可以将很多类型的数据都转换为字符串
# 将数字转换为字符串
print(str(123)) # 整数转换为字符串
print(str(666.666)) # 浮点数转换为字符串
print(str(True)) # 布尔型转换为字符串
print(str([1, 2, 3])) # 列表转换为字符串
print(str((1, 2, 3))) # 元组转换为字符串
print(str({2, 4, 1})) # 集合转换为字符串
print(str({1: "A", 2: "B"})) # 字典转换为字符串
格式化字符串
- format() 不仅可以实现字符串的拼接，还可以格式化字符串。
- 想要将表达式的计算结果插入字符串中，则需要用到占位符 {}。
-
{l:d}
l ：参数序号
d : 格式控制符
参数序号与 : 之间不能有空格
| 格式控制符 | 说明 |
|---|---|
| s | 字符串 |
| d | 十进制整数 |
| f、F | 十进制浮点数 |
| g、G | 十进制整数或浮点数 |
| e、E | 科学计算法表示浮点数 |
| o | 八进制整数。符号是小写英文字符o |
| x、X | 十六进制整数，x是小写表示，X是大写表示 |
- %s 占位符 可以接受所有的数据类型
- %d 占位符 只能接受数字类型 有局限性
格式化占位符控制符示例：
money = 123456.654321
name = "明哥"
print("{0:s}年龄{1:d},工资是{2:f}元/月".format(name, 26, money))
print("{0}年龄{1},工资是{2:0.2f}元/月".format(name, 26, money)) # 格式化输出保留两位小数3.14
print("{0},工资是{1:G}元/月".format(name, money))
print("{0},工资是{1:g}元/月".format(name, money))
print("{0},工资是{1:e}元/月".format(name, money))
print("{0},工资是{1:E}元/月".format(name, money))
print("十进制数{0:d}的八进制表示为{0:o}".format(18))
print("十进制数{0:d}的十六进制表示为{0:x}".format(18))
print("十进制数{0:d}的十六进制表示为{0:X}".format(18))
操作字符串
字符串查找及常用函数
-
str.find(sub, start, end)
在索引start到end之间查找子字符sub，如果找到，则返回最左端位置的索引；如果没有找到，则返回-1。
s_str = "Hello World lxm"
print(s_str.find("l")) # 找到第一个索引
print(s_str.find("l", 4, 6)) # 从索引4找到索引6，没有符合要求。返回-1
print(s_str.find("l", 4)) # 从索引4 一直往后找，找到第一个字符l的所在索引
print(s_str.find("l", 8, 12)) # 从索引8 一直往后找,找到第一个字符l的所在索引
print()
s_str1 = "lxm"
print(s_str1 in s_str) # 字符串是否在另一个字符串中
-
count ：统计一个字符串在大字符串中出现的次数
str_name = "A B C D E F G H D E C D A" print(str_name.count("D")) # out: 3 -
isdigit ：判断一个字符串里的数据是不是都是数字。
str_pwd = "625" print(str_pwd.isdigit()) # out: True str_user = "625Admin" print(str_user.isdigit()) # out: False
-
isalpha ： 判断一个字符串里的数据是不是都是字母。中文也算字母。
str_1 = "abcEFG" print("# out: %s" % str_1.isalpha()) # out: True str_1 = " abcEFG" # 加了一个空格 print("# out: %s" % str_1.isalpha()) # out: False str_1 = "/abcEFG" # 加了一个/ print("# out: %s" % str_1.isalpha()) # out: False str_1 = "小明abcEFG" # 加了小明 print("# out: %s" % str_1.isalpha()) # out: True -
startswith : 比较开头的元素是否相同
-
endswith ：比较结尾的元素是否相同
msg = "nanjing is jiangsu" print("# out: %s" % msg.startswith("nanjing")) # out: True print("# out: %s" % msg.startswith("n1")) # out: False print("# out: %s " % msg.endswith("su")) # out: True print("# out: %s " % msg.endswith("u")) # out: True -
islower : 判断字符串的值是否全是小写。
-
isupper : 判断字符串的值是否全是大写
msg = "abc" print(msg.islower()) # out: False msg_str = "ABCD" print("# out: %s" % msg_str.isupper()) # out: True
- str.replace(old, new, count)
new字符串替换old字符串。count参数指定了替换old子字符串的个数，count被省略，则替换所有old子字符串。
-
re.sub()
不仅可以对一种字符串进行替代，还可以替代多种字符串。
注意：需要导入import re
re.sub参考链接
text = "AB CD EF GH IJ"
text = text.replace(" ", "|", 2) # 把前两个空格( )替换为|
print(text)
text_1 = "AB CD EF GH IJ"
text_1 = text_1.replace(" ", "|") # 把所有的空格（ ）替换为|
print(text_1)
import re # 导入re才能使用re.sub
s = '2022/07/07 09:40:30'
print(re.sub(r"/", "-", s)) # 把/替换成-
print(re.sub(r"[/:]", "-",s)) # 把/:替换成-
字符串分割
-
str.split(sep, maxsplit)
使用sep子字符串分割字符串str。maxsplit是最大分割次数，如果maxsplit被省略，则表示不限制分割次数。
sep为默认值时，认为空格、n、t等都是分隔符。
str.split()参考链接
s = "AB CD EF GH IJ"
print(s.split(" "))
s_1 = "AB CD EFnGHtIJ"
print(s_1.split()) # 为默认值时，认为空格、n、t等都是分隔符；
print(s.split(" ", 2)) # 根据空格( )分割两次
print(s.split(" ", 1)) # 根据空格( )分割一次
print(s.split(" ")[0]) # 根据空格( )分割，取第一个值。0为索引。
print(s.split(" ", 2)[2]) # 根据空格( )分割两次,取第三值。2为索引
去除字符串两边的空格 strip()
- 只去除字符串两边的空格，中间的不会去除。
str_name = " 小 明 " str_name = str_name.strip() print(str_name) # out: 小 明函数 定义函数
def 函数名(形式参数列表):
函数体
return 返回值
- 如果没有数据返回则可以省略return语句
由于定义函数时的参数不是实际数据，会在调用函数时传递给他们实际数据，所以我们称定义函数时的参数为形式参数，简称形参。
称调用函数时传递的实际数据为实际参数，简称实参。
调用函数 使用位置参数调用函数- 在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。
- 在调用函数时可以采用"关键字=实参"的形式，其中，关键字的名称就是定义函数时形参的名称。
- 实参不再受形参的顺序限制
# 定义rect_area函数,width、height 两个形参列表
def rect_area(width, height):
area = width * height
return area
# 使用位置参数调用函数
# 调用函数rect_area
r_area = rect_area(320.33, 480.23)
print("{0} x {1} 长方形的面积：{2}".format(320, 480, r_area))
print("{0} x {1} 长方形的面积：{2:0.2f}".format(320, 480, r_area)) # 结果保留两个小数
r_area = rect_area(0.2225, 2)
print("{0} x {1} 长方形的面积：{2:0.2f}".format(0.2225, 2, r_area)) # 结果保留两个小数
# 使用关键字参数调用函数
print()
r_area = rect_area(width=320.33, height=480.23)
print("{0} x {1} 长方形的面积：{2}".format(320, 480, r_area))
print("{0} x {1} 长方形的面积：{2:0.2f}".format(320, 480, r_area)) # 结果保留两个小数
r_area = rect_area(height=2, width=0.2225) # 实参不再受形参的顺序限制
print("{0} x {1} 长方形的面积：{2:0.2f}".format(0.2225, 2, r_area)) # 结果保留两个小数
参数
参数的默认值
# 参数默认值为苹果
def like_fruit(name="苹果"): # 苹果就是默认值
return "我喜欢吃{0}".format(name)
like_1 = like_fruit() # 直接调用不给实参，就会使用默认值
like_2 = like_fruit(name="香蕉")
like_3 = like_fruit(name="火龙果")
print(like_1)
print(like_2)
print(like_3)
可变参数
- Python中的函数可以定义接收不确定数量的参数，这种参数被称为可变参数。
- 可变参数有两种。即在参数前加 * 或 **
- *可变参数在函数中被组装成一个元组。
def sum_tol(*numbers):
total = 0.0
for number in numbers:
total += number
return total
print(sum_tol(100, 20, 30.0))
print(sum_tol(10.01, 30.0))
基于字典的可变参数(**可变参数)
- **可变参数在函数中被组装成一个字典
def show_info(**info):
print("------------show_info-----------")
for key, value in info.items():
print("{0} - {1}".format(key, value))
show_info(name="明哥", age=26, sex="男")
show_info(student_name="小明", student_no="10001")
函数中的变量作用域
全局变量 和 局部变量
-
局部变量: 由某对象或函数内部定义的变量,就是局部变量, 局部变量又可称之为内部变量。
只能被内部引用，而无法被其它对象或函数引用。
-
全局变量:在函数外部定义的变量,或者在函数的内部,用global关键字定义的变量,就是全局变量。
全局变量是可以被本程序所有对象或函数引用。
-
作用域: 作用的范围 局部变量的作用范围只限定在函数的内部; 全局变量的作用范围横跨整个文件;
-
变量的生命周期:内置 > 全局 > 局部
- global是Python中的全局变量关键字。
- global关键字的作用是可以使得一个局部变量为全局变量。
# 创建全局变量x
x = "明哥"
def print_value():
x = "无名" # 局部变量
print("（局部变量）函数中的x = {0}".format(x))
print_value()
# 输出：（局部变量）函数中的x = 无名
print("全局变量x = {0}".format(x))
# 输出：全局变量x = 明哥
def print_value_tow():
global x # 将x变量提升为全局变量
x = "明哥丨分晏" # 局部变量
print("（局部变量）函数中的x = {0}，n 并把x变量提升为全局变量".format(x))
print_value_tow()
# 输出：（局部变量）函数中的x = 明哥丨分晏，
# 并把x变量提升为全局变量
print("x = {0}".format(x))
# 输出：x = 明哥丨分晏
函数类型
- Python中的任意一个函数都有数据类型，这种数据类型是function，被称为函数类型。
- 一个函数可以作为另一个函数返回值使用
- 一个函数可以作为另一个函数参数使用
# 定义减法函数
def sub(a, b):
return a - b
# 定义加法函数
def add(a, b):
return a + b
# 定义平方函数
def square(a):
return a * a
# 定义计算函数
def calc(opr):
if opr == "+":
return add
else:
return sub
f1 = calc("+") # f1实际上是add函数
f2 = calc("-") # f2实际上是sub函数
f3 = calc("") # f2实际上是square函数
print(type(f1))
print(type(f2))
print(type(f3))
print("666 + 111 = {0}".format(f1(666, 111)))
print("666 - 111 = {0}".format(f2(666, 111)))
print("5 * 5 = {0}".format(f3(5)))
过滤函数filter
- filter(function, iterable)
# 提供过滤条件函数
def fun_1(x):
return x > 50 # 找出大于50的元素
data1 = [66, 15, 91, 28, 98, 50, 7, 80, 99]
filtered = filter(fun_1, data1)
print(type(filtered))
data2 = list(filtered) # 将filtered转换为列表
print(data2)
映射函数map
- map(function, interable)
# 提供变换规则的函数
def func_2(x):
return x * 2 # 变换规则乘以2
data3 = [11, 22, 33, 44, 25]
mapped = map(func_2, data3)
print(type(mapped))
data4 = list(mapped) # 转换为列表
print(data3)
print(data4)
lambda函数
-
使用lambda关键字定义匿名函数。
-
lambda关键字定义的函数也被称为lambda函数。
-
方法：lambda 参数列表:lambda体
lambda体 可以为其他函数
# 定义减法函数
def sub1(a, b):
return a - b
# 定义加法函数
def add1(a, b):
return a + b
# 定义计算函数
def calc(opr):
if opr == "+":
return add1
else:
return sub1
def calc1(opr1):
if opr1 == "+":
return lambda a, b: (a + b) # 替代add1函数
else:
return lambda a, b: (a - b) # 替代sub1函数
print("--------------add1函数、sub1函数结果----------------")
f1 = calc("+") # f1实际上是add1函数
f2 = calc("-") # f2实际上是sub2函数
print("666 + 111 = {0}".format(f1(666, 111)))
print("666 - 111 = {0}".format(f2(666, 111)))
print("--------------lambda函数结果-----------------------")
f6 = calc1("+") # lambda函数
f7 = calc1("-") # lambda函数
print("666 + 111 = {0}".format(f6(666, 111)))
print("666 - 111 = {0}".format(f7(666, 111)))
filter、map、reduce、zip函数参考链接
创建对象## 定义类
语法：
class 类名(父类):
#类体
pass
class Car(object): # object 可以不写。不写默认继承object #类体 pass # 没有类体时，需要使用关键字pass。不写pass会出现异常。 class Car(): # 等价于上面 #类体 pass创建对象
- 实例化对象，创建对象。
# 定义类Car
class Car():
#类体
pass
# 创建对象
car = Car() # Python中区分大小写。car是对象，Car是类。
类的成员
实例变量
- 实例变量就是对象个体特有的“数据”。如狗狗的名称和年龄等。
- 对实例变量访问通过“对象.实例变量”形式访问。
class Dog:
def __init__(self, name, age):
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
d = Dog("土豆", 4) # d为对象
print("我们家狗狗叫{0}，{1}岁了。".format(d.name, d.age)) # 通过“对象.实例变量”形式访问实列变量。
# out:我们家狗狗叫土豆，2岁了。
构造方法：
- __init__方法是构造方法,构造方法用来创建和初始化实例变量。注意：init的前后是两个下划线。
class Dog:
# 构造方法和实例方法第一个参数都是self。 self表示当前对象，当前实列。
def __init__(self, name, age, sex="雌性"): # sex="雌性" 为省略值
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
self.sex = sex # 创建和初始化实例变量sex
d1 = Dog("土豆", 2)
d2 = Dog("球球", 3, "雄性")
d3 = Dog(name="豆豆", sex="雄性", age=4)
print("狗狗叫{0}，{1}岁了 {2}。".format(d1.name, d1.age, d1.sex))
# out:狗狗叫土豆，2岁了 雌性。
print("狗狗叫{0}，{1}岁了 {2}。".format(d2.name, d2.age, d2.sex))
# out:狗狗叫球球，3岁了 雄性。
print("狗狗叫{0}，{1}岁了 {2}。".format(d3.name, d3.age, d3.sex))
# out:狗狗叫豆豆，4岁了 雄性。
实例方法
- 实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。
class Dog:
# 构造方法
def __init__(self, name, age, sex="雌性"):
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
self.sex = sex # 创建和初始化实例变量sex
# 实例方法
def run(self):
print("{}在跑……".format(self.name))
# 实例方法
def speak(self, sound):
print("{}在叫，'{}'!".format(self.name, sound))
dog = Dog("球球", 2)
dog.run()
# out:球球在跑……
dog.speak("旺 旺 旺 旺")
# out:球球在叫，'旺 旺 旺 旺'!
类变量
- 类变量是属于类的变量，不属于单个对象。
class Account:
interest_rate = 0.0568 # 类变量 利率interest_rate
def __init__(self, owner, amount):
self.owner = owner # 创建并初始化实例变量
self.amount = amount # 创建并初始化实例变量
account = Account("明哥", 88888888.88)
print("账户名：{}".format(account.owner)) # 通过“对象.实例变量”访问
# out:账户名：明哥
print("账户金额：{} 元".format(account.amount)) # 通过"对象.实例变量"访问
# out:账户金额：88888888.88 元
print("利率：{}".format(Account.interest_rate)) # 通过“类名.类变量”访问
# out:利率：0.0568
类方法
- 类方法与类变量类似，属于类，不属于个体实例。
- 关键字：@classmethod
class Account:
interest_rate = 0.0568 # 类变量 利率interest_rate
def __init__(self, owner, amount):
self.owner = owner # 定义实例变量账户名
self.amount = amount # 定义实例变量账户金额
# 类方法
@classmethod # 类方法关键字。不加关键字。就成为实例方法了。
def interest_by(cls, amt):
return cls.interest_rate * amt
interest = Account.interest_by(66666.66)
print("计算利息：{:.4f}".format(interest)) # {:.4f} 等价于 {0:0.4f} 保留四位小数。 格式化控制符
# out:计算利息：3786.6663
私有变量
- 为了防止外部调用者随意存取类的内部数据(成员变量)，内部数据（成员变量）会被封装为"私有变量"
- 私有变量定义方法：在变量前加上双下划线(__)
class Account:
__interest_rate = 0.0568 # 私有变量 类变量 利率__interest_rate
def __init__(self, owner, amount):
self.owner = owner # 创建并初始化实例变量owner
self.__amount = amount # 创建并初始化私有实例变量__amount
def desc(self):
return "{} 金额：{} 元，利率：{}。".format(self.owner, self.__amount, Account.__interest_rate)
account = Account("明哥", 88888.88)
str_1 = account.desc()
print(str_1)
# out:明哥 金额：88888.88 元，利率：0.0568。
print("账户名：{}".format(account.owner))
# out:账户名：明哥
print("账户金额：{}".format(account.__amount)) # 发生错误 因为私有变量不能被外部访问
# out：AttributeError: 'Account' object has no attribute '__amount'
print("利率：{}".format(Account.__interest_rate)) # 发生错误 因为私有变量不能被外部访问
# out:AttributeError: type object 'Account' has no attribute '__interest_rate'
私有方法
- 私有方法与私有变量的封装是类似。防止外部调用者随意存取类的内部方法
- 定义方法：在方法前加上双下画线（__）
class Account:
__interest_rate = 0.0568 # 私有变量 类变量 利率__interest_rate
# 构造方法
def __init__(self, owner, amount):
self.owner = owner # 创建并初始化实例变量owner 外部调用者可调用
self.__amount = amount # 创建并初始化私有实例变量__amount 外部调用者不可调用
# 私有方法 外部调用者不可调用
def __get_info(self):
return "{} 金额：{}元，利率：{}。".format(self.owner, self.__amount, Account.__interest_rate)
# 实例方法 外部调用者可调用
def desc(self):
print(self.__get_info())
account = Account("明哥", 66666.66)
account.desc() # 调用类的实例方法desc Account类的desc实例方法中可以调用私有变量。 因为desc实例方法在Account类中，属于内部调用。
# out:明哥 金额：66666.66元，利率：0.0568。
account.__get_info() # 外部调用者直接掉用私有方法就会发生错误
# out：AttributeError: 'Account' object has no attribute '__get_info'
使用属性
- 为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和get（取值）方法进行访问
- 关键字：@property
class Dog:
# 构造方法
def __init__(self, name, age, sex="雌性"): # sex="雌性" 省略值：默认值。不给sex赋值，默认为雌性。
self.name = name # 创建并初始化实例变量name 外部调用者可以调用
self.__age = age # 创建和初始化私有实例变量__age 外部调用者不可以调用
@property # 外部调用者获取age值
def age(self):
return self.__age
@age.setter # 外部调用者给age重新赋值
def age(self, age):
self.__age = age
dog = Dog("球球", 3)
print("{}的年龄：{}岁了。".format(dog.name, dog.age))
# out:球球的年龄：3岁了。
dog.age = 2 # 给age重新赋值
print("修改后{}的年龄：{}岁。".format(dog.name, dog.age))
# out:修改后球球的年龄：2岁。
继承性
- 继承也是面向对象重要的基本特性之一。
- 它源于人们认识客观世界的过程，是自然界普遍存在的一种现象。
- 在面向对象编程中，被继承的类称为父类或基类，新的类称为子类或派生类。
-
语法：
class 子类名(父类): # 类体 pass -
例子：
class Animal: # 定义Animal类 作为父类 def __init__(self, name): # 构造方法 self.name = name # 创建并初始化实例变量name def show_info(self): # 实例方法 return "动物的名字是：{}".format(self.name) def move_dong(self): # 实例方法 print("{}动一动……".format(self.name)) # Cat类继承Animal类 父类：Animal 子类：Cat class Cat(Animal): # 子类Cat构造方法。 def __init__(self, name, age): # super() 指代父类 # 调用父类构造方法，初始化父类的成员变量 super().__init__(name) self.age = age # 创建并初始化实例变量age cat = Cat("TOM", 2) # 子类Cat 继承了父类Animal。 可以通过创建子类对象使用父类中的成员变量 cat.move_dong() # out: TOM动一动…… print(cat.show_info()) # out: 动物的名字是：TOM
-
语法：
class 子类名(父类1, 父类2, ... , 父类n): # 类体 pass
示例：
# 定义Horse类
class Horse:
# 构造方法
def __init__(self, name):
self.name = name # 创建并初始化实力变量
# 实例方法
def show_info(self):
return "Horse 马的名字：{}".format(self.name)
# 实例方法
def run(self):
return "Horse {}在跑......".format(self.name)
# 定义 Donkey类
class Donkey:
# 构造方法
def __init__(self, name):
self.name = name # 创建并初始化name
# 实例方法
def show_info(self):
return "Donkey 驴的名字：{}".format(self.name)
# 实例方法
def run(self):
return "Donkey {}在跑......".format(self.name)
# 实例方法
def roll(self):
return "Donkey {}打滚.....".format(self.name)
# 子类Mule继承父类House，继承父类Donkey
class Mule(Horse, Donkey):
# 子级中的构造方法
def __int__(self, name, age):
# 初始化父类中的成员变量。
super().__init__(name)
self.age = age # 创建并初始化实力变量。子类中
m = Mule("骡宝利") # 创建m对象
print(m.run()) # 继承父类Horse
# out：Horse 骡宝利在跑......
print(m.roll()) # 继承父类Donkey
# out: Donkey 骡宝利打滚.....
print(m.show_info()) # 继承父类Horse
# out: Horse 马的名字：骡宝利
重写
class Horse:
def __init__(self, name):
self.name = name # 创建并初始化实例变量
def show_info(self):
return "Horse 马的名字：{}".format(self.name)
def run(self):
return "Horse 马({})在跑......".format(self.name)
class Donkey:
def __init__(self, name):
self.name = name # 创建并初始化实例变量name
def show_info(self):
return "Donkey 驴的名字：{}".format(self.name)
def run(self):
return "Donkey 驴({})在跑......".format(self.name)
def roll(self):
return "Donkey 驴打滚...{}".format(self.name)
class Mule(Horse, Donkey):
def __init__(self, name, age):
super().__init__(name) # 初始化父类成员变量
self.age = age # 创建并初始化成员变量
# show_info方法重写
def show_info(self):
return "Mule 方法重写： 骡:{},{}岁。".format(self.name, self.age)
m = Mule("骡宝莉", 2)
print(m.run())
# out:Horse 马(骡宝莉)在跑......
print(m.roll())
# out:Donkey 驴打滚...骡宝莉
print(m.show_info())
# out:Mule 方法重写： 骡:骡宝莉,2岁。
多态性
- ”多态“值对象可以表现出多种形态。
- 例如：猫、狗、鸭子都属于东武，他们有”叫“和”动“等行为，但是”叫“的方式不同。”动“的方式也不同。
- 一龙生九子，九子各不同。
- 在多个子类继承父类，并重写父类得方法后，这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类方法。
class Animal:
def speak(self):
print("动物叫，但不知道是那种动物叫.....")
class Dog(Animal):
def speak(self):
print("小狗，旺旺旺叫......")
class Cat(Animal):
def speak(self):
print("小猫：喵喵喵叫......")
an1 = Dog()
an2 = Cat()
an1.speak()
# out:小狗，旺旺旺叫......
an2.speak()
# out:小猫：喵喵喵叫......
异常捕获
捕获异常
- 语法：
try:
<可能会引发异常的语句>
except[异常类型]: # 异常类型可以省略
<处理异常>
i = input("请输入字数：")
n = 8888
try:
result = n / int(i)
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out: 不能除以0，异常：division by zero
多个except代码块
- 语法：
try:
<可能会引发异常的语句>
except[异常类型1]:
<处理异常>
except[异常类型2]:
<处理异常>
...
except:
<处理异常>
示例：
i = input("请输入字数：")
n = 8888
try:
result = n / int(i)
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out: 不能除以0，异常：division by zero
except ValueError as e:
print("输入的【{}】是无效数字，异常：{}".format(i, e))
# out:输入的【ddd】是无效数字，异常：invalid literal for int() with base 10: 'ddd'
多重异常捕获
- 如果多个except代码块的异常处理过程类似，则可以合并处理，这就是多重异常捕获
n = 8888
try:
result = n / int(i)
print(result)
print("{}除以{}等于{}".format(n, i, result))
except (ZeroDivisionError, ValueError) as e:
print("异常发生，异常：{}".format(e))
# out: 异常发生，异常：division by zero
# out: 异常发生，异常：invalid literal for int() with base 10: 'ddd'
try-except语句嵌套
i = input("请输入字数：")
n = 8888
try:
i2 = int(i)
try:
result = n / i2
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out:不能除以0，异常：division by zero
except (ZeroDivisionError, ValueError) as e:
print("输入的【{}】是无效数字，异常：{}".format(i, e))
# out: 输入的【ddd】是无效数字，异常：invalid literal for int() with base 10: 'ddd'
使用finally代码块释放资源
- 语法：
try:
<可能会引发异常的语句>
except[异常类型1]:
<处理异常>
except[异常类型2]:
<处理异常>
...
except:
<处理异常>
finally:
<释放资源>
示例：
i = input("请输入字数：")
n = 8888
try:
i2 = int(i)
try:
result = n / i2
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out:不能除以0，异常：division by zero
except (ZeroDivisionError, ValueError) as e:
print("输入的【{}】是无效数字，异常：{}".format(i, e))
# out: 输入的【ddd】是无效数字，异常：invalid literal for int() with base 10: 'ddd'
finally:
print("释放资源")
# out: 释放资源
# 发生异常，不发生异常。都会打印释放资源
print(“{}除以{}等于{}”.format(n, i, result))
except (ZeroDivisionError, ValueError) as e:
print(“异常发生，异常：{}”.format(e))
# out: 异常发生，异常：division by zero
# out: 异常发生，异常：invalid literal for int() with base 10: ‘ddd’
## try-except语句嵌套
```python
i = input("请输入字数：")
n = 8888
try:
i2 = int(i)
try:
result = n / i2
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out:不能除以0，异常：division by zero
except (ZeroDivisionError, ValueError) as e:
print("输入的【{}】是无效数字，异常：{}".format(i, e))
# out: 输入的【ddd】是无效数字，异常：invalid literal for int() with base 10: 'ddd'
使用finally代码块释放资源
- 语法：
try:
<可能会引发异常的语句>
except[异常类型1]:
<处理异常>
except[异常类型2]:
<处理异常>
...
except:
<处理异常>
finally:
<释放资源>
示例：
i = input("请输入字数：")
n = 8888
try:
i2 = int(i)
try:
result = n / i2
print(result)
print("{}除以{}等于{}".format(n, i, result))
except ZeroDivisionError as e:
print("不能除以0，异常：{}".format(e))
# out:不能除以0，异常：division by zero
except (ZeroDivisionError, ValueError) as e:
print("输入的【{}】是无效数字，异常：{}".format(i, e))
# out: 输入的【ddd】是无效数字，异常：invalid literal for int() with base 10: 'ddd'
finally:
print("释放资源")
# out: 释放资源
# 发生异常，不发生异常。都会打印释放资源
