python_路径操作及类和对象

一。路径操作

1。调用方式

第一种
import os.path
# 第二种方式
from os import path
# os.path 主要处理系统路径相关的操作。

2.获取文件的绝对路径

理由：因为绝对路径不会变

os.path.abspath(__file__)

例子：

print(os.path.abspath(__file__))

运行结果：

 解析：

# __file__  ：获取文件相对路径
# __name__ ：获取函数名字

例子：

1）在控制台他的父目录下执行py文件显示结果如下__init__.py

2）如果在__init__.py 直接run,会展__init__.py路径，而在控制台执行的py文件不会展示，调用代码都是一样的。

例子：

 3.获取上一级路径

os.path.dirname(file_path)

 运行结果：

4.路径拼接：

　　os.path.join(path,*paths)

路径拼接 文件 / 文件
所有获取到的路径，只是一个路径的表示，并不代表这个文件或者路径真的存在。
说白了：路径得到的是一个字符串。这个字符串是一个路径格式 `\` ，
运行结果：

5.获取当前文件路径

os.getcwd()

运行结果：

6.判断路径是否存在

os.path.exists(path)

运行结果：

7.创建一个新的目录（文件夹）

os.mkdir()

运行前,只有三个文件:

file_name=os.path.abspath(__file__)

dir_name=os.path.dirname(file_name)

dict_2=os.path.join(dir_name,  'dict_2.txt' )

if not os.path.exists(dict_2):
    os.mkdir(dict_2)

运行后，创建了一个文件夹：

如果需要创建文件，需要用到 文件写入功能与路径拼接结合：

dict_3=os.path.join(dir_name,  'dict_3.txt' )
with open(dict_3,'w') as f:
    f.write('')
运行结果：

 8.判断是否是文件或是目录

#判断是否是文件
print(os.path.isfile(dict_2))

#判断是否是路径
print(os.path.isdir(dict_2))

运行结果：

二.类与对象

1.定义

1）类

定义：是一个类别，比如：人类，兽类每个类都有共同点

class 类名：
　　类的组成部分

2）对象：

定义：对象又被称为实例，是一个类中得个体。比如人类中有男人和女人

3）命名方式

类的命名：大驼峰命名： 两个单词的首字母大写。

函数的命名：下划线命名：perfect_man_help

变量命名：下划线命名.

class Zip:
    pass
运行结果：

4）实例化调用，类的对比

#实例化
a=Zip()

#类的对比,两个实例化 不代表同一个类。
a=Zip()
b=Zip()
print(a)
print(b)
运行结果：

2.属性

1）定义：表示的是类/对象的特征。

类属性（类变量）： 这个类的特征，这个群体的特征， 别的类（别的群体）可能不具备
实例属性（实例变量） ： 给个个体的特征，类当中的其他成员可能不具备。

2）类属性的获取：
类名.属性

类属性：可以先天定义也可以 后天学习（手工添加）

3）类属性调用及添加

class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'
#先天类属性调用
print(Photo.format)
print(Photo.look)
#类属性后天学习（添加）
Photo.idea='hello word'
print(Photo.idea)
运行结果：

4）实例属性的调用与添加：

#实力属性的后天获取与学习（添加）
luck=Photo()
print(luck.look)

#实例后天学习（修改）
luck.look='beautiful'
print(luck.look)

#实例后天添加
luck.idea='hello world !'
print(luck.idea)

运行结果：

5）类属性与实例属性的区别

 区别一：

类属性：所有的成员都是一样的。
实例属性：不是每个成员都一样

 区别二：

类属性，可以被实例、对象访问
实例属性， 不可以被类获取

#类属性与实例属性区别
class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'
#区别一：所有的成员都是一样的，类属性，可以被实例、对象访问
a=Photo()
b=Photo()
print(a.look)
print(b.look)
运行结果：

#区别二：不是每个成员都一样，实例属性， 不可以被类获取或者其他实例化类调用
a.idea='hello world !'
print(Photo.idea)
运行结果：

print(b.idea)
运行结果：

 3.类方法

 定义：

方法：表示类 、 对象的行为。
方法本质上是函数。

1）方法与函数的区别：

1.类方法需要加self,函数方法不用；

2.类方法是放在类里面的，需要加缩进，函数方法是顶格写的；

3.调用过程不一样，类方法调用过程是：类.类方法，函数要么不加前缀，要么加模块名；

2）对象.方法、实例.方法

class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'
    #类方法
    def wall_painting(self):
        pass
#对象.方法
Photo().wall_painting()
#实例.方法
a=Photo()
a.wall_painting()

3）.类方法：

# 类方法：@classmethod

代表类本身

使用方法：
1. 在方法的上面添加 @classmethod;
2. 把实例方法当中的 self 改成 cls.

class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'
    #类方法
    @classmethod
    def wall_painting(cls):
        print("墙画是{}".format(cls.look))

#类方法@classmethod调用
Photo().wall_painting()
a=Photo()
a.wall_painting()
Photo.wall_painting()
运行结果：

静态方法：@staticmethod

静态方法表示： 方法的上面加上一个 @staticmethod
不需要用 self， cls 作为固定参数

用途：方便管理。

与类方法@classmethod对比：

1.是刚刚好放在一个类当中的普通函数而已，除了放在类当中，和普通函数没什么区别；

2.没有实际作用，和类或者对象没有关系（联系）；
3.不需要用 self， cls 作为固定参数。

self与cls区别：

self: 在 **类里面** ，表示一个 **对象** 他自己。自我， this
cls, ： 在 **类里面** ，表示一个 **类** 他自己。自我， this

调用静态方法与函数的区别：

静态方法，（普通函数） 只需要在调用静态方法，前面加上类名或者对象名

类外面的普通函数：普通函数不需要加类，模块

class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'

　　@staticmethod
　　def bedside_painting():
    　　print("床头画是{}".format("非常好看的"))

#静态方法调用
Photo.bedside_painting()
Photo().bedside_painting()
a=Photo()
a.bedside_painting()
运行结果：

 普通方法调用：

#普通方法调用
Photo().putong_photo()
a=Photo()
a.putong_photo()
运行结果：

#错误调用
# Photo.putong_photo()

Photo() :是类初始化的过程，类初始化会调用一边类的所有方法

运行结果：

4.初始化

定义：要通过定义的类得到一个具体的对象。

表现：
__init__ ，可以自己定义初始化参数

特征：

__init__ 定义的形式参数 和 对象的实例化 的实际参数，是一一对应的。
1. 必须 return None（初始化__init__返回的结果是None）；
2. 传入的参数必须要设置成实例属性，才能被被对象访问到。

1）调用有初始化的类

class Photo:
    # 定义类属性
    format = 'peng'
    size = "12M"
    look = 'very beautiful'
    #初始化
    def __init__(self,what,who):
        self.what=what
        self.who=who
    #类方法
    @classmethod
    def wall_painting(cls):
        print("墙画是{}".format(cls.look))
    @staticmethod
    def bedside_painting():
        print("床头画是{}".format("非常好看的"))
    def putong_photo(self,grade):
        self.wall_painting()
        #定义grade值
        print("普通画是{}".format(grade))
        #定义实例属性
        self.dingyide=False

#调用有初始化的类，实际参数需要和__init__中的形式参数一一对应
a = Photo('淘宝','Me')

print(a.what)

print(a.who)

运行结果：

#方法内部可以相互调用
a.putong_photo()

#方法内部是可以定义参数的。
a.putong_photo('超级好看')
运行结果：

#初始化后，后台定义dingyide属性
a.dingyide=True
print(a.dingyide)
运行结果：

#初始化后，修改__init__属性
a.what="京东"
print(a.what)

运行结果：

 5.存续，理解还不是很透彻。

1）类可以调用类属性，不可以调用实例属性__ini__属于实例属性；

　　实例属性可以调用类属性；

2）实例方法可以调用类方法；

　　类不可以调用实例方法，cls 代表类本身，是不支持再调用类中的其他的实例方法