python基础学习

最新推荐文章于 2023-03-29 22:31:47 发布

Brrby

最新推荐文章于 2023-03-29 22:31:47 发布

阅读量1.7k

点赞数 1

分类专栏： python 文章标签： python 列表字符串

本文链接：https://blog.csdn.net/qq_30433703/article/details/112237828

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

python基础学习

print
数据转换
input函数
比较
条件判断
- 条件表达式
range函数
while、for循环
列表
- 获取指定元素的索引
- 获取列表指定元素(正向索引、逆向索引)
- 列表切片
- 判断元素是否存在列表里
- 遍历列表中的元素
- 列表的添加
- 列表的删除
- 列表的修改
- 列表的排序
- 列表生成式
字典
- 字典的创建
- 字典元素的获取
- 判断元素是否在字典里
- 删除、清空、新增、修改
- 获取字典视图
- 字典元素的遍历
- 字典的特点
- 字典生成式
元组
- 元组创建方式
- 元组元素的遍历
集合
- 集合的相关操作
- 集合间的关系
- 集合的数学操作
- 集合生成式
列表、字典、元组、集合的总结
字符串
- 查找
- 大小写转换
- 格式化字符串
函数
- 返回值
类与对象
- 动态绑定属性和方法
- 封装
- 继承
- 方法重写
以主程序运行
安装第三方模板
io操作
- with

print

在python里，输出只有print，没有printf和println，想换行输出可以使用 \n
在这里插入图片描述
将输出内容输入到指定文件里：

#此处指定的盘符必须存在   a+表示文件不存在就创建,存在直接在已经存在的文件里追加内容(不覆盖内容)
f=open('D:/text.txt','a+')
#打印时指定输出文件用file=来指定
print('new sentence\n'*5,file=f)
f.close()

数据转换

将不同数据类型的数据拼接在一起需要数据转换

method	mean
str()	将变量转化为字符串类型
int()	将变量转化为int类型
float()	将变量转化为float类型

在这里插入图片描述

a='额外'
b=21
print(a+'一点，我今年'+str(b)+'了')

在这里插入图片描述

input函数

input函数接收的值都是字符串类型
在这里插入图片描述

a=input('请输入一个数字：')
b=input('请接着再输入一个数字：')
print('你好，通过你输入的内容：\n得出结果两数相加为'+str(int(a)+int(b))+'\n第一个数减去第二个数为'+str(int(a)-int(b))+'\n第二个数减去第一个数为'+str(int(b)-int(a))+'\n两数相乘为'+str(int(a)*int(b))+'\n第一个数除以第二个数为'+str(int(int(a)/int(b)))+'\n第二个数除以第一个数为'+str(int(b)/int(a)))

在这里插入图片描述

比较

==比较内容
is比较地址值
在这里插入图片描述

条件判断

python 中没有 || 和 &&，继而替换的分别是 or 和 and

------------------------------------------------------------------------------------------------
if   ...  :
	条件体
else:
	条件体
------------------------------------------------------------------------------------------------
if   ...  :
	条件体
elif   ...  :
	条件体
else:
	条件体
------------------------------------------------------------------------------------------------
if   ...  :
	条件体
else:
	条件体

在这里插入图片描述

条件表达式

X  if  判断条件  else  Y

表示判断条件为true时，返回X，为false时返回Y
和三目表达式是一个道理

a=input('请输入第一个数：\n')
b=input('请输入第二个数：\n')
print(str(a)+'大于'+str(b) if int(a)>int(b) else str(a)+'小于'+str(b))

在这里插入图片描述

range函数

类型	含义
range(stop)	[0,stop) 只有一个参数时,默认从0开始,步长为1
range(start,stop)	[start,stop) 两个参数时,步长也为1
range(start,stop,step)	[start,stop)

# range(stop)  只有一个参数时,默认从0开始,步长为1    [0,stop)
a=range(10)
print(list(a))

# range(start,stop)  两个参数时,步长也为1    [start,stop)
b=range(1,10)
print(list(b))

# range(start,stop,step)      [start,stop)
c=range(1,10,2)
print(list(c))

在这里插入图片描述

while、for循环


#求1到100之间偶数总和

sum=0
i=0
while i<=100:
    if(i%2==0):
        sum+=i
    i+=1
print('1到100之间的偶数和为：'+str(sum))

在这里插入图片描述


#求1到100之间的数的总和
sum=0
i=0


for i in range(1,101):
    sum+=i
print('1到100之间的总和为：'+str(sum))

在这里插入图片描述

列表

变量可以存储一个元素，列表可以存储很多个元素，列表就相当于其他语言中的数组。
列表是一个可变有序序列

lst=['铅笔','钢笔',21,'橡皮擦',1,'小刚',36,'小汉']
print(lst,type(lst),id(lst))
print(lst[0],type(lst[0]),id(lst[0]))
print(lst[2],type(lst[2]),id(lst[2]))

在这里插入图片描述

获取指定元素的索引

lst.index(value)
lst.index(value,start,stop)
在这里插入图片描述
查找列表里相同元素的index，就要指定start和stop，规则为[start,stop)

获取列表指定元素(正向索引、逆向索引)

列表的正向索引下标从0开始从第一个开始
列表的逆向索引下标从-1开始从列表最后一个开始
在这里插入图片描述

列表切片

列表名[start:stop:step]
在这里插入图片描述

判断元素是否存在列表里

in
not in
在这里插入图片描述

遍历列表中的元素

在这里插入图片描述

列表的添加

在这里插入图片描述
添加元素后，地址是没变的

append方法添加只会在列表末尾添加一个，所以在添加另一个列表时，会当作一个整体添加，而extend方法可添加多个

列表的删除

在这里插入图片描述

列表的修改

在这里插入图片描述

列表的排序

使用sort方法排序不会产生新的列表对象
在这里插入图片描述
使用内置函数sorted()排序会产生新的列表对象

列表生成式

在这里插入图片描述

字典

字典是python内置的数据结构之一，与列表一样是一个可变序列
字典以键值对的方式存储数据，是一个无序的序列
字典里的键不能变，但是值可以变

字典的创建

使用{}的方式：

a={ '键':值, '键':值, '键':值, '键':值, .......}

使用内置函数dict()的方式：

b=dict( 键=值, 键=值, 键=值, 键=值, .......)

a={'小强':90,'小黄':85,'小东':60}
b={'name':'大壮','age':21,'sex':'man'}
c=dict(小强=90,小黄=85,小东=60)
d=dict(name='大壮',age=21,sex='man')
e={}
print(a,type(a),'\n'+str(b),type(b),'\n'+str(c),type(c),'\n'+str(d),type(d),'\n'+str(e),type(e))

在这里插入图片描述

字典元素的获取

通过[ ]的方式：

a[‘键’]

通过get()的方式：

a.get(‘键’)

[ ] 取值如果字典中不存在指定的key，抛出keyError的异常
get() 取值如果字典中不存在指定的key直接返回None，而且可以通过参数设置默认的value用于在指定的key不存在时返回

a={'小强':90,'小黄':85,'小东':60}

b=dict(小强=90,小黄=85,小东=60)

print(a['小强'])
print(a['黄小'])
print(b.get('小东'))
print(b.get('范围'))
print(b.get('现场',32))   #get()方法获取元素可以指定指定的key不存在时默认的value

在这里插入图片描述

判断元素是否在字典里

判断元素是否在字典里是通过元素的键来判断的
in
not in

b=dict(小强=90,小黄=85,小东=60)
print('小黄' in b)
print('小黄' not in b)
print('cedw' in b)
print('小东' in b)

在这里插入图片描述

删除、清空、新增、修改

b=dict(小强=90,小黄=85,小东=60)
print(b)
del b['小黄']     #删除指定的字典元素
print(b)
b['新增元素']=100    #新增字典元素
print(b)
b['小强']=1111    #修改字典元素
print(b)
b.clear()    #清空字典
print(b)

在这里插入图片描述

获取字典视图

keys()
获取字典中所有的key
values()
获取字典中所有的value
items()
获取字典中所有的键值对

b=dict(小强=90,小黄=85,小东=60)

ks=b.keys()
print(ks)
print(type(ks))
print(list(ks))     #list()将元素类型转换成列表

vs=b.values()
print(vs)
print(type(vs))
print(list(vs))

ts=b.items()
print(ts)
print(type(ts))
print(list(ts))   #转换成列表后的元素是由元组组成的

在这里插入图片描述

字典元素的遍历

b=dict(小强=90,小黄=85,小东=60)
for i in b:
    print(i,b.get(i))

在这里插入图片描述

字典的特点

在这里插入图片描述

字典生成式

ii jj 都是长度相同的列表
x={i:j  for  i,j  in  zip(ii,jj)}         #x就是一个字典了

ii=['one','tow','three','four']
jj=[1,2,3,4]

x={i:j for i,j in zip(ii,jj)}
print(x)

y={i.upper():j for i,j in zip(ii,jj)}
print(y)

在这里插入图片描述
当ii和jj的长度不一样时，默认选长度短的一个作为生成字典的长度

ii=['one','tow','three','four']
jj=['one','tOw','thRee','fOuR','fIve','sIx']

x={i:j for i,j in zip(ii,jj)}
print(x)

y={i.upper():j.upper() for i,j in zip(ii,jj)}
print(y)

z={i.upper():j.lower() for i,j in zip(ii,jj)}
print(z)

在这里插入图片描述

元组

元组是python的内置对象之一，是一个不可变序列
在这里插入图片描述

不可变序列：字符串、元组

没有增删改操作

可变序列：列表、字典、集合

可对序列执行增删改操作且执行后对象地址不发生改变

元组创建方式

直接用小括号：

a=( ‘叫哦呜’ , 213 , True , 32.21 )

使用内置函数：

a=tuple( ( ‘dw’ , 21 , ‘成为’ ) )

a=('叫哦呜',213,True,32.21)
print(a,type(a))
b='cew速度',4321,True,3.43    #元组里有多个元素时可以省略括号
print(b,type(b))
c=('加哦',)    #元祖里只有一个元素时在创建时必须加括号和逗号
print(c,type(c))
d=tuple(('dw',21,'成为'))     #使用内置函数tuple创建
print(d,type(d))
e=()		#空元组的创建
print(e,type(e))

在这里插入图片描述

元组元素的遍历

a='cew速度',4321,['小孩',21,'女'],True,3.43    #元组里有多个元素时可以省略括号
print(a,type(a))
for i in a:
    print(i,type(i))

在这里插入图片描述

集合

集合是python的内置数据结构，与列表和字典一样都是可变序列
集合和字典一样都是用 { } 创建，但集合没有value而字典有value

创建方式：

1. 直接用 { }
a={ ‘喜欢我i’ , 21 , ‘单位’ , True , 20.53 }

2. 使用内置函数set()
a=set(range(11))
b=set([ 2 , ‘得出’ , 3.14 , False ])
c=set(( ‘非常v’ , ‘xx’ , False , 1111 ))
d=set(‘我不是真的123’)
e=set({ ‘喜欢我i’ , 21 , ‘单位’ , True , 20.53 })

i1=[2,'得出',3.14,False]   #i1列表
print(i1,type(i1))
i2=('非常v','xx',False,1111)    #i2元组
print(i2,type(i2))

a=set(range(11))
print(a,type(a))
b=set(i1)   #将i1列表转换为集合
print(b,type(b))
c=set(i2)    #将i2列表转换为集合
print(c,type(c))
d=set('我不是真的123')   #将字符串转换为集合
print(d,type(d))
e=set()    #创建一个空的集合只能使用set()
print(e,type(e))
f={}    #不能通过{}的方式创建空集合, {}的方式是创建空字典
print(f,type(f))

在这里插入图片描述

集合的相关操作

#判断指定元素是否存在集合中

a={'小红',100,10,'大王',50,88,'儿子'}
print(a,type(a))
print('100在a集合里？'+str(100 in a)+'\n66在a集合里？'+str(66 in a)+'\n小红在a集合里？'+str('小红' in a)+'\n儿子不在a集合里？'+str('儿子' not in a))

在这里插入图片描述

#集合添加元素

a={'大王',50,88,'儿子'}
print(a,id(a))
a.add('new1')    #add()方法一次只能添加一个元素
print(a,id(a))
a.update({'n1','n2','n3'})    #update()方法一次至少添加一个
print(a,id(a))
#update()方法可以以列表、元组、集合的添加元素来添加多个元素

在这里插入图片描述

a={'大王',50,88,'儿子'}
print(a)
a.remove('儿子')
print(a)

a.remove('爸爸')     #remove()方法删除集合中不存在的元素时会报错
print(a)

a.discard('老王')     #discard()方法删除集合中不存在的元素时不会报错
print(a)
a.discard('大王')
print(a)

a.pop()     #一次删除集合中任意一个元素
print(a)

a.clear()     #清空集合

在这里插入图片描述

集合间的关系

判断两个集合内的元素是否一样：

==、 !=

判断子集：

issubset()

判断超集：

issuperset()

判断是否没有交集：

isdisjoint()

a={1,2,3,4,5,6,7,8,9}
b={4,6,9,1}
c={50,6,4,21}
d={50,11,29,21}

print(b.issubset(a))    #b是a的子集吗
print(a.issuperset(b))    #a是b的超集吗
print(b.isdisjoint(c))   #b和c没有交集吗
print(b.isdisjoint(d))   #b和d没有交集吗

在这里插入图片描述

集合的数学操作

交集：

intersection &

并集：

union |

差集：

difference -

对称差集：

symmetric_difference ^

在这里插入图片描述

a={1,2,3,4,5,6,7,8,9}
b={50,11,29,21,2,7,3,9}

#intersection和&作用一样都是求交集
print(a.intersection(b))
print(a&b)

#union和|作用一样都是求并集
print(a.union(b))
print(a|b)

#差集就是一个集合和另一个集合的不同的元素
print(a.difference(b))
print(a-b)

#对称差集就是两个集合除去交集后两个集合中剩下的所有元素的并集
print(a.symmetric_difference(b))
print(a^b)

在这里插入图片描述

集合生成式

和列表生成式差不多，只是把[]改成{}
在这里插入图片描述
没有元组生成式

列表、字典、元组、集合的总结

在这里插入图片描述

字符串

查找

在这里插入图片描述

s='天上人间，玉宇琼楼，人'
print(s.index('人间'))
print(s.rindex('人'))
print(s.find('人间'))
print(s.rfind('人'))
print(s.find('小区'))
print(s.rfind('人们'))

在这里插入图片描述

大小写转换

在这里插入图片描述

s='eventuaLLy hE saVed enoUgh MonEy workIng at thIs trAde on tHe side To bUy his fREedOm'
print(s.upper()+'\t转换为全大写')
print(s.lower()+'\t转换为全小写')
print(s.swapcase()+'\t每个单词中的小写字母转换为大写而大写字母转换为小写')
print(s.capitalize()+'\t字符串的首字母大写,其他小写')
print(s.title()+'\t字符串中的每个单词的首字母大写,其他小写')

在这里插入图片描述

格式化字符串

在这里插入图片描述

name='小汉'
age=21
name1='汉哥'
age1=20
name2='小壮'
age2=22

print('我叫%s,今年%d岁了'%(name,age))

print('我叫{0},今年{1}岁了'.format(name1,age1))

print(f'我叫{name2},今年{age2}岁了')

在这里插入图片描述

函数

定义方式：
def 函数名(形参1, 形参2 ......) :
函数体

在函数调用过程中，进行的参数传递：

如果是不可变对象，在函数体里对形参进行修改跳出函数后不会影响实参的值
如果是可变对象，在函数体里对形参进行修改跳出函数后会影响实参的值

n1=89
n2='我是n2'
n3=[12,34,'细节']

def fun(a,b,c):
   a=0
   b=0
   c.clear()
   print('a', a)
   print('b', b)
   print('c', c)

print('n1', n1)
print('n2', n2)
print('n3', n3)
fun(n1,n2,n3)
print('n1', n1)
print('n2', n2)
print('n3', n3)

在这里插入图片描述

返回值

函数返回值只有一个，直接返回类型
函数函数值如果是多个，返回的类型为元组

类与对象

创建语法：

class Stu:
    hahaha='睡觉哦我'	#类属性(类里在方法外的变量)
    
    #构造函数
    def __init__(self,name,age,sex,addr,cla):
        self.name=name;
        self.age=age;
        self.sex=sex;
        self.addr=addr;
        self.cla=cla;

    #对象方法(实例方法)
    def fly(self):
        print('我可以飞')

    #静态方法
    @staticmethod
    def sm():
        print('我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法')

对象的创建：

stu=Stu(‘小汉’ , 21 , ‘男’ , ‘成都’ , ‘软一’)

例子：

class Stu:
    hahaha='睡觉哦我'
    
    #构造函数
    def __init__(self,name,age,sex,addr,cla):
        self.name=name;
        self.age=age;
        self.sex=sex;
        self.addr=addr;
        self.cla=cla;

    #对象方法
    def fly(self,a):
        print('我'+self.name+'可以飞！'+a+",你呢？")

    #静态方法
    @staticmethod
    def sm():
        print('我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法')





stu=Stu('小汉',21,'男','成都','软一')
stu.fly('范佳鑫')
print(stu.name)

在这里插入图片描述

动态绑定属性和方法

class Stu:
    hahaha='睡觉哦我'

    #构造函数
    def __init__(self,name,age,sex,addr,cla):
        self.name=name;
        self.age=age;
        self.sex=sex;
        self.addr=addr;
        self.cla=cla;

    #对象方法
    def fly(self,a):
        print('我'+self.name+'可以飞！'+a+",你呢？")

    #静态方法
    @staticmethod
    def sm():
        print('我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法')





stu=Stu('小汉',21,'男','成都','软一')
stu.asi='难道我i'    #这行就是动态绑定属性
print(stu.asi)

def outShow():
    print('定义在类之外的动态绑定')

stu.outShow=outShow	#这行就是动态绑定方法

stu.outShow()

封装

在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面使用两个_

class Car:
    def __init__(self,name,price):
        self.name=name; #公用属性
        self.__price=price; #私用属性

    def start(self):
        print("汽车启动");


car=Car("红旗",20);
car.start();
# print(car.price)
print(dir(car)) #查看类属性
print(car.name)
print(car._Car__price) #访问私用属性

继承

在这里插入图片描述

如果一个类没有继承任何东西，则默认继承Object类。

#这是一个没有继承任何父类的animal类

class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");


animal=Animal("老虎","big","yellow");
animal.eat()
animal.sleep()

在这里插入图片描述

class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");

class Cat(Animal):
    def __init__(self,name,size,color,old,sex):
        super().__init__(name,size,color);
        self.old=old;
        self.sex=sex;

cat=Cat("小咪",50,"white",20,"公");
cat.sleep();
cat.eat();

在这里插入图片描述


class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");

# 水生
class Aquatic:
    def __init__(self,addr):
        self.addr=addr;

    def live(self):
        print("在"+self.addr+"生活");

# 陆生
class Ground:
    def __init__(self, addr):
        self.addr = addr;

    def live(self):
        print("在" + self.addr + "生活");


class fish(Animal,Aquatic):
    def __init__(self,name,size,color,addr,old,sex):
        Animal.__init__(self,name,size,color);
        Aquatic.__init__(self,addr);
        self.old=old;
        self.sex=sex;


fish=fish("金鱼","small","red","ocean","3","母");
fish.eat();
fish.live();
fish.sleep();

在这里插入图片描述


class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");

# 水生
class Aquatic:
    def __init__(self,addr):
        self.addr=addr;

    def live(self):
        print("在"+self.addr+"生活");

# 陆生
class Ground:
    def __init__(self, addr):
        self.addr = addr;

    def live(self):
        print("在" + self.addr + "生活");



class Tiger(Animal,Ground):
    def __init__(self,name,size,color,addr,old,sex):
        Animal.__init__(self,name,size,color);
        Ground.__init__(self,addr);
        self.old=old;
        self.sex=sex;


tiger=Tiger("小虎",53,"yellow","陆地上",15,"公");
tiger.sleep();
tiger.eat();
tiger.live();

在这里插入图片描述

方法重写


class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");

# 水生
class Aquatic:
    def __init__(self,addr):
        self.addr=addr;

    def live(self):
        print("在"+self.addr+"生活");

# 陆生
class Ground:
    def __init__(self, addr):
        self.addr = addr;

    def live(self):
        print("在" + self.addr + "生活");



class Tiger(Animal,Ground):
    def __init__(self,name,size,color,addr,old,sex):
        Animal.__init__(self,name,size,color);
        Ground.__init__(self,addr);
        self.old=old;
        self.sex=sex;

    def sleep(self):   #重写
        print(self.name+"在"+self.addr+"上躺着睡着的");

    def eat(self):   #重写
        print(self.name+"只吃肉，因为它是食肉动物");

    def live(self):   #重写
        print(self.name+"生活在山林间，喜欢独来独往且无固定巢穴");


tiger=Tiger("小虎",'big',"yellow","陆地上",15,"公");
tiger.sleep();
tiger.eat();
tiger.live();

在这里插入图片描述

子类重写后的方法中可以通过super().方法名();来调用父类中被重写的方法

#重写时还想调用父类的方法

class Animal:
    def __init__(self,name,size,color):
        self.name=name;
        self.size=size;
        self.color=color;

    def eat(self):
        print(self.name+"在吃东西");

    def sleep(self):
        print(self.name+"睡着了");

# 水生
class Aquatic:
    def __init__(self,addr):
        self.addr=addr;

    def live(self):
        print("在"+self.addr+"生活");

# 陆生
class Ground:
    def __init__(self, addr):
        self.addr = addr;

    def live(self):
        print("在" + self.addr + "生活");



class Tiger(Animal,Ground):
    def __init__(self,name,size,color,addr,old,sex):
        Animal.__init__(self,name,size,color);
        Ground.__init__(self,addr);
        self.old=old;
        self.sex=sex;

    def sleep(self):   #重写
        super().sleep(); #调用父类的方法
        print(self.name+"在"+self.addr+"上躺着睡着的");

    def eat(self):   #重写
        super().eat(); #调用父类的方法
        print(self.name+"只吃肉，因为它是食肉动物");

    def live(self):   #重写
        super().live(); #调用父类的方法
        print(self.name+"生活在山林间，喜欢独来独往且无固定巢穴");


tiger=Tiger("小虎",'big',"yellow","陆地上",15,"公");
tiger.sleep();
tiger.eat();
tiger.live();

在这里插入图片描述

以主程序运行

新建一个模块calc：


def add(a, b):
    return a+b


print(add(5, 10))

运行calc：

再新建一个模块dald：

import calc

x=calc.add(90,3)
print(x)

运行dald：

这时候也运行了5+10的运算，且主程序是dald

但是dald只是调用了calc的add方法不想牵扯其他东西，这时候就要对calc模块进行如下修改：


def add(a, b):
    return a+b


if __name__=="__main__":
    print(add(5, 10))

dald：

import calc

x=calc.add(90,3)
print(x)

运行dald：

安装第三方模板

就以安装matplotlib模板来说：

在dos里输入：pip install 模块名

完成后在pycharm里点击 file->setting->Project:PycharmProjects->Python Interpreter：在这里插入图片描述

点击刚才下载好的matplotlib：在这里插入图片描述
点击install package，然后再在模块里导入下载的模块就可以了

io操作

在这里插入图片描述

x=open('D:\\text.txt','r');
print(x.read())
x.close()

在这里插入图片描述

x=open('C:\\Users\\Administrator\\Desktop\\new.txt','w');
x.write("我是新创建的")
x.close()

执行后：

当new.txt已存在时会覆盖原有文件的内容

x=open('C:\\Users\\Administrator\\Desktop\\new.txt','a');
x.write("wo jiu shi zhui jia de nei rong le")
x.close()

在这里插入图片描述

现在这个文件有图片，我们可以使用b去复制它们：

x=open('D:\\Camera Roll\\c70098150e1ecbdfa7730704c16bc23.png','rb')
y=open('C:\\Users\\Administrator\\Desktop\\new.png','wb')
y.write(x.read())
x.close()
y.close()

在这里插入图片描述

with

with语句可以自动管理上下文资源，不论什么原因跳出with块都能确保文件正确关闭，以此来达到释放资源的目的
在这里插入图片描述

with open('D:\\工作临时文档\\2020\\更换yum源.txt','r') as file:
    print(file.read())

在这里插入图片描述

with open('C:\\Users\\Administrator\\Desktop\\cdb449fb7b1c4e76256f22e739df0fb.jpg','rb') as file:
    with open('C:\\Users\\Administrator\\Desktop\\复制的.jpg','wb') as file1:
        file1.write(file.read())

在这里插入图片描述