文章目录

----------------------------------基础----------------------------------
1.变量
2.运算符
3.输入和输出
总结
4.流程控制结构
5.高级数据类型
总结
6.函数（上）
- 定义
- 函数的定义、调用、参数
- 参数的分类——必选参数、默认参数【缺省参数】、可选参数、关键字参数
- 函数返回值
- 函数嵌套
总结
7.函数（下）
- 7.1函数的基本类型
- 7.2全局变量和局部变量
- 7.3引用传值
- 7.4匿名函数
- 7.5递归函数
总结
8.内置函数
- 8.1内置函数功能列表
- 8.2数学运算
- 8.3类型转换运算
- 8.4序列操作函数
- 8.5内置函数set
总结
--------------------------------面向对象--------------------------------
1.面向对象(上)
- 1.1定义
- 1.2类和对象
- 1.3定义类和创建对象、实例方法和属性、init方法
- 1.4 init方法
- 1.5 self理解
- 1.6 魔术方法
2.面向对象(中)
- 2.1析构方法
- 2.2单继承
- 2.3多继承
- 2.4间接继承
- 2.5重写和调用父类方法
- 2.6 类属性和实例属性
- 2.7类方法和静态方法
- 2.8三种方法对比
- 2.9多态
- 2.10 三大特征（面向对象）
3.面向对象(下)
- 3.1私有化属性
- 3.2私有化方法
- 3.3Property属性函数（意义不大）
- 3.4__new__方法
- 3.5单例模式
------------------------------------异常处理--------------------------------------
1.异常处理(1)
2.异常处理(2)
3.异常处理（3)
4.动态添加属性和方法（了解）
5. ___slots_ __属性
6.文件操作
- 6.1文件读写
- 6.2备份文件
- 6.3文件定位（了解）
- 6.4模块导入
7.常见模块
8.模块的制作、发布、安装
- 8.1模块的制作
- 8.2模块的发布
- 8.3模块的安装
------------------------------------内存管理---------------------------------
1.引用计数法
2.标记清除、分代收集算法
3.小整数和大整数对象池（内存优化）
4.规范
5.命令行参数_sys
6.命令行参数_argparse

----------------------------------基础----------------------------------

1.变量

元组类型
```
b = ()
```
列表类型
```
b = []
```
字典类型
```
b = {}
```
简单类型
```
b = 123
a = ’123‘
c = True
d = 5.0
```
命名规则
1、开头必须以字母或下划线_开头
2、区分大小写
3、除了开头，其余字母、数字、下划线均可
4、python关键字不能用作变量名
命名规范

2.运算符

算术运算符
比较运算符
逻辑运算符

优先级：() > not > and > or
赋值运算符

3.输入和输出

输出

%占位符

#输出 %占位符
name = '张扬'
classPro = '清华附中3班'
age = 7  #整数为%d
print('我的名字是%s:来自[%s],今年%d岁了'%(name,classPro,age))

.format()

name = '张扬'
classPro = '清华附中3班'
age = 7  #整数为%d
print('我的名字是{}:来自[{}],今年{}岁了'.format(name,classPro ,age))

\n换行符

输入

# input输入的一定是字符串形式 如果必须要求输入其他类型的数
# 比如%d要求整数 就用int（input（））转换
name = input("请输入你的姓名：")

总结

4.流程控制结构

选择控制 if-elif-else

score = int(input('请输入成绩：'))
if score > 70:print('成绩可以')
elif score >60:print('及格了')
else:print('没及格，延毕！')

循环控制
- for循环
```
for i in range(1,101):print(i , end = " ")
```
- while循环
```
row = 1
while row<9:print(row)row += 1
```
- break 跳出当前循环
- continue 执行当前循环的下一次
注：许多案例，如九九乘法表、直角三角形等等

5.高级数据类型

序列：一组按照顺序排列的值（数据集合）

索引/下表（默认从0开始）
切片：截取字符串中的其中一段内容，[start : end :step] （step默认为1,end默认为不包含）

1：字符串（不可变）

Test='python'
# print(type(Test))
# print('获取第一个字符%s'%Test[0])
# print('获取第二个字符%s'%Test[1])
# for item in Test:
#     print(item,end=' ')
name='peter'
# print('姓名首字母转换大写%s'%name.capitalize()) capitalize 首字母变大写
a='     hello       '
# b=a.strip() #去除字符串中两边的空格
# print(a)
# print(a.lstrip()) #删除左边的空格
# print(a.rstrip()) #删除右边的空格
# 复制字符串
# print('a的内存地址%d'%id(a)) #id函数 可以查看一个对象的内存地址
# b=a #在此只是把a对象的内存地址赋给了b
# print('a的内存地址%d'%id(a))
# print(b)
# dataStr='I love Python'
# print(dataStr.find('M')) #find函数可以查找目标对象在序列对象中的为值,如果没找到就返回-1
# print(dataStr.index('W')) #检测字符串中是否包含子字符串 返回的是下标值
# index如果没有找到对象的数据 便会报异常，而find函数不会，找不到返回-1
# print(dataStr.startswith('I'))  #判断开头
# print(dataStr.endswith('n'))#判断结尾
#
# print(dataStr.lower()) #转换成小写
# print(dataStr.upper())#转换成大写strMsg='hello world'
# slice [start:end:step] 左闭右开  start<=value<end 范围
# print(strMsg) #输出完整的数据
# print(strMsg[0])
print(strMsg[2:5]) #2-5下标之间的数据
print(strMsg[2:]) #第三个字符到最后
print(strMsg[:3]) #1-3    strMsg[0:3]=strMsg[:3]
print(strMsg[::-1]) #倒叙输出  负号表示方向  从右边往左去遍历
# 共有方法  +  *  in
# 字符串合并
strA='人生苦短'
strB='我用Python'
# list 合并
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)
# print(strA+strB)
# 复制 *
# print(strA*3)
# print(listA*3)
# in  对象是否存在 结果是一个bool值
print('我' in strA) #False
print(9 in listA)  #False
dictA={"name":"peter"}
print("name" in dictA)

2：列表（可变）
2.1：支持增删改查
2.2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
2.3:用[] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据

2.4：支持索引和切片来进行操作

# li=[] #空列表
# li=[1,2,3,"你好"]
# print(len(li)) #len函数可以获取到列表对象中的数据个数
# strA='我喜欢python'
# print(len(strA))
# print(type(li))
# 查找
listA=['abcd',785,12.23,'qiuzhi',True]
# print(listA) #输出完整的列表
# print(listA[0]) #输出第一个元素
# print(listA[1:3]) #从第二个开始到第三个元素
# print(listA[2:]) #从第三个元素开始到最后所有的元素
# print(listA[::-1]) #负数从右像左开始输出
# print(listA*3) #输出多次列表中的数据【复制】
# print('--------------增加-----------------------')
# print('追加之前',listA)
# listA.append(['fff','ddd']) #追加操作
# listA.append(8888)
# print('追加之后',listA)
# listA.insert(1,'这是我刚插入的数据') #插入操作 需要执行一个位置插入
# print(listA)
# rsData=list(range(10)) #强制转换为list对象
# print(type(rsData))
# listA.extend(rsData) #拓展  等于批量添加
# listA.extend([11,22,33,44])
# print(listA)
# print('-----------------修改------------------------')
# print('修改之前',listA)
# listA[0]=333.6
# print('修改之后',listA)
listB=list(range(10,50))print('------------删除list数据项------------------')
print(listB)
# del listB[0] #删除列表中第一个元素
# del listB[1:3] #批量删除多项数据 slice
# listB.remove(20) #移除指定的元素  参数是具体的数据值
listB.pop(1) #移除制定的项  参数是索引值
print(listB)print(listB.index(19,20,25))  #返回的是一个索引下标

3：元组（不可变）
3.1：不可变
3.2：用（）创建元组类型，数据项用逗号来分割
3.3：可以是任何的类型
3.4：当元组中只有一个元素时，要加上逗号，不然后解释器会当做其他类型来处理

3.5：同样可是支持切片操作

# 元组的创建 不能进行修改
tupleA=() #空元组
# print(id(tupleA))
tupleA=('abcd',89,9.12,'peter',[11,22,33])
# print(id(tupleA))
# print(type(tupleA))
# print(tupleA)
# 元组的查询
# for item in tupleA:
# #     print(item,end=' ')
# print(tupleA[2:4])
# print(tupleA[::-1])# print(tupleA[::-2]) #表示反转字符串 每隔两个取一次
# # print(tupleA[::-3]) #表示反转字符串 每隔三个取一次
# # print(tupleA[-2:-1:]) #倒着取下标 为-2 到 -1 区间的
# # print(tupleA[-4:-2:]) #倒着取下标 为-2 到 -1 区间的# tupleA[0]='PythonHello'  #错误的
# tupleA[4][0]=285202  #可以对元组中的列表类型的数据进行修改
# print(tupleA)
# print(type(tupleA[4]))tupleB=('1',) # 当元组中只有一个数据项的时候，必须要在第一个数据项后面加上 逗号
# print(type(tupleB))
tupleC=(1,2,3,4,3,4,4,1)   #tuple(range(10))print(tupleC.count(4)) #可以统计元素出现的次数

字典

4.1：不是序列类型 没有下标的概念，是一个无序的键值集合，是内置的高级数据类型
4.2：用{} 来表示字典对象，每个键值对用逗号分隔
4.3：键必须是不可变的类型【元组、字符串】，值可以是任意的类型
4.4: 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者

# 如何创建字典
dictA={"pro":'艺术','shcool':'北京电影学院'} #空字典
# 添加字典数据
dictA['name']='李易峰'  #key:value
dictA['age']='30'
dictA['pos']='歌手'
#结束添加
# print(dictA) #输出完整的字典
# print(len(dictA))  #数据项长度
# print(type(dictA))# print(dictA['name']) #通过键获取对应的值
dictA['name']='谢霆锋'  #修改键对应的值
dictA['shcool']='香港大学'
dictA.update({'height':1.80}) #可以添加或者更新
print(dictA)# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# 获取所有的键和值
print(dictA.items())
for key,value in dictA.items():print('%s==%s'%(key,value))# 删除操作
del dictA['name']  通过指定键进行删除
dictA.pop('age')   通过指定键进行删除
print(dictA)
# 如何排序 按照key排序
print(sorted(dictA.items(),key=lambda d:d[0]))
# 按照value排序
print(sorted(dictA.items(),key=lambda d:d[1]))
# 字典拷贝
import copy
# dictB=copy.copy(dictA) #浅拷贝
dictC=copy.deepcopy(dictA) #深拷贝
print(id(dictC))
print(id(dictA))
# dictB['name']='peter'
dictC['name']='刘德华'
print(dictC)
print(dictA)

公用方法

总结

6.函数（上）

定义

什么是函数：一系列Python语句的组合，可以在程序中运行一次或者多次。
一般是完成具体的独立的功能
为什么要使用函数：代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化
函数定义：def 函数名():函数体[一系列的python语句，表示独立的功能]
函数的调用：本质上就是去执行函数定义里面的代码块，在调用函数之前必须先定义。

函数的定义、调用、参数

# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的身高是%s'%'计算机信息管理')
#处理其他的逻辑信息
# 多次去打印出小张的信息
print('---------------多次输出相同的信息---------------------')
# print('小张的身高是%f'%1.73)
# print('小张的体重是%f'%160)
# print('小张的爱好是%s'%'唱歌')
# print('小张的专业是%s'%'计算机信息管理')
# 针对上面的场景 就需要进一步的去优化代码【方案：封装函数】
# 函数的定义
# def 函数名(参数列表):0-n 个
#     代码块def printInfo():'''这个函数是用来打印个人信息的 是对小张信息显示的组合:return:'''# 函数代码块print('小张的身高是%f' % 1.73)print('小张的体重是%f' % 160)print('小张的爱好是%s' % '唱歌')print('小张的专业是%s' % '计算机信息管理')pass
#函数的调用
# printInfo() #函数的调用
# printInfo() #多次调用
# printInfo()
# printInfo()
# printInfo()
# print('我是其他的代码块...')
# 进一步的去完善这样的需求【输出不同人的信息】 方案：通过传入参数来解决
def printInfo(name,height,weight,hobby,pro): #形式参数# 函数代码块print('%s的身高是%f' %(name,height))print('%s的体重是%f' %(name,weight))print('%s的爱好是%s' %(name,hobby))print('%s的专业是%s' %(name,pro))pass# 调用带参数的信息
printInfo('小李',189,200,'打游戏','咨询师') #实参
print('------------------带参数的调用---------------------------')
printInfo('peter',175,160,'码代码','计算机应用')

注：pass的作用？

参数的分类——必选参数、默认参数【缺省参数】、可选参数、关键字参数
1：必选参数——实际参数和形式参数
形参——sum（a，b）// 不占内存地址

实参——sum（10，20）// 占内存地址

# 参数的分类：
# 必选参数、默认参数[缺省参数]、可选参数、关键字参数
# 参数:其实就是函数为了实现某项特定的功能,进而为了得到实现功能所需要的数据
# 为了得到外部数据的
# 1 必选参数
def sum(a,b): #形式参数：只是意义上的一种参数，在定义的时候是不占内存地址的sum=a+bprint(sum)pass
# 函数调用  在调用的时候必选参数 是必须要赋值的
sum(20,15) #20 15 实际参数：实参，实实在在的参数，是实际占用内存地址的
# sum(15) #不能这样写的,

2：默认参数/缺省参数

# 2:默认参数【缺省参数】 始终存在于参数列表中的尾部
def sum1(a,b=40,c=90):print('默认参数使用=%d'%(a+b))pass
# # 默认参数调用
sum1(10) #在调用的时候如果未赋值，就会用定义函数时给定的默认值
sum1(2,56)

3：可变参数

#可变参数(当参数的个数不确定时使用，比较灵活
def getComputer(*args): #可变长的参数'''计算累加和:param args: 可变长的参数类型:return:'''# print(args)result=0for item in args:result+=itempassprint('result=%d'%result)pass
getComputer(1)
getComputer(1,2)
getComputer(1,2,3)
getComputer(1,2,3,4,5,6,7,8)

4.关键字可变参数 0-n（字典类型的参数）

# 关键字可变参数  0-n
# ** 来定义
# 在函数体内 参数关键字是一个字典类型 key是一个字符串
def keyFunc(**kwargs):print(kwargs)pass
# 调用
# keyFunc(1,2,3) 不可以传递的
dictA={"name":'Leo',"age":35}
keyFunc(**dictA)
keyFunc(name='peter',age=26,)
keyFunc()```

5.组合参数

# 组合的使用
def complexFunc(*args,**kwargs):print(args)print(kwargs)pass
complexFunc(1,2,3,4,name='刘德华')
complexFunc(age=36)# def TestMup(**kwargs,*args): #不符合要求的'''可选参数必须放到关键字可选参数之前可选参数：接受的数据是一个元组类型关键字可选参数：接受的数据是一个字段类型:param kwargs::param args::return:'''
#     pass

函数返回值

# 函数返回值
# 概念：函数执行完以后会返回一个对象，如果在函数的内部有return 就可以返回实际的值,否则返回None
# 类型：可以返回任意类型，返回值类型应该取决于return后面的类型
# 用途：给调用方返回数据
# 在一个函数体内可以出现多个return值：但是肯定只能返回一个return
# 如果在一个函数体内 执行了return,意味着函数就执行完成退出了，return后面的代码语句将不会执行
def Sum(a,b):sum=a+breturn sum#将计算的结果返回pass# rs=Sum(10,30) #将返回值赋给其他的变量
# print(rs) #函数的返回值返回到调用的地方
def calComputer(num):li=[]result=0i=1while i<=num:result+=ii+=1passli.append(result)return lipass# 调用函数
value=calComputer(10)
print(type(value)) #value 类型
print(value)def returnTuple():'''返回元组类型的数据:return:'''# return 1,2,3return {"name":"测试"}passA=returnTuple()
print(type(A))

函数嵌套

# 函数嵌套
def fun1():print("--------------fun1 start-------------------")print("--------------执行代码省略-------------------")print("--------------fun1 end-------------------")passdef fun2():print("--------------fun2 start-------------------")# 调用第一个函数fun1()print("--------------fun2 end-------------------")passfun2() #调用函数2# 函数的分类：根据函数的返回值和函数的参数
# 有参数无返回值的
# 有参数又返回值的
# 无参数又返回值的
# 无参数无返回值的

总结

7.函数（下）

7.1函数的基本类型

7.2全局变量和局部变量

------------局部变量----------------
局部变量就是在函数内部定义的变量【作用域仅仅局限在函数的内部】
不同的函数可以定义相同的局部变量，但是各自用各自的不会产生影响
局部变量的作用：为了临时的保存数据需要在函数中定义来进行存储
------------全局变量----------------
下面的pro的定义就是一个全局变量【作用域的范围不同】
当全局变量和局部变量出现重复定义的时候，程序会优先执行使用函数内部定义的变量【地头蛇】
如果在函数的内部要想对全局变量进行修改的话，对于不可变类型【str、元组、number】- #必须使用global 关键字进行声明

注：

# 以下两个是全部变量
pro='计算机信息管理'
name='吴老师'
def printInfo():# name='peter' #局部变量print('{}.{}'.format(name,pro))pass
def TestMethod():name='刘德华'print(name,pro)pass
def changeGlobal():'''要修改全局变量:return:'''global pro #声明全局变量 后才可以修改pro='市场营销' #局部变量passchangeGlobal()
print(pro) #被修改了吗
TestMethod()
printInfo()

7.3引用传值

注：这个和java不一样，python是引用传递（记得区分可变类型和不可变类型）。

a=1  #不可变类型
def func(x):print('x的地址{}'.format(id(x)))x=2print('x的值修改之后地址{}'.format(id(x)))print(x)pass
# 调用函数
# print('a的地址:{}'.format(id(a)))
# func(a)
# print(a)# 可变类型
# li=[]
# # def testRenc(parms):
# #
# #     li.append([1,3,4,54,67])
# #     print(id(parms))
# #     print('内部的{}'.format(parms))
# #     pass
# #
# # print(id(li))
# # testRenc(li)
# # print('外部的变量对象{}'.format(li))
# 小结
# 1.在python当中  万物皆对象,在函数调用的时候，实参传递的就是对象的引用
# 2.了解了原理之后，就可以更好的去把控 在函数内部的处理是否会影响到函数外部的数据变化
#参数传递是通过对象引用来完成 、参数传递是通过对象引用来完成、参数传递是通过对象引用来完成

7.4匿名函数

语法：
lambda 参数1、参数2、参数3:表达式
特点：
7.1使用lambda关键字去创建函数
7.2.没有名字的函数
7.3匿名函数冒号后面的表达式有且只有一个, 注意：是表达式，而不是语句
7.4匿名函数自带return，而这个return的结果就是表达式计算后的结果
缺点：
lambde只能是单个表达式，不是一个代码块，lambde的设计就是为了满足简单函数的场景，

仅仅能封装有限的逻辑,复杂逻辑实现不了，必须使用def来处理

def computer(x,y):'''计算数据和:param x::param y::return:'''return x+ypass
# 对应的匿名函数
M=lambda x,y:x+y
# 通过变量去调用匿名函数
# print(M(23,19))
# print(computer(10,45))result=lambda a,b,c:a*b*c
# print(result(12,34,2))
age=25# print('可以参军' if age>18 else '继续上学') #可以替换传统双分支的写法# funcTest=lambda x,y:x if x>y else y
# print(funcTest(2,12))# rs=(lambda x,y:x if x>y else y)(16,12) #直接的调用
# print(rs)
varRs=lambda x:(x**2)+890
print(varRs(10))

7.5递归函数

定义
递归满足的条件
自己调用自己
必须有一个明确的结束条件
优点： 逻辑简单、定义简单

缺点： 容易导致栈溢出，内存资源紧张，甚至内存泄漏

def jiecheng(n):result=1for item in range(1,n+1):result*=itempassreturn result# print('10的阶乘{}'.format(jiecheng(10)))
# 递归方式去实现
def diguiJc(n):'''递归实现:param n: 阶乘参数:return:'''if n==1:return 1else:return n*diguiJc(n-1)pass# 递归调用
print('5的阶乘{}'.format(diguiJc(5)))
# 递归案例 模拟实现 树形结构的遍历
import os #引入文件操作模块
def findFile(file_Path):listRs=os.listdir(file_Path) #得到该路径下所有文件夹for fileItem in listRs:full_path=os.path.join(file_Path,fileItem) #获取完整的文件路径if os.path.isdir(full_path):#判断是否是文件夹findFile(full_path) #如果是一个文件夹 再次去递归else:print(fileItem)passpasselse:returnpass# 调用搜索文件夹对象
findFile('E:\\软件')

总结

8.内置函数

8.1内置函数功能列表

8.2数学运算

# 取绝对值
# print(abs(-34))
# round  取近似值
# print(round(3.66,1))
# pow 求次方
# print(3**3)
# print(pow(3,3))
# max 求最大值
# print(max([23,123,4,5,2,1,786,234]))
# print(max(23,235))
# sum 使用
# print(sum(range(50),3))
# eval 执行表达式
a,b,c=1,2,3
print('动态执行的函数={}'.format(eval('a*b+c-30')))
def TestFun():print('我执行了吗?')pass
# eval('TestFun()') #可以调用函数执行
# 类型转换函数
# print(bin(10)) #转换二进制
# print(hex(23)) #十六进制
# 元组转换为列表
tup=(1,2,3,4)
# print(type(tup))
li=list(tup) #强制转换
# print(type(li))
li.append('强制转换成功')
# print(li)
tupList=tuple(li)
# print(type(tupList))# 字典操作 dict()
# dic=dict(name='小明',age=18) #创建一个字典
# # print(type(dic))
# # # dict['name']='小明'
# # # dict['age']=18
# # print(dic)
# bytes转换
# print(bytes('我喜欢python',encoding='utf-8'))

注：

8.3类型转换运算

8.4序列操作函数

all

# all()  result:bool 对象中的元素除了是 0、空、FALSE 外都算 TRUE, 所有的元素都为True
# 结果就为True
print(all([])) #True
print(all(())) #True
print(all([1,2,4,False]))#False
print(all([1,2,4]))#True
print(all((3,4,0)))#False

any

# any  result:bool 类似于逻辑运算符 or的判断，只要有一个元素为True 结果就为True
print('--------any-------------')
print(any(('',False,0)))
print(any((1,2,3)))

sorted(返回的是一个新的结果，原始对象不会变)

# sort 和sorted
li=[2,45,1,67,23,10] #原始对象
# li.sort() #list的排序方法 直接修改的原始对象
tupArray=(2,45,1,67,23,10)
print('--------排序之前---------{}'.format(li))
varList=sorted(li) #升序排列
varList=sorted(li,reverse=True) #降序排序
print('--------排序之后---------{}'.format(varList))
varRs=sorted(tupArray,reverse=False)
print(varRs)

reverse : list.reverse()
range

zip

# zip() :就是用来打包的，会把序列中对应的索引位置的元素存储为一个元组
s1=['a','b','c']
s2=['你','我','c他','peter']
s3=['你','我','c他','哈哈','呵呵']
# print(list(zip(s1))) 压缩一个数据
zipList=zip(s2,s3) #两个参数
print(list(zipList))
def printBookInfo():'''zip 函数的使用:return:'''books=[] #存储所有的图书信息id = input('请输入编号: 每个项以空格分隔')  #strbookName = input('请输入书名: 每个项以空格分隔') #strbookPos = input('请输入位置: 每个项以空格分隔')idList=id.split(' ')nameList = bookName.split(' ')posList = bookPos.split(' ')bookInfo=zip(idList,nameList,posList) #打包处理for bookItem in bookInfo:'''遍历图书信息进行存储'''dictInfo={'编号':bookItem[0],'书名':bookItem[1],'位置':bookItem[2]}books.append(dictInfo) #将字典对象添加到list容器中passfor item in books:print(item)# printBookInfo()

enumerate

# enumerate 函数用于将一个可遍历的数据对象
# (如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，
# 一般用在 for 循环当中listObj=['a','b','c']
for index,item in enumerate(listObj,5):print(index,item)pass
dicObj={}
dicObj['name']='李易峰'
dicObj['hobby']='唱歌'
dicObj['pro']='艺术设计'
# print(dicObj)for item in enumerate(dicObj):print(item)

8.5内置函数set

定义:不支持切片和索引，类似字典，但是只有key，是一个无序且不重复的元素集合

创建方式：

# set 不支持索引和切片，是一个无序的且不重复的容器
# 类似于字典 但是只有key  没有value
# 创建集合
dic1={1:3}
set1={1,2,3}
set2={2,3,4}
print(type(set1)) #集合
print(type(dic1)) #字典
# 添加操作
set1.add('python')
print(set1)
# 清空操作
set1.clear()
print(set1)
# 差集操作
rs=set1.difference(set2)
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(quData)
print(set1)
print(set1.discard(3)) #指定移除的元素
print(set1)
# update 两个集合
set1.update(set2)
print(set1)

总结

--------------------------------面向对象--------------------------------

1.面向对象(上)

1.1定义

面向对象编程：oop [object oriented programming] 是一种python的编程思路；
面向过程：就是我们一开始学习的，按照解决问题的步骤去写代码【根据业务逻辑去写代码】，在思考问题的时候, 首先分析’怎么按照步骤去实现’ 然后将问题解决拆解成若干个步骤，并将这些步骤对应成方法一步一步的最终完成功能。
面向对象：关注的是设计思维【找洗车店给钱洗车】

1.2类和对象

类和对象类:类是具有一组 相同或者相似特征【属性】和行为【方法】的一系列[多个]对象组合现实世界    计算机世界
行为---------> 方法
特征---------->属性对象: 对象是实实在在的一个东西，类的实例化，具象化类是对象的抽象化  而对象是类的一个实例

1.3定义类和创建对象、实例方法和属性、init方法

实例方法：在类的内部，使用def 关键字来定义  第一个参数默认是 self
【名字标识可以是其他的名字，但是这个位置必须被占用】实例方法是归于 类的实例所有属性：类属性  实例属性
在类的内部定义的变量【类属性】
在方法内部定义的【通过类似于self.变量名】 变量，是实例属性

# 定义类和对象
# 类结构  类名  属性  方法
# class 类名:
#     属性
#     方法class Person:'''对应人的特征'''# name='小明'  #类属性age=20       #类属性'''对应人的行为  实例方法'''def __init__(self):self.name='小明'   #实例属性passdef eat(parms):print("大口的吃饭")passdef run(self):   #实例方法print('飞快的跑')passpass
def printInfo():'''普通方法:return:'''pass
# 创建一个对象【类的实例化】
# 规则格式  对象名=类名()
xm=Person()
xm.eat() #调用函数
xm.run()
print("{}的年龄是：{}".format(xm.name,xm.age))# 创建另外一个实例对象
xw=Person()
xw.eat()  #实例方法

1.4 init方法

# init传递参数 改进
class Pepole:def __init__(self,name,sex,age):'''实例属性的声明'''self.name=nameself.sex=sexself.age=agepassdef eat(self,food):'''吃的行为:return:'''print(self.name+'喜欢吃'+food)passzp=Pepole('张鹏','男生',18)
print(zp.name,zp.age)
zp.eat('香蕉')
lh=Pepole('李辉','男生',28)
lh.eat('苹果')
print(lh.name,lh.age)xh=Pepole('小花','女生',20)
xh.eat('橘子')
print(xh.name,xh.age)# 总结 __init__
# 1. python 自带的内置函数 具有特殊的函数   使用双下划线 包起来的【魔术方法】
# 2. 是一个初始化的方法 用来定义实例属性 和初始化数据的，在创建对象的时候自动调用  不用手动去调用
# 3. 利用传参的机制可以让我们定义功能更加强大并且方便的 类

1.5 self理解

小结  self特点
self只有在类中定义 实例方法的时候才有意义,在调用时候不必传入相应的参数 而是由解释器 自动去指向;![在这里插入图片描述](https://img-blog.csdnimg.cn/6021b15274424412930d9e9cfee67965.png)self的名字是可以更改的  可以定义成其他的名字，只是约定俗成的定义成了 self
self 指的是 类实例对象本身, 相当于java中 this

class Person:def __init__(self,pro,name,food):''':param pro: 专业:param name: 姓名:param food: 食物'''self.pro=pro  #实例属性的定义self.name=nameself.food=foodprint('----init-----函数执行')pass'''定义类'''def eat(self,name,food):'''实例方法:return:'''# print('self=%s',id(self))print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))passpass# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象

1.6 魔术方法

定义：

class Person:def __init__(self,pro,name,food):''':param pro: 专业:param name: 姓名:param food: 食物'''self.pro=pro  #实例属性的定义self.name=nameself.food=foodprint('----init-----函数执行')pass'''定义类'''def eat(self,name,food):'''实例方法:return:'''# print('self=%s',id(self))print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))passdef __str__(self):'''打印对象 自定义对象 是内容格式的:return:'''return '%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro)passdef __new__(cls, *args, **kwargs):'''创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写场景：可以控制创建对象的一些属性限定 经常用来做单例模式的时候来使用:param args::param kwargs:'''print('----new-----函数的执行')return object.__new__(cls) #在这里是真正创建对象实例的passpass# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象
# 小结  self特点
# self只有在类中定义 实例方法的时候才有意义,在调用时候不必传入相应的参数 而是由解释器 自动去指向
# self的名字是可以更改的  可以定义成其他的名字，只是约定俗成的定义成了 self
# self 指的是 类实例对象本身, 相当于java中 this# __new__和__init___函数的区别
# __new__ 类的实例化方法 必须要返回该实例 否则对象就创建不成功
# __init___ 用来做数据属性的初始化工作  也可以认为是实例的构造方法  接受类的实例 self 并对其进行构造
# __new__   至少有一个参数是 cls 代表要实例化的类 ，此参数在实例化时由python解释器自动提供
# __new__  函数 执行要早于 __init___ 函数

2.面向对象(中)

2.1析构方法

class Animal:def __init__(self,name):self.name=nameprint('这是构造初始化方法')passdef __del__(self):# 主要的应用就是来操作 对象的释放  一旦释放完毕  对象便不能在使用print('当在某个作用域下面 没有被使用【引用】的情况下 解析器会自动的调用此函数 来释放内存空间')print('这是析构方法')print('%s 这个对象 被彻底清理了 内存空间也释放了'%self.name)passcat=Animal('小花猫')
# del cat  #手动的去清理删除对象  会指定__del__函数
print(cat.name)
input('程序等待中.....')
# print('*'*40)
# dog=Animal('柯基小狗')

2.2单继承

class Animal:def  eat(self):'''吃:return:'''print('吃饭了')passdef drink(self):'''喝:return:'''passclass Dog(Animal): #继承了Animal 父类 此时dog就是子类def wwj(self):'''子类独有的实现:return:'''print('小狗汪汪叫')pass
class Cat(Animal):def mmj(self):'''子类独有的实现:return:'''print('小猫喵喵叫')passd1=Dog()
d1.eat() #具备了吃的行为  是继承了父类的行为
d1.wwj()
print('**************cat 的行为**********************')
c1=Cat()
c1.eat()
c1.mmj()

2.3多继承

注：# 问题是当多个父类当中存在相同方法的时候应该去调用哪一个呢？
答：广度优先/（print(A.mro) #可以显示类的依次继承关系）

class shenxian:def fly(self):print("神仙都会飞")pass
class Monkey:def chitao(self):print('猴子喜欢吃桃')pass
class Sunwukong(shenxian,Monkey): #即使神仙  同时也是猴子pass# swk=Sunwukong()
# swk.chitao()
# swk.fly()
####################################################
# 问题是  当多个父类当中存在相同方法的时候  应该去调用哪一个呢
class D(object):def eat(self):print('D.eat')passpass
class C(D):def eat(self):print('C.eat')passpass
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  也是继承的顺序

2.4间接继承

class GrandFather:def eat(self):print('吃的 方法')passpass
class Father(GrandFather):passclass Son(Father):passson=Son()
print(Son.__mro__)
son.eat() #此方法 是从GrandFather继承过来的

2.5重写和调用父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
为什么要重写，父类的方法已经不满足子类的需要，那么子类就可以重写父类或者完善父类的方法


class Dog:def __init__(self,name,color):self.name=nameself.color=colordef bark(self):print('汪汪叫....')passpass
class kejiquan(Dog):def __init__(self,name,color):#属于重写父类的方法# 针对这种需求  我们就需要去调用父类的函数了# Dog.__init__(self,name,color) #手动调用  调用父类的方法了 执行完毕就可以具备name,color这两个实例属性了\super().__init__(name,color) #super是自动找到父类 进而调用方法, 假设继承了多个父类，那么会按照顺序逐个去找 然后在调用# 拓展其他的属性self.height=90self.weight=20passdef __str__(self):return '{}的颜色会{} 它的身高是{}cm 体重是:{}'.format(self.name,self.color,self.height,self.weight)def bark(self): #属于重写类的方法super().bark() #调用父类的方法print('叫的跟神一样')print(self.name)passkj=kejiquan('柯基犬','红色')
kj.bark()
print(kj)

注： super是自动找到父类进而调用方法

2.6 类属性和实例属性

注：类属性就是类对象所拥有的属性（类对象不同于实例对象，这里和java有点不同，这里所说的类对象应该就是java里面的元对象）

小结
类属性是可以被类对象和实例对象共同访问使用的
实例属性只能由实例对象所访问

class Student:name='李明' #属于类属性  就是student类对象所拥有的def __init__(self,age):self.age=age #实例属性pass@staticmethoddef aaa(x,y):print(x+y)passStudent.name='李易峰' #通过类对象去修改数据 可以修改的  因为name的所拥有的权利属于类对象lm=Student(18)
print(lm.name) #通过实例对象去访问类属性
# lm.name='刘德华'  #通过实例对象 对类属性进行修改 可以吗? 不可以的
print(lm.name)
print(lm.age)
Student.aaa(4,6)
print('---------xh的数据---------------')
xh=Student(28)
print(xh.name)
print(xh.age)
print('---------通过类对象 student 去访问name---------------')
# print(Student.name)  如 类名.属性名 形式去访问
# print(Student.age)
# 小结
# 类属性是可以 被类对象和实例对象共同访问使用的
# 实例属性只能由实例对象所访问

分析：

2.7类方法和静态方法

类方法是类所拥有的，可以访问类变量，可以通过类对象和实例对象访问。必须传参数。
静态方法和类方法差不多，但是不必须传参数。
为什么要使用静态方法呢？1. 由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互；2.也就是说，在静态方法中，不会涉及到类中方法和属性的操作；3.数据资源能够得到有效的充分利用。

class  People:country='china'#类方法 用 classmethod 来进行修饰@classmethoddef get_country(cls):return cls.country #访问类属性pass@classmethoddef change_country(cls,data):cls.country=data #修改类属性的值  在类方法中pass@staticmethoddef getData():return People.country  #通过类对象去引用pass@staticmethoddef add(x,y):return x+ypassprint(People.add(10,56)) #带有参数的静态方法# print(People.getData())# print(People.get_country()) #通过类对象去引用
p=People()
print(p.getData()) #注意 一般情况下 我们不会通过实例对象去访问静态方法
# print('实例对象访问 %s'%p.get_country())
# print('-----------------修改之后---------------------------')
# People.change_country('英国')
# print(People.get_country()) #通过类对象去引用# 为什么要使用静态方法呢
# 由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，
# 也就是说，在静态方法中，不会涉及到类中方法和属性的操作
# 数据资源能够得到有效的充分利用# demo  返回当前的系统时间
import  time # 引入第三方的时间模块
class TimeTest:def __init__(self,hour,min,second):self.hour=hourself.min = minself.second = second@staticmethoddef showTime():return time.strftime("%H:%M:%S",time.localtime())passpassprint(TimeTest.showTime())
t=TimeTest(2,10,15)
print(t.showTime()) #没有必要通过这种方式去访问 静态方法

2.8三种方法对比

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

2.9多态

多态：顾名思义就是多种状态、形态，就是同一种行为对于不同的子类【对象】有不同的行为表现
要想实现多态必须的有两个前提需要遵守：
1、继承：多态必须发生在父类和子类之间
2、重写: 子类重写父类的方法
多态有什么用: 增加程序的灵活性；增加程序的拓展性。

# 案例演示
class Animal:'''父类【基类】'''def say_who(self):print('我是一个动物....')passpass
class Duck(Animal):'''鸭子类 【子类】 派生类'''def say_who(self):'''在这里重写父类的方法:return:'''print('我是一只漂亮的鸭子')passpass
class Dog(Animal):'''小狗类 【子类】 派生类'''def say_who(self):print('我是一只哈巴狗')passpassclass Cat(Animal):'''小猫类 【子类】 派生类'''def say_who(self):print('我是一只小花猫 喵喵喵喵')passpassclass Bird(Animal):'''新增鸟类 无需修改原来的代码'''def say_who(self):print('我是一只黄鹂鸟')passclass People:def say_who(self):print('我是人类')passclass student(People):def say_who(self):print('我是一年级的学习 张明')passdef commonInvoke(obj):'''统一调用的方法:param obj: 对象的实例:return:'''obj.say_who()# duck1=Duck()
# duck1.say_who()
# dog1=Dog()
# dog1.say_who()
# cat1=Cat()
# cat1.say_who()listObj=[Duck(), Dog(),Cat(),Bird(),student()]
for item in listObj:'''循环去调用函数'''commonInvoke(item)

2.10 三大特征（面向对象）

在python中展现面向对象的三大特征:
封装、继承、多态
封装:指的是把内容封装到某个地方，便于后面的使用
他需要:
把内容封装到某个地方
从另外一个地方去调用被封装的内容
对于封装来说其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self来获取被封装的内容
继承: 和现实生活当中的继承是一样的：也就是子可以继承父的内容【属性和行为】（爸爸有的儿子都有，相反儿子有的爸爸不一定有）
所以对于面向对象的继承来说其实就是将多个类共有的方法提取到父类中子类仅需继承父类而不必一一去实现
这样就可以极大的提高效率减少代码的重复编写，精简代码的层级结构便于拓展
```
 class 类名(父类):'''子类就可以继承父类中公共的属性和方法'''pass
```
多态：顾名思义就是多种状态、形态，就是同一种行为对于不同的子类【对象】有不同的行为表现
要想实现多态必须的有两个前提需要遵守：
1、继承：多态必须发生在父类和子类之间
2、重写: 子类重写父类的方法

3.面向对象(下)

3.1私有化属性

使用私有属性的场景
1.把特定的一个属性隐藏起来不想让类的外部进行直接调用
2.我想保护这个属性不想让属性的值随意的改变
3.保护这个属性不想让派生类【子类】去继承


class Person:__hobby='跳舞'  #私有的类属性def __init__(self):self.__name='李四' #加两个下划线 将此属性私有化之后  就不能再外部直接访问了,当然在类的内部是可以防蚊贴self.age=30passdef __str__(self):'''私有化的属性在内部可以使用 self.__name:return:'''return '{}的年龄是{} 爱好是{}'.format(self.__name,self.age,Person.__hobby)def  changeValue(self):Person.__hobby='唱歌'
class Student(Person):def printInfo(self):# print(self.__name)  #在此访问父类中的私有属性 可以吗?   不可以print(self.age)passstu=Student()
# print(stu.__name)
stu.printInfo()
stu.changeValue() #修改私有属性的值
print(stu)
# print(stu.__hobby) #实例对象访问类属性
# print(Person.__hobby) #实例对象访问类属性# xl=Person()
# # print(xl.__name) #是通过类对象 在外部访问的 不能访问私有属性
# print(xl)# 小结：
# 1 私有化的【实例】属性 不能再外部直接的访问  可以在类的内部随意的使用
# 2.子类不能继承父类的私有化属性【只能继承父类公共的属性和行为】
# 3. 在属性名的前面直接加‘ __’  就可以变为私有化了

3.2私有化方法

class Animal:def __eat(self):print('吃东西')passdef run(self):self.__eat() #在此调用私有化的方法print('飞快的跑')passclass Bird(Animal):passb1=Bird()
# print(b1.eat())
# b1.eat()
b1.run()

3.3Property属性函数（意义不大）

目的：不需要通过函数的形式，来访问私有属性

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)# 实现方式2  通过装饰器的方式去声明@property  #用装饰器修饰 添加属性标志  提供一个getter方法def age(self):return self.__age@age.setter   #提供一个setter方法def age(self,parms):if parms < 0:print('年龄不能小于0')else:self.__age=parmspasspasspass
p1=Person()
print(p1.age)
p1.age=30
print(p1.age)
# p1.get_age()
# p1.set_age()

3.4new方法

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)passtigger=Animal() #实例化的过程会自动调用__new__去创建实例
# 在新式类中 __new__  才是真正的实例化的方法，为类提供外壳制造出实例框架，然后调用该框架内的构造方法__init__ 进行丰满操作
# 比喻建房子 __new__   方法负责开发地皮 打地基 并将原料存放在工地，而__init__ 负责从工地取材料建造出地皮开发图纸规定的大楼，
# 负责细节设计、建造 最终完成

3.5单例模式

单例模式是一种常用的软件设计模式 目的：确保某一个类只有一个实例存在
如果希望在真个系统中某个类只能出现一个实例的时候，那么这个单例对象就满足要求
创建一个单例对象基于__new__去实现的【推荐的一种】


class DataBaseClass(object):def __new__(cls, *args, **kwargs):# cls._instance=cls.__new__(cls)  不能使用自身的new方法# 容易造成一个深度递归，应该调用父类的new方法if not hasattr(cls,'_instance'):  #如果不存在就开始创建cls._instance=super().__new__(cls,*args, **kwargs)return cls._instancepassclass DBoptSingle(DataBaseClass):passdb1=DBoptSingle()
print(id(db1))
db2=DBoptSingle()
print(id(db2))
db3=DBoptSingle()
print(id(db3))

------------------------------------异常处理--------------------------------------

1.异常处理(1)

语法格式

# import Exception
# except 在捕获错误异常的时候  只要根据具体的错误类型来捕获的
# 用一个块 可以捕获多个不同类型的异常
# Exception 可以捕获所有的异常  当对出现的问题或者错误不确定的情况下  可以使用Exception
# print(dir(Exception))
try:# print(b) #捕获逻辑的代码li=[1,2,34]print(li[10])  #通过下标去访问列表# a=10/0pass
except  NameError as msg:
#     # 捕获到的错误 才会在这里执行
#     print(msg)pass
except IndexError as msg:
#     print(msg)pass
except ZeroDivisionError as msg:
#     print(msg)pass
except Exception as result:# print(result)# 在此尽量的去处理捕获到的错误pass
# print('初次接触异常处理')
# print('HAHAHAHHAHA')# try-except-else# try:
#     print('我是没有错误产生的')
#     pass
# except SyntaxError as msg:
#     print(msg)
# except Exception as msg:
#     print('error',msg)
# else:
#     print('当Try里面的代码 没有出现异常的情况下 我才会执行')
#     pass# try-except-finally
try:int('34')open('aaaa.txt')
except Exception as msg:print(msg)pass
finally:print('释放文件的资源、数据库连接是资源等等')print('不管有没有出错都执行的代码块')

2.异常处理(2)

常见的异常类型

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

异常处理机制


def A(s):return 10/int(s)pass
def B(s):return A(s)*2
def main():# B(0)try:B('0')passexcept Exception as msg:print(msg)passpass# main()
# 不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了 这样的话 就大大减少我们写try---except的麻烦
# 异常的抛出机制
#如果在运行时发生异常  解释器会查找相应的异常捕获类型
#如果在当前函数里面没有找到的话  它会将异常传递给上层的调用函数，看能否处理
# 如果在最外层 没有找到的话，解释器就会退出 程序down哦

3.异常处理（3)

自定义异常：都要直接或者间接继承Error或者Exception类

class ToolongMyException(Exception):def __init__(self,leng):''':param leng: 长度'''self.len=lengpassdef __str__(self):return '您输入姓名数据长度是'+str(self.len)+'超过长度了..'passdef name_Test():name=input('请输入姓名.....')try:if  len(name)>5:raise ToolongMyException(len(name))else:print(name)passpassexcept ToolongMyException as result:print(result)passfinally:print('执行完毕了....')name_Test()

4.动态添加属性和方法（了解）

代码

import types  #添加方法的库def dymicMethod(self):print('{}的体重是:{}kg 在 {} 读大学'.format(self.name,self.weight,Student.shcool))pass
@classmethod
def classTest(cls):print('这是一个类方法')pass@staticmethod
def staticMethodTest():print('这是一个静态方法')passclass Student:def __init__(self,name,age):self.name=nameself.age=agepassdef __str__(self):return '{}今天{}岁了'.format(self.name,self.age)passprint('绑定类方法')
Student.TestMethod=classTest
# Student.TestMethod()Student.staticMethodTest=staticMethodTest
Student.staticMethodTest()print('---------------绑定类方法执行结束----------------------')zyh=Student('张艳华',20)
zyh.weight=50 #动态添加
zyh.printInfo=types.MethodType(dymicMethod,zyh) #动态的绑定方法zyh.TestMethod()
print('-------------实例对象调用 动态绑定类方法-----------------------')
# print(zyh)
# print(zyh.weight)
print('-------------另外一个实例对象  张明--------------------------')
zm=Student('张名',20)
zm.weight=80 #动态添加
print(zm)zm.printInfo=types.MethodType(dymicMethod,zm) #动态的绑定方法
# print(zm.weight)
print('-------------给类对象添加属性--------------------------')
Student.shcool='北京邮电大学' #动态添加类属性
print(zm.shcool)
print('-------------执行动态调用实例方法--------------------------')
zyh.printInfo() #调用动态绑定的方法
zm.printInfo()

5. slots 属性

作用：限制要添加的实例属性；节约内存空间


class Student(object):__slots__ = ('name','age')def __str__(self):return '{}....{}'.format(self.name,self.age)pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 没有在范围内 所以报错
# print(xw.__dict__) #所有可以用的属性都在这里存储  不足的地方就是占用的内存空间大
# 可以看到 在定义了 slots变量之后 student类的实例已经不能随意创建不在 __slots__定义的属性了
# 同时还可以看到实例当中也不在有__dict__
# print(xw)# 在继承关系当中的使用  __slots__
# 子类未声明  __slots__时，那么是不会继承父类的__slots__，此时子类是可以随意的属性赋值的
# 子类声明 了__slots__时，继承父类的__slots__，也就是子类__slots__的范围是为：
# 其自身+父类的__slots__
class subStudent(Student):__slots__ = ('gender','pro')pass
ln=subStudent()
ln.gender='男'
ln.pro='计算机信息管理'
print(ln.gender,ln.pro)

6.文件操作

6.1文件读写

写

# 文件的操作
# 打开文件 open
# 默认的编码是gbk 这个是中文编码，最好的习惯呢就是我们再打开一个文件的时候
# 给它指定一个编码类型
fobj = open('./Test.txt','w',encoding='utf-8')
# # 开始操作 读/写操作
fobj.write('在苍茫的大海上')
fobj.write('狂风卷积着乌云')
fobj.write('在乌云和大海之间\r\n')
fobj.write('海燕像黑色的闪电\r\n')
fobj.close()
# 以二进制的形式去写数据
fobj=open('Test_1.txt','wb') #str-->bytes
fobj.write('在乌云和大海之间'.encode('utf-8'))
fobj.close()
#用于追加数据
fobj=open('Test.txt','a')
fobj.write('在乌云和大海之间\r\n')
fobj.write('海燕像黑色的闪电\r\n')
fobj.close()
fobj=open('Test.txt','a') #  a  用于追加数据
fobj.write('在苍茫的大海上')
fobj.write('狂风卷积着乌云')
fobj.write('在乌云和大海之间\n')
fobj.write('海燕像黑色的闪电\n')
fobj.write('今天我诗兴大发\n')
fobj.write('发感觉咋样呢\n')
fobj.close()

读

# 读数据操作
f=open('Test.txt','rb')
data=f.read() #读取所有的数据
print(data)
print(data.decode('gbk'))
# print(f.read(12))
# # print(f.read())
# print(f.readline()) #读一行数据
# print(f.readlines(1))
# f.close()  #文件对象关闭掉# with上下文管理对象
# 优点 自动释放打开关联的对象
with open('Test.txt','a') as f:# print(f.read())f.write('我觉得python非常的好学\n')# 小结
# 文件读写的几种操作方式
# read  r r+  rb  rb+
# r r+ 只读  使用普通读取场景
# rb  rb+  适用于 文件 图片 视频 音频 这样文件读取
# write w  w+ wb+  wb a  ab
# w wb+ w+  每次都会去创建文件
# 二进制读写的时候 要注意编码问题  默认情况下 我们写入文件的编码是gbk
# a  ab a+  在原有的文件的基础之后去【文件指针的末尾】去追加，
# 并不会每次的都去创建一个新的文件def ctime(sec):pass

注：模式

6.2备份文件

# import fileOpt# 文件的备份
def copyFile():# 接收用户输入的文件名old_file=input('请输入要备份的文件名:')file_list=old_file.split('.')# 构造新的文件名.加上备份的后缀new_file=file_list[0]+'_备份.'+file_list[1]old_f=open(old_file,'r') #打开需要备份的文件new_f=open(new_file,'w') #以写的模式去打开新文件,不存在则创建content=old_f.read() #将文件内容读取出来new_f.write(content) #将读取的内容写入到备份文件old_f.close()new_f.close()passcopyFile()def copyBigFile():# 接收用户输入的文件名old_file=input('请输入要备份的文件名:')file_list=old_file.split('.')# 构造新的文件名.加上备份的后缀new_file=file_list[0]+'_备份.'+file_list[1]try:#监视啊哟处理的逻辑with open(old_file,'r') as old_f,open(new_file,'w')as new_f:while True:content=old_f.read(1024) #一次读取1024字符new_f.write(content)if len(content)<1024:breakexcept  Exception as msg:print(msg)pass

6.3文件定位（了解）

# tell  返回指针当前所在的位置
# 对于中文讲 每次读取到的一个汉字 实际上占用了 2个字符
with open('Test.txt','r+') as f:print(f.read(3))print(f.tell())print(f.read(2))print(f.tell())passtruncate 可以对源文件进行截取操作
fobjB=open('Test.txt','r')
print(fobjB.read())
fobjB.close()
print('截取之后的数据........')fobjA=open('Test.txt','r+')
fobjA.truncate(15) #保留前15个字符
print(fobjA.read())
fobjA.close()# seek 可以控制光标所在位置
with open('Test_备份.txt','rb') as f:f.seek(4,0) #光标是从0的位置开始 像前【右】移动 4个字符data=f.read(2)print(data.decode('gbk'))f.seek(-2,1) #相当于光标有设置到了0的位置print(f.read(4).decode('gbk'))f.seek(-6,2) #2 表示光标在末尾处  往回移动了6个字符print(f.read(4).decode('gbk'))pass# 对于这种情况 用'r'这种模式打开文件，在文本文件中，没有使用二进制的选项打开文件，
# 只允许从文件的开头计算相对位置，从文件尾部计算或者当前计算的话 就会引发异常

6.4模块导入

1：import 模块
注： import 到首次导入模块的时候会发生如下3步操作：
1 打开模块文件
2 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3 在程序中会有一个模块【可以取别名的】的名称指向模块的名称空间去
```
import time as myTime  #加了一个别名
print(myTime.ctime())
# print(time.ctime()) #调用模块中的函数了
import fileOpt
```
2：路径搜索过程
3：from 模块 import 方法
注：from …import 首次导入发生了3个步骤
1 以模块为准创造一个模块的名称空间
2 执行模块对应的文件了，将执行过程中产生的名字都丢到模块的名称空间
3 在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字,意味着可以不用加任何的前缀而直接使用
```
from time import ctime,time #部分导入
# from time import *
print(ctime())# 优点：不用加前缀 代码更加简洁了
# 缺点: 容易与当前执行文件中名称空间中的名字冲突
```

4.比较

 # 相同点和不同点# 相同# 都会执行模块对应的文件 并且呢 都会产生模块课的名称空间# 两者在调用功能时呢，都需要转到定义时寻找作用域关系# 不同点# import 需要加前缀  from...import 不需要加前缀

7.常见模块

os模块
time、datatime模块

8.模块的制作、发布、安装

8.1模块的制作

模块的制作
一个随便的py文件就是一个模块
有了__name__,这样别的模块调用的时候，不会运行

注：__all__的作用

8.2模块的发布

1.写好包放在一个目录下
2.创建setup.py文件
3.创建模块
4.生成压缩包
5.tree看结构

8.3模块的安装

1.压缩包解压
2.安装
3.模块引入

------------------------------------内存管理---------------------------------

1.引用计数法

注：类似于java，这个系统自动回收垃圾对象，明显有循环引用的弊端。

代码例子

import sys
import psutil
import os
import gcprint(gc.get_threshold())
def showMemSize(tag):pid=os.getpid()p=psutil.Process(pid)info=p.memory_full_info()memory=info.uss/1024/1024print('{} memory used:{} MB'.format(tag,memory))pass# 验证循环引用的情况
def func():showMemSize('初始化')a=[i for i in range(10000000)]b=[i for i in range(10000000)]a.append(b)b.append(a)showMemSize('创建列表对象 a b 之后')# print(sys.getrefcount(a))# print(sys.getrefcount(b))# del a# del bpassfunc()
gc.collect() #手动是释放的
showMemSize('完成时候的')
# sys.getrefcount()
# a=[]
# print(sys.getrefcount(a)) #两次
# b=a
# print(sys.getrefcount(a)) #三次
# c=b
# d=b
# e=c
# f=e
# g=d
# print(sys.getrefcount(a)) #八次

2.标记清除、分代收集算法

标记清楚：先标记对象，然后清除垃圾（java的可达性分析）

3.小整数和大整数对象池（内存优化）

类似于java的字符串常量池
大整数池和小整数池的区别是：
1 从结果来看是一样的
2 大整数池是没有提前的创建好对象，是个空池子，需要我们自己去创建，创建好之后，会把整数对象保存到池子里面，后面都不需要再创建了直接拿来使用；小整数池是提前将【-5,256】的数据都提前创建好；字符串的驻留共享机制intern机制
```
a=140
b=140
print(id(a))
print(id(a))
# del a
# del b
# c=140
# print(id(c))
# biga=100000
# bigb=100000
# print(id(biga))
# print(id(bigb))
# del biga
# del bigb
# bigc=100000
# print(id(bigc))
# sa='ab_c'
# sb='ab_c'
# sc='ab_c'
# sd='ab_c'
```

4.规范

缩进：4个空格的缩进
添加注释
命名规范：类–大驼峰法，方法–小驼峰法

5.命令行参数_sys

sys模块

import sys
import argparse
print('参数个数为:', len(sys.argv), '个参数.')
print('参数列表:', str(sys.argv[1:]))

执行结果
弊端：

6.命令行参数_argparse

argparse为首选

# 创建一个解析器对象
parse=argparse.ArgumentParser(prog='my - 我自己的程序', usage='%(prog)s [options] usage',description = 'my-编写自定义命令行的文件',epilog = 'my - epilog')# 添加位置参数【必选参数】
parse.add_argument('name',type=str, help='你自己的名字')
parse.add_argument('age',type=str,help='你的年龄')# 添加可选参数
# parse.add_argument('-s','--sex', action='append',type=str,help='你的性别')
# 限定一个范围
parse.add_argument('-s','--sex',default='男', choices=['男','femal','女','male'],type=str,help='你的性别')
# print(parse.print_help())result=parse.parse_args() #开始解析参数
print(result.name,result.age,result.sex)

构造对象的参数说明
参数的属性

参考链接：
https://www.bilibili.com/video/BV1vA411b7Rn?p=24

python学习（总）相关推荐

Python学习六大路线，教你快速上手
最近几年随着互联网的发展学习Python人越来越多,Python的初学者总希望能够得到一份Python学习路线图,小编经过多方面汇总,总结出比较全套Python学习路线,快速上手.对于一个零基础的想学 ...
自学必看篇：从零基础到精通的Python学习路线（附加教程）
近几年Python的受欢迎程度可谓是扶摇直上,当然了学习的人也是愈来愈多.一些学习Python的小白在学习初期,总希望能够得到一份Python学习路线图.我经过多方汇总为大家汇总了一份Python学习 ...
python自学路线-零基础Python学习路线，小白的进阶之路！
近几年Python的受欢迎程度可谓是扶摇直上,当然了学习的人也是愈来愈多.一些学习Python的小白在学习初期,总希望能够得到一份Python学习路线图,小编经过多方汇总为大家汇总了一份Python学 ...
python自学网站有哪些-Python学习网站有哪些？Python基础教程网站推荐
Python学习网站有哪些?Python基础教程网站推荐:菜鸟教程.PHP中文网.PHP中文网.W3C.Reddit.博学谷.python中文学习大本营.Python 3 Module of the ...
零基础Python学习路线图，小白的进阶之路！
近几年Python的受欢迎程度可谓是扶摇直上,当然了学习的人也是愈来愈多.一些学习Python的小白在学习初期,总希望能够得到一份Python学习路线图,小编经过多方汇总为大家汇总了一份Python学 ...
Python学习笔记:第三方模块2
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
学霸大佬整理，超全 Python 学习路线图（附工具+视频+书籍+面试）
已经加小詹领取过的朋友,不需要重复领取哦! Python 有多火?据了解,Python 已经入驻小学生教材,未来不学 Python 不仅知识会脱节,可能与小朋友都没有了共同话题-- 不少读者总说想学 ...
Python学习教程：0基础学Python？手把手教你从变量和赋值语句学
这篇Python学习教程将手把手教你入门学Python,从变量和赋值语句学起,前面也有专门给大家出过相关的详细教程,有需要的伙伴,可以找一下前面的教程! 导读:在本文中,你会学到如何处理数字.定义与使 ...
Python学习day16-模块基础
<!doctype html>day16 - 博客 Python学习day16-模块基础模块的四种形式import和from-import循环导入模块的搜索路径Python文件的两种用途 ...
python学习[第十三篇] 条件和循环
python学习[第十三篇] 条件和循环 if语句单一if 语句 if语句有三个部分构成,关键字if本身,判断结果真假的条件表达式,以及表达式为真或非0是执行的代码 if expression: e ...

python学习（总）