python文件读写、字典、习题、模块包库、pycharm、面向对象

文件的读写

#
#使用open()函数读取文件中的内容
 filepath='d:/note1.txt'
 file1=open(filepath)  #打开d:/note1.txt  open(文件路径,读写模式)
# 读写模式默认是r(读取),也可以用w(写入),a(追加写入)
 print(file1.read())  #读取文件中的内容,返回值是字符串
 for i in range(2):
     print(file1.readline())  #读取一行的内容
 print(file1.readlines())  #读取文件中的全部内容,返回值是列表,每一行作为列表中的一个元素
 file1.close()  #关闭文件

#如果遇到文件有乱码的情况,下检查文件的编码,改为正确的
#如果文件是正确的编码,但是仍然有乱码,那么检查pycharm的编码格式
#settings→editor→file encondings,调整文字的格式

#文件允许同时进行读取与写入,有r+,w+,a+
 filepath='d:/note210307_1.txt'
 file1=open(filepath,'w+')
 file1.write('好雨知时节,当春乃发生.随风潜入夜,润物细无声.野径云俱黑,江船火独明.晓看红湿处,花重锦官城')
 file1.seek(0)  #让光标回到文件开头,在文件同时进行读写时,通过使用seek()达到同时读写的目的
 print(file1.read())
 file1.close()

#r+ 如果文件不存在,则报错,写入时是覆盖写入
#w+ 如果文件不存在,则新建文件,写入时是清空写入
#a+ 如果文件不存在,则新建文件,写入时是追加写入

 filepath='d:/note210307_1.txt'
 file1=open(filepath)
 file1.seek(11)  #光标偏移一段距离
 print(file1.read())
 file1.close()

# with open()与open()非常类似,并且它可以同时处理多个文件,并且不需要写close()方法
 filepath1='d:/note210307_1.txt'
 filepath2='d:/note210307.txt'
 with open(filepath1) as file1,open(filepath2) as file2:
     print(file1.read())
     print(file2.read())

#将100以内的自然数写入到文件中
with open('d:/自然数210307.txt','w+') as file1:
    for i in range(1,101):
        if i==100:
            file1.write(str(i))  #写入时的参数,必须是字符串类型
        else:
            file1.write(str(i)+',')  #写入时的参数,必须是字符串类型

#课堂小结
#open()方法,read(),write(),close()
#readline(),readlines()
#r+,w+,a+
#seek()
#with open()

字典

#字典
#字典永远以键值对出现,不会出现有键没值或者有值没键的情况
#字典是无序的
 dict1={'A':'apple','B':'book'}
 dict2={'B':'book','A':'apple'}
 print(dict1==dict2)
 list1=[10,20]
 list2=[20,10]
 print(list1==list2)
#字典的键能存放哪些对象?字典的值能存放哪些?
dict1={'A':'apple'}  #字典的键可以存放不可变对象,不能存放可变对象,字典的值可以存放任意对象
#字典本身算作可变对象

#可变对象,肯定可以增删改
 dict2={'A':'apple','B':'book','C':'cake','D':'duck'}
 dict2['E']='earth'  #字典中没有这个键值对,则新增
 dict2['D']='disk'  #字典中有这个键,则修改
 print(dict2)

 dict2.update({'F':'fish','A':'ace'})  #新增或修改
 print(dict2)

#删除字典中的键值对
 del dict2['A']
 dict2['MK']='apple'
 print(dict2)

#字典中的键是唯一的,不会出现重复的键
dict3={'A':'apple','A':'ace'}
 print(dict3)

#清空字典
 print(id(dict3))
 dict3.clear()  #清空字典,内存中的地址不变
 print(id(dict3))

 print(id(dict3))
 dict3={}  #相当于重新建了一个空字典,替换了旧的字典,内存中的地址发生了变化
 print(id(dict3))

#判断某个对象是否存在于字典中,根据键进行判断,而不是值
 dict_new1={'ABC':'ABCDE'}
 print('ABCDE' in dict_new1)
 print('ABC' in dict_new1)

#遍历字典中的键值对
dict20={'A':'apple','B':'book','C':'cake','D':'duck'}
 for k,v in dict20.items():
     print(k,v)

#遍历键
 for one in dict20.keys():
     print(one)

#遍历值
 for one in dict20.values():
     print(one)

 print(dict20.keys())  #类列表,可以遍历,但不能使用下标
#可以将类列表转换为真正的列表
 list20=list(dict20.keys())
 print(list20)

 list20_value=list(dict20.values())
 print(list20_value)

#json格式
str1='''{
    "aac003" : "tom",
    "tel" : "13959687639",
    "crm003" : "1",
    "crm004" : "1"
}'''
import json  #加载json模块
str1_new=json.loads(str1)  #loads()方法,将json格式转为真正的字典
# print(type(str1_new))
str2=json.dumps(str1_new)  #dumps()方法,将字典转为json格式
print(type(str2))
print(str2)

#课堂小结
#字典的概念,字典是无序的
#自定的增删改
#遍历字典中的键值对

习题

#210308_习题讲解1
#第三次课思考题
 str1='A girl come in, the name is Jack, level 955;'
 def getName(srcStr):
     str_new=srcStr.split('the name is')[1]  #此处得到 Jack, level 955;
     str_new1=str_new.split(',')[0].strip()  #此处得到Jack
     return str_new1
 print(getName(str1))

#第四次课思考题第一题
# Jack Green ,   21  ;  Mike Mos, 9;  #修改之前的字符串
#Jack Green        :21;  #修改之后的字符串
#Mike Mos          :09;

#第一步,拆分原始字符串,以分号作为切割符
#第二步,把姓名和年龄分开,以逗号作为分割符
#第三步,按照题目要求的格式进行打印
 str1='Jack Green ,   21  ;  Mike Mos, 9;'
 list1=str1.split(';')  #第一步
 for one in list1:
     if one !='':  #不处理列表中的空元素
         name,age=one.split(',')  #第二步,用两个变量分别接收姓名和年龄
         name=name.strip()  #去掉前后的空格
         age=int(age.strip())  #去掉前后的空格并转为整数
         print(f'{name:<20}:{age:>02}')

#第四次课思考题第二题
log = '''
f20180111151741/i_JuSWztB3.jpg	92506	FrIjRevHSi6xv4-NQa2wrHu5a1zQ	15156550875370965	image/jpeg	0	
f20180111153550/i_9wWzVenl.gif	769872	FvslKY9JUaCQm-lu02E34tvAP_oG	15156561674621628	image/gif	0	
'''

#第一步,将文件类型提取出来
#1.以行为单位,每次取1行  2.以\t为切割符,分割一行中的值  3.再次以"."作为切割符,取得文件类型
#第二步,将文件大小提取出来
#第三步,将相同类型的文件进行累加,不同类型的文件分开显示

dict1={}
line_list=log.split('\n')  #分割每一行,返回值是一个列表,每个元素就是一行的值
for one in line_list:  #遍历每一行
    if one !='':  #不处理空行
        one1=one.split('\t')[0]  #取得一行中的第一段的值
        file_type=one1.split('.')[1]  #取得文件类型
        file_size=int(one.split('\t')[1])  #取得文件的大小,并转为整数
        if file_type not in dict1:  #如果字典中没有这个文件类型
            dict1[file_type]=file_size  #将键值对放入字典
        else:  #否则,也就表示字典中已经有该文件类型
            dict1[file_type]+=file_size  #将文件大小进行累加
print(dict1)
----------------------
```python
#210308_习题讲解2
#第五次课思考题第一题
#('2017-03-13 11:50:09', 271, 131)
#(①, ②, ③)  #①签到时间,②课程id,③学生id
# {
#     ③:[
#     {'lessonid':②,'checkintime':①},
#     {'lessonid':②,'checkintime':①},
#       ]
#     ③:[
#     {'lessonid':②,'checkintime':①},
#     {'lessonid':②,'checkintime':①},
#       ]
# }

#第一步,分析原始字符串,①签到时间,②课程id,③学生id
#第二步,分析需求预期实现的效果
# {③: [{'lessonid': ②, 'checkintime': ①},{'lessonid': ②, 'checkintime': ①}]}
#第三步,分析如何将原始字符串转换为目标格式
#第四步,按照题目要求将①②③的值放入对应的位置
 dict1={}  #外层字典
 dict2={}  #内层字典
 filepath='d:/0005_1.txt'
 with open(filepath) as file1:
     list1=file1.read().splitlines()  #读取文件每一行的内容,返回值是一个列表
     for one in list1:
         #去掉不需要的字符
         one1=one.replace('(','').replace(')','').replace("'",'').replace('\t','').strip(',').strip(';')
         checkintime,lessonid,studentid=one1.split(',')  #取得签到时间,课程id,学生id
         checkintime=checkintime.strip()  #去掉前后的空格
         lessonid=int(lessonid.strip())
         studentid=int(studentid.strip())
         dict2={'lessonid':lessonid,'checkintime':checkintime}  #将签到信息放入内层字典
         if studentid not in dict1:  #如果学生id不在外层字典中
             dict1[studentid]=[]  #将学生信息作为键添加到外层字典,这个键对应的值是一个空列表
         dict1[studentid].append(dict2)  #把内层字典添加到子列表中

 import pprint
 pprint.pprint(dict1)

#第五次课思考题第二题
#第一步,分析需要提取哪些数据 name的值,salary的值
#第二步,按照题目要求进行打印
# name: Jack   ;    salary:  12000
#  name :Mike ; salary:  12300
# name: Luk ;   salary:  10030
#   name :Tim ;  salary:   9000
# name: John ;    salary:  12000
# name: Lisa ;    salary:   11000
filepath='d:/第5次课练习题2数据.txt'
filepath2='d:/file2.txt'
with open(filepath) as file1,open(filepath2,'w+') as file2:
    file_lines=file1.read().splitlines()  #取得文件每一行的内容
    for one in file_lines:
        one1,one2=one.split(';')  #one1是name: Jack,one2是    salary:  12000
        name=one1.split(':')[1].strip()  #取得name的值
        salary=int(one2.split(':')[1].strip())  #取得salary的值并转为整数
        file2.write(f'name: {name:<7};    salary:  {salary:>5} ;  tax: {int(salary*0.1):>4} ; income:  {int(salary*0.9):>5}\n')

#210310_模块与包
#一个python文件就是一个模块
#存放py文件的目录,我们称之为包,或者文件夹
#如果文件夹中有一个__init__.py,那么就称之为包
#如果是包,必定会有__init__.py,如果没有,则是一个普通的文件夹
#当加载一个包时,会自动执行一次__init__.py中的内容
# import AUTO47

 import time  #加载时间模块
 time.sleep(1)

#标准库,不需要安装,加载就能使用
 import this  #python之禅

#第三方库,需要安装后才可以使用
 import requests  #网络爬虫
 import xlwt,xlrd  #读写excel

#导入模块的几种方式
#import 模块名
 import Sumdata_210310
 print(Sumdata_210310.fun1(3,6))  #模块名.函数名

#from 包 import 模块
 from AUTO47 import Sumdata_210310
 print(Sumdata_210310.fun1(3,6))  #模块名.函数名

#from 包.模块 import 函数
 from AUTO47.Sumdata_210310 import fun1,fun2  #导入多个函数时,中间用逗号隔开
 print(fun1(3,6))  #函数名
 print(fun2(3,6))

#from 模块 import 函数
 from Sumdata_210310 import fun1
 print(fun1(3,6))  #函数名

#from 模块 import *  #加载模块下的所有内容,不推荐这种写法
 from Sumdata_210310 import *
 print(fun1(3,6))
 print(fun2(3,6))

#不同的模块当中,有相同的函数名,可以使用别名对函数进行区分
from AUTO47.Sumdata_210310 import fun1 as f1
from AUTO47.Sumdata2_210310 import fun1 as f2
print(f1(3,6))
print(f2(3,6))

# if __name__ == '__main__': 这句话表示,以下的代码,只在本模块内执行
#如果被别的模块调用,则不执行以下的代码

#课堂小结
#导入模块的几种方式
import 模块名
from 包 import 模块
from 包.模块 import 函数
from 模块 import 函数

#导入模块时,如果出现红色波浪线,可以右键文件夹,选择Mark Directory as,选择Sources Root
#就可以将这个目录加入到标准路径中
# if __name__ == '__main__': 的用处

三方库

#210310_加载第三方库
#标准库 time,this,re,os,sys,math等
#第三方库 xlwt,xlrd,pytest,requests,selenium

import os  #加载操作系统模块
 os.system("calc")  #调用操作系统的计算器
 os.system("cmd")
 os.system("mstsc")

import sys  #加载系统模块
#标准路径,当导入一个包或模块时,python会按照从上到下的顺序从每一个标准路径中查看有没有符合条件的包或模块
 print(sys.path)
 for one in sys.path:
     print(one)
#如果模块位于标准路径中,则可以导入,否则,无法导入
 sys.path.append('D:/')  #临时添加到标准路径
 for one in sys.path:
     print(one)

 from PKG20 import QQQ  #如果这样写, 标准路径中应该有D:/
 print(QQQ.sumdata(3,6))

#永久添加路径到标准路径??
#在python目录的lib\site-packages新建一个.pth文件,文件名任意,后缀名必须是.pth
#将需要添加的路径写入到文件中,这个路径必须真实存在,否则不显示
 import QQQ  #如果这样写,那么标准路径中应该有D:/PKG20
 print(QQQ.sumdata(3,6))

#模块的命名规范,以字母开头
#当有多个标准路径中有同名模块时,按照标准路径从上到下的顺序进行导入
#所有的第三方库都安装在C:\Python38\lib\site-packages目录内

#安装第三方库的命令
#在cmd中,执行pip install 模块名

#如果安装时,速度较慢,可以考虑使用国内的镜像站进行安装
#豆瓣源
 pip install selenium -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com
#清华源
pip install selenium -i https://pypi.tuna.tsinghua.edu.cn/simple/ --trusted-host pypi.tuna.tsinghua.edu.cn

#查看安装了哪些第三方库
#在cmd中执行pip list

#更新安装
#在cmd中执行pip install selenium -U

#卸载第三方库
#在cmd中执行pip uninstall selenium

#统计10000以内有多少个含有3的数
 count=0  #定义一个计数器
 for i in range(10001):  #在10000以内开始循环
     if '3' in str(i):  #如果i当中含有3
         count+=1  #计数器+1
 print(count)

#用列表推导式实现
print(len([i for i in range(10001) if '3' in str(i)]))

#课堂小结
#标准库与第三方库
#标准路径,临时添加到标准路径,永久添加到标准路径
#安装第三方库的命令
#第6节课思考题

pycharm

#210312_pycharm使用技巧
#settings→editor→file and code template,选择python script
#${NAME}  文件名
#${DATE}  日期

#自动补齐
# if __name__ == '__main__':  #先输入main,然后按tab键

#自动补齐一个自定义的段落
#settings→editror→live templates,在右侧点击+号,就可以新增自定义的内容
#完成之后,在下方要勾选python

#修改注释的颜色
settings→editor→color scheme→python
#line comments

#修改函数的颜色
settings→editor→color scheme→python

#取消语法检查,或者降低语法检查的级别
#第一种,点击右下角的小侦探图标
#inspection是最高级别检查, 回对语法和拼写规范等都进行检查
#syntax是中等级别,只检查语法错误
#None 不进行任何检查
#第二种,如果右下角没有小侦探图标,则修改以下选项
settings→editro→inspections,选择python,去掉勾选


#设置分屏
#settings→keymap,查询split关键字,找到分屏的图标,设置快捷键

# 常见的快捷键
# 先输入main,然后ctrl+J,然后回车
# 快速换行
# shift+回车
# 快速注释
 ctrl+/ 按一次注释,再按一次取消注释
#快速缩进
#tab 按一次缩进,默认为4个空格的距离,再按一次再次缩进,shift+tab 取消缩进

#切换编码,当遇到乱码时可以通过切换编码来解决乱码的问题
settings→editor→file encodings

#冒泡算法,给列表排序的算法
 list1=[23,-1,6,92,128,-99,50,36]
 list1.sort()  #对列表进行永久排序,这个方法只排序,没有返回值
 list1.sort(reverse=True)  #排序且倒序
 print(list1)
 print(sorted(list1))  #临时排序,返回值是排序后的结果
 print(sorted(list1,reverse=True))  #临时排序,且倒序
 print(list1[::-1])  #只翻转不排序
 str1='山西悬空寺空悬西山'
 print(str1[::-1])

#冒泡算法
# 4,3,2,1,5 每一轮比较n-1次,一共需要比较n-1轮,从第二轮开始,每一轮都可以额外少比一次
list2=[23,-1,6,92,128,-99,50,36]
for i in range(len(list2)-1):  #外层循环,控制比较的轮次数
    for j in range(len(list2)-1-i):  #内层循环,控制每轮比几次
        if list2[j]>list2[j+1]:  #如果前面的数比后面的数大
            # print(f'第{j}位和第{j+1}位的顺序不对')
            # print(f'变化之前------------------->{list2}')
            list2[j],list2[j+1]=list2[j+1],list2[j]  #两数互换
            # print(f'变化之后------------------->{list2}')
    # print(f'----------------第{i+1}轮循环结束')
print(list2)

面向对象

#面向对象基础**

#类和实例
#新建一个长方形的类
class Rectangle:
    def __init__(self,length,width):
        self.length=length
        self.width=width
    def permerter(self):
        return (self.length+self.width)*2
    def area(self):
        return self.length*self.width

#类不能直接被使用,需要先实例化,再使用
rec=Rectangle(5,4)  #实例化一个长为5,宽为4的长方形
print(rec.permerter())
print(rec.area())

面向对象进阶

class Rectangle:
    def __init__(self,length,width):
        self.length=length
        self.width=width
    def permerter(self):  #只能由实例调用,称之为实例方法
        return (self.length+self.width)*2
    def area(self):
        return self.length*self.width
    @classmethod  #装饰器,声明下面的方法是类方法
    def features(cls):  #类方法,可以由实例调用,也可以由类调用
        print('两边的长相等,两边的宽也相等,长和宽的角度为90°')
    @staticmethod  #装饰器,声明下面的方法是静态方法
    def sumdata(sum1,sum2):  #静态方法,与类没有实质性的关系,只是一个写在了类里面的函数
        return sum1+sum2

# rec=Rectangle(5,3)
# print(rec.permerter())
 rec.features()  #实例可以调用类方法
 Rectangle.features()  #类也可以调用类方法
 print(Rectangle.sumdata(10,10))  #类可以调用静态方法
 print(rec.sumdata(10,10))  #实例也可以调用静态方法

#类方法还是方法,但静态方法其实是函数
#1.用type的方式证明
 print(type(Rectangle.features))  #method
 print(type(Rectangle.sumdata))  #function

#2.使用inspect模块进行判断
import inspect  #python的自检模块,可以判断某个对象是否是某种类型,返回值是布尔型
 print(inspect.ismethod(Rectangle.features))
 print(inspect.isfunction(Rectangle.features))
 print(inspect.ismethod(Rectangle.sumdata))
 print(inspect.isfunction(Rectangle.sumdata))

#继承
#1.完全继承
 class Square(Rectangle):
     pass
 squ=Square(6,6)
 print(squ.permerter())
 print(squ.area())

#2.部分继承,改写一些方法
 class Square(Rectangle):
     def __init__(self,side):  #重写了__init__方法,覆盖了父类的同名方法
         self.length=side
         self.width=side
 squ=Square(6)
 print(squ.permerter())
# print(squ.area())

#3.对父类的方法进行扩展
class Square(Rectangle):
    def __init__(self,side):
        self.length=side
        self.width=side
    @classmethod
    def features(cls):
        super().features()  #声明继承父类的同名方法的代码
        print('长和宽也相等')
squ=Square(6)
squ.features()

#课堂小结
#实例方法,类方法,静态方法
#实例方法,可以由实例调用
#类方法,可以由实例和类调用,本质上还是方法
#静态方法,可以由实例和类调用,本质上是函数,与类没有实际的关系,只是写在了类里面
#type的方式,以及使用inspect模块,判断是函数还是方法
#完全继承,部分继承,父类方法的扩展

面向对象高级

#私有属性,不能被子类继承,在属性的前面加上__就变为了私有属性
#私有方法,不能被子类继承,在方法的前面加上__就变为了私有方法
#__只在前面加,后面不加,一般前后都有__的,属于类当中自带的方法或属性
class Class_test1:
    __str1='A'  #私有属性
    def __init__(self):
        pass
    def __method1(self):  #私有方法
        print('这是一个私有方法')
    def method2(self):
        print(self.__str1)  #在对外开放的方法里调用私有属性
        self.__method1()  #在对外开放的方法里调用私有方法
cls1=Class_test1()
 print(cls1.__str1)
 cls1.__method1()
 cls1.method2()
 class Class_test2(Class_test1):
     pass
 cls2=Class_test2()
 print(cls2.__str1)
 cls2.__method1()
 cls2.method2()

#所有的类,都是object的子类,无论是否声明继承objcet,实际上都继承object
class Class1:
    '''
    人生得意须尽欢
    莫使金樽空对月
    '''
 print(Class1.__doc__)  #显示类的注释
 print(Class1.__bases__)  #显示所有父类的名称
# print(Class1.__base__)  #显示第一个父类的名称
# print(Class1.__name__)  #显示类的名称

#多继承
 class Money1:
     def money(self):
         print('一个亿')
 class Money2:
     def money(self):
         print('两个亿')
 class Human(Money1,Money2):  #继承顺序决定了碰到同名方法时继承哪一个
     pass
 hum=Human()
 hum.money()

#多态
 class Animal:
     def say(self):
         pass
 class Dog(Animal):
     def say(self):
         print('汪汪汪')
 class Cat(Animal):
     def say(self):
         print('喵喵喵')
 dog=Dog()
 cat=Cat()
 def animal_say(obj):
     obj.say()
 animal_say(dog)

 class Fanguan:
     pass
 class Yuxiangrousi(Fanguan):
     def caidan(self):
         print('鱼香肉丝')
 class Gongbaojiding(Fanguan):
     def caidan(self):
          print('宫保鸡丁')
 class Qingjiaotudousi(Fanguan):
     def caidan(self):
         print('青椒土豆丝')
 guke1=Yuxiangrousi()
 guke2=Gongbaojiding()
 guke3=Qingjiaotudousi()
 def fuwuyuan(obj):
     obj.caidan()
 fuwuyuan(guke1)

# 写一个猜数字游戏,需求如下:随机生成一个0-100之间的数字,让用户猜,如果用户猜对了,
# 提示:回答正确,游戏结束.如果猜错了给出对应的提示(您输入的值过大,您输入的值过小),最多允许猜7次.
from random import randint  #加载随机数模块
answer=randint(1,100)  #在1-100之间随机生成一个整数,包含1和100
for i in range(7):
    input1=input('请输入一个数字:')
    if not input1.isdigit():
        print('输入的不是数字,游戏结束')
        break
    else:
        input1=int(input1)
        if input1==answer:
            print('回答正确,游戏结束')
            break
        elif input1>answer:
            print('数字过大')
        elif input1<answer:
            print('数字过小')

#写一个三角形的类
class Sanjiaoxing:
    def __init__(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c
    def zhouchang(self):
        if self.a+self.b<=self.c or self.a+self.c<=self.b or self.b+self.c<=self.a:
            return '无法构成三角形,忽略周长'
        else:
            return self.a+self.b+self.c
    def mianji(self):
        if self.a+self.b<=self.c or self.a+self.c<=self.b or self.b+self.c<=self.a:
            return '无法构成三角形,忽略周长'
        else:
            p=(self.a+self.b+self.c)/2
            return (p*(p-self.a)*(p-self.b)*(p-self.c))**0.5