学习笔记｜Python

优雅、明确、简单，人生苦短，我用 python。

零、背景

01编译器

1.1区分

**编译器：**将程序翻译成机器语言的工具。

解释器：当编译器以解释方式运行时，也称之为解释器。

1.2翻译方式

编译器翻译的方式有两种：（区别：翻译的时间点不同）

编译：编译编译型语言
解释：解释解释型语n

1.3对比

速度：编译型语言执行速度更快。
跨平台型：解释型语言跨平台型更好。

02设计目标

1999年，吉多·范罗苏姆提出了Python的目标：

一门简单直观的语言，并与主要竞争者一样强大。
开源，以便任何人都可以为它做贡献。
代码像纯英语一样容易理解。
适用于短期开发的日常任务。

03设计哲学

优雅
明确
简单

Python开发者的哲学是：用一种方法，最好是只有一种方法来做一件事。
如果面临多种选择，Python开发者一般拒绝花哨的语法，而选择明确没有或者很少有歧义的语法。

在Python社区，吉多被称为“仁慈的独裁者”

04特点

完全面向对象：在Python中一切皆对象。
强大的标准库
大量的第三方模块

一、执行程序

01执行方式

1.1 脚本式

python/python3

1	`>>> python HelloPython.py`

1.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单行注释

格式：#后面建议先写一个空格，再写注释文字

1 2	`# 注释写在代码上方 ptint("Hello，Python！")`

**格式：**代码和注释间至少两个空格

1	`ptint("Hello，Python！") # 代码和注释之间至少两个空格`

1.2多行注释

**格式：**三个引号（单引号或者双引号）

"""
连续敲三个引号，
在引号中间输入多行注释
"""
print（"hello！"）

1.3什么时候需要使用注释

对于复杂操作，应在操作开始前，写上注释。
对于不是一目了然的代码，应在其行尾添加注释。
不要描述代码，应注释为什么写这行代码。

02算术运算符

运算符	描述	样例
+
-
*
/
%	取余	9 % 2 （返回余数=1）
//	取整除	9 // 2 （返回商=4）
******	幂	2 ** 3（返回乘积=8）

在python 中 * 运算符可用于字符串，计算结果是字符串重复制定次数的结果

1	`print("-" * 3) # 打印结果为 '---'`

03变量

3.1变量原理

1）QQ运行过程

QQ在运行前，被保存在硬盘中
运行之后，QQ程序就会被加载到内存中
读取用户输入的账号和密码
把读取的账号和密码存储到内存中
将账号和密码发送给腾讯服务器

2）储存账号密码

在内存中为账号和密码各自分配一块空间
- 在QQ程序结束前，这两块空间由QQ程序负责管理，其他程序不允许使用
- 在QQ自己使用完成之前，这两块空间只保存账号和密码
使用一个别名，标记账号和密码在内存中的位置

在程序内部，为账号和密码在内存中分配的空间就叫做变量
程序就是用来处理数据的！变量就是用来储存数据的！

3.2变量定义

**格式：**变量名 = 值

1	`name = "python"`

python 中定义变量不需要制定类型

3.3变量类型

数据类型分为数字型和非数字型

1）数字型

int	整型
float	浮点型
bool	布尔型	True `非0数`、Flase `0`
complex	复数型	主要用于科学计算

2）非数字型

	字符串
	列表
	元组
	字典

用type函数查看变量的类型

1 2	`>>> type(a) <class 'str'>`

3.4不同类型变量运算

数字变量之间可以进行算数运算
- True = 1
- Flase = 0
字符串变量之间使用 + 连接

>>> a = "张"
>>> b = "三"
>>> a + b
'张三'

字符串变量 和 整型变量 使用 * 重复拼接相同的字符串

1 2	`>>> "-" * 5 '-----'`

3.5变量命名

1）标示符

**标识符 **就是 变量名、函数名
标示符需要见名知意

2）规则

字母、下划线、数字组成
不能以数字开头
不能与关键字重名

3）关键字

用以下命令可以查看 Python 中的关键字：

1 2	`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`表示小数点后只显示两位
%%	输出%

1
2
3

# 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都认为是一个字符串

1	`age = input("请输入信息：")`

4.3类型转换函数

int(x)
float(x)

4.4定义函数 & 调用函数

封装独立的功能

def 关键字（定义一个函数）

1
2
3

# 该文件命名为 new_function.py  （符合标识符命名规则）
def my_fun()：                  
    print("这个函数可以打印这句话")

import 关键字（导入文件，调用函数）

1 2	`import new_function new_function.my_fun # 调用 new_function.py 中的 my_fun 函数`

return 关键字

1 2	`def sum(num1,num2): return num1 + num2`

格式：
1. ⚠️定义函数有 () 和 : ，参数在 () 中
2. ⚠️调用函数用 .
3. dfe 是**define** 的缩写
4. 函数名与模块名（即函数的 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 使用场景：
1. 希望某个条件不满足时，执行一些代码
2. 需要拼接复杂的逻辑计算条件

# 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 2	`# 随机生成数，包括1和10 random.randint("1,10")`

07关键字、函数、方法

7.1关键字

是 Python 内置的、具有特殊意义的标识符
关键字后不需要使用括号

7.2函数

函数封装了独立功能，可以直接调用

1 2	`# 函数后面要加括号函数名（参数）`

7.3方法

方法和函数类似，同样是封装了独立功能
方法需要通过对象来调用，表示针对这个对象要做的操作

1	`对象.方法名（参数）`

三、高级变量

01列表（List）

1.1定义格式

列表定义： 在其他语言中叫做数组
列表用 [] 定义，数据之间用 , 分隔

>>> name_list01 = []           # 创建一个空列表
>>> name_list02 = ["hu", "wen", "tao"]   # 创建一个有三个数据的列表
>>> print(name_list02[0])
hu

1.2常用操作

在 IDLE 定义一个列表name_list
输入 name_list. ，按下 Tab 键，按 上下箭头 翻找方法

1 2	`>>> 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函数

统计列表中的元素总数

1	`list_len = len(list_name)`

3） count方法

统计列表中某一个数据出现的次数

1 2	`# 统计 Tom 在列表name_list中出现的次数 count = name_list.count("Tom")`

4） remove方法

删除第一次出现的数据

1	`name_list.remove("张三")`

5）sort方法

默认升序排序 reverse = Flase

1 2	`# 降序排序 name_list.sort(reverse=True)`

1.3循环遍历

在 python 中为了提高列表遍历效率，专门提供了迭代遍历（iteration）

顺序地从列表中获取数据，并放入一个变量中

1
2
3

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定义一个元素的元组

正确样例：

1 2	`single_tuple = (5,) many_tuple = (5,6,7)`

错误样例：
Python 解释器会将 5 当作 int 型变量

1	`single_tuple = (5)`

2.2常用操作

在 IDLE 定义一个列表info_tuple
输入 info_tuple. ，按下 Tab 键，按 上下箭头 翻找方法

1 2	`>>> info_tuple = [] >>> info_tuple.index`

方法	说明
元组.count（数据）	统计该数据在元组中出现的次数
元组.index（数据）	确定该数据在元组中的索引

count方法

1
2
3

info_tuple = ("zhangsan", 18, 1.75)
# 统计 “zhangsan” 出现的次数
print(info_tuple.count("zhangshan"))

index 方法

1
2
3

info_tuple = ("zhangsan", 18, 1.75)
# 统计 “zhangsan” 在元组的索引
print(info_tuple.index("zhangshan"))

2.3元组的应用场景

函数的参数和 返回值，一个函数可以接受任意多个参数，或者 一次返回多个数据
**格式化字符串，**格式化字符串后面的 () 本质上是个元组
**让列表不可以修改，**以保护数据安全

1
2
3

info_tuple = ("小明", 18)
print("%s 年龄是 %d" % ("小明", 18))
print("%s 年龄是 %d" % info_tuple)

⚠️用格式化字符串，拼接生成新的字符串

1	`info_str = "%s 年龄是 %d" % info_tuple`

2.4元组和列表转换

list 函数：将元组转化为列表

1	`list(元组)`

tuple 函数：将列表转化为元组

1	`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 函数删除数据

1 2	`# 在删除的时候，如果指定的 key 不存在，程序会报错！ xiaoming_dict.pop("name")`

1）len函数

统计键值对数量

1	`print(len(xiaoming_dict))`

2）update方法

合并字典
- 如果被合并的字典中包含已存在的键值对，会覆盖原有的键值对

# 新建一个临时键值对
temp_dict = {"height":1.75，
            "age":20}
# 将临时键值对合并入 xiaoming_dict 字典中
xiaoming_dict.update(temp_dict)

3）clear方法

清空字典

1	`xiaoming_dict.clear`

3.3循环遍历

遍历字典中的所有 key ，再根据 key 获取 value

1 2	`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循环遍历

依次取出每个字符

1
2
3

hello_str = “hello，python”
for c in hello_str:
  print(c)

4.2len函数

统计字符串长度

1	`print(len(hello_str))`

4.3count方法

统计某一子串出现的次数

1	`print(hello_str.count("llo"))`

4.4index方法

统计某一个子串第一次出现的位置

1 2	`# 如果使用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）
当结束索引为空，便可切到字符串末尾

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. 准备文件，确定文件名，保证能 **在需要的位置 ** 编写代码
2. 编写 主运行循环，实现基本的 用户输入和判断

1.1文件准备

新建 card_main.py 保存 主程序功能代码
- 程序的入口
- 每一次启动名片管理系统都通过 main 这个文件启动
新建 card_tools.py 保存 所有名片功能函数
- 将对名片的 新增、查询、修改、删除 等功能封装在不同的函数中

1.2 pass关键字

如果开发时，不希望立即编写分支内部的代码，
可以使用 pass 关键字，表示已一个占位符，能够保证程序的代码结构正确
pass 不会执行任何操作

1.3 TODO注释

在 # 后跟上 TODO ，用于标记需要去做的工作
pycham 中左下角有 TODO 列表

1 2	`# TODO(作者/邮箱) 注释内容代码。。。`

1.4 shebang符号（#!）

shebang 在 unix 系统脚本中的 第一行开头 使用
指明 **执行这个文件 **的 解释程序

例如：

如果解释器 python3 在 /usr/bin/python3，
使用shebang符号就可以在终端中使用 ./文件名.py 就可以执行
前提修改 文件名.py 的读写权限 chomd +x 文件名.py

1
2
3

#！ /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(参数)
- 传递一个不可变类型参数
- 返回一个整数

1 2	`>>> hash("hello") 3690660419994397917`

在 python 中，设置字典的 键值对 时，会首先对 key 进行 hash 以确定内存中保存字典的数据，方便后续的增删改查

04 全局变量和局部变量

注意：python 中函数内部不能直接修改全局变量的引用 — 使用赋值语句修改全局变量的值

1
2
3

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）缺省参数的定义位置

必须保证 带有默认值的缺省参数 在参数列表末尾

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）三要素

在程序开发中，要设计一个类，满足三个要素：
1. 类名这类事物的名字，满足大驼峰命名法
2. 属性这类事物具有什么样的特征
3. 方法这类事物具有什么样的行为

2）类名的确定

名次提炼法 分析整个业务流程，出现的名词，通常就是找到的类

3）属性和方法的确定

对 对象的特征描述，通常可以定义为属性
对象具有的行为（动词），通常可以定义为方法

03基本语法

3.1dir内置函数

查看对象的所有属性及方法

1 2	`gl_list = [1,2] dir(gl_list)`

3.2定义类

方法中，第一个参数必须是 self
类名的命名规则 要符合 大驼峰命名法

class 类名:
  def 方法(self,参数列表):
    pass
  def 方法(self,参数列表):
    pass

3.3创建对象

1	`对象变量 = 类名()`

引用的概念强调

用 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初始化方法

当使用类名（） 创建对象时，会自动执行以下操作：
1. 为对象在内存中 分配空间 --创建对象
2. 为对象的属性 设置初始值 --初始化方法
这个 初始化方法 就是 __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__ 方法进行改造
1. 设置形参接收参数
2. 将参数传递给 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("--" )

运行结果为：

1
2
3

初始化方法执行了！
--
该对象内存即将销毁！

因为 tom 变量是全局变量，只有在整个程序结束的时候，才会销毁tom变量的内存空间，才会执行_del_ 方法

3.9_str_方法

在python中，打印对象变量，默认会打印出 这个变量 是由哪一类创建的对象，以及在内存中的地址（十六进制）
如果希望打印对象变量时，能够打印自定义的内容，就可以使用 _str_方法

1
2
3

class Cat:
  def __str__(self):
    return "这个内置方法返回一个字符串"

还可以让返回值带有参数

class Cat:
  def __init__(self,new_name):
    self.name = new_name
  def __str__(self):
    return "我的名字叫 %s" % self.name

3.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
False

04私有属性和私有方法

应用场景：

对象的某些属性和方法，只希望在对象的内部（在类的内部）被使用，而不希望在外部（在类的外部）被直接访问到
私有属性就是对象不希望公开的属性
私有方法就是对象不希望公开的方法

定义方式：

在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.secret

python处理方式：

python中，没有真正意义的私有

python对私有属性、私有方法的处理方法就是，在名称前面加上 _类名__私有属性名或者私有方法名

1
2
3

# 所以直接用 这种方式 也可以访问到私有属性或者私有方法
# 对象名._类名__属性名
print(xiaomei._women__age)

九、继承

面对对象的三大特性：

封装根据职责将属性和方法封装到一个抽象的类中
继承实现代码的重用
多态不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

01单继承

1.1单继承的概念和语法

1）概念： 子类（派生类）拥有父类（基类）所有的方法和属性

2）语法：

1 2	`calss 类名(父类名): pass`

3）继承的传递性

子类拥有父类和 父类的父类 中封装的所有属性和方法

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）语法：

1 2	`class 子类名(父类名1，父类名2...): pass`

2.2多继承的使用注意事项

如果 不同的父类 中存在 同名的方法或者属性，应避免使用多继承

2.3Python中的MRO–方法搜索顺序

method resolution order
python 中针对类类提供了一个内置属性 __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类（即上面第九行的继承顺序）
如果找到，直接执行不再搜素；如果没找到，程序报错。

1	`(<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

1 2	`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)