学习笔记｜Python
本文最后更新于：1 年前
零、背景
01编译器
1.1区分
编译器：将程序翻译成机器语言的工具。
解释器：当编译器以解释方式运行时，也称之为解释器。
1.2翻译方式
编译器翻译的方式有两种：（区别：翻译的时间点不同）
编译：编译编译型语言
解释：解释解释型语言
1.3对比
- 速度：编译型语言执行速度更快。
- 跨平台型：解释型语言跨平台型更好。
02设计目标
1999年，吉多·范罗苏姆提出了Python的目标：
- 一门简单直观的语言，并与主要竞争者一样强大。
- 开源，以便任何人都可以为它做贡献。
- 代码像纯英语一样容易理解。
- 适用于短期开发的日常任务。
03设计哲学
优雅
明确
简单
Python开发者的哲学是：用一种方法，最好是只有一种方法来做一件事。
如果面临多种选择，Python开发者一般拒绝花哨的语法，而选择明确没有或者很少有歧义的语法。
在Python社区，吉多被称为“仁慈的独裁者”
04特点
- 完全面向对象：在Python中一切皆对象。
- 强大的标准库
- 大量的第三方模块
一、执行程序
01执行方式
1.1 脚本式
python/python3
>>> python HelloPython.py1.2 交互式
IDLE 中 shell
- 优点：适合学习和验证语法或局部代码
- exit（）/ ctrl+D 退出解释器
1.3 集成开发环境
集成开发环境（Intergrated development environment) —— 集成了开发软件需要的所有工具
1）Pycharm技巧
- if代码块可折叠
- if代码块，光标所在位置有提示
- ctrl + / 批量添加多行的单行注释
- 在函数名处的提示中，添加函数文档注释（自动显示形参注释）
2）Pycharm命名规则
- 文件名：小写字母、数字、下划线
- 文件名不能以数字开头
3)单步越过和单步进入
Step Over（F8）：单步越过，_跳过_函数内部
Step Into（F7）：单步进入，_进入_函数内部
02常见错误
NameError：name 'pprint' is not defined：名称错误SyntaxError：invalid syntax：语法错误IndentationError：unexpected indent：缩进错误
03执行原理
3.1计算机中的三大件
- CPU
- 中央处理器，超大规模的集成电路
- 负责 处理数据/计算
- 内存
- 临时储存数据（断电后，数据消失）
- 速度快
- 空间小（单位价格高）
- 硬盘
- 永久储存数据
- 速度慢
- 空间大（单位价格低）
3.2程序执行原理
- 程序运行前，被保存在硬盘之中
- 当要运行一个程序时，
- 操作系统先让CPU把程序复制到内存中
- CPU 执行内存中的代码
程序要执行，首先被加载到内存中
3.3python执行原理
- 操作系统让 CPU 把 Python解释器 的程序复制到内存中
- Python解释器根据语法规则，从上向下翻译Python程序中的代码
- CPU负责执行翻译完成的代码
- Python解释器有多大（3.4M）？
# 1.确认解释器位置
$ which python3
#2.查看 python3 文件大小(只是一个软链接)
$ls -lh /usr/bin/python
#3.查看具体文件大小
$ls -lh /usr/bin/python2.7建立软连接的目的，是为了方便使用者不用记住解释器的版本号
04代码规范
- python官方代码格式文档：PEP8
- Google 开源项目风格指南
任何语言的程序员，编写出符合规范的代码，是开始程序生涯的第一步。
二、基本语法
01注释
1.1单行注释
- 格式：
#后面建议先写一个空格，再写注释文字
# 注释写在代码上方
ptint("Hello，Python！")- 格式：代码和注释间至少两个空格
ptint("Hello，Python！") # 代码和注释之间至少两个空格1.2多行注释
- 格式：三个引号（单引号或者双引号）
"""
连续敲三个引号，
在引号中间输入多行注释
"""
print（"hello！"）1.3什么时候需要使用注释
- 对于复杂操作，应在操作开始前，写上注释。
- 对于不是一目了然的代码，应在其行尾添加注释。
- 不要描述代码，应注释为什么写这行代码。
02算术运算符
| 运算符 | 描述 | 样例 |
|---|---|---|
| + | ||
| - | ||
| * | ||
| / | ||
| % | 取余 | 9 % 2 （返回余数=1） |
| // | 取整除 | 9 // 2 （返回商=4） |
| ** | 幂 | 2 ** 3（返回乘积=8） |
- 在python 中
*运算符可用于字符串，计算结果是字符串重复制定次数的结果
print("-" * 3) # 打印结果为 '---'03变量
3.1变量原理
1）QQ运行过程
QQ在运行前，被保存在硬盘中
运行之后，QQ程序就会被加载到内存中
读取用户输入的账号和密码
把读取的账号和密码存储到内存中
将账号和密码发送给腾讯服务器
2）储存账号密码
- 在内存中为账号和密码各自分配一块空间
- 在QQ程序结束前，这两块空间由QQ程序负责管理，其他程序不允许使用
- 在QQ自己使用完成之前，这两块空间只保存账号和密码
- 使用一个别名，标记账号和密码在内存中的位置
- 在程序内部，为账号和密码在内存中分配的空间就叫做变量
- 程序就是用来处理数据的！变量就是用来储存数据的！
3.2变量定义
格式：变量名 = 值
name = "python"- python 中定义变量不需要制定类型
3.3变量类型
- 数据类型分为数字型和非数字型
1）数字型
| int | 整型 | |
|---|---|---|
| float | 浮点型 | |
| bool | 布尔型 | True 非0数、Flase 0 |
| complex | 复数型 | 主要用于科学计算 |
2）非数字型
| 字符串 | |
|---|---|
| 列表 | |
| 元组 | |
| 字典 |
- 用
type函数查看变量的类型
>>> type(a)
<class 'str'>3.4不同类型变量运算
- 数字变量之间可以进行算数运算
True= 1Flase= 0
- 字符串变量之间使用
+连接
>>> a = "张"
>>> b = "三"
>>> a + b
'张三'- 字符串变量 和 整型变量 使用
*重复拼接相同的字符串
>>> "-" * 5
'-----'3.5变量命名
1）标示符
- 标识符 *就是 *变量名、函数名
- 标示符需要见名知意
2）规则
- 字母、下划线、数字组成
- 不能以数字开头
- 不能与关键字重名
3）关键字
用以下命令可以查看 Python 中的关键字：
import keyword
print(keyword.kwlist)结果如下：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']4）风格
- 下划线法（Python推荐）
- 大驼峰
- 小驼峰
04函数
4.1 print函数
- 打印
print("hello,python!")
print(name)
# 不换行打印- 格式化输出
| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %06d | 有符号十进制，06 表示输出整数显示位数，不足的地方用 0 补全 |
| %0.2f | 浮点数，0.2表示小数点后只显示两位 |
| %% | 输出% |
# print(”格式化字符串“ % 变量名)
# 当输出多个变量时，% 后接一对括号，括号中用 逗号 分隔变量名
print("我的学号是 %06d ，我的名字时 %s" % (student_no, name))- 当变量发生运算时，
# 这是把字符串输出10遍
print("数据比例为：%.2f%%" % scale * 10)
# 这是把 scale的值乘10
print("数据比例为：%.2f%%" % (scale * 10))- 转义字符
| \t | 垂直制表符 | 垂直方向，保持对齐(4位) |
|---|---|---|
| \r | 回车 | 将光标的位置，回退到本行的开头位置 |
| \n | 换行符 | |
| \\ | 反斜杠 | |
| \‘ | 单引号 | |
| \“ | 双引号 |
- \r 的使用
# 进度条功能
import time
for i in range(20):
print("\r" + "【" + "■" *i + " " *(19-i) + "】", sep="", end="")
time.sleep(0.2)
print("\n下载完成")# 显示倒计时
import time
for i in range(10):
print("\r离程序退出还剩%s秒" % (9-i), end="")
time.sleep(1)# 缓冲转圈
import time
lst = ["\\", "|", "/", "——"]
for i in range(20):
j = i % 4
print("\r" + lst[j], end="")
time.sleep(0.2)4.2 input函数
- input接收的任何内容 ，Python都认为是一个字符串
age = input("请输入信息：")4.3类型转换函数
- int(x)
- float(x)
4.4定义函数 & 调用函数
封装 独立的功能
def关键字（定义一个函数）
# 该文件命名为 new_function.py （符合标识符命名规则）
def my_fun()：
print("这个函数可以打印这句话")import关键字 （导入文件，调用函数）
import new_function
new_function.my_fun # 调用 new_function.py 中的 my_fun 函数return关键字
def sum(num1,num2):
return num1 + num2- 格式：
- ⚠️定义函数有
()和:，参数在()中 - ⚠️调用函数用
. dfe是define的缩写- 函数名 与 模块名（即函数的 python文件名）命名应该符合标识符的命名规则
- ⚠️定义函数有
4.5函数的文档注释
- 函数定义的上方 保留两个空行
- 注释写在函数名下面，用三个双引号 *
"""""*
05语句
5.1 判断
if后加一个空格，条件后加冒号:，else*后直接加 *:- 代码缩进四个空格 或者 一个
Tab键 【建议使用空格】 - 在Python 开发中，
Tab键和空格不混用
if age > 18:
print("已成年！")
elif age == 18:
print("刚成年！")
else:
print("未成年！")if嵌套格式
if sex == 1:
if age > 18:
print("允许参战")
else:
print("未成年不允许")
else:
print("以防受伤")5.2逻辑运算
and: 与or：或not：非
not使用场景：- 希望某个条件不满足时，执行一些代码
- 需要拼接复杂的逻辑计算条件
# not + 布尔型变量
is_dog = True
if not is_dog:
print("不是狗狗")5.3循环语句
- while
- break
- continue
i = 0;
while i < 10:
if i % 3 == 0:
print(i)
else:
i += 1;
continue
print("已打印")
i += 2- for
for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环，循环结束后，会执行代码应用场景：
在 迭代遍历 嵌套的数据类型时，例如 一个列表包含多个字典
需求：要判断 某一个字典中 是否存在指定的值
- 如果 存在，提示并且退出循环 【break 来完成】
- 如果 不存在，在 循环整体结束 后，得到一个统一的提示 【else 来完成】
student = [
{"name" : "阿土"}，
{"name" : "阿美"}
]
find_name = "阿美"
for stu_dict in student:
if stu_dict["name"] == find_name:
print(stu_dict)
print("已找到！")
break # 已经找到后，无需继续循环
else:
print("没找到！")06工具包
先导入工具包，后使用包内函数
6.1 keyword
- kwlist函数：查看关键字
6.2 random
- randint()函数：随机生成数，类型int
# 随机生成数，包括1和10
random.randint("1,10")07关键字、函数、方法
7.1关键字
- 是 Python 内置的、具有特殊意义的标识符
- 关键字后不需要使用括号
7.2函数
- 函数 封装了独立功能，可以直接调用
# 函数后面要加括号
函数名（参数）7.3方法
- 方法 和 函数 类似，同样是封装了独立功能
- 方法 需要通过 对象 来调用，表示针对这个 对象 要做的操作
对象.方法名（参数）三、高级变量
01列表（List）
1.1定义格式
- 列表定义： 在其他语言中叫做数组
- 列表用
[]定义，数据之间用,分隔
>>> name_list01 = [] # 创建一个空列表
>>> name_list02 = ["hu", "wen", "tao"] # 创建一个有三个数据的列表
>>> print(name_list02[0])
hu1.2常用操作
- 在
IDLE定义一个列表name_list - 输入
name_list.，按下Tab键，按上下箭头翻找方法
>>> name_list = []
>>> name_list.append| 分类 | 方法 | 说明 |
|---|---|---|
| 增加 | 列表.insert（索引，数据） | 在索引位置插入数据 |
| 列表.append（数据） | 在末尾追加数据 | |
| 列表.extend（列表2） | 将列表2的数据追加在列表中 | |
| 修改 | 列表[索引] = 数据 | |
| 删除 | del列表[索引] | 从内存中删除指定索引数据 |
| 列表.remove[数据] | 删除第一个出现的制定数据 | |
| 列表.pop | 删除末尾数据 | |
| 列表.pop（索引） | 删除指定索引数据 | |
| 列表.clear | 清空列表 | |
| 统计 | len（列表） | 列表长度 |
| 列表.count（数据） | 数据在列表中出现次数 | |
| 排序 | 列表.sort（） | 升序排序 |
| 列表.sort（reverse=True） | 降序排序 | |
| 列表.reverse（） | 逆序、反转 |
1）del关键字
del 本质上是 用来将一个变量从内存中删除
name = “tom”
del name
name_list = ["张三","李四","王五"]
del name_list[1]⚠️注意：
使用del 关键字将变量从内存中删除后，后续代码就不能再使用这个变量
del name_list[1] 可以删除数据，但是推荐用列表方法
2）len函数
- 统计列表中的元素总数
list_len = len(list_name)3） count方法
- 统计列表中某一个数据出现的次数
# 统计 Tom 在列表name_list中出现的次数
count = name_list.count("Tom")4） remove方法
- 删除第一次出现的数据
name_list.remove("张三")5）sort方法
- 默认升序排序 reverse = Flase
# 降序排序
name_list.sort(reverse=True)1.3循环遍历
在
python中为了提高列表遍历效率，专门提供了迭代遍历（iteration）
- 顺序地从列表中获取数据，并放入一个变量中
name_list = ["zhangsan","lisi","wangwu"]
for my_name in name_list:
print("my name is %s" % my_name)1.4列表应用场景
- 储存同类型数据
- 通过 迭代遍历，在循环体内部，针对每一项元素，执行相同的操作
02元组（Tuple）
- 元组
Tuple与 列表List类似， - 相似之处：
- 用于储存一串数据，数据之间用
，分隔
- 用于储存一串数据，数据之间用
- 不同之处：
- 元组用
()定义 - 元组中的元素定义完成，便不能修改
- 元组用
2.1定义一个元素的元组
正确样例：
single_tuple = (5,) many_tuple = (5,6,7)+ 错误样例： + `Python` 解释器会将 `5` 当作 `int` 型变量 ```python single_tuple = (5)
2.2常用操作
- 在
IDLE定义一个列表info_tuple - 输入
info_tuple.，按下Tab键，按上下箭头翻找方法
>>> info_tuple = []
>>> info_tuple.index| 方法 | 说明 |
|---|---|
| 元组.count（数据） | 统计该数据在元组中出现的次数 |
| 元组.index（数据） | 确定该数据在元组中的索引 |
- count方法
info_tuple = ("zhangsan", 18, 1.75)
# 统计 “zhangsan” 出现的次数
print(info_tuple.count("zhangshan"))- index 方法
info_tuple = ("zhangsan", 18, 1.75)
# 统计 “zhangsan” 在元组的索引
print(info_tuple.index("zhangshan"))2.3元组的应用场景
函数的 参数 和 返回值，一个函数可以接受任意多个参数，或者 一次返回多个数据
格式化字符串，格式化字符串后面的
()本质上是个元组让列表不可以修改，以保护数据安全
info_tuple = ("小明", 18)
print("%s 年龄是 %d" % ("小明", 18))
print("%s 年龄是 %d" % info_tuple)- ⚠️用格式化字符串，拼接生成新的字符串
info_str = "%s 年龄是 %d" % info_tuple2.4元组和列表转换
list函数：将元组转化为列表
list(元组)tuple函数：将列表转化为元组
tuple(列表)03字典（dictionary）
3.1定义格式
dictionary（字典）是除列表以外，python 中 最灵活 的数据类型字典同样可以 储存多个数据
- 用来 描述一个物体 的相关信息
和列表的区别
- 列表 是 有序 的对象集合
- 字典 是 无序 的对象集合（不关心保存顺序）
字典用
{}定义字典使用 键值对 储存数据，键值对 之间使用
,分隔- 键
key是索引 - 值
value是数据 - 键 和 *值 * 之间使用
:分隔 - 键必须是唯一的
- 值 可以取任何数据类型，但 键 只能使用 字符串、数字、元组
- 键
# 前面是键，后面是值，中间用 冒号 分隔
xiaoming_dict = {"name":"小明",
"age":18,
"gender":True,
"height":175}3.2常用操作
- 取值
# 在取值的时候，如果指定的 key 不存在，程序会报错！
print(xiaoming_dict["name"])
# 字典.get(key)，当key不存在时不报错!
xiaoming_dict.get("name")- 增加/修改
# 如果key不存在，会新增键值对
xiaoming_dict["farther"] = "大明"
# 如果key存在，会修改键值对
xiaoming_dict["age"] = 19- 删除
- 使用 pop 函数删除数据
# 在删除的时候，如果指定的 key 不存在，程序会报错！
xiaoming_dict.pop("name")1）len函数
- 统计 键值对 数量
print(len(xiaoming_dict))2）update方法
- 合并字典
- 如果被合并的字典中包含已存在的键值对，会覆盖原有的键值对
# 新建一个临时键值对
temp_dict = {"height":1.75，
"age":20}
# 将临时键值对合并入 xiaoming_dict 字典中
xiaoming_dict.update(temp_dict)3）clear方法
- 清空字典
xiaoming_dict.clear3.3循环遍历
- 遍历字典中的所有
key，再根据key获取value
for key in xiaoming_dict:
print("%s : %s" %(key, xiaoming_dict[key]))3.4应用场景
- 使用 多个键值对，储存 描述一个物体 的相关信息 — 描述更复杂的数据信息
- 将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部，针对每个字典进行 相同的处理
- card_list = [ { }, { }, { } ]
card_list = [{"name":"zhangsan",
"qq":1213123,
"phone":10086},
{"name":lisi,
"qq":980890,
"phone":10010}
]04字符串
- 用
""''定义字符串- 如果字符串内部需要使用
""，则使用''来定义 - 如果字符串内部需要使用
‘’，则使用“”来定义
- 如果字符串内部需要使用
4.1循环遍历
- 依次取出每个字符
hello_str = “hello，python”
for c in hello_str:
print(c)4.2len函数
- 统计字符串长度
print(len(hello_str))4.3count方法
- 统计某一子串出现的次数
print(hello_str.count("llo"))4.4index方法
- 统计某一个子串第一次出现的位置
# 如果使用index方法传递的子串不存在，程序会报错
print(hello_str.index("llo"))4.5常用操作
string 内置的方法超级多
1）判断类型 -9
| 方法 | 描述 |
|---|---|
| string.isspace() | 判断 string 中只包含空白字符（空格和转义字符），则返回 True |
| string.isalnum() | 如果 string 至少有一个字符，且所有字符都是字母或者数字，则返回True |
| string.isalpha() | 如果 string 至少有一个字符，且所有字符都是字母，则返回True |
| string.isdecimal() | 如果 string 只包含数字，则返回 True，（不能识别小数） |
| string.isdigit() | 如果 string 只包含数字，则返回 True，（不能识别小数）、（1）、\u00b2 【unicode字符串】 |
| string.isnumeric() | 如果 string 只包含数字，则返回 True，（不能识别小数）、（1）、\u00b2、汉字数字 |
2）查找和替换 -7
| 方法 | 描述 |
|---|---|
| string.startswith(str) | 检查字符串是否以 str 开头，是则返回 True |
| string.endswith(str) | 检查字符串是否以 str 结束，是则返回 True |
| string.find(str,start=0,end=len(string)) | 检查 str 是否包含在指定范围 start - end 内，如果是则返回开始的索引值，否则返回-1 |
| string.replace(old_str,new_str,num=string.count(old)) | 把 string 中的 old_str 替换成 new_str，如果有num，则替换次数不超过num次【不改变原有的字符串，返回新的字符串】 |
3）大小写转换 -5
4）文本对齐 -3
| 方法 | 描述 |
|---|---|
| string.ljust(width) | 返回一个原字符串左对齐，并用空格填充至长度 width 的新字符串 |
| string.rjust(width) | 返回一个原字符串右对齐，并用空格填充至长度 width 的新字符串 |
| string.center(width) | 返回一个原字符串居中，并用空格填充至长度 width 的新字符串 |
5）去除空白字符 -3
| 方法 | 描述 |
|---|---|
| string.lstrip() | 截掉 string 左边（开始）的空白字符 |
| string.rstrip() | 截掉 string 右边 （开始）的空白字符 |
| string.strip() | 截掉 string 左右两边的空白字符 |
6）拆分和连接 -5
| 方法 | 描述 |
|---|---|
| string.split(str=””,num) | 以 str 为分隔符拆分 string，如果num存在，则仅分隔 num+1 个字符串，若 split 无参数，则 str 默认包含 ‘\r’、‘\n’、’\t’ 和空格 |
| string.join(seq) | 以 string 作为分隔符，将 seq 中所有元素合并成一个新的字符串【seq可以是列表】 |
05共同方法
5.1切片
切片 方法适用于 字符串、列表、元组
通过 索引值 来限定范围 ，包括前索引对应数值，不包括后索引对应数值。【左开右闭】
正序索引（0，1，2） 倒序索引（-1，-2，-3）
当结束索引为空，便可切到字符串末尾
# 字符串[开始索引:结束索引:步长]
# 该切片为str[0]、str[1]
str[0:2:2]5.2 Python内置函数
| 函数 | 描述 | 备注 |
|---|---|---|
| len(item) | 计算容器中的个数 | |
| del(item) | 删除变量 | del 有两种使用方式【关键字 和 函数】 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只比较 key |
| min(item) | 返回容器中的元素最小值 | 如果是字典，只比较 key |
5.3运算符
| 运算符 | Python表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1,2] + [3,4] | [1,2,3,4] | 合并 | 字符串、列表、元组 |
| * | [“hi”] * 3 | [“hi”,”hi”,”hi”] | 重复 | 字符串、列表、元组 |
| in | 3 in (1,2,3) | True | 元素是否存在 | 字符串、列表、元组、字典【key】 |
| not in | 4 not in (1,2,3,4) | True | 元素是否不存在 | 字符串、列表、元组、字典【key】 |
| > >= == < <= | (1,2,3) < (2,2,3) | True | 元素比较 | 字符串、列表、元组 |
注意：
in和not in对 字典 进行操作时，判断的是 字典的键in和not in被称为 成员运算符
四、项目训练：名片管理
01框架搭建
- 搭建 名片管理系统 框架结构
- 准备文件，确定文件名，保证能 *在需要的位置 * 编写代码
- 编写 主运行循环，实现基本的 用户输入和判断
1.1文件准备
- 新建 card_main.py 保存 主程序功能代码
- 程序的入口
- 每一次启动名片管理系统都通过 main 这个文件启动
- 新建 card_tools.py 保存 所有名片功能函数
- 将对名片的 新增、查询、修改、删除 等功能封装在不同的函数中
1.2 pass关键字
如果开发时，不希望立即编写分支内部的代码，
可以使用 pass 关键字，表示已一个占位符，能够保证程序的代码结构正确
pass 不会执行任何操作
1.3 TODO注释
- 在
#后跟上TODO，用于标记需要去做的工作 - pycham 中左下角有 TODO 列表
# TODO(作者/邮箱) 注释内容
代码。。。1.4 shebang符号（#!）
- shebang 在 unix 系统脚本中的 第一行开头 使用
- 指明 执行这个文件 *的 *解释程序
例如：
- 如果解释器 python3 在 /usr/bin/python3，
- 使用shebang符号就可以在终端中使用
./文件名.py就可以执行 - 前提修改
文件名.py的读写权限chomd +x 文件名.py
#！ /usr/bin/python3
print("这样就可以直接在终端中执行命令")五 、变量进阶
01变量的引用
- 变量 和 数据 都是保存在 内存 中
- 在 python 中 函数的 参数传递 以及 返回值 都是靠 引用 来传递的
在python中
变量 和 数据 都是分开存储的
数据 保存在内存中的一个位置
变量 中保存着数据在内存中的地址
变量中记录着数据的地址，就叫做 引用
使用
id()函数来查看 变量中保存的内存地址
注意：如果变量已被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用
- 变量 不再 对之前的数据引用
- 变量 改为 对新赋值的数据引用
>>> a = 1
>>> id(1)
4305020032
>>> id(a)
4305020032 # 原引用
>>> a = 2
>>> id(2)
4305020064
>>> id(a)
4305020064 # 新引用02可变类型和不可变类型
- 不可变类型，内存中的数据不允许被修改
- 数字类型 int bool float complex long(2,x)
- 字符串 str
- 元组 tuple
- 可变类型，内存中的数据可以被修改
- 列表
- 字典
注意：
用 方法 修改 可变类型数据，地址不改变
使用 赋值语句 修改 可变类型数据，地址发生改变
>>> a = [1,2,3]
>>> id(a)
4561371272 # 原地址
>>> a.append(99)
>>> a
[1, 2, 3, 99]
>>> id(a)
4561371272 # 地址不变
>>> a.clear()
>>> a
[]
>>> id(a)
4561371272 # 地址不变
>>> a = []
>>> id(a)
4561371656 # 使用赋值语句更改数据，地址改变字典中的 key 只能用不可变类型数据
03 hash函数
- python内置有一个hash(参数)
- 传递一个 不可变类型参数
- 返回一个 整数
>>> hash("hello")
3690660419994397917- 在
python中，设置字典的 键值对 时，会首先对key进行hash以确定内存中保存字典的数据，方便后续的增删改查
04 全局变量和局部变量
- 注意：
python中 函数内部不能直接修改全局变量的引用 — 使用赋值语句修改全局变量的值
num = 10
def:
num = 99 #只能新建一个局部变量 num=99，不能修改 全局变量 num=10- 只能使用
global进行声明，才可以在函数内部修改全局变量
num = 10
def:
global num #global 关键字会告诉解释器后面的变量时一个全局变量
num = 99- 全局变量定义位置：
- 所有函数上方
- 全局变量命名建议
- 为避免局部变量和全局变量混淆，全局变量前应增加
g_或者gl_的前缀
- 为避免局部变量和全局变量混淆，全局变量前应增加
六、函数进阶
01返回多个数据
使用元组让函数一次返回多个值
如果函数返回类型时元组，小括号可省略
def math(a,b):
c = a + b
d = a * b
return c,d #也可以写成 return（c,d）02接收多个数据
- 返回i值为元组时，用多个变量一次接收函数的返回值
def math(a,b):
c = a + b
d = a * b
return c,d
gl_c,gl_d = math(a,b) # 可依次接收返回值的各个数据03交换两个数字
Python 专有，利用元组
a = 6
b = 100
a, b = (b, a) # 用 a,b 来接收元组（a,b）
a, b = b, a # 括号可以省略七、参数进阶
01用赋值语句修改参数
- 无论传递的参数是可变的还是不可变的，使用赋值语句修改局部变量的引用，不会影响到外部实参
def demo(num):
num = 200
print(num) # 200
gl_num = 10
demo(gl_num)
print(gl_num) # 10 实参没有改变02用方法修改参数
- 传递参数是可变类型，使用方法修改数据的内容，不修改变量引用，同样会改变外部数据
def demo(num_list):
num_list.append(9)
print(num_list) # 1,2,3,9
gl_list = [1,2,3]
demo(gl_list)
print(gl_list) # 1,2,3,9 实参被改变03 += 的本质
列表变量调用
+=本质上是在执行列表变量的extend方法，不会修改变量的引用，改变数据内容num += 1是在做先相加再赋值的操作（针对数字和字符串）。
def demo(num,num_list):
# num = num + num #修改引用，不影响外部实参
num += num
print(num)
# 本质上是在调用 extend 方法
# num_list.extend(num_lsit) #直接修改数据内容 影响外部实参
num_list += num_list
print(num_list)
gl_num = 9
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(num)
print(num_list)04缺省参数
定义函数时，给某个参数指定一个默认值，具有默认值的参数就叫做 缺省参数
调用函数时，若没有传入 缺省参数 的值，则在函数内部使用 默认参数值
设置缺省参数时，应将最常见的值，设置为参数的缺省值，从而简化函数的调用
1.1 指定函数的缺省参数
- 在参数后面使用赋值语句
def print_info(name,gender=True):
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s 是 %s" %(name,gender_text))1.2缺省参数注意事项
1）缺省参数的定义位置
- 必须保证 带有默认值的缺省参数 在参数列表末尾
def print_info(name, title, gender=True):2）调用带有多个缺省参数的函数
- 调用函数时，如果有多个缺省参数，传参需指定参数名
def print_info(name, title="007", gender=True):
# 调用时，传参需指定参数名
print_info("小明",gender=False)05多值参数
5.1定义多值参数的函数
有时需要 一个函数 能够处理的参数 个数 是不确定的，这时使用 多值参数
python中有 两种 多值参数：- 形参前加
*可以接收 元组 - 形参前加
**可以接收 字典
- 形参前加
习惯命名：
*args——存放 元组 参数**kwargs——存放 字典 参数
args 是 arguments 的缩写，kw 是 keyword 的缩写
def demo(num, *args, **kwargs):
print(num)
print(args)
print(kwargs)
demo(1,2,3,4,5,name="xiaoming") # 重点：传参方式，自动识别
#打印结果如下
1
（2，3，4，5）
{‘name’:‘xiaoming’}5.2元组和字典的拆包
在调用多值参数的函数时，如果希望：
- 将一个元组，直接传递给
args - 将一个字典，直接传递给
keargs
- 将一个元组，直接传递给
就使用拆包，简化参数传递，拆包的方式是：
- 在 元组变量前，增加
* - 在 字典变量前，增加
**
- 在 元组变量前，增加
def demo(*args,**kwargs):
print(args)
print(kwargs)
gl_nums = (1,2,3)
gl_info = {'name':'小明','age':18}
# 需要将整个元组/字典 传递给函数对应的参数
demo(*gl_nums,**gl_info)八、面向对象
面对对象编程 —— Object Orientd Programming 简写 OOP
###01基本概念
1.1面对过程–怎么做？
- 把完成某一个需求的 所有步骤 从头到尾 逐步实现
- 把某些 功能独立 的代码 封装 成一个又一个 函数
- 最后完成代码，顺序地 调用不同的函数
特点：
注重步骤和过程，不注重职责分工
如果需求复杂，代码会很复杂
开发复杂项目，没有固定套路，难度大
1.2面对对象–谁来做？
相比较函数，面对对象 是 更大的封装 ，根据 职责 在 一个对象中封装多个方法
- 在完成某一个需求时，首先确认 职责 —— 要做的事情（方法）
- 根据 职责 确定不同的 对象，在 对象 内部封装不同的 方法（多个）
- 最后完成代码，顺序地让 不同的对象 调用 不同的方法
特点：
- 注重 对象和职责，不同的对象承担不同的职责
- 更加适合应对复杂的需求变化，是专业应对复杂项目开发，提供的固定套路
- 需要在面向过程的基础上，在学习一些面向对象的语法
02面对对象
2.1 类
- 类 是对一群具有 相同 特征 和 行为 的事物的一个统称，是抽象的，不能直接使用
- 特征 被称为 属性
- 行为 被称为 方法
2.2 对象
- 对象 是 由类创建出来的一个具体存在，可以直接使用
- 属性
- 方法
2.3 类的设计
1）三要素
- 在程序开发中，要设计一个类，满足三个要素：
- 类名 这类事物的名字，满足大驼峰命名法
- 属性 这类事物具有什么样的特征
- 方法 这类事物具有什么样的行为
2）类名的确定
- 名次提炼法 分析整个业务流程，出现的 名词 ，通常就是找到的类
3）属性和方法的确定
- 对 对象的特征描述，通常可以定义为 属性
- 对象具有的行为（动词），通常可以定义为 方法
03基本语法
3.1dir内置函数
- 查看对象的所有属性及方法
gl_list = [1,2]
dir(gl_list)3.2定义类
- 方法中，第一个参数必须是 self
- 类名的命名规则 要符合 大驼峰命名法
class 类名:
def 方法(self,参数列表):
pass
def 方法(self,参数列表):
pass3.3创建对象
对象变量 = 类名()引用的概念强调
用 print 输出对象变量，能够输出 给对象是由哪一类创建的对象，以及在内存中的地址（十六进制）
class Cat:
def eat(self):
pass
tom = Cat()
print(tom)输出的结果为： <main.Cat object at 0x1030a3cc0>
3.4给对象增加属性
- 只需要在类的外部，直接通过
.来设置属性【不推荐】 - 不推荐的原因：如果在运行的时候，没有找到属性，程序就会报错
class Cat:
def eat(self):
pass
tom = Cat()
tom.name = "小猫"3.5初始化方法
- 当使用
类名（）创建对象时，会自动执行以下操作：- 为对象在内存中 分配空间 –创建对象
- 为对象的属性 设置初始值 –初始化方法
- 这个 初始化方法 就是
__init__方法，__init__是对象的内置方法 __init__方法 是专门用来定义一个类 具有哪些属性 的方法
class Cat():
def __init__(self): # 创建类时，被自动调用
print("初始化方法执行完毕！")
tom = Cat()3.6在初始化方法内部定义属性
__init__方法内部使用self.属性名 = 属性的初始值就可以定义属性- 定义属性后，使用类创建的对象，都有该属性
class Cat:
def __init__(self):
self.name = "小猫"
tom = Cat()
print(tom.name)3.7初始化的同时定义初始值
- 在创建对象的同时，根据传入的参数设置对象的属性，用
__init__方法 进行改造- 设置形参接收参数
- 将参数传递给
self.属性名
class Cat:
def __init__(self,new_name):
self.name = new_name
tom = Cat("小猫")
print(tom.name)3.8_del_方法
- 在python中，
- 使用
类名()创建对象时，分配完空间后，自动调用__init__方法 - 当对象被销毁时，自动调用
__del__方法
- 使用
- 应用场景
__init__方法 ：改造初始化方法，让创建对象时，更加灵活__del__方法：希望在销毁对象之前，可以再做一些事情
- 生命周期
- 对象的生命周期 是 调用
__init__和 调用__del__之间的时间
- 对象的生命周期 是 调用
calss Cat():
def __init__(self):
print("初始化方法执行了！")
def __del__(self):
print("该对象内存即将销毁！")
tom = Cat()
print("--" )- 运行结果为：
初始化方法执行了！
--
该对象内存即将销毁！因为 tom 变量是全局变量，只有在整个程序结束的时候，才会销毁tom变量的内存空间，才会执行
_del_方法
3.9_str_方法
在python中，打印对象变量，默认会打印出 这个变量 是由哪一类创建的对象，以及在内存中的地址（十六进制）
如果希望打印对象变量时，能够打印自定义的内容，就可以使用
_str_方法
class Cat:
def __str__(self):
return "这个内置方法返回一个字符串"- 还可以让返回值带有参数
class Cat:
def __init__(self,new_name):
self.name = new_name
def __str__(self):
return "我的名字叫 %s" % self.name3.10封装案例一
需求：
- 房子有户型、总面积、家具名列表
- 新房子没有任何家具
- 家具有名字和占地面积
- 席梦思（bed）：4
- 衣柜（chest）：2
- 餐桌（table）：1.5
- 将家具添加到房子中
- 打印房子户型、总面积、剩余面积、家具名列表
分析：
寻找类：房子、家具
类的属性（变量）：
- 房子：户型、总面积、家具列表
- 家具：名称、面积
类的方法：
- 添加家具：判断面积是否足够、重新计算剩余面积
实现：
class Item:
# 接收传入的参数：家具名字、面积
def __init__(self,name,area):
self.name = name
self.area = area
class House:
# 接收传入的参数：户型、总面积
def __init__(self,type,area):
self.type = type
self.area = area
# 将剩余面积初始化为总面积
self.free_area = area
# 将家具列表初始化为空
self.item_list = []
# 打印房子信息
def __str__(self):
return ("户型: %s\n总面积：%.2f\n剩余：%.2f\n家具：%s"
%(self.type,self.area,
self.free_area,self.item_list))
# 添加家具的函数
def add(self,item):
# 添加家具前，先判断剩余面积是否够用
if item.area <= self.free_area:
# 满足条件，更改剩余面积
self.free_area -= item.area
# 将家具名添加到家具列表
self.item_list.append(item.name)
print("添加成功！")
# 如果不够，输出反馈信息
else:
print("%s 的面积太大了，无法添加" %item.name)
# 实例化房子和家具，并添加家具
house = House("01",180)
bed = Item("席梦思",40)
chest = Item("衣柜",2)
table = Item("餐桌",1.5)
house.add(bed)
house.add(bed)
print(house)3.11封装案例二（对象作参数）
- 士兵 许三多 有一把 AK47
- 士兵 可以 开火
- 枪 能够 发射 子弹
- 枪 装填 装填子弹 —— 增加子弹数量
分析：
- 寻找类：士兵、枪
- 类的属性：
- 士兵：名字，枪的类型
- 枪：子弹的数量
- 类的函数：
- 士兵：射击
- 枪：装填子弹、发射子弹
实现：
# 开发一个士兵类
class Soldier:
def __init__(self,name):
self.name = name
# 士兵最开始没有发枪
self.gun = None
def kaihuo(self):
# 判断士兵是否有枪
if self.gun is None:
print("%s 没枪！" % self.name)
return
# 让枪装填子弹
self.gun.addzidan(50)
# 让枪发射子弹
self.gun.shoot()
class Gun:
def __init__(self,mode):
# 枪的型号
self.mode = mode
# 枪的子弹数量
self.count = 0
def shoot(self):
if self.count>0:
print("发射子弹!")
self.count -=1
def addzidan(self,count):
self.count = count
xusanduo = Soldier("xusanduo") # 实例化一个 许三多 的士兵
ak47 = Gun("ak47") # 实例化一个 ak47 的枪
xusanduo.gun = ak47 # 把 ak47 给 许三多
xusanduo.kaihuo() # 许三多 开火，实则调用 枪 的方法
print(xusanduo.gun.count) # 打印 子弹剩余数量小结：
将 一个类实例化的对象 当作参数传递给 另一个类（一个对象的 属性 可以是 另外一个类 创建的对象 ）
None关键字 表示 什么都没有- 表示一个 空对象，没有方法和属性，是一个特殊的常量
- 可以将
None赋值给任何一个变量
3.12身份运算符
身份运算符用于比较两个对象的内存地址是否一致 — 是否对同一个对象的引用
- 在对
None进行比较时，建议使用is【PEP8官方文档】
| 运算符 | 描述 |
|---|---|
| is | 判断是不是引用相同的对象 |
| not is | 判断是不是引用不同的对象 |
is 和 == 的区别：
is 用于两个变量 引用的对象是否是同一个
== 用于判断引用变量的值 是否相等
>>> a = [1,2,3]
>>> b = [1,2,3]
>>> a == b
True
>>> a is b
False04私有属性和私有方法
应用场景：
- 对象的某些属性和方法，只希望在对象的内部（在类的内部）被使用，而不希望在外部（在类的外部）被直接访问到
- 私有属性就是对象不希望公开的属性
- 私有方法就是对象不希望公开的方法
定义方式：
- 在i定义属性和定义方法时，在属性名前或者方法名前，增加两个下划线，定义出来的就是私有的属性或方法
class women:
def _init_(self,name):
self.name = name
self.__age = 18 # 定义 age 为私有属性
def secret(self):
print(self.__age)
xiaomei = women("xiaomei")
# 无法直接访问私有属性
print(xiaomei.age)
# 可以通过类中的方法 访问私有属性
xiaomei.secretpython处理方式：
python中，没有真正意义的私有
- python对私有属性、私有方法的处理方法就是，在名称前面加上
_类名__私有属性名或者私有方法名
# 所以直接用 这种方式 也可以访问到私有属性或者私有方法
# 对象名._类名__属性名
print(xiaomei._women__age)九、继承
面对对象的三大特性：
- 封装 根据职责将属性和方法 封装到一个抽象的类中
- 继承 实现代码的重用
- 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
01单继承
1.1单继承的概念和语法
1） 概念： 子类（派生类） 拥有父类（基类）所有的方法和属性
2）语法：
calss 类名(父类名):
pass3）继承的传递性
- 子类 拥有 父类 和 父类的父类 中封装的所有属性和方法
1.2方法的重写
1）应用场景：
- 子类 继承 父类 所有属性和方法
- 当 父类 的方法实现不能满足 子类 需求时，可以对方法进行 重写（override）
2）重写的情况有两种：
- 覆盖 父类的方法
- 扩展 父类的方法
3）覆盖父类的方法
class Animal:
def eat(self):
pass
def bark(self):
pass
class Dog(Animal):
def bark(self):
print("汪！") # 此处子类Dog 覆盖重写了 父类Animal 中的bark()方法4）扩展父类的方法
class Animal:
def eat(self):
pass
def bark(self):
pass
class Dog(Animal):
def bark(self):
print("汪！") # 此处子类Dog 覆盖重写了 父类Animal 中的bark()方法
super().bark(self) # 此处继续保留父类的方法是
super().不是super.super是一个特殊的类super()是由super类创建出来的对象
1.3 父类的私有属性和私有方法
- 私有属性、私有方法 是对象的隐私，外界 及 子类 都不能直接访问
- 私有属性、私有方法 用于做一些内部的事情
- 子类可以通过父类的 公有方法 间接 访问 私有属性、私有方法
02多继承
2.1多继承的概念和语法
1）概念：子类拥有 多个 父类，并具有所有父类的属性和方法
2）语法：
class 子类名(父类名1，父类名2...):
pass2.2多继承的使用注意事项
- 如果 不同的父类 中存在 同名的方法或者属性，应避免使用多继承
2.3Python中的MRO–方法搜索顺序
method resolution orderpython中针对类 类 提供了一个内置属性__mro__可以查看 方法 搜索顺序主要用于在多继承时，判断方法、属性的调用路径
class A:
def test(self):
pass
class B:
def test(self):
pass
class D(A,B): # D继承A和B，A和B拥有重名方法
pass
d = D()
print(D.__mro__) # 查看D类对象调用方法的顺序- 输出结果显示，先查找D类，再查找A类，以及B类（即上面第九行的继承顺序）
- 如果找到，直接执行不再搜素；如果没找到，程序报错。
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)2.4新式类和旧式类（经典类）
object是python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
- 新式类： 以
object为基类的类，推荐使用 - 旧式类： 不以
object为基类的类，不推荐使用
- 在
Python 3.x中定义类时，如果没有指定父类，会 默认使用object作为该类的 基类——Python 3.x中定义的类都是 新式类 - 在
Python 2.x中定义类时，如果没有指定父类，则不会以object作为 基类
新式类 和 经典类 在多继承时 —— 会影响到方法的搜索顺序
为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行！
今后在定义类时，如果没有父类，建议统一继承自 object
class 类名(object):
pass十、多态
- 多态：不同的 子类对象 调用 相同的父类方法 ，产生 不同的执行结果
- 多态可以增加代码灵活度
- 以 继承 和 重写父类方法 为前提
- 多态 是调用方法的技巧，不会影响类的内部设计
01案例演练
需求
- 在
Dog类中封装方法game- 普通狗只是简单的玩耍
- 定义
XiaoTianDog继承自Dog，并且重写game方法- 哮天犬需要在天上玩耍
- 定义
Person类，并且封装一个 和狗玩 的方法- 在方法内部，直接让 狗对象 调用
game方法
- 在方法内部，直接让 狗对象 调用
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍..." % self.name)
class XiaoTianDog(Dog):
def game(self):
print("%s 飞到天上去玩耍..." % self.name)
class Person(object):
def __init__(self, name):
self.name = name
def game_with_dog(self, dog):
print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))
# 让狗玩耍
dog.game()
# 1. 创建一个狗对象
wangcai = XiaoTianDog("飞天旺财")
# 2. 创建一个小明对象
xiaoming = Person("小明")
# 3. 让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)案例小结
Person类中只需要让 狗对象 调用game方法，而不关心具体是 什么狗game方法是在Dog父类中定义的
- 在程序执行时，传入不同的 狗对象 实参，就会产生不同的执行效果
十一、类属性和类方法
01.类的结构
本博客所有文章均个人原创，除特别声明外均采用 CC BY-SA 4.0协议，转载请注明出处！
