提示：优雅 明确 简单
python
一、python基础
one_day
1、编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件运行时不需要重新翻译，直接使用编译结果就行了。程序执行效率高，以来编译器，跨平台性差。如C、C++
2、解释型语言：解释型语言编写的程序不需要预先编译，以文本方式存储程序代码，会将代码一句一句直接运行。在发布程序是，看起来省了编译工序，但是在运行程序的时候，必须先解释再运行。速度略慢，跨平台性好。
3、概念
（1）python的源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做python的开发
（2）python程序的文件扩展名通常都是.py
4、练习
编写
print(“hello python”)
执行
python 01python.py
python 2.X默认不支持中文
5、交互式运行python程序
直接在终端中运行解释器，而不输入执行的文件名
在python的shell中直接输入python代码，会立即看到程序执行结果
退出：exit()或者CTRL+d
安装ipython和ipython3
参考链接：https://www.cnblogs.com/spring-jie/p/10758037.html
提示：前提是安装好pip3和python3
出现错误可能是软链接问题
参考：https://blog.csdn.net/qq_44739762/article/details/100558709
集成开发环境（IDE,integrated D evelopment Environment）–集成了开发软件需要的所有工具
tow_day
pycharm：
打开新的文件之后，会在目录下新建一个.idea的目录，用于项目相关的信息，例如：解释器版本、项目包含的文件。
命名规则
项目：前面以数字编号、随着知识点递增、编号地址
文件名：hs_hsi_xx
设置字体：
保证所有用户都能使用解压缩的文件：
在解压缩pycharm移动到/opt目录下
安装：
Icon:图标
Exec:可执行文件的文件目录
注释：
单行：# ，空面增加一个空格，增加可读性
代码后面注释 ：需要先两个空格# 内容
多行注释：
“”" “”"
算数运算
例：
优先级：
例如：
计算机中的三大硬件组成
CPU：中央处理器，一块集成电路，负责处理数据/计算
内存：临时存储数据，速度快，空间小
硬盘：永久存储数据，速度慢，空间大
程序执行原理：
python执行原理：
数据类型：
int :整数型
str :字符串
bool ：布尔类型，真或者假
float ：小数类型，浮点数
非数字型：
字符串
列表
元组
字典
变量的输入
input（）：接受键盘输入的内容，输入的都是字符串型的
类型转换：int(“内容”) 等等
# 输入单价
price = int(input("苹果的单价："))
# 输入重量
weight= int(input("苹果的重量："))
# 输入总金额
money = price_str * weight_str
print("总金额：", money)
格式化字符：含义
%s 字符串
%d 有符号十进制整数，%06d表示输出的证书显示位数，不足的地方使用0补全
%f 浮点数，%02f表示小数点后只显示两位
%% 输出%
price = 8.5
weight = 4.5
money = float(price * weight)
print("苹果的单价是：%.2f,购买的重量：%.2f,需要支付：%.4f" % (price, weight, money))
scale = 0.125 * 100
print("数据比例是：%.3f%%" % scale)
scale = 0.125 * 100
print("数据比例是：%.3f%%" % (scale * 100))
变量的命名规则
标识符和关键字
标识符：变量名、函数名
标识符：可以由字母、下划线、数字组成、不能以数字开头、不能与关键字重名
关键字：内部已经使用的标识符，具有特殊的功能和含义，开发者不准许定义关键字相同的标识符
标识符是区分大小写的
命名规则：
每个单词都使用小写字母
单词与单词之间使用_下划线 连接
if 要判断的条件：
条件成立时，要做的事情
。。。。
逻辑运算：
条件1 and 条件2
条件1 or 条件2
not 条件
elif ：与if时平级关系
if嵌套：
tab 向右缩进
shift + tab 向左缩进
案件例题：
has_ticket = False
knife_length = 2
if has_ticket:
print("可以进了，准备安检")
if knife_length >= 10:
print("不能进小哥，刀子太长了，有%d" % knife_length)
else:
print("请进站")
else:
print("不能进")
例二：
# if (()
# or ()
# or ()):
import random
player = int(input("请输入你要出的拳石头（1）/剪刀（2）/布（3）："))
computer = random.randint(1, 3)
print("玩家选择的拳头是 %d - 电脑出的拳是 %d" % (player, computer))
if ((player == 1 and computer == 2)
or (player == 2 and computer == 3)
or (player == 3 and computer == 1)):
print("电脑真菜")
elif player == computer:
print("平局")
else:
print("再来一局")
程序的三大流程：
while循环：
赋值运算符：
例如：1-100偶数相加
result = 0
i = 0
while i <= 100:
if i % 2 == 0: #偶数判断
print(i)
result += i
i += 1
print("0-100之间的偶数相加结果=%d" % result)
break和continue
i = 0
while i < 10:
if i == 5:
# 注意在循环中，如果使用continue关键字
# 在使用关键字之前，需要确认循环的计数是否修改
# 否则可能导致死循环
i += 1
continue
print(i)
i += 1
print("over")
循环嵌套：
对print函数的加强：
print("*", end="----")
print("*")
小星星案例：
print("*" * 1)
print("*" * 2)
print("*" * 3)
print("*" * 4)
print("*" * 5)
row = 1
while row <= 5:
print("*" * row)
row += 1
row = 1
while row <= 5:
# 增加一个小的循环，专门处理每一行中的每一列打印的星星
# 列的计数器
col = 1
while col <= row:
# print("%d" % col)
print("*", end="")
col += 1
# print("第 %d 行" % row)
print("") # 一行星星完成之后，添加换行
row += 1
九九乘法表：
row = 1
while row <= 9:
col = 1
while col <= row:
# print("*", end="")
print("%d * %d = %d" % (col, row, row * col), end=" \t")
col += 1
# print("% d" % row)
print("")
row += 1
转义字符：
three_day
函数的作用：
在开发程序时，使用函数可以提高编写的效率以及代码的重用。
函数的定义：
Pycharm的调试工具
函数参数的使用：（重点理解）
实参和形参
形参：用来接收数据的，在函数内部作为变量使用
形参：用来把数据传递到函数内部的
函数返回值：
函数嵌套：
def test1():
print("*" * 20)
def test2():
print("-" * 50)
# 调用函数嵌套
test1()
print("=" * 30)
# test1()
test2()
模块：
每个以.py结尾的python源代码文件都是一个模块
模块名也是一个标识符
Pyc：
C是complied编译过的二进制文件，保存在_pycharm_的目录中
列表（list）
index : 索引
append ：方法可以向列表的末尾追加数据
insert ：方法可以在列表的指定索引位置插入数据
extend ：方法可以添加一列到列表中
name_list = ["zhangsan","lisi", "wanger"]
# 取值
print(name_list[1])
# 取索引
print(name_list.index("lisi"))
name_list[1] = "里斯"
# name_list[3] = "niuer"
print(name_list[1])
temp_list = ["hao", "huai", "ya"]
name_list.append("niuer")
name_list.insert(1,"mei")
name_list.extend(temp_list)
print(name_list)
删除
# 删除
# remove 方法可以从列表中删除指定的数据
name_list.remove("ya")
# pop 方法默认删除最后一个列表元素，可以指定删除要删除元素的索引
name_list.pop(3)
# 清空整个列表
name_list.clear()
print(name_list)
# 提示：在日常开发中，要从列表中删除数据，建议使用列表提供的方法
name_list = ["张三", "王二", "麻子"]
#使用del关键字删除列表元素
del name_list[1]
# del 关键字本质上是用来将一个变量从内存中删除
name = "123"
del name
# 注意如果使用del关键字将变量从内存中删除
# 后续的代码将不能再使用这个变量了
print(name)
print(name_list)
列表统计
name_list = ["张三", "王二", "麻子"]
# len(length 长度)函数可以统计列表中元素的总数
list_len = len(name_list)
print("列表中包含 %d 个元素" %list_len)
# count 方法可以统计列表中某一个数据出现的次数
count = name_list.count("张三")
print("张三出现了 %d 次" %count)
# 删除第一次出现的数据
name_list.remove("张三")
print(name_list)
排序
列表.sort() 升序排序
列表.sort(reverse = True) 降序排序
列表.reverse() 逆序、反转
name_list = ["z张三", "w王二", "m麻子", "z张三"]
num_list = [6,8,2,7,1]
# 升序
name_list.sort()
num_list.sort()
print(name_list)
print(num_list)
# 降序
name_list.sort(reverse=True)
num_list.sort(reverse=True)
print(name_list)
print(num_list)
# 逆序、反转
name_list.reverse()
num_list.reverse()
print(name_list)
print(num_list)
结果
['m麻子', 'w王二', 'z张三', 'z张三']
[1, 2, 6, 7, 8]
['z张三', 'z张三', 'w王二', 'm麻子']
[8, 7, 6, 2, 1]
['m麻子', 'w王二', 'z张三', 'z张三']
[1, 2, 6, 7, 8]
循环遍历
迭代遍历
列表存储相同类型的数据，通过遍历在循环体内部，针对列表中的每一项元素，执行相同的操作
元组（Tuple）
与列表类似，不同之处在于元组的元素不能删除
元组表示多个元素组成的序列
元组在python开发中，有特定的应用场景
用于存储一串信息，数据之间使用 ，分隔
元组用（）定义
元组的素引从0开始，素引就是数据在元组位置的编号
定义只包含一个元素的元组
元素的索引
info_tuple = ("zhangsan", 18, 1.55, "zhangsan", "zhangsan")
# 取值和索引
print(info_tuple[2])
# 已经知道数据的内容，希望知道该数据在元组中的索引
print(info_tuple.index(1.55))
# 统计计数
print(info_tuple.count("zhangsan"))
# 统计元组中包含的个数
print(len(info_tuple))
结果
1.55
2
3
5
元组应用
元组和列表之间转换
字典（dictionary）
列表存储有序的对象集合
字典存储无序的对象集合
xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75,
"weight":180
}
print(xiaoming)
结果
{'name': '小明', 'age': 18, 'gender': True, 'height': 1.75, 'weight': 180}
字典的增删改查
xiaoming_dict = {"name": "小明"}
# 取值,取值的时候，如果指定的key不存在，程序报错
print(xiaoming_dict["name"])
# 增加/修改，如果key不存在新增键值对
xiaoming_dict["age"] = 18
# 如果存在，或修改已经存在的键值对
xiaoming_dict["name"] = "小小"
# 删除
xiaoming_dict.pop("name")
print(xiaoming_dict)
结果
小明
{'age': 18}
#小明的打印是因为在第二行已经打印了，最后无法打印是因为在后面删除被删除
常见操作
xiaoming_dict = {"name": "小明",
"age": 18
}
# 统计键值对数量
print(len(xiaoming_dict))
# 合并字典,如果被合并的字典中包含已经存在的键值对
# 会覆盖原来的键值对
temp_dict = {"height": 1.78,
"age": 78
}
xiaoming_dict.update(temp_dict)
# 清空字典
xiaoming_dict.clear()
print(xiaoming_dict)
循环遍历
xiaoming_dict = {"name": "小明",
"qq": 123456,
"phone": 1594648
}
# 迭代遍历
# 变量k是每次循环中，获取到的键值对的key
for k in xiaoming_dict:
print("%s - %s" % (k, xiaoming_dict[k]))
结果
name - 小明
qq - 123456
phone - 1594648
实际应用
# 使用多个键值对，存储描述一个物体的相关信息——描述更复杂的数据信息
# 将多个字典放在一个列表中，再进行遍历
card_list = [
{"name": "张三",
"qq": 123456,
"phone": 1110},
{"name": "里斯",
"qq": 123156156,
"phone": 15640},
]
for card_info in card_list:
print(card_info)
结果
{'name': '张三', 'qq': 123456, 'phone': 1110}
{'name': '里斯', 'qq': 123156156, 'phone': 15640}
字符串
str1 = "hello python"
str2= '我的外号是“case”'
print(str2)
print(str1[6])
for char in str2:
print(char)
结果
我的外号是“case”
p
我
的
外
号
是
“
c
a
s
e
”
长度、计数、位置
hello_str = "hello hello"
# 统计字符串长度
len(hello_str)
print(len(hello_str))
# 统计某个一个(子)小字符串出现的次数
print(hello_str.count("llo"))
print(hello_str.count("8"))
# 某一个字符串出现的位置
print(hello_str.index("llo"))
结果
11
2
0
2
常见分类
数字判断
# 判断字符串中只包含数字
# 都不能判断小数
# unicode 字符串，使用函数.isdigit()
# 中文数字.isnumeric()
num_str = "一千零一"
print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())
结果
False
False
True
替换和查找
hello_str = "hello new word"
# 判断是否以指定字符串开始
print(hello_str.startswith("hello"))
# 判断是否以指定字符串结束
print(hello_str.endswith("word"))
# 查找指定字符串,
# index方法同样可以查找指定字符串在大字符串中的索引
# index :如果指定的字符串不存在会报错
# find ：如果指定的字符串不存在，会返回-1
print(hello_str.find("llo"))
print(hello_str.find("add"))
# 替换字符串
# replace执行完成之后，会返回一个新的字符串
# 注意：不会修改原有字符串的内容
print(hello_str.replace("word", "case"))
print(hello_str)
结果
True
True
2
-1
hello new case
hello new word
对齐：
# 文本对齐
# 假设：下面内容是兄网络上抓取的
# 要求：顺序并且居中对齐输出以下内容
poem = ["登黄鹤楼",
"王焕之",
"白日依山尽",
"黄河入海流",
"欲穷千里目",
"更上一层楼"]
for poem_str in poem:
print("|%s |" % poem_str.ce(30, " "))
print(poem)
# 对齐：string.ljust向左对齐 string.rjust 向右对齐 string.center居中
去除空白字符：
# 显示用string方法出去空白字符，在使用center方法居中显示文本
# string.strip()除去空白字符
拆分字符串：string.split
合并字符串：string.join(seq)
poem_str = "登黄鹤楼 \t 王焕之 \t 白日依山尽 \t黄河入海流\t 欲穷千里目\t 更上一层楼"
# for poem in poem_str:
print(poem_str.strip().center(10, " "))
# 拆分字符串
poem_list = poem_str.split()
print(poem_list)
# 合并字符串
result = " ".join(poem_list)
print(result.center(20))
字符串切片：
In [1]: num = "123456"
In [2]: num_str = "1234567890"
In [3]: num_str[2:6]
Out[3]: '3456'
In [4]: num_str[1:6]
Out[4]: '23456'
In [5]: num_str[1:]
Out[5]: '234567890'
In [6]: num_str[0:6]
Out[6]: '123456'
In [7]: num_str[:6]
Out[7]: '123456'
In [8]: num_str[:]
Out[8]: '1234567890'
In [9]: num_str[::2]
Out[9]: '13579'
In [10]: num_str[1::2]
Out[10]: '24680'
In [11]: num_str[-1]
Out[11]: '0'
In [12]: num_str[2:-1]
Out[12]: '3456789'
In [13]: num_str[-2:]
Out[13]: '90'
In [14]: num_str[0::-1]
Out[14]: '1'
In [15]: num_str[-1::-1]
Out[15]: '0987654321'
In [16]: num_str[::-1]
Out[16]: '0987654321'
Python的内置函数：
max和min函数如果是字典，只针对key比较
len(item) 计算容器中元素的个数
del(item)删除变量
字典不能比较大小
字典不能切片
.extend拼接是列表的内容发生变化
+号是产生一个新的列表
.append把括号的内容当成一个元素，追加到列表中
运算符：
In [62]: "a" in "abcd"
Out[62]: True
In [63]: "a" not in "abcd"
Out[63]: False
In [64]: 1 in [0, 1, 2]
Out[64]: True
In [65]: 1 not in [0, 1, 2]
Out[65]: False
In [66]: "a" in {"a":"xiaoxiao"}
Out[66]: True
In [67]: "xiaoxiao" in {"a":"xiaoxiao"}
Out[67]: False
完整的for循环语法：
for num in {1, 2, 3}:
print(num)
if num == 2:
break
else:
#如果循环体内部使用break退出循环，else下方的代码就不被执行
print("haha")
print("循环结束")
students = [
{"name": "小红"},
{"name": "小美"},
# {"": ""} 存了一个空数列报错，为啥?
{"name": "张三"}
]
# 在学院列表中搜索指定的姓名
find_name = "历史"
for stu_dict in students:
print(stu_dict)
if stu_dict["name"] == find_name:
print("找到了 %s" % find_name)
break
else:
print("没有找到：%s" % find_name)
# else:
# print("没有找到：%s" % find_name)
print("循环结束")
名片管理系统
01.框架搭建
字符串判断
pass
无线循环
TTODO注释
名片数据结构：
LINUX上的shebang符号（#！）
three_day
变量“：
In [1]: a = 1
In [2]: id(a)
Out[2]: 9470816
In [3]: id(1)
Out[3]: 9470816
In [4]: b = a
In [5]: id()b
File "<ipython-input-5-e26a8f1967a9>", line 1
id()b
^
SyntaxError: invalid syntax
In [6]: id(b)
Out[6]: 9470816
In [7]: a = 2
In [8]: id(a)
Out[8]: 9470848
In [9]: id(2)
Out[9]: 9470848
In [10]: id(b)
Out[10]: 9470816
In [11]: b = a
In [12]: id(b)
Out[12]: 9470848
def test(num):
pass
print("在函数内部的 %d 对应的地址是: %d " % (num, id(num)))
print("函数要返回数据的内存地址是 %d" % id(result))
return result
# 定义一个数字的变量
a = 10
result = "hello"
print("a保存数据的地址是:%d" % id(a))
# 注意：如果函数有返回值，但没有定义变量接收
# 程序不会报错，但无法获得返回结果
r = test(a)
print("%s 的内存地址是 %d" % (r,id(r)))
可变和不可变类型：
a[1,2,3]
b = a
则改变的是内存地址，不是地址内容
In [6]: id(b)
Out[6]: 9470816
In [7]: a = 2
In [8]: id(a)
Out[8]: 9470848
In [9]: id(2)
Out[9]: 9470848
In [10]: id(b)
Out[10]: 9470816
In [11]: b = a
In [12]: id(b)
Out[12]: 9470848
In [13]: a = [1,2,3]
In [14]: id(a)
Out[14]: 140033974136648
In [15]: a.append(000)
In [16]: a
Out[16]: [1, 2, 3, 0]
In [17]: a.append(0002222)
File "<ipython-input-17-86eea54c0c6d>", line 1
a.append(0002222)
^
SyntaxError: invalid token
In [18]: a.append(22)
In [19]: a
Out[19]: [1, 2, 3, 0, 22]
In [20]: a.remove(2)
In [21]: a
Out[21]: [1, 3, 0, 22]
In [22]: id(a)
Out[22]: 140033974136648
In [23]: a.clear()
In [24]: a
Out[24]: []
In [25]: id(a)
Out[25]: 140033974136648
In [26]: a = []
In [27]: id(a)
Out[27]: 140033974203336
In [28]: d = {"name": "xiao"}
In [29]:
In [29]: d
Out[29]: {'name': 'xiao'}
In [30]: d["age"] = 18
In [31]: d
Out[31]: {'name': 'xiao', 'age': 18}
In [32]: id(d)
Out[32]: 140033973783144
In [33]: d.pop("age")
Out[33]: 18
In [34]: d
Out[34]: {'name': 'xiao'}
In [35]: id(d)
Out[35]: 140033973783144
In [36]: d.clear()
In [37]: d
Out[37]: {}
In [38]: d = {}
In [39]: id(d)
Out[39]: 140033973806496
可变类型的数据变化，是通过发放来实现的
如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
变量不在对之前的数据引用
变量改为对新赋值的数据的引用
局部变量和全局变量
在函数内部修改全局变量
函数有返回多个数据时，可以使用元组，返回多个值
def measure():
"""测量温度和湿度"""
print("测量开始")
temp = 30
wetness = 50
# return (temp, wetness)
return temp, wetness
result = measure()
print(result)
# 需要单独的处理温度或者湿度
print(result[0])
print(result[1])
# 如果函数返回的类型是元组，同时希望单独处理元组中的元素
# 可以使用多个变量，一次接受函数的返回结果
# 注意:使用多个变量接收结果是,变量的个数呵呵元组中元素的个数保持一致
gl_temp, gl_wetness = measure()
print(gl_temp)
print(gl_wetness)
a和b交换,不适用其他变量
a=a+b
b=a-b
a=a-b
# a = 1
# b = 2
#
# # c = a
# # a = b
# # b = c
#
# print(a,b)
#
# # a, b = (b, a)
# a, b = b, a
#
# print(a,b)
在重新赋值时是引用的改变，使用方法修改内容是列表内容的改变
思考：
列表变量使用+=不会做相加赋值的操作
本质上是在调用列表的extend方法
def demo(num,num_lsit):
print("函数开始")
num += num
num_lsit += num_lsit
print(num)
print(num_lsit)
print("函数完成")
gl_num = 9
gl_num_list = [1,2,3]
demo(gl_num,gl_num_list)
print(gl_num)
print(gl_num_list)
结果
函数开始
18
[1, 2, 3, 1, 2, 3]
函数完成
9
[1, 2, 3, 1, 2, 3]
``
升序和降序：
gl_list = [8,6,9]
# 默认按照升序排序
# gl_list.sort()
# 如果需要降序排序,需要执行reverse参数
gl_list.sort(reverse=True)
缺省参数：
提示;在指定缺省参数的默认值时，应该使用常见的值作为参数值
def print_info(name, gender=True):
"""
:param name: 班上同学的姓名
:param gender: Ture男生 False 女生
"""
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s 是 %s" % (name, gender_text))
print_info("小明")
缺省参数注意：
多值参数：
多值函数求和
# 多值函数求和
def sun_numbers(*args):
num = 0
print(args)
# 循环遍历
for n in args:
num += n
return num
result = sun_numbers(1, 2, 3, 4, 5, 6)
print(result)
元组和字典的拆包
def demo(*args,**kwargs):
print(args)
print(kwargs)
# 元组变量/字典变量
gl_nums = (1,2,3)
gl_dict = {"name": "小明","age": 18}
# demo(gl_nums,gl_dict)
# 拆包语法
demo(*gl_nums, **gl_dict)
递归：
def sum_number(num):
print(num)
if num == 1:
return
sum_number(num - 1)
sum_number(3)
加法计算：
# 计算
def sum_number(num):
if num == 1:
return 1
temp = sum_number(num - 1)
return num + temp
result = sum_number(2)
print(result)
面向对象的编程
类和对象的概念
对象
类和对象的关系
类的设计
dir函数
定义类
应用概念的强调
给对象增加属性
哪一个对象调用的方法，就是self就是哪一个对象的引用
初始化方法：
class Cat:
def __init__(self):
print("这是一个初始化方法")
# 使用类名（）创建对象的时候，会自动调用初始化方法_int_
tom = Cat()
初始化内部定义属性：
初始化方法——初始化的同时设置初始值
内置方法和属性
class Cat:
def __init__(self,new_name):
self.name = new_name
print("%s 来了" %self.name)
def __del__(self):
print("%s 我去了" % self.name)
tom = Cat("Tom")
print(tom.name)
# del 关键字可以删除一个对象
del tom
print("_" * 50)
_str_方法
封装
class Person:
def __init__(self, name, weight):
# self.属性 = 形参
self.name = name
self.weight = weight
def __str__(self):
return "我的名字叫%s 体重是 %.2f公斤" % (self.name, self.weight)
def run(self):
print("%s 爱跑步，跑步锻炼身体" % self.name)
self.weight -= 0.5
def eat(self):
print("%s 是吃货，吃完减肥" % self.name)
self.weight += 1
pass
xiaoming = Person("小明", 99.555)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
结果
小明 爱跑步，跑步锻炼身体
小明 是吃货，吃完减肥
我的名字叫小明 体重是 100.06公斤
摆放家具
添加家具
class HouseItem:
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return "【%s】占地 %.2f" % (self.name, self.area)
class House:
def __init__(self, house_type, area):
self.house_type = house_type
self.area = area
# 剩余面积
self.free_area = area
# 家具名称
self.item_list = []
def __str__(self):
return ("户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s"
% (self.house_type, self.area,
self.free_area, self.item_list))
def add_item(self, item):
print("要添加 %s" % item)
# 判断房子面积
if item.area > self.free_area:
print("%s 的面积太大了，无法添加" % item.name)
return
# 将家具的名称添加到列表中
self.item_list.append(item.name)
# 计算剩余面积
self.free_area -= item.area
# 创建家具
bed = HouseItem("小床", 4)
chest = HouseItem("衣柜", 100)
table = HouseItem("餐桌", 60)
print(bed)
print(chest)
print(table)
# 创建房子对象
my_home = House("两室一厅", 120)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)
一个对对象的属性可以是列外一个类创建的对象
None关键字
身份运算符：
私有属性和私有方法：
定义属性和方法时，在属性名和属性方法名前增加两个下划线，定义的就是私有属性或方法
class Women:
def __init__(self, name):
self.name = name
self._age = 18
def _seret(self):
# 在对象的方法内部是可以访问私有属性的
print("%s 的年龄是 %d" % (self.name, self._age))
xiaofang = Women("小芳")
# 私有属性在外界是不能访问的
# 私有方法，同样不准许在外界直接访问
print(xiaofang)
xiaofang
four_day
封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同的代码不需要编写
多态：不同的对象调用不同的方法产生不同的执行结果，增加代码的灵活性
1、单继承
继承的概念：子类拥有弗雷的所有方法和属性
方法的重写
方法的重写是对父类方法的覆盖
对父类方法的扩展
定义属性用_init_(self)方法
私有方法和属性是两个下划线
多继承
class A:
def test(self):
print("test1方法")
class B:
def test2(self):
print("test2")
class C(A, B):
pass
c = C()
c.test()
c.test2()
MRO方法搜索
在定义类时，如果没有父类，建议统一继承自object
多态
不同的子类对对象调用相同的父类方法，产生不同的执行结果
多态可以增加代码的灵活度
以继承和重写父类的方法为前提
是调用方法的技巧，不会影响到类的内部设计
类的结构
类是一个特殊的对象（理解）
类的属性和实例属性
class Tool(object):
# 使赋值语句定义类属性，记录所有工具对象的数量
count = 0
def __init__(self,name):
self.name = name
# 让类属性的值+1
Tool.count += 1
# 创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头1")
tool3 = Tool("榔头2")
tool4 = Tool("榔头3")
# 输出工具对象的总数
print(Tool.count)
4
类方法
单例
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
def __new__(cls, *args, **kwargs):
# 判断类属性，是否为空对象
if cls.instance is None:
# 调用父类的方法，作为第一对象分配空间
cls.instance = super().__new__(cls)
# 返回类属性保存的对象引用
return cls.instance
play1 = MusicPlayer()
print(play1)
play2 = MusicPlayer()
print(play2)
play3 = MusicPlayer()
print(play3)
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
# 记录是否执行过初始化方法
init_flag = False
def __new__(cls, *args, **kwargs):
# 判断类属性，是否为空对象
if cls.instance is None:
# 调用父类的方法，作为第一对象分配空间
cls.instance = super().__new__(cls)
# 返回类属性保存的对象引用
return cls.instance
def __init__(self):
if MusicPlayer.init_flag == True:
return
print("初始化播放器")
MusicPlayer.init_flag = True
play1 = MusicPlayer()
print(play1)
play2 = MusicPlayer()
print(play2)
play3 = MusicPlayer()
print(play3)
异常
try :
# 不能正确执行代码
num = int(input("输入整数:"))
except:
# 错误的处理方式
print("请输入正确的整数:")
print()
结果
输入整数:k
请输入正确的整数:
try:
# 提示用户输入一个整数
num = int(input("请输入一个整数"))
# 使用8除以用户输入的整数并且输出
result = 8 / num
print(result)
except ZeroDivisionError:
print("除0错误")
except ValueError:
print("请输入正确的整数")
完整的代码块
try:
# 提示用户输入一个整数
num = int(input("请输入一个整数"))
# 使用8除以用户输入的整数并且输出
result = 8 / num
print(result)
except Exception as reslut:
print("未知错误:%s" % reslut)
else:
print("尝试成功")
pass
finally:
print("无论是否出现错误都会被执行的代码")
pass
结果
请输入一个整数0
未知错误:division by zero
无论是否出现错误都会被执行的代码
主动抛出异常
f input_password():
# 提示用户输入密码
pwd = input("请输入密码")
# 判断密码长度
if len(pwd) >= 8:
return pwd
# 如果小于8主动抛出异常
print("主动抛出异常")
# 创建异常对象
ex = Exception("密码长度不够")
# 提示用户输入密码
raise ex
try:
print(input_password())
except Exception as result:
print(result)
结果
请输入密码k
主动抛出异常
密码长度不够
模块
模块提供：全局变量、函数、类，注意：直接执行的代码不是向外界提供的工具
包
制作模块和发布
from distutils.core import setup
setup(name="case_message", # 包名
version="1.0", # 版本
description="case's接收和发送消息的模块", # 描述信息
author="case", # 作者
author_email="case@rain1596497686.com", # 作者邮箱
url="www.baidu.com", # 主页
py_modules=[
"case_message.send_message",
"case_message.send_message"
]
)
安装第三方模块
对文件的操作
read文件读取
# 打开文件
file = open("case_name")
# 读取文件内容
text = file.read()
print(text)
# 关闭文件
file.close()
文件打开后默认是只读的方式
按行读取内容
小文件复制：
# 1. 打开
file_read = open("readme.txt") # 默认只读方式打开
file_write = open("readme[复件].txt", "w") # w 只写方式打开
# 2. 读、写
text = file_read.read() # read()一次性读取所有内容
file_write.write(text)
# 3. 关闭
file_read.close()
file_write.close()
大文件复制：
# 1. 打开
file_read = open("readme.txt") # 默认只读方式打开
file_write = open("readme[复件].txt", "w") # w 只写方式打开
# 2. 读、写
while True:
# 读取一行内容
text = file_read.readline()
# 判断是否读取到内容
if not text:
break
file_write.write(text)
# 3. 关闭
file_read.close()
file_write.close()
# *-* coding:utf8 *-*
针对eval（）函数直接使用input输入的内容，可用一下函数对内容进行破坏
__import__('os').system('touch a')
错误提示
SyntaxError :invalid syntax
语法错误 ：语法无效
NameError :name ‘print’ is not defined
名称错误：‘print’名字没有定义
IndentationError ：unexpected indent
缩进错误：不期望出现的缩进
IndexError: list index out of range
列表索引超出范围
IndexError: list assignment index out of range
索引错误列表指定的索引超出范围
ValueError：substring not found
子字符串未找到
总结
本文章有许多内容需要完善，持续完善中
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
