python笔记19年8月23日

-------------py打包exe教程------------
准备好需要转换的py文件和一张用于做图标.ico的照片
将他们存放于同一个文件夹中,文件的路径全部为英文路径
1.利用cmd窗口安装pyinstaller插件
指令 :pip install pyinstaller
2.使用cd指令到py文件夹
3.执行命令 pyinstaller -F -i XXX.ico XXXX.py
执行完命令后，exe文件就在dist文件夹中
--------------Python基础指令--------------
--------------------------------------------【这个代表部界限用来区分是否是这个内容的东西】
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆【这个重点要牢记】
1.基础指令打印指令

print(’‘你好世界’’)
你好世界
不要小看打印指令次指令用处广泛
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
2.获取 键盘输入指令

输入input
输出%s %d %f {} .format
这个是-变量的命名-【详细内容请看3.变量的命名】
↓
这个就是键盘输入指令
↓ ↓
姓名=input(‘请输入您的姓名:’)
年龄=input(‘请输入您的年龄’)
QQ=input(‘请输入您的QQ’)
电话=input(‘请输入您的电话’)
地址=input(‘请输入您的地址’)
使用打印指令加上 我们创建好的变量 即可完成
↓
print(‘姓名:{}年龄是:{}岁’.format(姓名,年龄))
print(‘QQ:{}’.format(QQ))
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
3.pass#空语句，是为了保持程序结构的完整性
不做任何事情，一般用做占位语句。

变量=[1,2,3,‘Hi’]
print(len(变量)) #len函数可以获取到列表对象中的数据个数
1.Python注释

单行注释用#和多汗注释"’’"
#—coding=utf-8-编码注释【可以让别人在修改或者翻译的时候知道你使用的什么编码】
特殊注释#/usr/bin/env python3【这个一遍win系统没有任何作用】
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

2.数据类型和命名

使用指令tpye()【里面输入你想要知道的数据类型】
数字(num)
字符数(str)-------------如a=‘阿宅’
字典(dict)--------------如a={}
元组(Tuple)------------如a=()
列表(list)----------------如a=[]
有符号整数(int)----------如a=1
长整行(long)
浮点数(float)------------如a=1.1
复数(complex)
布尔值(bool)------------如 a=True或者a=False
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

3.变量的命名

变量命名必须是 a-z A- Z 或者下划线 () 开头其他的字符可以用字母或数字或【中文也是可以的】
变量区分大小写
输入指令

import keyword
keyword.kewlist
查询不可只用的变量名称
Python的关键词不能用做变量名
命名的规范
①见名知意,尽量使用有语义的单词命名.如使用password作用密码,username 用户名.
②小驼峰式命名法:第一个单词首字母小写其他大写,如userName
③大驼峰式命名法:全部单词首字母都用大写. 如UserName
④下划线命名法:每个单词用(_)下划线连接, 如user_name
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

---

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
4.基本操作符

运算符:+、-、、/、**、&、//
比较符:==、!=、>、<、>=、<=
逻辑符:and、or、not
赋值符:=、+=、-=、=、/=、%=、**=、//=
以下是操作符的基本使用方法【只提供部分操作符的使用方法】
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
1.运算符的用法

a=7,b=3
+加法 a+b = 10

• 减法 a-b = 4

• 乘法 a*b=21
  指数 ab=343 左边底数 右边指数
  %取余 a%b=1 x%y X除以Y的余数
  /除法 a/b=2.333333333333335
  //地板除 a//b=2 X//Y结果忽略小数点后面的小数位,只保留整数位
  ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
  2.比较符的用法

a=10
b=10
c=3
要检测倆个值
不等于就是一个感叹号加上一个(!=)

a != b
False

a !=c
Trues
如果
想要检查一个值是否大于或小于另一个值.符号分别是大于>和小于<

a > c
True

a ＜ c
False

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
3.逻辑符的用法

a=10
b=10
c=3
and或者or 也是被称为逻辑运算符and把倆表达式连接在一起如果倆个的对比结果都是True则and运算符也会通过表达式将整个表达and=只要有一个是False那么最后得出的也是False

or=只要有一个是True那么最后得出的也是True

not=这运算符不是将几个表达式连在一起,而是反转对比的布尔值

举个例子

a=10
b=10
c=3
①>>>ab and ac 由于a和b的值都是10所以第一个结果是True但是c的值是3因此第二个对比结果是False
false

②>>>a==b and a>=c 第一个对比是True因为10大于3第二个结果也是对的
True

③>>>a!=b and a>=c 第一个结果是False 因为我们已经有一个对比是False所以第2个表达式的结果就不重要了
False

④>>>a!=b and a==c 同理,在使用and运算符的时候,除非2个都是true结果才可能是True看②
False
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
相反,对or来说,如果任意一个对比结果是True☆or的运算符会让整个表达式结果都为True
如果倆个比较的计算结果都是False,结果才会是False
举个例子

a=10
b=10
c=3
①>>>ab or ac 一个结果是True 因为我们已经有一个对比是True所以第2个表达式的结果就不重要了
True

②>>>a==b or a>=c第一个对比是True因为10大于3第二个结果也是对的
True

③>>>a!=b and a>=c第一个结果是False 但是第2个是对的所以
True

④>>>a!=b and a==c两个都是错的所以都是False
False
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
第三个逻辑运算符是not
这运算符不是将几个表达式连在一起，而是反转对比的布尔值
举个例子

a=10
b=10
c=3
not(ab and ac)
Ttue

not(ab or ac)
False
注意!.（）把对比的表达式放到里面
解析器就会首先比对（）的表达式,然后用not反转比对结果

举个例子不用（）

not ab and ac
False

就会得到不一样的结果~这是因为not在’ab’的对比表达式前面所以就被and连接
所以在个表达式的结果就会是(not ab)and(ac)分为了两部分.
所以not只转换了ab这表达式的结果,也不是反转了整个表达式的计算结果
之前我提到过,’‘感叹号’‘在其他编程语言中都是作用逻辑’非’运算符,但是Python使用单词’‘not’
替代了’,这样可以更方便读懂.然后呢
因为对比的结果都是布尔值所以我们可以将对比的结果储存在变量中

–套娃变量–

d=a==b and a>=c
d
True

e=ab and ac
e
False
并且可以在对比表示式中使用这些变量!

d and e
False
因为d是True,但是e是False所以表达式是False

d or e
因为d是True,我们前面所学过的or只要有一个True,就可以返回True结果就是True
True

not(d or e)
False
在括号中的d or e 结果是 True,但是我们用了not进行反转所以就是False结果就是False

d and not e
True
这个表达式中,d是True然后 然后not对e进行反转 本来是False的值变成了True

每个编程语言中都有比对的表达式.

如果有一天你成为真正的程序员的话,那你肯定就知道大部分的代码其实就是不断地
去做对比,去检查数据是否正确,只有知道对比才能让程序去做正确的事情.

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
4.字符串格式化的用法

%c 字符
%s 通过str()字符串转换来格式化
%i 有符号十进制整数
%d 有符号十进制整数
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数(小写字母)
%e 索引符号(小写e)
%E 索引符号(大写E)
%f 浮点实数
%g %f和%e的简写
%G %f和%E的简写
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
5.赋值符的用法
【下面的不用多说把 定义个变量】

a=10
b=10
c=3
单个=等于对python就是给变量赋值
如果想要查询两个边路是否相等,就要用倆等于==

a == b【为什么会是True呢？因为a和b都是10相等】
True

a == c【为什么会是False呢？因为a和c不相等】
False

---

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
6.删除指令的用法
程序输入import os[使用os指令]

os.remove(“这个是删除指令写出文件位置”)

os.removedirs(“这个是删除文件夹”)

小课堂
1.Python是一个动态语言.不用想Java那样 去指示办理的数据类型
2.所以Python解析会根据你写的储存的变量在变量中的数据来反向推断变量的类型
3.Python的变量可以在 执行期间 更换自身数据类型 可以从int小数内类变成string的整数内
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
7.流程控制的掌握
流程:计算机执行代码的顺序
流程控制:对计算机代码执行的顺序进行有效的管理,只有流程控制才能实现开服当中的业务逻辑
流程控制的分类
1.顺序流程:代码一种自上而下的执行结构,也是Python默认的流程.
2.选择流程/分支流程:在某一步的判断,有选择的去执行相应的逻辑一种结构.
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
☆7.1.选择流程/分支流程的使用方法
单分支

if [就是如果的意思] 跟的是条件表达式:：

一条条的python代码
一条条的python代码
...........等等等

举一个简单的例子
创建一个变量
成绩=20
if 成绩<=60:[成绩60会显示下方字如果没达标就显示程序已经结束]
print(‘恭喜你及格了’)
pass#空语句
print(‘程序运行结束’)
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
双分支

if [就是如果的意思] 跟的是条件表达式:
一条条的python代码
一条条的python代码
…
else :[必定会执其中一个分支行]
一条条的python代码
一条条的python代码
…
举个例子
成绩=20
if 成绩>60:[成绩60会显示下方字如果没达到会显示else里面]
print(‘恭喜你及格了’)
pass#空语句
else:#当False的时候才会执行
print(‘抱歉’)
pass#空语句
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
多分支
if [就是如果的意思] 跟的是条件表达式:
一条条的python代码
一条条的python代码
…
elif跟的是条件表达式:[简称套娃]
一条条的python代码
一条条的python代码
一条条的python代码
elif跟的是条件表达式:[简称套娃]
一条条的python代码
一条条的python代码
一条条的python代码
else跟的是条件表达式:
一条条的python代码
一条条的python代码
一条条的python代码
…
条件表达式:比较运算符/逻辑运算符/复合的运算符
举个例子
有符号整数(int)----------如a=1

成绩=int(input(‘请输入你的成绩:’))
print(type(score))
if 成绩>90:
print(‘你的成绩是A哦’)
pass
elif 成绩>=80:
print(‘你的成绩是B哦’)
pass
elif 成绩>=70:
print(‘你的成绩是C哦’)
pass
elif 成绩>=60:
print(‘你的成绩是D哦’)
pass
else:
print(“不及格”)

print(‘程序已结束’)
[只要满足其中一个分支,几号回退出if语句elif[必定会执行一个分支]]
2.至少有2中情况可以选择
3.elif 必须跟上一个条件
3.else 是选配,根据实际的情况来填写

用以上学到的知识回答下面的问题

小王的老婆对小王说 去买4个包子
如果看见卖西瓜的,就买两个包子.
我们用Python条件通关一条或者多条执行(True或False)来决定执行代码

---

解析
if 有卖瓜的:
买俩包子
else:
买四个包子

if 条件1:
if 条件2:
print(‘满足条件1’,同时满足条件2)
else:
print(‘满足条件1’,但是不满足条件2)
elset条件3:
if 条件4:
if 条件4
print(‘满足条件3’,同时满足条件2)

重点！
8.☆if-else语句的使用方法与流程
Python条件语句是通过一条或多条语句的执行结构
(True或者False)来决定执行的代码块

---------图片教程---------
开始
↓
↓
↓
条件判断语句→→→False→→→条件不构成时执行代码块
↓ ↓
↓ ↓
↓ ↓
True ↓
↓ ↓
↓ ↓
↓ ↓
条件成立时执行的代码块 ↓
↓ ↓
↓ ↓
└→→→→→→→→→结束←←←←←←┘

举个简单的例子
#猜拳小游戏
#XiaZhai乱写的
import random #直接导入产生随机数【这个以后会教】
玩家=int(input(’[0:石头 1:剪刀 2:布]请出拳:’))
机器人=random.randint(0,2)
if 玩家0 and 机器人1: #多条件可写
print(‘莫妮卡:下次我一定可以赢o(´^｀)o’)
pass
elif 玩家1 and 机器人2: #多条件可写
print(‘莫妮卡:下次我一定可以赢o(´^｀)o’)
pass
elif 玩家2 and 机器人0: #多条件可写
print(‘莫妮卡:下次我一定可以赢o(´^｀)o’)
pass
elif 玩家==机器人:
print(‘莫妮卡:小甜心看来,我们出的是一样的’)
pass
else:
print(‘莫妮卡:下次我会让你的小甜心’)

第2个例子

if-else 的嵌套使用

一个场景需要分阶段或层次,做出不同的处理

#要执行内部的条件 if 语句一定要外部的 if 语句满足条件才可以

例子
学分=int(input(“请输入你的学分”))
if 学分>10:
成绩 = int(input(“请输入你的成绩”))
if 成绩>=80:
print(‘你可以升班级了’)
pass
else:
print(‘很遗憾,你的成绩不达标’)
pass
pass
else:
print(‘成绩太差’)

以上都是重点内容要牢记于心

9.☆循环流程的使用
在一定的条件下,一直重复的执行某段代码的逻辑.[事情]
while 条件表达式:
一条条的python代码
一条条的python代码
一条条的python代码
…
for … in …可选代集合对象:
一条条的python代码
一条条的python代码
一条条的python代码
举一个例子

while的例子

案例 输出 1~100之间的数据

XXXXX=1 #定义一个变量
while XXXXX<=100:
print(XXXXX)
XXXXX+=1
pass

例子2
使用if-else写的猜拳游戏加上刚刚学习到的循环模块

import random #直接导入产生随机数
几次=1
while 几次<=10:
玩家=int(input(’[0:石头 1:剪刀 2:布]请出拳:’))
机器人=random.randint(0,2)
if 玩家0 and 机器人1: #多条件可写
print(‘莫妮卡:我打赌下一次你会让我赢对吧[亲爱-的?]’)
pass
elif 玩家1 and 机器人2: #多条件可写
print(‘莫妮卡:啊!,再来一次好吗?我分心了’)
pass
elif 玩家2 and 机器人0: #多条件可写
print(‘莫妮卡:下次你可以让我一下吗?[小甜心?]’)
pass
print(‘莫妮卡:亲爱的看来,我们出的是一样的’)
pass
else:
print(‘莫妮卡:(╹▽╹)下次我会让你赢的小甜心’)
pass
几次+=1

例子3
使用循环做一个乘除法表格
行=1#-------[变量,初始值]
while 行<=9:#-----[条件表达]
列=1#-------[变量,初始值]
while 列<=行:#-----[条件表达]
print("%d*%d=%d"%(行,列,行列),end=" ")#[end在输出中自动换行的默认行为]
列+=1#---------------------[变量自增]
pass
print()#---------------------- [在这里体现空格]
行+=1#---------------------------------- [变量的控制]
pass
#end=’'会使函数关闭 ”在输出中自动包含换行的默认行为“
启动效果请自行尝试

例子4
行=9#-------[变量,初始值]
while 行>=1:#-----[条件表达]
列=1#-------[变量,初始值]
while 列<=行:#-----[条件表达]
print("%d*%d=%d"%(行,列,行*列),end=" ")#[end在输出中自动包含换行的默认行为]
列+=1#---------------------[变量自增]
pass
print()#-------------[在这里体现空格]
行 -=1#--------------------- [变量的控制]
pass
启动效果请自行尝试

例子5
行=1
while 行<=10:
几个=1
while 几个<=10-行:
print(’ ‘,end=’ ‘)#里面打个空格就可以了
几个+=1
pass
空格=1
while 空格<=2*行-1:#控制打印星号
print(‘8’,end=’’)#控制打的什么
空格+=1
pass
print()
行+=1

例子6
while 数字<=100:
if 数字>20:
break
pass
print(a)
数字+=1

举了那么多例子当然是重点啦
下一个
9.for循环【重点】
for跟while循环一样也可以完成循环.
在Python中for循环可以遍历任何序列的项目
如果一个列表或者一个字符串等.

for 循环

语法特点:遍历操作,依次的取集合容器中

for 临时变量 in 容器:

执行代码块

---

for循环各式:
for 临时变量 in 字符串,列表等:
执行代码块
执行代码块
for循环示列
a=“python”
for i in a:
print(i)
for 循环遍历列表
li=[‘a’,‘b’,‘c’.‘d’]
for in li:
print(i)
使用方法计算偶数和奇树

range() 函数可创建一个整数列表，一般用在 for 循环中。
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

print(’-----------------for的使用--------------’)
for a in range(50,201):
if a%2==0:
print(’%d是偶数’%a)
pass
else:
print(’%d是奇数’%a)

小课堂
pass剩下的语句还会执行，continue不会
#这两个关键词只能用在循环中
break退出循环
[代表中断结束的意思 [只要是满足条件直接结束本层循环]]

range() 函数可创建一个整数列表，一般用在 for 循环中。

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

9.1break的运用

for a in ‘l love python’:
if a==‘e’:#【到e停止循环的意思】
break#彻底中断循环【退出循环】
print(a)#【不在执行这个代码】
执行
l

l
o
v
进程已结束，退出代码 0

9.2continue的运用
continue跳过本次循环[结束本次循环,继续的进行下一次循环
[当continue的条件满足的时候,本次循环剩下的语句将不再执行]#后面的循环继续)
例子
for a in ‘l love python’:
if a==“o”:#【不执行o】
continue
print(a)#【不执行这个了】
执行
l

l
v
e

p
y
t
h
n

例子2
for a in ‘l love python’:
if a==“o”:
continue
print(a,end=’ ')
执行
l l v e p y t h n
进程已结束，退出代码 0

---

range() 函数可创建一个整数列表，一般用在 for 循环中。
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

更简单的99乘法表
for 行 in range(1,10):
for 列 in range(1,行+1):
print("%d*%d=%d"%(行,列,行列),end=’ ')
pass
print()#控制换行
pass
对比之前的99乘法表指令
行=1#-------[变量,初始值]
while 行<=9:#-----[条件表达]
列=1#-------[变量,初始值]
while 列<=行:#-----[条件表达]
print("%d%d=%d"%(行,列,行列),end=" ")#[end在输出中自动换行的默认行为]
列+=1#---------------------[变量自增]
pass
print()#---------------------- [在这里体现空格]
行+=1#---------------------------------- [变量的控制]
pass

while使用:适用于未知的循环次数 [用于判断]
for使用:适用于已知的循环次数[可迭代对象遍历][常用的循环]

for-----else的合并用法

账号=‘2433523382’
密码=‘2433523389’
for i in range(3):#可以输入3次
zh=input(‘请输入账号:’)
mm=input(‘请输入密码:’)
if 账号zh and 密码mm:#输入正确就执行brak
print(‘登陆成功’)
break#[退出本次循环]
pass
else:
print(‘你登陆已经被锁定[请前去WWW.xxxx.com解冻]’)

---

while----else合并用法

a=1
while a<=10:
print(a)
if a==6:#到6就执行brack
break#[退出本次循环]
a+=1
pass
else:
print(‘else执行了麻???’)

用以上学习到的内容
回到以下作业必须按照要求来写

猜年龄小游戏，有三点需求
1.允许用户最多尝试3次
2.每次尝试3次后，如果没猜对，就稳客户还要不要玩，如果玩就回答Y或y
就让继续猜，如果回复N或者n，就退出程序
3.如果猜对就直接退出

下面是阿宅的答案推荐先个人尝试后在看
a=0
while a<=2:
print(‘小军今年10岁，他爸爸今年35岁，他爸爸比他大多少岁？’)
c=int(input(‘请输入你要猜的名称:’))
if c35:
print(‘恭喜你猜对了’)
break#退出程序
pass
elif c>25:
print(‘猜大了’)
pass
else:
print(“猜小了”)
pass
a+=1
if a3:
e=input(‘如果还想在猜请输入Y/N’)
if e==“Y” or e==‘y’:
a=0 #重置为初始值
pass
elif e==“N” or e==“n”:
pass
else:
print(‘请输入正确的指令’)
pass

作业2
BMI是什么Body Mass Index 的缩写,BMI中文是“体质指数”的意思,是以你的身高体重计算出来的。

阿宅身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮助小王计算他1的BMI指数，
并根据BMI指数：
低于18.5 过轻
18.5-28： 正常
25-28： 过重
高于32： 严重肥胖
用if-eif判断打印结果

下面是阿宅的答案推荐先个人尝试后在看

BMI是什么Body Mass Index 的缩写,BMI中文是“体质指数”的意思,是以你的身高体重计算出来的。

身高=1.75
体重=80.5
BMI=体重/(身高**2)
print("")
if BMI<18.5:
print(“你的体重过轻”)
pass
elif 18.5<=BMI<25:
print(‘标准体重’)
pass
elif 25<=BMI<28:
print(‘有点肥胖’)
pass
elif 25<=BMI<32:
print(‘严重肥胖，建议减肥’)
pass
else:
print(‘严重肥胖　马上减肥．．．．．’)

#—coding=utf-8–
#猜拳小游戏
#XiaZhai乱写的
import random #直接导入产生随机数
几次=0
while 几次<=2:
玩家=int(input(’[0:石头 1:剪刀 2:布]请出拳:’))
机器人=random.randint(0,2)
if 玩家0 and 机器人1: #多条件可写
print(‘莫妮卡:我打赌下一次你会让我赢对吧[亲爱-的?]’)
pass
elif 玩家1 and 机器人2: #多条件可写
print(‘莫妮卡:啊!,再来一次好吗?我分心了’)
pass
elif 玩家2 and 机器人0: #多条件可写
print(‘莫妮卡:下次你可以让我一下吗?[小甜心?]’)
pass
elif 玩家==机器人:
print(‘莫妮卡:亲爱的看来,我们出的是一样的’)
pass
else:
print(‘莫妮卡:(╹▽╹)下次我会让你赢的小甜心’)
pass
几次+=1
if 几次 == 3:
是否继续 = input(‘如果还想在和莫妮卡石头剪刀布的话请输入Y/N（）’)
if 是否继续 == “Y” or 是否继续 == ‘N’:
jici = 0 # 重置为初始值
pass
elif 是否继续 == “N” or 是否继续 == “n”:
pass
else:
print(‘请输入正确的指令’)
pass

7~9小结
if后面一定跟的一定是一个条件表达式【根据给的条件来明确要走哪个分支】
If-else语句 【条件判断语句】 while循环：
①if else语句 【while循环条件判断，结合逻辑运算符嵌套】
①while循环语法
②elif语句 【必须有初始变量，必须有一个条件表达式，在代码块中必须有一个计数量值，不然会出现死循环】
【分支之间的条件是互斥的，你内级别的东西必须满足外级别的】 ②while循环条件判断方法
③if else嵌套
③结合逻辑运算符循环嵌套

for循环：
【主要用于遍历，数据必须是你知道的】 breake丶continue语句
①for 循环各式
【for后面跟着的是变量然后是in 后面是我们遍历的对象：】 ①continue 结束当前循环并进入下一个选好
②for循环遍历字符串丶列表（可选代对象）…
【range() 函数可创建一个整数列表，】 ②break结束整个循环不再继续

布尔值(bool)------------如 True或者False=真和假

10.Python高级数据类型
讲解
①计算机是可以当做数学计算的机器，因此，计算机程序理所当然地各种数值.
但是计算机处理的远远不止数值，还可以处理文本、图形、音频、视频、网页、等各种各样的数据。
不同的数据、需要定义不同的数据类型。在Python中、能够直接处理的数据类型有：
数值、字符串、列表、元组、字典等。
②序列：在Python当中 序列就是一组按照顺序排列的值【数据集合】
在Python中存在三种内置的序列类型：字符串、列表、元组、

优点：可以支持索引和切片的操作

特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端

切片：【高级特效】可以根据下标来获取序列对象的任意[部分]数据
语法结构：[startstep] step默认1

10.目录 目标
01.字符串及常用方法 01 操作字符串-
02.列表及常用方法 02操作列表
03.元组 03使用元组
04字典及常用方法 04操作字典
05共有操作.
↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
11.字符串的操作与使用
【字符串切片及常用方法】
难点！
1字符串常用方法
2切片操作
3与其他类型综合操作
开始 6个长度是字符【从0开始】
字符串及常用方法 ╔═════════════════╗
a=‘p i t h o n’
↓ ↓ ↓ ↓ ↓ ↓
对应下标，下标从0开始 0 1 2 3 4 5
→ 0
生活中我们经常坐大巴车，每一个座位一个编号，一个位置对应一个下标。
字符串中也有下标，要提取出字符串中的部分数据，可以用下标取。下标叫越界，切片不会

切片是指截取字符串中的其中一段内容。
切片使用语法：[起始下标:结束下标:步长]切片截取的内容不包含结束
下标对应的数据，步长指的是隔几个下标获取一个字符。

切片：【高级特效】可以根据下标来获取序列对象的任意[部分]数据
语法结构：[startstep] step默认1
②字符串及常用方法
1.capitzlize() 2.endswith/startswith() 3.find()
#首字母大写 #是否 某某结束/开始 #检测某某是否在字符串中
4.isalnum() 5.isalpha() 6.isdigit()
#判断是否是字母/数字 #判断是否是字母 #判断是否是数字’abc123’.isdigit()
7.islower() 8.join() 9.lower/upper()
#判断是否小写 #小循环取出所以的值用某某去链接 #大小写转换
10.swapcase() 11.lstrip/rstrip/strip 12.split()
#大写变小写，小写变大写 #移除左/右/两侧空白 #切割字符串
13.title() 14.count() 15.replace(old,new,count=None)
#把每一个单词的首字母变成大写 #统计出现的次数 #old被换字符串，new替换字符串，count换多少个。无count表示全部替换。

每个字符串的用法
下载地址:https://www.lanzoux.com/iMIMzeqko1a

12.列表的操作与使用
【列表常用方法】
列表统称:list:是Pytjpm当中非常重要的数据结构,是一种有序的数据集合
贴点:
1:支持:增加,删除,更改,查询
2:列表中的数据是可以变量的[数据项可以变换,内存地址不会改变]
3:我们用[]来表示列表类型,数据项之间用逗号来分割,注意:数据项可以是任何类型的数据
4:支持索引和切片来进行操作
5:列表的下标取值/切片/是否越界与字符串一致,区别就是列表是获取元素
②字符串及常用方法
1.append 2.count 3.extend
#在列表后面追加元素 #统计元素出现的次数 #扩展,相当于批量添加
4.index 5.insert 6.pop
#获取指定元素索引号 #在指定位置插入 #删除最后一个元素
7.remove 8.reverse 9.sort
#移除左边找到的第一个元素 #反转列表 #列表排序
每个字符串的用法
下载地址https://www.lanzoux.com/iyyFWetzkha

变量=[1,2,3,‘Hi’]
print(len(变量)) #len函数可以获取到列表对象中的数据个数
1.Python注释 #reverse=True 倒序

12元组的操作与使用
【元组的应用】

元组:是一种不可变的序列,在创建之后不能做任何的修改

1.不可变

2.用()创建元组类型,用逗号来分割

3.可以是任何类型

4.当元组中只有一个元素时,要加速逗号,不然解释器会当做整数来处理

5.同样是支持切片操作

---

元组与列表类似.不同之处在于元组的元素不能修改
但是可以修改元组里面的列表类型
元组=(‘abcd’,89,9.12,‘你好’,[11,22,33])
元组[4][0]=2433523382 #可以对元组中的列表类型的数据进行修改
元组使用小括号,元组也是通过下标来进行访问

元组创建很简单,只需要在括号中添加元素,并且使用逗号隔开即可.
元组的内置方法count,统计元素在元组中出现的次数
元组的内置方法index 查找指定元素在元组中的下标索引
使用方法
下载地址:https://www.lanzoux.com/ih1W9f4ncqf

14.字典的操作与使用
【字典常用方法】
字典是Python的中重要的一种数据类型,可以存储任何对象.
字典是以键置最形式创建的{‘key’:vaue}利用大括号包裹着
字典中找某个元紊时，是根据键、值字典的每个元紊由2部分组成, 键:值
访问值的安全方式get方法.在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设罝默认 值
注意点：
1字典的键（key) 不能重复，值（value)可以重复。
2、字典的键（key)只能是不可变类型，如数字，字符串，元组。
【字典常用方法】
修改元素
字典中的值是可以修改的,通过键找到对应值修改
新增元素
如果在使用 变量名[‘键’]=数据时,这个’键’在字典中,不存在,那么就会新增这个元素
删除元素
del 删除指定元素 clear 清空字典
统计个数
len()可以查看字典中有几个键值对
获取键:keys
python3中返回包含字典所有key值的dict kevs对象,用for循环取出每一个key值.
获取值:values
python3版本中使用values返回一个包含所有值(value)的dict values地下
获取键值对
python3 返回一个包含所有 (键,值)元组的列表dict items 对象
删除指定键
pop(‘键’)删除指定键
#字典:也是Python中重要的数据类型,字典是有 键值对 组成的集合,

通常使用剑来访问数据,效率非常高,和列表一样 支持对数据的添加.修改和删除操作

特点:

1.不是序列类型 没有下标的概念,是一个无序的 键值

2.用{}来表示对象,每个键值对象用逗号分隔

3.键 必须是不可变的类型[元组,字符串]值可以是任意的类型

4.每个键必定是唯一的,如果存在重复的健,后者会覆盖前者

使用方法
下载地址:

15.公用方法
合并操作+
两个对象相加操作,会合并两个对象
适合用于 字符串,列表,元组

*复制
对象自身按照指定次数进行+操作
适合用于 字符串,列表,元组

in判读元素是否存在
判读指定元素是否存在于对象中
适合用于 字符串,列表,元组
#字符串合并
字符串A=‘人生苦短’
字符串B=‘我用Python’
#list 合并
列表A=list(range(10))
列表B=list(range(11,20))
print(字符串A+字符串B)
print(列表A+列表B)

复制 *

print(字符串A3)
print(列表A3)

in 对象是否存在

print('生’in 字符串A)
print('9’in 列表A)

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
小结
字符串 列表
.下标与切片 .下标与切片
.常规用法 .循环遍历
.超能够用方法

元组					                     字典

.创造元组 .字典各式
.元组的方法 .字典常用方法
.字典遍历
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

Python函数
.基本上所有的高级语言都支持函数,Python也不例外.Python不但能飞船灵活地定义函数,而且本身
内置了很多有用的函数,可以直接调用.
.函数就是最基础的一种代码抽象方式.

1.函数的基础
概念:在编写程序的过程中,有某一功能代码出现多次,但是为了提高编写的效率一级代码的重用,
所以把具有独立功能的代码块组成为一个 小模块,这就是函数

什么是函数:就是一系列Python语句的组合,可以在程序中运行一次或者多次.
一般是完成具体的独立的功能

函数定义:
def+关键字+小括号+冒号+换行缩进+代码块 定义一个函数
def 函数名():
函数体[一系列Python语句,表示独立的功能]
函数调用:
本质上就是去执行函数定义里面的代码块,在调用函数之前 波西定义

函数说明文档:
函数内容的第一行可以用字符串进行函数说明
使用方法
下载地址:https://www.lanzoux.com/i85c6f5xb9i

2.函数的参数
定义函数的时候，我们把参数的名字和位置确定下来.函数
的接口定义就完成了。对于函数的调用者来说.只需要知道
如何传递正确的参数，以及函数将返回什么样的值就够了

Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必
选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数
定义出来的接口，不但能处理复杂的参数.还可以简化调用者的代码

( 缺 省 参 数 )
缺省参数.在调用函数时如果没有传参数.
那么会使用定义函数时给的缺省值
缺省参数必须在参数列表的最后面.否则会报错

( 不 定 长 参 数 )
一个函数有时候会处理比当初声明的参数要多
这就是不定长参数.定义函数时不用声明参数名
加了星号（*)的变量args会存放所有未命名的变
量参数，args为元组；而加**的变量kwargs会存放
命名参数.即形如key=value的參数，kwargs为字典

( 引 用 传 参 )
Python中函数是引用传递（注意:不是值传递）
对于不可交类型,因变量不能修改，所以运算不会
影响到变量自身；而对于可变类型来说,函数体中
的运算有可能会更改传入的参数变量
使用方法
下载地址:https://www.lanzoux.com/iMPLXfdm4xc

3.函数的返回值

概念:函数执行以后会返回一个对象,如果在函数的内部有return 就可以返回实际的值,否则返回的是一个None
类型:可以返回任何类型,返回值类型应该取决于return后面的类型
用途:给数据方式返回数据
在一个函数体内可以出现多个return,但肯定只能返回一个return
如果在一个函数体内 执行了return,意味着函数执行完成退出了.return后面的代码语句将不会执行

所谓"返回值"，就是程序中函数芫成一件事情后，最后给调用者的结果
举个生活例子：

我小明10块钱，让他给我买包烟。这个例子中，10块钱是我给小明的，就相当于
调用函数时传递到参数，让小明买烟这个事情最终的目标是，让他把烟带回来然后给W
我…此时烟就是返回值

你想要组装一台电脑，你将你的电脑配置参数传给电脑店老板，电脑店老板最后得返
回一台组装if的电脑给你。你调用电脑店老板这个方法去帮你组装电脑，他总得给你返
回一台组装好的电脑吧，这台电脑就是返回值。
程序中也蒸要返回值，比如用调用函数去计算两个数的和，思后得返回两个数相加的调用者。
如果函数需要返回多个结果呢？
将要返回的值用逗号隔开。最终会返回一个包含所有返回值的元组。

下载地址:https://www.lanzoux.com/i5W9sfh941g

---

4.函数的嵌套调用
函数可以嵌套调用,即在一个函数内部调用另外一个函数.
内部函数可以访问外层函数中定义的变量.当不能重新赋值(rebind)
函数的嵌套无非就是在一个函数内部调用另一个函数

下载地址:https://www.lanzoux.com/i7XIKfh940f

函数基础 函数返回值
·def 定义函数 ·return
·函数调用 ·多个返回值
·函数说明

函数参数 函数嵌套调用
·函数传参 ·嵌套调用函数的方法
·缺省参数
·不定长参数

重点
函数的参数
有必选参数
有默认参数
有可变参数
关键字可选参数

函数的返回值
.返回一个数据还是多个数据都由 return Kauai取决

函数的嵌套调用
函数的嵌套无非就是在一个函数内部调用另一个函数

练习作业
写函数,接受N个数字,球这些参数数字的和
def 求和(*args):
‘’’
处理接受的数据
:param args: 可变长的参数 可以接受一个元组
:return:返回的是计算的和
‘’’
#处理接受的数据
结果=0
for 复数 in args:
结果+=复数
pass
return 结果
pass
#测试第一个作业
结果2=求和(7,9,5,1,4,2,3)
print(‘结果2={0}’.format(结果2)) #format 格式化输出

结果2=求和(7,9,5,1,4)
print(‘结果2=%d’%(结果2))

写函数,找出传入的列表或元组的奇树位队友的元素,并返回一个新的列表

def process_Func(con):
“”"
处理列表数据
:param con:接收的是一个列表或元组
:return:返回的是一个新的列表对象
“”"
listNew=[]
index=1
for i in con:
if index%2==1: #判断基数位
listNew.append(i)
pass
pass
return listNew
pass

rs3=process_Func([2,3,4,5,6,7])

print(rs3)

rs4=process_Func(tuple(range(10,20)))
print(rs4)

写函数,检查传入字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将
新内容返回给调用者.

def dictFunc(dicParms):#**kwargs
‘’’
处理字典类型的数据
:param dicParms:处理字典类型
:return:返回一个新内容
‘’’
result={}#空字典
for key,value in dicParms.items(): #包括key-value
if len(value)>2:
result[key]=value[:2]#向字典去添加数据
pass
else:
result[key]=value
pass
pass
return result
pass
#调用函数
dictObj={‘name’:‘阿宅’,‘hobby’:[‘睡觉’,‘睡觉’,‘睡觉’],‘pro’:‘摸鱼’}
print(dictFunc(dictObj))

PS"字典中的value只能是字符串或列表"

---

函数的4种基础类型
1.无参数,无返回值,一般用于提示信息打印.
def 无返回值():
print("-" * 20)
2.无参数,有返回值,多用在数据采集中,比如获取系统信息.
def cpu():
# 获取cpu信息
return info

添加return 把参数返回给调用者

3.有参数,无返回值,多用在设置某一些不需要返回值的参数设置.
def set(a)
pass

4.有参数,有返回值,一般是计算型的,需要参数,最终也要返回结果.
def 计算(a,b):
c=a+b

最后添加return 把参数返回给调用者

局部变量与全局变量

局部变量 就是在函数内部定义的变量[作用域仅仅局限在函数的内部]

局部变量的作用:为了临时的保存数据 需要在函数中定义存储数据

不同的函数 可以定义相同的局部变量.但是他们的定义是各自用各自的不会产生影响

def printInfo():
name=‘peter’#name是变量是在函数中定义的
print(’{}’.format(name))
pass
def TestMethod():
name=‘阿宅’
print(name)
pass
TestMethod()
printInfo()
#--------------全局变量-----------------

pro就是定义就是一个全局变量[作用域的不同]

当全局和局部出现重复的变量的定义的时候,程序优先使用函数内部的变量

如果在函数的内部想要进行全局变量修改的话 必须使用 global 关键字进行声明

一下2个是全局变量

pro=‘计算机与信息管理’
name=‘小阿宅’#有局部变量的优先使用函数内部变量
def printInfo():
name=‘peter’#局部变量
print(’{}.{}’.format(name,pro))
pass
def TestMethod():
name=‘阿宅’
print(’{}.{}’.format(name,pro))
pass
def changeGlobal():
‘’’
修改全局变量
:return:
‘’’
global pro
pro=‘市场营销’#局部变量
pass

changeGlobal()
print(pro)
TestMethod()
printInfo()

函数参数应用传值
在Python中,值是靠引用来传递的
可以用id()查询一个对象的应用是否相同,id是值保存在内测中那块内测地址的表示
参数传递是通过对象引用来完成
#不可变类型
a=1
def func(x):
print(‘x的地址{}’.format(id(x)))
x=2
print(‘x的地址修改后{}’.format(id(x)))
pass
#调用函数
print(‘a的地址:{}’.format(id(a)))
func(a)

可变类型

li=[]
def testRenc(parms):
print(id(parms))
li.append([1,2,3,4,5,3,6,4])
print(‘内部的对象{}’.format(li))
pass
print(id(li))
testRenc(li)
print(‘外部的对象{}’.format(li))
#小结

1.在python当中 万物皆对象.在函数调用的时候,实参传递的就是对象的引用

2.了解了原理之后,就可以更好的去把控 在函数的累不的处理是否会影响到函数外部数据变化

#参数传递是通过对象引用来完成

匿名函数

语法: lambda 参数,参数,参数:表达式

特点:

1.使用lambda关键字创建

2.没有名字的函数

3.匿名函数冒号后面的表达式有且只有一个,注意:是表达式,而不是语句

4.匿名函数自带return,而且这个retutn的结果就是表达式计算后的结果

缺点

lambde 只是单个表达式,不是一个代码块,他的设计就是未来简单的场景,仅仅能封装有限的逻辑复杂的逻辑实现不了,必须使用def来处理

python中使用lambda关键字创建匿名函数,
所谓匿名函数就是这函数没有名字不用def关键字创建标准的函数.

lambda 参数1,参数2,:执行代码语句
使用lambda表达式计算两个数和:
test=lambd x,y:x+y
test(1,3)
test(4,5)
换成普通函数其实就是这样的
def test(y,x)
return x+y

变量=lambda y,x:y+x#通过变量来调用匿名函数
print(变量(22,19))

---

递归函数

#递归函数方式去实现

自己调用自己

必须有一个明确的结束条件

优点:逻辑简单丶定义简单

缺点: 容易导致溢出.甚至内存泄露

def diguijc(n):
‘’’
递归实现
:param n: 阶乘查参数
:return:
‘’’
if n==1:
return 1
else:
return n*diguijc(n-1)
pass

查找文件
import os #引入文件操作模块
def 查找(file_path):
ilisRs=os.listdir(file_path)#得到该路径下所有的文件夹
for fileItem in ilisRs:
full_path=os.path.join(file_path,fileItem)# 获取完整的文件路径
if os.path.isdir(full_path):#判读是不是文件夹
查找(full_path)#如果是一个文件夹 再次递归
else:
print(fileItem)
pass
pass
else:
return
pass
#调用文件夹目录
查找(‘B:\游戏’)

优点
递归使代码看起来更简洁
可以用递归将复杂任务分解成更简单的句子问题
使用递归比使用一些嵌套送代更容易
缺点
递归逻辑很难调试.递归条件处理不好容易造成程序无法结束,直到最大递归错误.
递归占用大量内存,耗费计算机资源/

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
总结
函数的基础类型
共四种类型
1.无参数,无返回值,一般用于提示信息打印.
def 无返回值():
print("-" * 20)
2.无参数,有返回值,多用在数据采集中,比如获取系统信息.
def cpu():
# 获取cpu信息
return info

添加return 把参数返回给调用者

3.有参数,无返回值,多用在设置某一些不需要返回值的参数设置.
def set(a)
pass

4.有参数,有返回值,一般是计算型的,需要参数,最终也要返回结果.
def 计算(a,b):
c=a+b

局部变量和全局变量
1.局部变量是函数内部的
2.全局变量是定义在函数外部的
3.使用global关键字可以在函数内部修改函数外部的变量

匿名函数
1.语法: lambda 参数,参数,参数:表达式
2.使用lambda关键字创建
3.没有名字的函数
4.匿名函数冒号后面的表达式有且只有一个,注意:是表达式,而不是语句
5.匿名函数自带return,而且这个retutn的结果就是表达式计算后的结果
6. lambde 只是单个表达式,不是一个代码块,他的设计就是未来简单的场景,仅仅能封装有限的逻辑复杂的逻辑实现不了,必须使用def来处理
7.python中使用lambda关键字创建匿名函数,
8.所谓匿名函数就是这函数没有名字不用def关键字创建标准的函数

递归函数
1.递归函数方式去实现
2.自己调用自己
3.必须有一个明确的结束条件
4.优点:逻辑简单丶定义简单
5.缺点: 容易导致溢出.甚至内存泄露

复习
引用
引用的概念 获取id()可变类型与不可变类型
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

		              目录
		        内置函数介绍
		           数据运算
		           类型转换
		           序列操作
		            Set集合

---

		          内部函数

取绝对值

print(abs(-10))

除数值外

print(round(3.66))

求次方

print(pow(3,3))

求商和余数

print(divmod(7,3))

求最大值

print(max(2999,22222))

求和

print(sum(range(50)))

执行字符串类别

a,b,c,=1,2,3,
print(eval(‘a*b/c-20’))
def TestFun():
print(‘我执行了麻’)
pass
eval(‘TestFun()’)#可以调用函数
类型转换

数字转字符

print(bin(10))#转换二进制

转为十六进制

print(hex(23))#十六进制

转为八进制

print(oct(56))#八进制
#元组转列表
tup=(1,2,3)
li=list(tup)
li.append(‘前置转换成功’)
print(li)
#列表转元组
转换=tuple(li)
print(type(转换))

创建字典

dic=dict()
print(type(dic))
dic[‘name’]=‘小明’
dic[‘age’]=18
print(dic)

转为字节数组

print(bytes(‘我喜欢python’,encoding=‘utf-8’))
序列操作
all 函数用于判断给定的可送代参数 iterable 中的所以元素是否都为 TRUE, 如果是返回 True,
否则返回 False 元素除了0,空,FALSE 外都算TRUE
print(all([]))#True 这个就是 空
print(all(()))#True
print(all([1,2,3,4,False])) #False
print(all([1,2,3,4,]))#True
print(all((1,2,4,0)))#False

any()函数用于判断给定的可送代参数 iterable 是否全部为False,则返回 False 如果有一个 True,则返回 True
print(any([]))#False 这个就是 空
print(any(()))#False
print(any([1,2,3,4,False])) #True
print(any([1,2,3,4,]))#True
print(any((1,2,4,0)))#True

zip 可以将元组解压为列表:就是用来打包的

s1=[‘a’,‘b’,‘c’]
s2=[‘我’,‘爱’,‘你’]

print(list(zip(s1))) 压缩一个数据

zip1=zip(s1,s2)#两个参数
print(list(zip1))
def printBookInfo():
books=[]# 存储所有的图书信息
id=input(‘请输入编号: 每个项目用空格分开’) #ste
id2 = input(‘请输入书名: 每个项目用空格分开’)#ste
id3 = input(‘请输入位置: 每个项目用空格分开’)
id4=id.split(’ ‘)
id5 = id2.split(’ ‘)
id6 = id3.split(’ ')

bookInfo=zip(id4,id5,id6)#打包处理
for bookItem in bookInfo:

    dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}
    books.append(dictInfo)#将字典对象添加到list容器中
    pass
for item in books:
 print(item)

printBookInfo()

enumerate
listobj=[‘a’,‘b’,‘c’]
for index,itme in enumerate(listobj,5):
print(index,itme)
pass

什么是合集?
set(合集) 也是python中的一种数据类型,是一个无序且不重复的元素集合

第一种方式

set1={“1”,“2”}

#第二种方法
list1=[‘6’,‘1’,‘5’,‘4’,‘3’]
set2= set (list1)

set 不支持索引和切片,是一个无序的且不重复的容器

类似 字典 只有key 没有value

#创建合集
dic1={1:3}
set1={1,2,3}
set2={3,4,5}
print(type(set1))
print(type(dic1))
#添加的操作
set1.add(‘python’)
print(set1)
#清空操作
set1.clear()
print(set1)
#合集的差集
rs=set2.difference(set1)
print(rs)
print(set1-set2)
print(set1)
#集合交集
print(set1.intersection(set2))
print(set2&set1)
#并集的操作
print(set1.union(set2))
print(set1 | set2)
#pop 从集合中拿数据并且同时删除
print(set1)
quData=set1.pop()
print(set1)
#指定移除
print(set1.discard(3))
print(set1)
#更新合集
set1.update(set2)
print(set1)

总结
python 内置函数小结
数学运算符
abs(),round(),pow().divmod().max().max().min().sum().
eval()
类型转换
int(),float(),str().ord().chr().bool().bin().hex().
oct().list().tuple().dict().bytes()
序列操作
all(),any(),sorted(),reverse().reange(),zip().enumerate(),
集合
add(),clear(),difference(),intersection(),union(),pop(),discard(0,update()

求和就是
比如1到10就是
1+2+3+4+5+6+7+8+9+10=55

求三组连续自然数的和:求出1到10,20到30和35到45的三个和

def sumRange(m,n):
return sum(range(m,n+1))
pass
print(sumRange(1,10))
print(sumRange(20,30))
print(sumRange(35,45))

100个和尚要吃100个馒头 大和尚一人吃3个馒头,小和尚三个人吃一个馒头.请问大小和尚个多少人

def PersonCount():
‘’’
假设大和尚a 小和尚就是100-a
:return:
‘’’
for a in range(1,100):
if a3+(100-a)(1/3)==100:
#100个和尚吃100个馒头
return (a,100-a)
pass
pass

rsObj=PersonCount()
print(‘大和尚{}小和尚{}’.format(rsObj[0],rsObj[1]))

#指定一个列表,列表里含有唯一一个只出现一个的数字.写程序找出这个"独一无二"的数字
li=[1,3,4,3,3,5,2,4,2]
set1=set(li)

print(set1)

for i in set1:
li.remove(i)
pass
set2=set(li)#set2中为原来li中重复的数字合集
for i in set1:#set1中数据全部去从后形成的集合
if i not in set2:
print(i)
pass
pass
pass

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
面向对象介绍
概述
1.面向过程:根据业务逻辑从上到下写代码
2.函数式:将某项能代码封装到函数中,日后便无需反复编写.仅调用函数即可
3.蛮对对象编程:将数据域函数绑定到一起,进行封装,这样能够更快速的开发程序,减少了重复代码的重写过程

面向对象编程: oop [ object oriented programming]是一种python的编程思路
面向过程:就是我们一开始学习的，按照解决问题的步骤去写代码[根据业务逻辑去写代码]
例子
第一种洗车方式
1.自己.上某宝买洗车工具。
2.根据自己的不多的预算买，抹布，水泵，清洁剂。
3.跟店小二狂砍一个小时，便宜了2块钱。
4.等了一周，买的东西到了，开始洗车
5.洗到一半，水泵坏了，泡泡还没洗干净
6.
7.
8.到完成的步骤
第二种洗车方式
1.找一家靠谱的洗车店
2.给钱洗车

然后将问题解决拆解成若干个步骤，并将这些步骤对应成方法一步一步的
最终完成功能

面向过程编程与函数式编程对比
面向过程 函数式
while True: def发送邮件(内容)
if cpu利用率> 90%: #发送邮件提醒
#发送邮件提醒 连接邮件服务器
连接邮件服务器 发送邮件
发送邮件 关闭连接
关闭连接 while True:
if硬盘利用率> 90%: if cpu利用率> 90%:发送邮件(‘CPU报警’)
#发送邮件提醒 if硬盘使用空间> 90%: 发送邮件( ‘硬盘报警’)
连接邮件服务器 if内存占用> 80%:发送邮件(‘内存报警’)
发送邮件
关闭连接
if内存占用> 90%:
#发送邮件提醒
连接邮件服务器
发送邮件
关闭连接
在举一个例子
出差–北京
小明–什么时间–买什么票[高铁汽车飞机]—酒店—回程时间
亲力亲为的去做[面向过程]
面向过程不足: 小明没有更多的精力去考虑别的事情

boss—秘书[小明需要考虑的事情]----财务----目的: 北京
boss有更多的精力去处理其他的时候，创造更多的价值

从计算机的角度来看:面向过程不适合做大项目
而面向对象合适做更大项目的设计

面向对象分析
●面向过程和面向对象都是-种解决实际问题的思路。
●洗车第一种方式:
●强调的是步骤、过程、每一步都是自己亲自去实现的，这种解决问题的思路我们就叫做
面向过程
●洗车第二种的方式:
●强调的是洗车店，由洗车店去帮我们洗车，过程不用我们自己去操心，对我们而言，我
们并不必亲自实现整个步骤只需要调用洗车店就可以解决问题，这种解决问题的思路
就是面向对象。

●面向过程的关注点是:怎么做
●面向对象的关注点是:谁来做
面向对象—多人运动
面向对象与面向对象编程
●面向对象:按人们认识客观世界的系统思维方式，采用基于对象(实体)的概念
建立模型,模拟客观世界分析、设计、实现软件的办法。
●面向对象编程(Object Oriented Programming-OOP)是一种解决软件复用的
设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用
数据、状态，以类的形式描述出来，以对象实例的形式在软件系统中复用，以达
到提高软件开发效率的作用。”

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

—类和对象—
●类和对象是面向对象编程中重要的概念
●类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
●对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
—类的组成部分—
●类的方法:允许对进行操作的方法(行为)类(Class)由3个部分构成
●类的方法:允许对进行操作的方法(行为)类的属性:一组数据
●类的方法:允许对进行操作的方法(行为)
例如:创建一-个人类
●事物名称(类名):人(Person)
●属性:身高(height)、年龄(age)
●方法:吃(eat),跑(run)…
类和对象
类:类是具有一组相同或者相似特征[属性]和行为[方法]的一系列[多个]
对象组合
现实世界 计算机世界
行为--------->方法
特征--------->属性
对象:对象是实实在在的一个东西，类的实例化，具象化
类是对象的抽象化 而对象是类的一个实例

类的抽象
●具有相同(或者类似)属性和行为的一系列对象的集合都可以抽像出一个类
●例1:小明开着他家的宝马去逛街
●例1:小明开着他家的宝马去逛街
●小明->可以抽象中人类
●宝马->可以抽象出车类

●例2:抽象坦克大战中的类
●坦克
●类名: Tank
●属性:血量类型
●方法:发射子弹
●墙壁
●类名:Wall
●属性:血量类型
●子弹
●类名: Bullet
●属性:杀伤力

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
定义类
●格式
#创建一个类
class Foo(object):
方法列表
●示例
#创建一个类
class Person:# 推荐用大驼峰 定义的单词第一个大写
‘’’
对应人的特征
‘’’
name=‘小明’
age=20
‘’’
对应人的行为
‘’’
def eat(self):
print(“大口的吃饭”)
pass
def rum(self):
print(“飞快的炮”)
pass
创建对象
●格式
对象名=类名()
●示例

创建一个对象[类的实列化]

规则各式 对象名=类名()

xm=Person()
xm.eat()#调用函数
xm.rum()
print("{}的年龄是: {}".format(xm.name,xm.age))
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

实例方法与属性
●在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同,
类方法必须包含参数self,且为第一个参数
class Animal (object) :
#实例方法，使用def关键字定义，第一个形参默认传实例对象本身，一 -般使用se1f作为第- -个参数
def test(self):
print(“我是实例方法”)
#一个类里面可以有多个实例方法
def show(self):
print (" Animal. show")
实例方法:在类的内部，使用def关键字来定义第一个 参数默认是self
self [名字标识可以是其他的名字，但是这个位置必须被占用]
实例方法是归于类的实例所有
属性
●类里面定义的变量。定义在类里面，方法外面的属性称之为类属性，定义在
方法里面使用self引用的属性称之为实例属性
class Animal (object) :
colour =’ 白色’ #类属性
def__init__ (self):
self. name = ‘旺财’# 实例属性
#实例方法，使用def关键字定义，第一个形参默认传实例对象本身，一-般使用self作为第一
def test (self):
print(“我是实例方法”)
#一个类里面可以有多个实例方法
def show(self):
print (" Animal. show’ )
属性: 类属性 实例属性
在类的内部定义的变量[类属性]
在方法内部定义的[通过类似于self.变量名] 变量，是实例属性

__init__方法
分析问题
●创建一个Animal类, 并实例化- -个dog对象和cat对象。
class Animal (object) :
def eat (self):
print(‘吃饭’)
dog = Animal() # 创建一个对象
dog. colour =’ red’ #添加属性----------------------------------每创建一个对象都要添加属性，试
dog. name =’ 旺财’# 添加属性 想如果再创建-一个对象的话，肯定
print (dog. name) 也需要进行添加属性，显然这样做
很费事，那么有没有办法能够在创
cat=Animal()#创建–个对象 建对象的时候，就顺便对象的属性给设置呢?
cat. colour =’black’#添加属性
cat. name =’小花’#添加属性
print (cat. name)

----init(self) 方法—
●__init_ (self)方法，初始化方法，实例化对象的时候自动调用，完成一-些初始化设置。
#创建一个动物类
class Animal (object):
#创建一个初始化方法
def init__ (self):--------------------------------init()方法，在创建一-个对象时默认被调用，不需要手动调用
self. name =’旺财’
self.color =’ 黄色’
dog = Animal() # 实例化对象
print (dog. name) # 访问属性
print (dog. colour) #访问colour属性

实用方法
class People:
def init(self,name,sex,age):#pythpn内置好的称呼叫魔术方法
‘’’
实例方法
‘’’
self.name=name
self.sex=sex
self.age=age

    pass
def eat(self,food):
    '''
    吃的动作
    :return:
    '''
    print(self.name+'喜欢吃'+food)
pass

zp=People(‘张鹏’,‘男生’,18)
print(zp.name,zp.age)
zp.eat(‘喜欢吃巧克力’)
py=People(‘潘雨’,‘男生’,17)
print(py.name,py.age)
py.eat(‘喜欢吃糖果’)
az=People(‘阿宅’,‘女生’,17)
print(az.name,az.age)
az.eat(‘喜欢吃苹果’)
#总结_ init.

1. python 自带的内置函数具有特殊的函数 使用双下划线包起来的[魔术方法]

2.是一个初始化的方法用来定义实例属性和初始化数据的，在创建对象的时候自动调用 不用手动去调用

3.利用传参的机制可以让我们定义功能更加强大并且方便的类

---

理解self
self是什么
●self和对象指向同一个内存地址，可以认为self就是对象的引用。
#创建一个类
class Car(object):
#创建一个方法打印self 的id
def getself(self):
print('self=%s ’ %(id(self)))
bmw = Car()

print(id( bmw))
140033867265696
print(id(bmw))
bmw. getself()
self=140033867265696
self传参问题
●所谓的self, 可以理解为对象自己，某个对象调用其方法时，python解释器
会把这个对象作为第一-个参数传递给self，所以开发者只需要传递后面的参数即可。
#创建一个类
class Car(object):
def_ init__ ( self,name , colour):
self .name = name
self .colour = colour
#创建一个方法打印self的id
def getself(self):
print('self=%s ’ %(id(self)))
bmw = Car(‘宝马’，‘黑色’)
#实例化对象时，self不需要开发者传参，python 自动将对象传递给self
print(id(bmw))
bmw. getself()

---

魔术方法
概述
●在python中，有一些内置好的特定的方法，方法名是“_ xXx_ ”,在进行特定的
操作时会自动被调用，这些方法称之为魔术方法。
●操作时会自动被调用，这些方法称之为魔术方法。
●__init__ 方法:初始化-个类，在创建实例对象为其赋值时使用。
●__str__ 方法:在将对象转换成字符串str(对象) 测试的时候，打印对象的信息。
●__new__方法:创建并返回-一个实例对象，调用了一-次， 就会得到一-个对象。
●__class__方法: 获得已知对象的类(对象._ class_ )。
●_del_方法:对象在程序运行结束后进行对象销毁的时候调用这个方法，来释放资源。
str 方法
●直接打印对象，输出结果只- -串类似id地址的信息。
class Person:
def init(self,pro,name,food):
‘’’

    :param pro: 专业
    :param name: 名字
    :param food: 爱吃什么
    '''
    self.pro=pro #实例属性的定义
    self.name=name
    self.food=food
    pass
'''
定义类
'''
def eat(self,name,food):
    '''
    实例方法
    :return:
    '''
    # print('self=%s',id(self))
    print('%s 喜欢吃 %s 修的专业是什么:%s'%(name,food,self.pro))
    pass
def __str__(self):
    '''
    打印对象
    :return:
    '''
    return '%s 喜欢吃 %s 修的专业是什么:%s'%(self.name,self.food,self.pro)
pass

xw=Person(‘心理学’,‘小王’,‘榴莲’)
print(xw) #直接输出对象

如果不写 def eat(self,name,food): print(xw)就输出

<main.Person object at 0x0000027C2F354520>

__new__的使用方法
def new(cls, *args, **kwargs):
‘’’
创建对象实例的方法 每调用一次就会生成一个新的对象cls 就是class的缩写

    场景: 可以控制创建对象的一些属性限定 警察用来做单例模式的时候来使用
    :param args:
    :param kwargs:
    '''
    print('=======new======')
    return object.__new__(cls)# 在这里是真正创建对象实例的 #如果不写上面的 init就不会执行
    pass
pass

#__new__和__init__函数的区别
#__new__类的实例化方法 必须要返回该实例 否则对象就创建不成功
#__init__用来做数据思绪的初始化工作 也可以认为是实例的构造方法 接受类的实例 根据 self 并对其进行构造
#__new__至少有一个参数是 cls 代表要实例化的类,此参数在实例化时由python接收器自动提供
#new先分配空间，然后才有对象
#__new__函数 执行要早于 init 函数
------------------------------------------------------------------------------------------------------------------------
小结
知识总结-1.
类和对象的概念
类就是一个模板，模板里可以包含多个函数，函数里实现一-些功能;
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数。

定义类和对象	

使用class语句来创建一个新类， class 之后为类的名称并以冒号结尾;
实例化类其他编程语言中-般用关键字new,但是在Python中并没有
这个关键字，类的实例化类似函数调用方式。

实例方法与属性

在类的内部，使用def关键字可以定义一个实例方法;
定义在类里面，方法外面的属性称之为类属性，定义在方法里面使用self
引用的属性称之为实例属性。

知识总结-2
init 方法
构造初始化函数，在创建实例对象为其赋值时使用。

理解self

self和对象指向同一个内存地址，self就是 对象的引用。
魔法方法
在python中，有-些内置好的特定的方法;
方法名是“_ xxx_ ";
在进行特定的操作时会自动被调用。
------------------------------------------------------------------------------------------------------------------------
目录
OOP 三大特性: 封装、继承、多态
1.析构方法
2.单继承
3.多继承
4.继承的传递
5.重写父类方法
6.调用父类方法
7.多态
8.类属性和实例属性
9.类方法和静态方法
重点
面向对象基础中

知识点

●类的继承
●父类的调用
●静态方法

难点

面向对象基础中
知识点
●继承与重写
●静态方法
------------------------------------------------------------------------------------------------------------------------
析构分析
析构方法的概述
当一个对象被删除或者被销毁时，python解释 器
也会默认调用一个方法，这个方法为__del__()方
法，也称为析构方法
class Animal:
def init(self,name):
self.name=name
print(‘这是结构初始化方法’)
pass
def del(self):
print(‘当在某个作用域下面没有被使用[引用]的情况下解析器会自动的调用此函数来释放内存空间’)
print(‘这是结构方法’)
print(’%s这个对象被彻底清理了内存空间也释放了’ %self.name)
pass
cat=Animal(‘小花猫’)
del cat # 手动的去清理删除对象 会指定 del 函数
input(‘启动程序请输[1]:’)
dog=Animal(‘小狗’)
析构方法总结
1、当整个程序脚本执行完毕后会自动调用__del__方法.
2、当对像被手动销毁时也会自动调用__del__方法
3、析构函数-般用于资源回收,利用__del__方法销毁对象回收内存等资源
------------------------------------------------------------------------------------------------------------------------
单继承
在python中展现面向对象的三大特征:
封装、继承、多态
封装:指的是把内容封装到某个地方，便于后面的使用
他需要:
把内容封装到某个地方
从另外一个地方去调用被封装的内容
对于封装来说其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接
或者self来获取被封装的内容

继承:和现实生活当中的继承是样的:也就是
子可以继承父的内容[属性和行为] (爸爸有的儿 子都有，相反儿子有的爸爸不一定有 )

class Animal:
def eat(self):
‘’’
吃
:return:
‘’’
print(‘您吃了麻’)
pass
def drink(self):
‘’’
喝
:return:
‘’’
print(‘您喝了麻’)
pass

class Dog(Animal):#继承了Animal父类此时dog就是子类
def wwj(self):
print(‘小狗汪汪叫’)
pass

class cat(Animal):
def mmj(self):
print(‘小喵猫猫叫’)
pass

d1=Dog()
d1.eat()#具备了吃的行为
d1.wwj()

所以对于面向对象的继承来说其实就是将多个类共有的方法提取到父类中
子类仅需继承父类而不必一一去实现

这样就可以极大的提高效率减少代码的重复编写，精简代码的层级结构便于拓展
class类名(父类):
‘’’’
子类就可以继承父类中公共的属性和方法
‘’’’
pass

			多继承
		             多继承概念

子类可以继承-一个父类，那是否可以继承两个父类或多个呢?答案是肯定的，这就是python的多继承
A B
向 向
指 指
C
C类可以继承A、B两个类，可 以将A, B中的方法继承过来，C拥有A，B的方法和属性
class D(object):
def eat(self):
print(‘D.eat’)
pass
pass
class C(D):
def eat(self):
print(‘C.eat’)
pass
pass
class B(D):
pass
class A(B,C):
pass

a=A()
a.eat()
print(A.mro)#可以显示类的依次继承关系

在执行eat的方法时查找方法的顺序是

首先到A里面去查找 如果A中没有则继续的太B类中太查找 如果B中没有

则去C中查找 如果C类中没有则去D类中去查找，如果还是没有找到就会报错

A-B-C-D 也是继承的顺序

__mro__方法解析顺序
在前面的代码中，我们使用了
__mro__方法
功能:查询执行顺序
描述:方法的执行顺序可以用mro查看。
一旦找到，则寻找过程立即中断，便不会再继续找了

-------继承传递的概念-----
在现实中遗产继承，爷爷的遗产可以被父亲.
继承，儿子可以继承父亲的。这样看来是不
是儿子也是有继承到爷爷的遗产。在面向对
象中的继承呢?子类是否能继承父类的父类.
的方法?

class GrandFather:
def eat(self):
print(‘吃的 方法’)
pass
pass

class Father(GrandFather):
pass

class Son(Father):
pass
son=Son()
print(Son.mro)
son.eat()# 此方法是从GrandFather继承过来的

-----重写父类------
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类
中同名的方法伪代码示例:
class D(object):
def eat(self):
print(‘D.eat’)
pass
pass
class C(D):
def eat(self):
print(‘C.eat’)
pass

方法覆盖

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

为什么要重写,父类的方法已经不满足之类的需要,那么子类就可以重写父类或者完善父类的方法

class Dog:
def init(self,name,color):
self.name=name
self.color=color
def bark(self):
print(‘汪汪叫…’)
pass
pass
class kejiquan(Dog):
def init(self,name,color):#属于重写父类的方法
# 针对这种需求我们就需要去调用父类的函数
Dog.init(self,name,color)#手动调用 调用父类的方法执行定毕就可以具备name.color这两个实例属性
super().init(name,color)# super是自动找到父类 进而调用方法,假设继承了躲个父类,你们会安装顺序逐个的去找 找到后去调用
#扩展其他属性
self.height=90
self.weight=20
pass
def str(self):
return ‘{}的颜色{} 它的身高是{}cm 体重是:{}’.format(self.name,self.color,self.weight,self.height)
def bark(self): #属于重写父类的方法
super().bark() #调用父类方法
print(‘叫的跟神一样’)
print(self.name)
pass

kj=kejiquan(‘柯基犬’,‘红色’)
kj.bark()
print(kj)

---------------类属性和实例属性----------------------------------------------------------------------------------

类属性的概念
类属性:就是类对象所拥有的属性，它被所有类对象
的实例对象所共有，类对象和实例对象可以访问

实例属性的概念
实例属性:实例对象所拥有的属性，只能通过实例对
象访问

属性:类属性和实例属性

类属性 就是类对象所拥有的属性

class Student:
name=‘李明’# 属于类属性就是student类对象所拥有的
def init(self,age):
self.age=age #实例函数
pass
pass

lm=Student(18)
print(lm.name)
print(lm.age)
print(’-----------通过内对象-Student-去访问-name--------------’)
print(Student.name)

小结 对内开放，对外封闭

类属性是可以被类对象和实例对象共同访问使用的

实例属性只能由实例对象所访问

---------------类方法和静态方法----------------------------------------------------------------------------------
类方法的概念
类对象所拥有的方法，需要用装饰器@classmethod来标
识其为类方法，对于类方法，第一个参数必须是类对象,
一般以c1s作为第一一个参数，类方法可以通过类对象，实例对象调用

class People:
coutry=‘China’
#类方法 用 classmethod 来进行修饰
@classmethod
def get_country(cls):
return cls.coutry #访问类属性
pass
@classmethod
def change_country(cls,data):
cls.coutry=data #修改类属性的值
pass
pass
@staticmethod #静态方法
def getData():
return People.coutry #通过类对象去引用
pass
@staticmethod
def add(x,y):
return x+y
pass

print(People.add(10,56)) #带参数的静态方法

print(People.getData())

print(People.get_country()) #通过类对象去引用

p=People
print(p.getData())# 注意一般情况下我们不会通过实例对象太访问静态方法

print(‘实例对象访问测试{%s}’%p.get_country())

People.change_country(‘英国’)

print(People.get_country()) #通过类对象去引用

为什么要使用静态方法呢

由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，

也就是说，在静态方法中，不会涉及到类中方法和属性的操作

数据资源能够得到有效的充分利用

demo 返回当前 系统时间

import time #引入第三方时间模块
class TimpTest:
def init(self,hour,min,second):
self.hour=hour
self.min=min
self.second=second
@staticmethod
def showTime():
return time.strftime("%H:%M:%S",time.localtime())
pass
pass
print(TimpTest.showTime())
t=TimpTest(2,10,15)
print(t.showTime()) #没有必要这种方式访问静态方法

为什么要使用静态方法呢

由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，

也就是说，在静态方法中，不会涉及到类中方法和属性的操作

数据资源能够得到有效的充分利用

从方法定义的形式可以看出来
1.类方法的第一个参数是类对象cls 进而去引用类对象的属性和方法必须用装饰器@classmethod来修饰
2.实例方法的第一个参数必须是self,通过这个self可以去引用类属性或者实例属性，若存在相同名称实例属性和类属性的话，实例属性的优先级最高
3.静态方法不需要定义额外的参数，若是要引用属性的话则可以通过类对象或者是实例对象去引用即可必须用装饰器@staticmethod来 修饰

---

----------------------------------------------------多态------------------------------------------------------------------------------------------------------
多态概念
所谓多态:定义时的类型和运行时的类型不一样，此时就成
为多态。
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是
原生多态，Python崇尚“鸭子类型”，利用python伪代码实
现Java和C#的多态

多态:顾名思义就是多种状态、形态，就是同一种行为
对于不同的子类[对象]有不同的行为表现
1、继承:多态必须发生在父类和子类之间
2、重写:子类重写父类的方法
多态有什么用:
增加程序的灵活性
增加程序的拓展性

案例演示

class Animal:
def say_who(self):
‘’’
父类[基类]
:return:
‘’’
print(‘我是一个动物’)
pass
pass
class Duck(Animal):
‘’’
鸭子类 [之类] 派生类
‘’’
def say_who(self):
‘’’
在这里重写父类的方法
:return:
‘’’
print(‘我是一只鸭子’)
pass
pass
class Dog(Animal):
‘’’
小狗类 [之类] 派生类
‘’’
def say_who(self):
print(‘我是一只可爱的小狗,我很可爱,请给我钱’)
pass
pass
class cat(Animal):
‘’’
小猫类 [之类] 派生类
‘’’
def say_who(self):
print(‘我是一只可爱的小猫’)
pass
pass

class Bired(Animal):
‘’’
新增鸟类 无须修改原来的代码
‘’’
def say_who(self):
print(‘我是一个小鸟’)
pass

def commonInvoke(obj):
‘’’
同意调用方法
:param obj: 对象的实例
:return:
‘’’
obj.say_who()

duck1=Duck()

duck1.say_who()

Dog2=Dog()

Dog2.say_who()

cat3=cat()

cat3.say_who()

listObj=[Duck(),Dog(),cat(),Bired()]
for item in listObj:
‘’’
循环去调用函数
‘’’
commonInvoke(item)

鸭子类型(duck typing)
在程序设计中，鸭子类型(英语: duck typing)是动态类型的一-种风格。在这种风格中，-一个对象有效的语义,
不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。“ 鸭子测试”可以这样表述:
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
复习知识点
☆—析构方法—☆
当一个对象被删除或者被销毁时，python解释器也会默认调用–个
方法，这个方法为_ del _()方法
☆—单继承—☆
子类在继承的时候，在定义类时，小括号()中为父类的名字父类的
属性、方法，会被继承给子类。
☆—多继承—☆
子类可以继承多个父类，在小括号()中 用逗号隔开
☆—继承的传递—☆
子类可以继承父类的父类的方法
☆—重写和调用父类方法—☆
重写父类方法后，调用的是子类的方法。
在重写的方法里面还可以调用父类方法。
☆—多态—☆
定义时的类型和运行时的类型不一样，此时就成为多态。
☆—类属性和实例属性—☆
类属性:就是类对象所拥有的属性
实例属性:实例对象所拥有的属性
☆—类方法和静态方法—☆
用@classmethod来表示类方法
用@staticmethod来表示静态方法
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

					导入
				-Python面向对象基础
		前面我们已经学习了面向对象编程的类、对
			象、类之间的关系等，接下来我们要深入学
				习如何具体控制属性、方法来满足需要，完成功能。

☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆目录☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
1.私有化属性
2.私有化方法
3.Property属性
4.new_方法
5.单例模式
6.错误与异常处理
7. Python动态 添加属性和方法
8._slots属性
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆学习目标☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
通过本次课程学习需要达到的目标
1.通过声明私有化属性、 方法，保护和控制数据(重点)
2.通过property属 性的使用，即控制好数据又方便访问(重点、难点)
3. 明确__new__方法的作用和用法(重点)
4.通过单例模式，控制实例个数(难点)
5.使用异常 处理机制，处理异常，提高代码健壮性
6.利用动态语言特点， 动态添加属性和方法
7.利用 slots 属性控制可动态的属性
☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆

					私有化属性

使用私有属性的场景

1.把特定的一个属性隐藏起来 不想让类的外部进行直接调用

2.我想保护这个属性不想让属性的值随意的改变

3.保护这个属性

不想让派生类[子类]去继承

class Person:
def init(self):
self.__name=‘小李’#加两个下划线 将此属性私有化 就不能再外部真接访问了
self.age=30
pass
def str(self):
‘’’
私有化的属性在内部可以使用self.__name
:return:
‘’’
return ‘{}的年龄是{}’.format(self.__name,self.age)
class Student(Person):
pass
stu=Student()
print(stu.age)

xl=Person()

print(xl.name)# 是通过类对象在外部访问的 不能访问私有属性

print(xl)

小结:

1私有化的[实例]属性不能再外部直接的访问可以在类的内部随意的使用

2.子类不能继承父类的私有化属性[只能继承父类公共的属性和行为]

3.在属性名的前面直接加“ .就可以变为私有化了

---

				私有化方法

概述与语法
●概述
●私有化方法跟私有化属性概念一 样，有些重要的方法，不允许外部调用，防止子类意
外重写，把普通的方法设置成私有化方法。
●语法
●私有化方法，即在方法名前面加两个下划线。
●示例
class Animal:
def __eat(self):
print(‘吃东西’)
pass
def run(self):
self.__eat()# 在此调用私有化的方法
print(‘跑步’)
pass

class Bird(Animal):
pass

b1=Bird()

b1.eat()

b1.run()
特性
●私有化方法一-般是类内部调用，子类不能继承，外部不能调用。
单下划线、双下划线、头尾双下划线说明
●. xx前面加一个下划线，以单下划线开头的表示的是protected类型的变量，即保护类
型只能允许其本身与子类进行访问，不能使用from xxx import*的方式导入。
●xxx_ 前后两个下滑线，魔法方法，一般是python自有， 开发者不要创建这类型的方法。
●xxx_ 后面单下滑线，避免属性名与python关键字冲突。

Property属性
●上节我们讲了访问私有变量的话，一 般写两个方法-一个访问， -一个修改， 由方法去控制访问。
●这样给调用者的感觉就是调用了一个方法，并不是访问属性。我们怎么做到让调用者直接以访
问属性的方式，而且我们又能控制的方式提供给调用者?
●Python中有-个被称为属性函数(property)的小概念， 它可以做一 些有用的事情。

-----------------------------------------------------------实现方式-1
●类属性即在类中定义值为property对象的类属性
●示例:给age属性设置值时，会自动调用setage方法，获取age属性值时，会自动调用
getage方法。
class Person(object):
def init (self):
self.__age = 18 # 定义一个私有化属性，属性名字前加连个_下滑线
def get_age(self): # 访问私有实例属性
return self.__age
def set_age(self,age): # 修改私有实例属性
if age < 0:
print(‘年龄不能小于0’)
else:
self.__age=age
pass
pass
# 定义一个类属性 实现通过直接访问属性的形式去访问私有的属性
age=property(get_age,set_age)
pass
p1=Person()
print(p1.age)
p1.age=20
print(p1.age)
-----------------------------------------------------------实现方式-1
-----------------------------------------------------------实现方式-2
●装饰器，即在方法.上使用装饰器
class Person(object):
def init (self):
self.__age = 18 #定义一个私有化属性，属性名字前加连个_下滑线
@property #使用装饰器对age进行装饰，提供一个getter方法
def age(self): #访问私有实例属性
return self.__age
@age.setter #使用装饰器进行装饰，提供一个setter方法
def age(self, age): #修改私有实例属性
if age<0:
print(‘年龄不能小于0’)
else:
self.__age = age
pass
pass
pass
xiaoming = Person( )
xiaoming.age = 20
print(xiaoming.age)
-----------------------------------------------------------实现方式-2

				__new__

概述
●. new 方法的作用是，创建并返回一个实例对象，如果_ new_ 只调用了- -次,
就会得到一个对象。继承自object的新式类才有new这一魔法方 法。
●注意事项:
new_ 是在一个对象实例化的时候所调用的第一 个方法
●_ new_ 至少必须要有- -个参数cls，代表要实例化的类,此参数在实例化时由Python解
释器自动提供，其他的参数是用来直接传递给_ init 方法
●_new_ 决定是否要使用该 _ init 方法， 因为_ new_ 可 以调用其他类的构造方法或
者直接返回别的实例对象来作为本类的实例，如果_ new 没有 返回实例对象，则
init 不会 被调用
●在_ new_ 方法中， 不能调用自己的_ new 方法， 即: return cls._ new_ (cls)， 否则会
报错(RecursionError: maximum recursion depth exceeded:超过最大递归深度)

例子1
class Animal:
def init(self):
self.color=‘红色’
pass
# 在python当中,如果不重新 new 默认结构如下
def new(cls, *args, **kwargs):
return super().new(cls, *args, **kwargs)
return object().new(cls, *args, **kwargs)
pass

tigger=Animal() # 实例化的过程会自动调用new去创建实例

在新式类中__new__ 才是真正的实例化的方法，为类提供外壳制造出实例框架，然后调用该框架内的构造方法__init__ 进行 丰满操作

---

				单列模式

概述
单例模式是常用设计模式的一种，单例就比如我们打开电脑的回收站，在系
统中只能打开一-个回收站，也就是说这个整个系统中只有一个实例，重复
打开也是使用这个实例。
●
简单的说就是不管创建多少次对象，类返回的对象都是最初创建的，不会再
新建其他对象。

例子1

单例模式是 一种常用的软件设计模式目的:确保某个类只有 一个实例存在

如果希望在真个系统中某个类只能出现个实例的时候， 那么这个单例对象就满足要求

创建一个单例对象基于__ new_ 去实现的 [推荐的一种]

class DatBaseClass(object):
def new(cls, *args, **kwargs):
# 如果类属性_ instance 的值为None ,那么新建一 个对象
# 如果类属性值不为None返回_ instance 保存的对象
# cls._instance=cls.new(cls) 切记不能使用直接的new方法
# 容易战场一个深度递归,应该调用父类的new方法
if not hasattr(cls,’_insteanc’): #如果不存在就开始创建
cls._insteanc=super().new(cls, *args, **kwargs)
return cls._insteanc
pass

class DBoptSingle(DatBaseClass):
pass

d1=DatBaseClass()
print(id(d1))
d2=DatBaseClass()
print(id(d2))
d3=DatBaseClass()
print(id(d3))

				错误与异常处理

概述
●有时候代码写错了，执行程序的时候，执行到错误代码的时候，程序直接终
止报错，这是因为Python检测到-个错误时，解释器就无法继续执行了，出
现了错误的提示，这就是"异常"。
●示例:变量b没有定义，直接打印变量b，会报异常。
语法格式

try:可能出现错误的代码块
except:出错之后执行的代码块
else:没有出错的代码块
finally:不管有没有出错都执行的代码块

try … except语句
●将可能出错的代码放到try里面except可以指定类型捕获异常
except里面的代码是捕获到异常时执行，将错误捕获，这样程序就不会因为一段代码包异常而导致整个程序崩溃。
●示例1:捕获ZeroDivisionError异常

异常
导致的错误
●Assert ionError
当assert语句失败时引发。
●Attr ibuteError
当属性分配或引用失败时引发。
●EOFError
当input()函数达到文件结束条件时引发。
●F loatingPointError
当浮点运算失败时引发。
●GeneratorExit
调用生成器的close()方法时引发。
●ImportErro
r找不到导入的模块时引发。
●IndexError
当序列的索引超出范围时引发。
●KeyError
在字典中找不到键时引发。
●KeyboardInterrupt
当用户 按下中断键(Ctrl+c或delete)时引发。
●MemoryError
当操作耗尽内存时引发。
●NameError
在局部或全局范围内找不到变量时引发。
●Not: Imp lementedError
由抽象方法提出。
●OSError
当系统操作导致系统相关错误时引发。
●Overf lowError
当算术运算的结果太大而无法表示时引发。
●ReferenceError
使用弱引用代理访问垃圾收集的引用时引发。
●Runt imeError
当错误不属于任何其他类别时引发。
●StopIteration
函数引发，以指示迭代器不再返回任何项。
●SyntaxError
遇到语法错误时由解析器引发。
●IndentationError
当缩进 不正确时引发。
●TabError
当缩进由不致的制表符和空格组成时引发。
●SystemError
当解释器检测到内部错误时引发。
●SystemExit
由sys.exit()函数引发。
●TypeError
将函数或操作应用于类型不正确的对象时引发。
●UnboundLocalError
当在函数或方法中引用局部变量，但没有将值绑定到该变量时引发。
●UnicodeError
当 发生与unicode相关的编码或解码错误时引发。
●UnicodeEncodeError
当编码过程中发生与unicode相关的错误时引发。
●UnicodeDecodeError
当解 码过程中出现与unicode相关的错误时引发。
●Unicode Trans lateError
翻译过程中发生与unicode相关的错误时引发。
●Va lueError
当函数得到类型正确但值不正确的参数时引发。
●ZeroDivis ionError
当除法或模运算的第二个操作数为零时引发。

try:
可能出现错误的代码块
except:
出错之后执行的代码块
else:
没有出错的代码块
finally:
不管有没有出错都执行的代码块

例子1

import Exceptopm

except 在捕获错误异常的时候只要根据具体的错误类型来捕获的

用一个块 可以捕获多个不同类型的异常

Exception 可以捕获所以的异常 当对出现的问题或者错误不确定的情况下可以使用Exception

try:
# print(我是异常)# 捕获逻辑的代码
li=[1,2,34]
# print(li[10]) #通过下标访问列表
# a=10/0
pass

except NameError as msg:

# 处理捕获到的错误 才会在这里执行

print(msg)

pass

except IndexError as msg:

print(msg)

pass

except ZeroDivisionError as msg:

print(msg)

except Exception as result:
print(result)
# 在此尽量的去处理捕获到的错误
pass
print(‘初次接’)

def A(s):
return 10/int(s)
pass
def B(s):
return A(s)*2
def main():
try:
A(‘0’)
pass
except Exception as msg:
print(msg)
pass
pass

main()

不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了这样的话就大大减少我们写try— except的麻烦

异常的抛出机制

如果在运行时发生异常 解释器会查找相应的异常捕获类型

如果在当前函数里面没有找到的话它会将异常传递给上层的调用函数，看能否处理

如果在最外层没有找到的话，解释器就会退出程序down哦

try:
print(‘我的天天’)
pass
except Exception as msg:
print(msg)
else:
print(‘当Try里的代码 没有出现异常的情况下 我才会执行’)

try:
int(‘fffffff’)
open(‘aaa.txt’)
except Exception as msg:
print(msg)
pass
finally:
print(‘释放文件的资源’)
print(‘不管有没有出错都执行这个代码’)

				自定义异常处理

自定义异常
●自定义异常，都要直接或间接继承Error或Exception类。
●由开发者主动抛出自定义异常，在python中使用raise关键字，

class ToolongMyExcption(Exception):
def init(self,leng):
‘’’

    :param leng:长度
    '''
    self.len=leng
    pass
def __str__(self):
    return "您输入的名称长度是"+str(self.len)+'超出长度了'
pass

def name_Test():
name=input(‘请输入名称:’)
try:
if len(name)>4:
raise ToolongMyExcption(len(name))
else:
print(name)
pass
pass
except ToolongMyExcption as result:
print(result)
pass
finally:
print(‘执行完毕’)
name_Test()