- os模块
- 递归
- 递归遍历目录
- 深度遍历
- 广度遍历
- python类
- 类的实例化对象
- 访问对象属性和方法
- 对象的初始状态（构造函数）
- 析构函数
- 重写__repr__与 __str__
- 限制访问变量
- 对象属性和类属性
- 对象与类，属性
- 动态给实例添加属性和方法
- 运算符重载
os模块
os:包含了普遍 *** 作系统的功能：
import os
#获取 *** 作系统类型 nt--windows posix--Linux,Unix或Mac OS X
print(os.name)
#windows不支持打印 *** 作系统详细信息
# print(os.uname())
#获取 *** 作系统中的环境变量
print(os.environ)
#获取指定环境变量路径
print(os.environ.get('APPDATA'))
#获取当前目录 ./a/
print(os.curdir)
#获取当前工作目录，
print(os.getcwd())
#以列表形式返回指定目录下的所有文件
print(os.listdir(r'C:\Users\xiaofeng\PycharmProjects\爬虫'))
# aaa=os.listdir(r'C:\Users\xiaofeng\PycharmProjects\爬虫')
# for x in aaa:
# print(x)
#在当前目录创建新目录 也可以指定目录
# os.mkdir('luce')
#删除目录
# os.rmdir('luce')
#获取文件属性
print(os.stat('./os模块.py'))
#重命名目录或文件
# os.rename('luce','xiao')
#删除普通文件
# os.remove('./11.txt')
#运行shell命令
# os.system('notepad') #打开记事本
# os.system('taskkill /f /im notepad.exe') #关闭模块
# os.system('write')#写字板
# os.system('mspaint')
# os.system('msconfig')
# os.system('shutdown -s -t 1000')#关机
# os.system('shundown -a') #取消关机
有些方法存在存在os模块，还有些存在os.path
#查看绝对路径
print(os.path.abspath('os模块.py'))
print('******************')
#拼接路径
p1=r'C:\Users\xiaofeng\PycharmProjects\爬虫\os模块'
p2=r'5.os模块.py'
# 参数2(p2)里开头不能有斜杠
print(os.path.join(p1,p2))
# 拆分路径
path1=r'C:\Users\xiaofeng\PycharmProjects\爬虫\os模块'
print(os.path.split(path1)) #拆分最后一个目录或文件，返回元组
#获取扩展名
print(os.path.splitext(path1))
判断是否是目录
print(os.path.isdir(path1))
判断文件是否存在
path2=r'C:\Users\xiaofeng\PycharmProjects\爬虫\os模块.txt'
print(os.path.isfile(path2))
判断目录是否存在
path3=path1=r'C:\Users\xiaofeng\PycharmProjects\爬虫'
print(os.path.exists(path3))
获取文件大小 （字节大小）
print(os.path.getsize(path2))
递归调用：一个函数，调用了自身，称为递归调用
递归函数：一个会调用自身的函数称为递归函数
循环能做的事情，递归都可以做
1,写出临界条件
2，找这一次和上一次的关系
3，假设当前函数已经能用，调用自身计算上一次的结果，
在求出本次结果
def sum2(n):
if n == 4:
return 1
else:
return n +sum2(n-1)
print(sum2(5))
#递归遍历目录
import os
def getAlldir(path,sp=''):
#获取目录下的文件
filelist=os.listdir(path)
#处理每一个文件
sp+=' '
for filiname in filelist:
#判断是否是路径(用绝对路径）
fileabspath = os.path.join(path, filiname)
if os.path.isdir(fileabspath):
print(sp+'目录',filiname)
# 递归调用
getAlldir(fileabspath,sp)#调用自身处理是否是目录
else:
print(sp+'普通文件',filiname)
getAlldir(r'C:\Users\xiaofeng\PycharmProjects\爬虫')
def getAlldir(path):
stack=[]
stack.append(path)
#处理栈，当栈为空的时候停止循环
while len(stack) !=0:
#从栈里取出数据
dirpath=stack.pop()#默认删除最后一个
# print(dirpath)
#目录下所有文件
filelist=os.listdir(dirpath)
# print(filelist)
#处理每一个文件，如果是普通文件就打印出来，
# 如果是目录则将该目录的地址压栈
for filname in filelist:
fileabspath=os.path.join(dirpath,filname)
if os.path.isdir(fileabspath):
#是目录就压栈
print('目录',filname)
stack.append(fileabspath)
else:
#打印普通文件
print('普通',filname)
getAlldir(r'C:\Users\xiaofeng\PycharmProjects\爬虫')
import collections
print("***********************************************************************")
def getadir(path):
queue=collections.deque()
#进队
queue.append(path)
while len(queue)!=0:
#出队数据
drpath=queue.popleft()
#找出所有文件
fillist=os.listdir(drpath)
for flname in fillist:
#绝对路径
fiabspath=os.path.join(drpath,flname)
#判断是否是目录，是就进队，，不是就打印
if os.path.isdir(fiabspath):
print('目录',flname)
queue.append(fiabspath)
else:
print('普通', flname)
getadir(r'C:\Users\xiaofeng\PycharmProjects\爬虫')
类名：首字母大小，其他遵循驼峰原则
属性：其他遵循驼峰原则
行为（方法/功能）：其他遵循驼峰原则
'''
创建类
类：一种数据类型，本身并不占内存空间，与number，string，等类似
用类创建实例化对象（变量），对象占用空间
格式：
class 类名（父类表）：
属性
行为
'''
创建类
#opject 基类，超类，，一般叫所有类的父类
#一般没有合适的父类就写object
class Person(object):
#定义属性(定义变量)
name='python'
age=0
height=0
#定义方法
#注意：方法的参数必须以self当第一个参数
#self代表类的实力（某个对象）
def run(self):
print('run')
def eat(self,food):
print('eat',food)
class Person(object):
#定义属性(定义变量)
name='python'
age=0
height=0
#定义方法
def run(self):
print('run')
def eat(self,food):
print('eat',food)
'''
是实例化对象
格式：对象名=类名（参数列表）
注意：没有参数，小括号也不能省略
'''
# 实例化一个对象
p=Person()
print(p)
p1=Person()
class Person(object):
#定义属性(定义变量)
name='python'
age=0
height=0
#定义方法
def run(self):
print('run')
def eat(self,food):
print('eat '+food)
def aaa(self):
print('python')
def bbb(self):
print('good')
per=Person()
访问属性
格式：对象名，属性名
赋值：对象名.属性名=新值
per.name='toy'
per.age=18
per.height=170
print(per.name,per.age,per.height)
访问方法
格式：对象名.方法名(参数)
per.bbb()
per.aaa()
per.run()
per.eat('apple')
构造函数：init() 在使用类创建对象的时候自动调用
注意：如果不显示的写出构造函数，默认会自动添加一个空的构造函数
#构造函数中的self
self代表类的实例，而非类
哪个对象调用方法，那么该方法中的self就代表那个对象
self._class_代表类名
class Person(object):
#定义属性(定义变量)
'''构造后该赋值么有意义了
name='python'
age=0
height=0'''
#定义方法
def run(self):
print(self.__class__)
ppp=self.__class__('tt',1,2)
print(ppp)
def aaa(self):
print('python')
def bbb(self):
print('good')
def say(self):
print('hello my is %s, I am old %d'
%(self.name,self.age))
#self不是关键字，换成其他标识符也是可以的，一般用self
#创建对象自动调用改方法
def __init__(self,name,age,height):
# print(name,age,height)
#当前对象的值赋值成传进来的值
self.name=name
self.age=age
self.height=height
# print("**********")
pass
pr=Person('aaaa',11,200)
pr.say()
析构函数： del() 释放对象时自动调用的
class Person(object):
#定义方法
def run(self):
print(self.__class__)
ppp=self.__class__('tt',1,2)
print(ppp)
#self不是关键字，换成其他标识符也是可以的，一般用self
#创建对象自动调用改方法
def __init__(self,name,age,height):
# print(name,age,height)
#当前对象的值赋值成传进来的值
self.name=name
self.age=age
self.height=height
def __del__(self):
print("这里时析构函数")
per=Person('python',12,88)
#释放对象
# del per
#释放后就不能在访问了
在函数里定义的对象，会在函数结束时自动结束对象
减少内存空间的浪费
def func():
per2=Person('tttt',2,2)
func()
class Person(object):
def __init__(self,name,age,height):
self.name=name
self.age=age
self.height=height
def __str__(self):
# print('这里是str') #会报错没有返回值
# return '这里是str'
return '%s-%d-%d'%(self.name,self.age,self.height)
per=Person('python',12,88)
print(per.name,per.age,per.height)
print(per)
print(per.__str__())
class Person(object):
#定义方法
def run(self):
# print("99")
print(self.__height)
#self不是关键字，换成其他标识符也是可以的，一般用self
#创建对象自动调用改方法
def __init__(self,name,age,height,aaa):
# print(name,age,height)
#当前对象的值赋值成传进来的值
self.name=name
self.__aaa__=aaa
self.age=age
self.__height=height
#通过内部的方法，修改私有属性
#通过自定义的方法实现对私有属性的赋值与取值
def setone(self,height):
#数据过滤
if height<0:
height=0
self.__height=height
def getone(self):
return self.__height
per=Person('python',12,88,66)
# per.age=2
# print(per.age)
#如果要让内部的属性不被外部直接访问
#在属性前家连个下划线__
#在python中，如果在属性前加两个下划线，
#那么这个属性就变成了私有属性
per.__height=0
print(per.__height) #不能直接访问
per.run()#内部可以使用
在python中 __XXX__ 属于特殊变量，可以直接访问
print(per.__aaa__)
在python中 __XXX__ 变量，这样的实列变量时可以访问的
#但是，按照约定的规则，当我们看到这样的变量时，
#意思是 虽然我可以被访问，但是请把我视为私有变量，不要直接访问我
print(per.__aaa__)
class Person(object):
#这里的属性实际上属于类属性（用类名来调用）
name='python'
def __init__(self,name):
#对象属性
self.name=name
per=Person('tom')
per.name='aaa'
#对象属性的优先级高于类属性
print(per.name)
#动态的给对象添加对象属性
per.age=11 #只针对于当前对象生效，
# 对于类创建的其他对象美哟作用
print(Person.name)
per2=Person('李磊')
# print(per2.age) #没有age属性
#删除对象中的某个属性 ,在调用会使用到同名的类属性
del per.name
print(per.name)
注意：以后千万不要讲对象属性与类属性重名，
因为对象属性会屏蔽掉类属性，但是删除对象属性后，
在使用又能使用类属性了
#创建一个空类
class Person(object):
pass
per=Person()
#动态添加属性，这体现了动态语言的特点（灵活）
per.name='tom'
print(per.name)
#动态添加方法
#引入MethodType
from types import MethodType
def say(self):
print('aaaaa '+self.name)
per.speak=MethodType(say,per)
per.speak()
class Person(object):
def __init__(self,num):
self.num=num
#运算符重载
def __add__(self, other):
return Person(self.num+other.num)
def __str__(self):
return 'num='+str(self.num)
per1=Person(1)
per2=Person(2)
print(per1+per2)#等于 print(per1.__add__(per2))
#运算符重载
# print(per1.__add__(per2))
print(per1)
print(per2)
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）