demoのpython学习笔记【2】——文件操作、面向对象的函数、HTML基础

学习任务

TSK.1 利用python进行文件操作

TSK.2 面向对象的函数

TSK.3 进阶函数知识

---

目录

前言

一、利用python进行文件操作

1.打开&关闭

2.读取&写入

2.1文件读取 

2.2文件写入

2.3 文件的其他操作

二、面向对象的函数

1.编程方式介绍

2.对象&类

2.1概述

2.2对象

2.3类（class）

2.4相关方法

2.5多态

三、高阶函数

总结

---

前言

python是个神奇的工具，可以帮助我们进行数据分析，科学计算等等功能，这里是我根据川川大佬所供资料的学习笔记，萌新一枚，还望大家多多指点QAQ

---

一、利用python进行文件操作

什么时文件呢？来看下百度百科的定义：所谓“文件”，就是在我们的计算机中，以实现某种功能、或某个软件的部分功能为目的而定义的一个单位。像我们平时常见的txt文本，doc、docx文档，html网页、zip压缩包等等都属于文件。总而言之，文件的作用就是将数据以不同的方式储存起来。下面来学习一下利用python进行文件的相关操作：

1.打开&关闭

f = open("文件名","访问模式")                #打开文件

f = close()                                               #关闭文件

访问模式	说明
w	打开一个文件只用于写入，如果该文件已经存在则将其覆盖，如果不存在，创建新文件。
r	以只读的方式打开一个文件，文件的指针将会在文件的开头位置，默认模式，如果文件不存在会报错。
a	打开一个文件用于追加，如果该文件已经存在，文件的指针会放在文件的结尾，即新的内容将会写入已有内容之后，如果文件不存在，如果文件不存在，创建一个新文件进行写入。
r+	打开一个文件用于读写，文件的指针放在文件的开头位置。
w+	打开一个文件用于读写,如果该文件已经存在将其覆盖，如果文件不存在，创建一个新文件。
a+	打开一个文件用于读写，文件的指针放在文件的末尾位置，即新的内容将会写入已有内容之后，如果文件不存在，如果文件不存在，创建以一个新文件写入。
rb	以二进制的方式打开一个文件用于只读，文件的指针将会在文件的开头位置，默认模式，如果文件不存在会报错。
wb	以二进制的格式打开一个文件只用于写入，如果该文件已经存在则将其覆盖，如果不存在，创建新文件。
ab	以二进制方式打开一个文件用于追加，如果该文件已经存在，文件的指针会放在文件的结尾，即新的内容将会写入已有内容之后，如果文件不存在，如果文件不存在，创建以一个新文件进行写入。
rb+	以二进制的方式打开一个文件用于读写，文件的指针放在文件的开头位置。
wb+	以二进制的方式打开一个文件用于读写,如果该文件已经存在将其覆盖，如果文件不存在，创建一个新文件。
ab+	以二进制的方式打开一个文件用于读写，文件的指针放在文件的末尾位置，，即新的内容将会写入已有内容之后，如果文件不存在，如果文件不存在，创建以一个新文件进行写入。

2.读取&写入

2.1文件读取 

数据读取方法

方法	说明	案例
read(num)	参数num表示读取数据的长度 不传递的话默认读取全部数据	f = open('text.txt','r') res = f.read(2)
readline(num)	每次读取一行，反馈字符串型变量 参数代表这行数据里被读取的长度	content = f.readline()
readlines	每次读一行，每行内容作为元素，返回列表	content = f.readlines()

'''csv、pdf、img等文件的读取方法'''
import csv                        #根据读取类型选库
def readCsv(path):
    #定义列表接受读取到的数据
    readList = []
    with open(path,'r') as re:
        read = csv.reader(re)
        for r in read:
            readList.append(r)
    return readList
print(readCsv(r'C:\Users\1\Desktop\csv\000002.csv'))

2.2文件写入

常规文件写入

step1. 打开文件        f = open('text.txt','a')

step2. 写入数据        f.write('111\n333\n222')

step3. 关闭文件        f.close()

csv文件写入

'''csv文件写入'''
import csv
def writeCsv(path,data):            '''path:代写入文件路径data:代写入文件的数据'''
    with open(path,'w') as w:
        write = csv.writer(w)
        for writeRow in data:
            write.writerow(writeRow)
path = 'D:\yaoming.csv'
writeCsv(path,[['1','2','3'],['4','5','6'],['7','8','9']])

文件的定位读写

定位：tell()告知当前光标所指位置

f = open('text.txt','rb')
str = f.read(3)
position = f.tell()
print('读取的位置是:',position)

定位到指定位置：seek(offset,from)       

                             '''offset:偏移量 from:开始位置(有三种模式:0:文件开头1:当前位置2:文件末尾)'''

f.seek(1,1)
str2 = f.read(5)
print('第三次读取的数据是:',str2)
position2 = f.tell()
print('第三次读取的位置是:',position2)

2.3 文件的其他操作

备份：为备用而准备的另外一份一模一样的文件，通常情况下，我们是直接打开文件的根目录，然后复制一份，进行手动备份，这里介绍一下利用python进行操作：

操作思路：

1.利用os库的splitext函数，读取并复制原文件名

2.创建新txt文件，并将原文件名复制过去

3.利用readlines函数移植内容

'''代码实现'''
import os.path
def copy(path): #path需要备份文件路径
    #打开需要备份的文件
    oldFileName = input('请输入你要备份文件的名称:')
    #打开文件
    fileName = open(oldFileName,'r')
    #判断文件是否打开
    if fileName:
        #获取备份的文件名
        copyFile = oldFileName.rfind('.')
        name = oldFileName[0:copyFile]
        #splitText获取文件名和扩展名
        fileFlag = os.path.splitext(path)[1]

        #定义新文件备份规则
        newFileName = name+'-副本'+fileFlag
        #打开新文件
        newFile = open(newFileName,'w')

        #读取旧文件数据,一行行往新文件里面写入
        for line in fileName.readlines():
            newFile.write(line)
        #关闭文件
        fileName.close()
        newFile.close()
    else:
        print('没有文件打开')
#调用函数
copy('text.txt')  

重命名：就是重新命名，python操作也挺简单的，利用os库的rename函数就能直接操作。

import os
os.rename("test.txt","毕业论文.txt")

删除：常用的办法是在目录下手动删除文件，python操作也挺简单的，os库的remove函数就行。

import os
os.remove("毕业论文.txt")

文件夹的建立、删除及目录下文件的获取：都是通过os模块下的函数实现的，不多做解释了。

import os
#文件夹的创建
os.mkdir("张三")
#当前目录下文件的获取
print(os.listdir("./"))
#删除文件夹
os.rmdir("张三")

二、面向对象的函数

1.编程方式介绍

编程方式大致可以分为三种：函数式编程、面向过程和面向对象

1.1函数式：把显示世界的事务和事物之间的联系抽象到程序世界（对运算过程进行抽象）

1.2面向过程：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现

1.3面向对象：把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为                         了描述某个事物在整个解决问题的步骤中的行为

     三大特征：封装、继承、多态         

                       封装：又称为信息的隐藏,类的实现和使用时分开的,类提供了外部访问的方法,调用                                      者不需要关注类里面的具体实现,会调用即可

                       继承：一个类继承另外一个类,被继承的类称为父类或者基类,继承的类称为子类或                                      者派生类,子类可以共享父类里面受保护,公有属性和方法,子类不能共享父类                                      私有属性和方法

                       多态:同一种事物有多种形态

2.对象&类

2.1概述

        类就是具有相似的内部状态和运动规律的实体的集合；对象某一个具体事物的存在，在现实世界中可以看得见摸得着。这是标准的定义，下面说下我自己的一些想法，我觉得类就是定义出来的一的容器，我们往这个容器里塞了很多的函数（也就是属性和方法），这个容器可以帮助我们实现很多的功能，当我们想要使用这些功能时，会创建一个对象，"对象名.类名"的方式告诉系统我这个对象是从哪个类来的，理所当然的，他具有这个类拥有的所有属性和方法，从而实现特殊功能的调用。调用对象之后功能必须我们单独调用才能发挥功效，有时候为了操作简便或者一些其他原因，会使用特定的方法去实现自动调用、属性删除等等等等。

2.2对象

创建：可根据定义完成的类创建对象        格式：对象名 = 类名（）

删除：del 对象名

#创建一个汽车类
class Car(object):
    #属性:颜色,四个轮子
    #方法:跑  鸣笛
    #定义一个普通(实例)方法
    def move(self):
        print('车子正在移动...')

    #定义一个普通(实例)方法
    def whistle(self):
        print('车子正在鸣笛')

#创建一个Car的实例对象c  赋给一个变量
c = Car()
#调用对象指向的方法
#调用格式:对象名.方法
c.move()
c.whistle()

实例对象：个人理解，比如说有个类叫Carone，这是官方名称，然后我可以随便给他取名，比如                      Cartwo，这就是实例变量，调用格式为Cartwo=Carone()

添加属性：格式：对象名.属性名 = 新的值

获取属性：利用print函数实现

调用：格式：对象名.方法名

#通过Person创建一个实例对象p
p = Person()
#添加属性
#语法格式:对象名.属性名 = 新的值
p.name = '张三'
p.age = 20
#获取属性
print(p.name)
print(p.age)

#对象调用方法
p.eat()
p.sleep()

#通过Person创建一个对象p2
p2 = Person()
#添加属性
p2.name = '李四'
p2.age = 30
p2.sex = '男'
#获取属性
print(p2.name,p2.age,p2.sex)

2.3类（class）

构成：名称、属性、方法（允许对其进行的操作）

定义方法：

class 类名:

    属性列表

    方法列表

 有两种定义方法：经典类：class+名称；新式类：class+名称（object）在继承和搜索上略有不同

#定义一个猫类
class Cat:
    #属性:品种,毛色,腿的数量
    #方法:吃老鼠 叫 抓人
    def eat(self):
        print('猫吃老鼠')

    def drink(self):
        print('猫喝芬达...')

#定义一个车类
class Car(object):
    #属性:颜色,四个轮子
    #行为:跑,鸣笛 
    def move(self):
        print('车子在移动')
        
    def whistle(self):
        print('车子在鸣笛')

继承：和现实生活有点像，但类继承的不是财富，而是属性与方法， 我们可以通过新式类定义方               法，定义父类（括号左边的）和子类（括号里的）子类中有方法被调用时先从子类里查找               ，找不到的话就在父类里寻找并调用。

#声明一个父类A
class A(object):
    #声明一个普通方法
    def sayHello(self):
        print('我是A')

#声明一个子类B
class B(A): #B类后面圆括号里面继承的父类名字
    #声明一个普通方法
    # def sayHello(self):
    #     print('我是B')
    pass

#实例化A类创建对象a
a = A()
a.sayHello()

#实例化B类创建对象b
b = B()
b.sayHello()

类属性：在类中定义的属性，有公有和私有之分，共有属性的定义如上所示，私有属性的定义则                  是在属性前加一个_，私有属性的访问较为复杂，需要使用"对象名.类名_属性名"的方式                  进行访问。

#定义一个人类，设置姓名和年龄属性

class Person(object):
    name = 'xiaoming'  #公有类属性
    __age = 12          #私有类属性

#创建Person类的对象p
p = Person()
print(p.name)  #实例对象访问类的公有属性
print(Person.name)  #类对象访问类的公有属性

print(p.__age)   #实例对象访问类的私有属性   not ok
print(Person.__age) ##类对象访问类的私有属性 not ok 

print(p._Person__age)   #实例对象访问类的私有属性   ok
print(Person._Person.__age) ##类对象访问类的私有属性 ok 

2.4相关方法

魔方方法：含下划线的方法的总称

_init_()：定义初始化方法（字面意思，一个对象啥都没有时也会自动调用的方法）

               实现属性、方法的自动调用

#定义一个汽车类
class Car(object):
    #定义初始化方法,当创建对象时候自动调用
    def __init__(self,color,wheelNum):
        self.color = color
        self.wheelNum = wheelNum

    #定义一个普通方法
    def move(self):
        print('车子在移动')
'''会发现color、wheelNum属性自动调用了，move方法没动'''

_del_()：又叫析构方法，和delete指定有关系，表述对象在删除时执行的函数（方法）

#定义一个动物类

import time

#定义一个动物类
class Animal(object):
    #定义初始化方法  创建对象时候自动调用
    def __init__(self,name):
        # print('__init__方法被调用')
        self.name = name

    #定义普通方法
    def walk(self):
        print('动物会跑')

    #定义一个析构方法  删除对象的时候自动调用
    def __del__(self):
        # print('__del__方法被调用')
        print('%s对象被干掉'%(self.name))

#创建一个dog对象
dog = Animal('哈皮狗')
# dog.walk()
# del dog
# print(dog.walk())

#创建一个cat对象
cat = Animal('波斯猫')
cat2 = cat
cat3 = cat

print('删除对象1')
del cat
print('删除对象2')
del cat2
print('删除对象3')
del cat3

time.sleep(2)
print('cat对象被删除')

_str_()：用于将数值转化为人阅读的形式,在调用print打印对象的时候自动调用

_repr_()：转化为python解释器读取的形式,给机器用的，供python的解释器读取

#定义一个人类
class People(object):
    #定义初始化方法
    def __init__(self,name,age,sex,height):
        self.name = name
        self.age = age
        self.sex = sex
        self.height = height

    定义魔方方法
    def __str__(self):
        msg = '%s-%d-%d-%d'%(self.name,self.age,self.sex,self.height)
        return msg

    #定义魔方方法
    def __repr__(self):
        msg = '%s-%d-%d-%d'%(self.name,self.age,self.sex,self.height)
        return msg

方法的重写：和前面提到的继承关系密切，简单来说就是通过在子类里定义同名方法把父类的方                          法给顶掉。

self方法（能称之为方法么）：简单来说就是代表对象本身

#定义一个动物类
class Animal(object):
    #定义一个初始化方法
    def __init__(self,name):
        self.name = name

    #定义一个普通方法
    def printName(self):
        print('动物的名字是:%s'%self.name)  #self=dog

#声明一个函数
def myPrint(animal):
    animal.printName()  #dog.printName

#实例化创建一个对象dog
dog = Animal('二哈')

#调用函数
myPrint(dog)  #把dog对象当做myPrint函数的参数 dog.name

cat = Animal('加菲猫')
myPrint(cat)

静态方法：用@staticmethod修饰的函数

class Person(object):
    country = 'china'  #类属性

    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls,country):
        cls.country = country
#创建Person对象
p = Person()
print(p.getCountry())  #通过实例对象访问类方法
print(Person.getCountry())  #通过类对象访问类方法

p.setCountry('chinese')
print(p.getCountry())
print(Person.getCountry())

类方法：用@classmethod修饰的方法，对于类方法，第一个参数必须是类对象，一般以cls表                      示作为第一个参数（当然可以用其他的名字，但是不建议修改）

class Person(object):
    country = 'china' #类属性

    @staticmethod
    def getCountry():
        return Person.country

#创建Person类的对象
p = Person()
print(p.getCountry())  #通过实例对象访问静态方法

_slots_方法：限制当前类的添加属性

class Student(object):
    __slots__ = ('name','sex')  #限制当前类添加的属性

#通过Student类创建对象stu
stu = Student()
#往对象里面添加属性
stu.name = '张三'
stu.sex = '男'
print(stu.name)
print(stu.sex)
#增加一个新的属性
# stu.weight = '80kg'  #报错,类中限制添加属性没有weight
# print(stu.weight)
Student.weight = '50kg'
print(stu.weight)

@property方法将方法转变为只读，重新实现一个属性的设置和读取

class Money(object):
    #定义初始化方法
    def __init__(self):
        self.__money = 0

    @property
    def money(self):  #相当于获取元素值方法
        return self.__money

    @money.setter   #money是上面取值的方法名  赋值的方法
    def money(self,value):
        if isinstance(value,int) or isinstance(value,float):
            self.__money = value
        else:
            print('Error:不是整形也不是浮点型')

#通过Money创建对象m
m = Money()
print(m.money)
m.money = 16888
print(m.money)

2.5多态

定义前面讲过了，就是一类事物有多种形态，多态性则是指单一调用方式得出不同结果这一性质。个人理解多态只得就是父类下不同的子类，多态性则是因为函数参数不同造成的结果不同。

三、高阶函数

1.递归函数：调用自己的函数

#1.使用循环求n的阶乘
def calNum(num):
    i = 1
    result = 1
    while i <= num:
        result *= i #=>result = result*i
        i += 1
    for i in range(1,num+1):
        result *= i
    return result
print(calNum(5))

#2.使用递归实现
def calNum(num):
    if num > 1:
        result = num * calNum(num-1)
    else:
        result = 1
    return result
print(calNum(5))

import os
def getAllFileDir(path,sp=''): #path文件路径
    #获取当前目录下所有的文件
    filelist = os.listdir(path)
    #处理每个文件,在文件之间加分隔符
    sp += '-'
    #遍历获取所有的文件,如果是目录使用递归继续遍历,如果是文本文件直接打印
    for fileName in filelist:
        #判断是否是路径(用绝对路径)
        fileAbsPath = os.path.join(path,fileName)
        #判断是否是目录
        if os.path.isdir(fileAbsPath):
            print(sp+'目录:',fileName)
            #使用递归函数
            getAllFileDir(fileAbsPath)
        else:
            print(sp+'文本文件:',fileName)

#调用函数
getAllFileDir('C:\python课程大纲\python课程大纲\Day05')

2.map：根据提供的函数对指定的序列做映射

格式：

map(function,iterable)

function---》函数，两个参数---》返回值是一个新的列表

iterable---》一个或者多个序列

#案例：将单个字符转换为对应的字面量整数
li2 = ['1','2','3','4']
#定义一个函数
def chrToInt(str):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5}[str]
res2 = map(chrToInt,li2)
# print(list(res2))

3.reduce：像是按照自定义的运算规则把全部参数走一遍

格式：

   reduce(function,iterable,[initializer])

   function:函数，有两个参数

   iterable：可迭代的对象

   initializer：可选，初始化参数

from functools import reduce
#案例:两个数的求和
def add(a,b):
    return a + b

res = reduce(add,range(1,5))
print(res)
res = reduce(add,[1,2,3,4])
print(res)
res = reduce(add,(1,2,3,4))
print(res)

 4.filter：按照一定规则过滤出符合条件的元素

格式：

   filter(function,iterable)

   function:函数   判断函数

   iterable：序列，序列的每一个元素作为参数传递到函数进行判断，返回True,False,最后将返回True的元素存放到一个新的列表中

#案例:筛选指定的元素
list01 = [1,2,3,4,5,6,7,8,9,10]
#案例1:将偶数筛选出来,奇数删除
#定义一个函数
def even(num):
    if num % 2 == 0:
        return True
    return False
res = filter(even,list01)
# print(list(res))

 5.sorted：对所有的可迭代对象进行排序

格式：

sorted(iterable[, cmp[, key[, reverse]]])

iterable:可迭代的对象

cmp ---》比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

key ---》主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse ---》 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

lst = [2,0,99,20,100,111]
lst.sort()
print(lst)
res = sorted(lst)
print(res)

6.选择排序：通过每次确定最值逐一确定位置

list = [1,90,10,0,100,8]
#每次确定最大值 直到结束
for i in range(len(list)-1,0,-1):
    maxone = 0 #假设它是最大值
    #用假设最大值跟其他元素逐个比较,如果不是最大值,获取真正的最大值
    for j in range(1,i+1):
        if list[j] > list[maxone]:
            maxone = j  #获取真正的最大值
        temp = list[i] #大的值赋给临时变量
        list[i] = list[maxone] #小的值赋给大的
        list[maxone] = temp
        """
        a = 10 b = 1
        temp = a 
        a = b 
        b = temp 
print(list)

7.冒泡排序：通过两两比较不断改进位置

list = [1,90,10,0,100,8]
#外层循环控制循环的次数
for i in range(len(list)):
    #相邻元素进行比较,交换位置
    for j in range(len(list)-1-i):
        if list[j] > list[j+1]: #如果前面元素大于后面
            temp = list[j]
            list[j] = list[j+1]
            list[j+1] = temp
print(list)

---

总结

python基础部分基本结束了，后面将进行pandas数据处理方面的学习