学习任务
TSK.1 利用python进行文件操作
TSK.2 面向对象的函数
TSK.3 进阶函数知识
目录
前言
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数据处理方面的学习