初识Python-CSDN博客

本文链接：https://blog.csdn.net/weixin_40970987/article/details/85120745
介绍

Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
特点

Python 是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言：这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
基本知识点

Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码。

#变量
FirstName = 'zhang'
print(FirstName)

#数字
num = 10
print(num)
print(0.1+0.2)

#字符串
str1 = "Dava:\"this is my house\""
print(str1)
str1 = '''邢晓红
我们会一直一直在一起的'''
print(str1)
print('\u0079')
a,b,c = 1,2,3
print(a,b,c)

#格式化字符串
name = "star"
age = 15
#=====方法一======
#字符串和数字不能直接进行拼接，否则会报错
print("姓名:" + name)
#=====方法二======
print("姓名:" + name + "年龄:" , age)
#=====方法三======
#占位符
#小数保留
str1 = "每个月工资是%.1f"%65.25
#取整
str1 = "每个月工资是%d"%643355.25
#字符
str1 = "我家住在%3.5s"%"rtertre"
print(str1)
print("姓名:%s,年龄:%s"%(name,age))
#=====方法四======
print(f"姓名:{name},年龄:{age}")

#字符串复制
str1 = 'abc'
str1 *= 20
print(str1)

#布尔值，也是一个整型
print(1 + True)
print(1 + False)

#type函数用于变量类型检查
print(type('hello'))
print(type(123))
print(type(13.14))
print(type(True))
print(type(None))

#获取对象在内存中的地址ID
print(id(123))

#类型转换
#int() float() str() bool()
a = '123'
a = 11.1
#a = 'abc'
a = True
a = False
#a = None
a = int(a)
a = float(a)
a = str(a)
a = bool(a)
print("a=",a)
print(type(a))

#运算符
a = 10 // 3
a = 10 ** 2
a = 10 % 3
a += 5
a -= 2
a *= 5
a **= 2
a /= 5
a //= 5
print(a)

#关系运算符
result = 1 > 2
result = 1 < 2
result = 1 <= 2
result = 1 >= 2
result = 1 < True
result = 1 == True
result = 1 != 2
#字符串比较的是unicode编码，而且是逐位进行比较
result = '2' > '1'#True
result = '2' > '11'#True
#以上比较的是对象的值，要想比较对象的id，需要使用is,is not
result = 1 is 2 #False
result = 1 is not True #True
#python中支持连着的写法,拿着中间值分别去与两边值进行比较
result = 10 < 15 > 13 # True 相当于10 < 15 and 15 > 13
print('result=',result)

#逻辑运算符
#not 非 取反
#and 与 有一个False就是False，第一个是False则不看后面的
#or 或 有一个True就是True，第一个是True则不看后面的
a = True
a = not a
a = True and True
a = True and False
a = True or False
print('a=',a)
#非布尔值与或运算，按照布尔值去进行计算，直接返回原值
a = 1 and 2 #2
a = 1 or 2 #1
a = 0 and 2 #0
a = 0 or 1 #1
print(a)
#优先级 not > and > or
a = 1 or 2 and 3 or not 4
print(a)

#条件运算符
#三元运算符
a = 20
b = 30
c = 15
max = a if a > b else b
min = a if a < b and a < c else b if b < c else c
print(max)
print(min)


#======================================================================================


#流程控制语句
#if判断
num = 11
if num > 10:
	print('num大于10')

#input函数用于获取用户输入，调用的时候程序会立即暂停，等待用户输入，回车后程序继续向下执行，返回值为一个字符串
a = input()
if a == "admin":
	print("欢迎管理员登录")
elif a == "star":
	print("欢迎用户登录")
else:
	print("欢迎游客登录")

#循环语句
#while循环
i = 0
while i < 10:
	print('你在想我吗？')
	i += 1
else:
	print("i不小于10")

#循环嵌套，形成99乘法表
i = 0
while i < 9:
	i += 1
	j = 0
	while j < i:
		j += 1
		print(f"{j}*{i}={i*j}",end=' ')
	print()	
	
#break 终止循环并跳出，包括else 
#continue 跳过本次循环
#pass 用于占位
i = 0
while i < 5:
	i += 1
	if i == 3:
		#break
		#continue
		pass
	print(i)

#引入time模块用于获取当前时间,单位是秒
from time import *
start = time()

#获取质数，只能被1和本身整除
i = 2
while i < 100:
	flag = True
	j = 2
	while j <= i**0.5:
		if i % j == 0:
			flag = False
			break
		j += 1
	if flag:
		print(i)
	i += 1
end = time()
print(f'{end-start}')
print('\tm')

#==================================================================================
#数据结构指计算机中数据存储的方式
#序列
#列表，可改变的序列
lst = [1,2,3,4,5]
#可以进行加法和乘法运算
lst = [1,2,3,4,5] + [6,7,8,4]
lst = lst * 2
print(lst)
print(type(lst))
#获取某个下标对应的元素
print(lst[3])
#通过切片获取指定的元素,获取到的数据会组成一个新的列表，不会影响原来的列表
#切片的获取包含开头，不包含末尾，如果其中一项不写，则表示从0开始取或者取到最后一位
#其中第三个参数为步长，可以控制怎么取
print(lst[1:3:1])

#列表操作
#获取列表长度
print(len(lst))
#in，not in判定元素在不在列表中
print(1 in lst)
print(3 not in lst)
#min,max获取列表中元素的最大值和最小值
#print(min(lst))
#print(max(lst))
#index获取索引值,第一个参数是指定元素，第二个参数是从哪个下标开始查找
print(lst.index(2,3))
#count获取当前元素出现的个数
print(lst.count(2))
#通过索引修改列表对象
lst[1] = 3
#del删除
del lst[1]
print(lst)
#通过切片来修改列表
lst[0:2] = [11,12]
print(lst)
#插入元素
lst[0:0] = [13]
lst[5:5] = [15]
#如果设置了步长，则序列中的个数必须与切片中的个数一致
print(len(lst[::6]))
lst[::6] = [1,2,3,4]
print(lst)
#删除元素
del lst[0:2]
lst[0:2] = []
#以上操作仅适用于可变序列
s = 'hello'
#s[::2] = [1,2]
print(s)
#列表方法
#append向列表末尾添加元素
lst.append(520)
#insert向指定位置插入元素
lst.insert(2,1314)
#extend使用新的序列来扩展当前序列
lst.extend([1,2,34])
#clear清空序列
#lst.clear()
#pop删除指定序列，不写参数则默认删除最后一个,并返回删除元素
lst.pop()
#remove删除指定元素,只删第一个
lst.remove(1)
#reverse用于翻转列表
lst.reverse()
#sort排序，默认为升序排列
lst.sort()
#reverse = True可改为降序排列
lst.sort(reverse = True)
print(lst)

#for循环遍历列表
for s in lst:
	print(s)

#range函数会自动生成一个由自然数组成的序列,通常和for循环一起使用，用于循环指定次数
#有3个参数,起始值，终止值，步长
range(0,9,3)
for i in range(5):
	print(i)
#字符串和元组，不可改变的序列

#元组和列表的方法大部分相同，只不过不能进行修改操作
tuple = (10,20,30,40)
print(tuple,type(tuple))
#非空元组，可以不加括号，但是里面必须有一个,
tuple = 10,20,30,40
print(tuple,type(tuple))
tuple = 10,
print(tuple,type(tuple))
#元组解构
a,b,c,d = (10,20,30,40)
print(a,b,c,d)
#*c可以取到元组剩余所有元素组成的列表
a,b,*c = (10,20,30,40)
print(a,b,c)
#值的交换
a = 10
b = 20
a,b = b,a
print(a,b)

# == != is is not
# == !=比较的是值
# is is not比较的是id
a = [1,2,3]
b = [1,2,3]
print(a == b) #True
print(a is b) #False
b = a
print(a is b) #True

#===========================================================
#字典dict
#一种新的数据结构=>映射
#以键值对(key-value)的形式存在，由于key的唯一性，相较于序列，更容易索引
#创建字典
d = {'name':'晓红','age':'24'}
#dict函数创建
d = dict(name='xiaohong',age='15')
#双值子序列转换
d = dict([('name','xiaohong'),('age','15')])
print(d)
#获取键值对的个数
print(len(d))
#获取值
print(d['name'])
print(d.get('nama','默认值'))
#设置值
d['name'] = 'star'
#若key值已存在，不会对字典做任何操作
d.setdefault('name','xiaohong')
print(d)
#添加值
d['sex']='男'
d.setdefault('address','临涧')
print(d)
#更新合并,如果键重复，拿后面的替换前面的
d1 = {'love':'xiaohong','job':'web','name':'yixuan'}
d.update(d1)
print(d)
#删除
d = {'a':1,'b':2,'c':3,'d':4,'f':5}
#del
del d['c']
#popitem删除字典最后一项,返回值是删除的key和value组成的一个元组
result = d.popitem()
print(result)
#pop删除指定项，设置默认值可删除不在字典中的key，返回值是删除的值
result = d.pop('a')
print(result)
d.pop('m','默认值')
#clear清空字典
d.clear()
print(d)

#copy浅复制,只复制第一层，第一层下面的值如果是可变对象，则无法复制下面的东西
d = {'a':1,'b':{'name':'晓红'},'c':3,'d':4,'f':5}
d2 = d.copy()
d2['b']['name'] = '逸轩'
print(d,id(d))
print(d2,id(d2))

#字典的遍历
d = {'name':'晓红','age':24,'love':{'name':'star'}}
#keys 返回所有的第一层的key值
for k in d.keys():
	print(k,d[k])
#values 返回所有的值
for v in d.values():
	print(v)
#items 返回所有的项，形成元组的形式构成序列
for k,v in d.items():
	print(k,v)


#集合(set)
#集合和列表相同又不同
'''
不同点：
	1、集合里面存的必须是不可变对象
	2、集合中的数据是无序的
	3、集合中不能出现重复的元素
'''
#创建空集合
s = set()
s = {1,2,3,4,5,6,12,1,3,3,4,2}
print(s,type(s))
#通过set序列、元组、字典都可以转化为集合，不过字典转化为的集合只包括键值。通过转化为集合可将序列去重
l = [1,2,3,4,5,6]
print(set(l))
t = (1,2,3,4,5,6)
print(set(t))
d = {'a':1,'b':2}
print(set(d))
#操作集合的方法
#in,not in判断元素在不在集合中
print(1 in s)
print(1 not in s)
#len获取集合中所有元素的个数
print(len(s))
#添加add
s.add(1000)
print(s,type(s))
#删除
#pop随机删除一个
s.pop()
print(s,type(s))
#remove删除指定元素
s.remove(12)
print(s,type(s))
#clear清空集合
#将一个集合更新到另一个集合中
s2 = {'a','c','v','s','a','s'}
s.update(s2)
print(s,type(s))
#copy实现浅复制
s3 = s.copy()
print(s3,type(s3))

#集合的运算
s = {1,2,3,4,5,6}
s1 = {5,6,8,3,2,5,3}
#交集 -->公共部分
result = s & s1
print(result)
#并集 -->两者所有的元素
result = s | s1
print(result)
#差集 -->自己单有的
result = s - s1
print(result)
#异或集 -->两者单有的
result = s ^ s1
print(result)
#判断一个是另一个的子集
print(s <= s1)
#判断一个是另一个的超子集)
print(s < s1)
#判断一个是另一个的父集
print(s >= s1)
#判断一个是另一个的超父集
print(s > s1)

#================================================================================

#函数
#混合参数时，位置参数要放在关键字参数的前面
def fn(a,b,c=20):
	print(a+b+c)
fn(1,c=2,b=3)
#参数为可变对象的时候，在函数内改变对象，函数外部也会跟着变化，因为两者指向的是同一地址，要想外部不做改变，可以采用copy的方式，对对象进行浅拷贝
def fn1(a):
	a[0] = 10
	print(a)
c = [1,2,3]
fn1(c.copy())
print(c)
#不定长形参
#装包
# * 指代未明确标出来的位置参数，所有被指代的实参将组成一个元组，只能有一个，可以放在任意位置，但是其后的其他参数必须得用关键字参数
def fnsum(*a):
	print(a,type(a))
	result = 0
	for num in a:
		result += num
	print(result)
fnsum(1,2,3,4,5,6)
def fn2(a,*c,b):
	print('a=',a)
	print('b=',b)
	print('c=',c)
fn2(1,2,3,4,5,b=4)
# ** 指代未明确标出来的关键字参数，所有被指代的实参将组成一个字典，其中关键字为key，值为value，只能有一个，必须放在所有形参的最后
def fn3(c,**d):
	print('d',d,type(d))
	print('c=',c)
fn3(a=1,b=2,c=3)
#解包
# * 用于对序列进行解包，序列的个数需要和形参的个数一致
def fn4(a,b,c):
	print('a=',a)
	print('b=',b)
	print('c=',c)
t = [1,2,3]
fn4(*t)
# **用于对字典进行解包，字典的key值需要和形参相对应
def fn5(a,b,c):
	print('a=',a)
	print('b=',b)
	print('c=',c)
d = {'a':1,'b':2,'c':3}
fn5(**d)

#help用于查看函数用法
help(print)
#文档字符串用于对函数用法进行说明
def fn6(a:str,b:bool,c:int=5):
	'''
		函数作用
		参数解释：
			a:类型，作用
			b:类型，作用
			c:类型，作用
	'''
	return a,b,c
help(fn6)

#作用域
'''
分为两种：
	全局作用域：
		程序运行时创建，程序结束时销毁
		不在函数内部创建的对象
		任意地方都可以使用
	函数作用域：
		函数调用时创建，调用结束时销毁
		函数内部创建的对象
		仅在当前函数内部可以使用
'''
a = 10
def fn7():
	a = 20
	print('函数内部，a=',a)
fn7()
print('函数外部，a=',a)
#变量在查找值时，会优先在自己所在的作用域内去查找，未找到就去上一级作用域去查找，以此类推
def fn8():
	a = 20
	def fn9():
		print(a)
	fn9()
fn8()
#想要在函数内部去修改外部的变量，此时需要用到global，此时函数内部的变量指向的就是函数外部的变量
a = 10
def fn10():
	global a
	a = 20
	print('函数内部，a=',a)
fn10()
print('函数外部，a=',a)

#命名空间其实就是一个字典，用来存储变量，每一个变量在命名空间中都有一个指定的位置
#全局命名空间用来保存全局变量，函数命名空间用来保存函数内部的变量
#利用locals()方法可以查看当前作用域内的命名空间
#利用globals()方法可以在函数内部查看全局的命名空间
#d = locals()
#print(d)
def fn11():
	a = 20
	#print(locals())
	#print(globals())
fn11()

'''
递归式函数的两个要件
	1.基线条件：
		问题可以被分解为的最小问题，当条件满足了，递归就不在进行了
	2.递归条件：
		将问题继续分解的条件
'''
def dg(n):
	#基线条件
	if n==1:
		return 1
	return n * dg(n-1)
print(dg(10))
#判断字符串是否回文
def reverse(str):
	arr = list(str)
	n = len(arr)
	i = -1
	def isRever(n,i):
		i += 1
		if i == n / 2 or i == (n + 1) / 2:
			return True
		if  arr[i] != arr[n-i]:
			return False
		return 	isRever(n,i)
	return isRever(n,i)	
str = 'abcba'
#reverse(str)

#高阶函数：函数接收一个函数为参数，或者返回值为一个函数
def fnt(fnc,lst):
	new_list = []
	for i in lst:
		if fnc:
			new_list.append(i)
	return new_list
lst = [1,2,3,4,5,6,7,8,9]

#匿名函数，lambda为标记，函数只执行一次
(lambda i: i + 1)(1)#自调用，一般不这样用

#过滤器filter,可以从序列中过滤出符合条件的情况，返回成一个新的序列
r = filter(lambda i: i % 2 == 0,lst)
print(list(r))

#map()函数可以对迭代对象中的所有元素做指定的操作，然后返回成一个新的对象
r = map(lambda i: i + 5,lst)
print(list(r))

#sort()方法对序列进行排序，可传入一个key让序列按照指定函数的要求来排列,原来的序列发生改变
l = ['nnnn','aa','bbbbbbb','ddddddddddd']
l.sort()
print(l)
l.sort(key=len)
print(l)
#sorted()函数和sort()方法用法相似，但是不会改变原来的序列，会生成一个新的序列
l = [1,2,'3','1']
l1 = sorted(l,key=int)
print(l1)

'''
闭包的三个要素条件：
	1、函数套函数，
	2、内部函数作为返回值返回，
	3、内部函数需要用到外部函数的变量
作用：用于保存一些私有的数据,仅内部函数用到，其他地方无法操作
'''
def getAverager():
	nums = []
	def averager(n):
		nums.append(n)
		return sum(nums)/len(nums)
	return averager
r = getAverager()
print(r(10))
print(r(20))

#装饰器,在不改变原函数的情况下扩展函数功能
def begin_end(old):
	def newFn(*a,**b):
		print('开始执行')
		r = old(*a,**b)
		print('执行结束')
		return r
	return newFn

@begin_end
def add(a,b):
	print(a + b)
add(1,2)
    
    #日期和时间============================================
    import time
    #获取当前时间戳
    ticks = time.time()
    print("当前时间戳为：",ticks)
    #将获取到的时间戳转化为元组形式展示
    localtime = time.localtime(time.time())
    #获取格式化后的时间
    localtime1 = time.asctime(time.localtime(time.time()))
    print("本地时间为:",localtime)
    print("本地时间为:",localtime1)
    #格式化日期  time.strftime(format,t) format为日期格式
    #格式化成2018-12-20 11:45:39形式
    print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
    #格式化成Sat Dec 28 22:24:24 2018形式
    print(time.strftime("%a %b %d %H:%M:%S %Y",time.localtime()))
    #将格式字符串转换为时间戳
    t1 = "2018-12-20 11:45:39"
    t2 = "Sat Dec 28 22:24:24 2018"
    print(time.mktime(time.strptime(t1,"%Y-%m-%d %H:%M:%S")))
    print(time.mktime(time.strptime(t2,"%a %b %d %H:%M:%S %Y")))
    
    #获取某月日历==========================================
    import calendar
    cal = calendar.month(2018,12)
    print("以下输出2016年1月份")
    print(cal)
    #判断是否为闰年,是返True
    print(calendar.isleap(2018))
    
    #函数(def标记)==============================================
    def printme(str):#括号中的为参数
    	"打印传入的字符串到标准显示设备上" #函数说明
    	print(str) #具体执行
    	return #结束
    #调用函数
    printme("我是一个打印函数哦")
    
    #所有参数在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
    def changeme(mylist):
    	"修改传入的列表"
    	mylist.append([1,2,3,4])
    	print("函数内取值：",mylist)
    	return
    
    mylist = [10,20,30]
    changeme(mylist)
    print("函数外取值：",mylist)
    
    #lambda匿名函数
    sum = lambda arg1, arg2: arg1 + arg2;
    print("Value of total：",sum(10,20))
    
    #模块======================================================
	'''
	引入模块的方法
	方法1：直接引入模块
		import 模块名
	方法2：给模块起别名
		import 模块名 as 别名
	方法3：仅引入需要的变量名
		from 模块名 import 变量1,变量2,变量3...
	方法4：给引入的变量名起别名
		from 模块名 import 变量 as 别名
	方法5：引入所有的变量
		from 模块名 import *
	'''
	
	import module1 as test
	#from module1 import *
	#每一个模块都有一个__name__属性，用于获取模块名。直接执行的模块为主模块，__name__属性值为__main__
	print(__name__)
	
	print(test.a)
	print(test.b)
	print(test._c)
	test.test()
	p = test.Person()
	print(p.name)
	
	'''
	print(a)
	print(b)
	#print(_c)#name '_c' is not defined
	test()
	p = Person()
	print(p.name)
	'''
	#对于模块特别复杂的，我们可以通过包的形式引入
	#包也是一个模块，普通模块是py文件，包是一个文件夹
	import package 
	from package import a , b
	print(package.m)
	print(package.n)
	print(a.name)
	print(b.name)
	
	#为了提高程序运行的性能，python会在编译过一次以后，在文件内生成一个__pycache__文件夹，里面为模块的缓存文件，下次再编译的时候直接调用
	
	引入内置模块：
	
	#python中有一个标准库，封装了一些常用的方法，我们可以直接去调用

	#pprint模块，用于美化打印的样式
	import pprint
	
	#sys模块。里面提供了一些变量和函数，让我们可以获取到python解析器的信息
	import sys
	
	#sys.argv
	#获取执行代码时，命令行中所包含的参数，以列表的形式展示
	print(sys.argv)
	
	#sys.modules
	#获取当前程序中引入放入所有模块,以字典的形式返回
	pprint.pprint(sys.modules)
	
	#sys.path
	#获取模块的搜索路径
	pprint.pprint(sys.path)
	
	#sys.platform
	#获取当前python运行的平台
	print(sys.platform)
	
	#sys.exit
	#推出程序
	#sys.exit('程序出现异常，退出')
	
	#os模块，让我们对操作系统进行访问
	import os
	
	#os.environ
	#获取到程序的环境变量
	pprint.pprint(os.environ)
	
	#os.system
	#用来执行操作系统的名字
	os.system('dir')
    
    #文件I/O===================================================
    #读取键盘输入
    str2 = input("请输入：");
    print("你输入的内容是：",str2);
    
    #读取文件
    import codecs
    fd = codecs.open('foo.txt') #打开文件 open函数
    '''
    a1 = fd.read() #读取文件
    print(dir(fd)) #查看fd可以进行哪些操作
    a2 = a1.replace('a','c') #替换文件中的某个元素
    print(a2)
    '''
    '''
    print(fd.readlines())#把文件每行内容作为一个字符串放在一个list中
    '''
    print(fd.readline())#读取一行文件
    
    fd.close() #关闭文件 close函数
    
    #写入文件
    '''
    fd = codecs.open('foo1.txt','w+')
    fd.write('aaa\nbbb\n')#写入一个字符串
    fd.close()
    '''
    
    fd = codecs.open('foo1.txt','w')
    fd.writelines(['123\n','234\n','345\n'])#写入一个列表
    fd.close()
    
    #打印文件行号和文件内容
    with codecs.open('foo.txt') as fd:
    	for line,value in enumerate(fd):
    		print(line,value)
    
    #获取文件固定行的内容
    import linecache
    print(linecache.getline('foo.txt',2))

	#文件地址
	#file_name = 'hello/hello.txt'
	#file_name = 'hello\hello.txt'
	#file_name = 'hello\\hello.txt'
	file_name = r'hello\hello.txt'
	
	#open打开文件
	#调用open来打开文件，可以将文件分为两种类型
	#t一种是纯文本文件，编码格式为utf-8
	#b一种是二进制文件，如图片、mp3、ppt等
	#open打开文件时，默认以文本文件的形式打开，默认的编码为None，所以打开指定编码的文件时，需要特别指定
	#使用open打开文件，需要指定所要做的操作，默认是只读'r'
	#'w'为写入，文件不存在创建文件，文件存在截断原文件，删除原文件的内容
	#'a'为追加，文件不存在创建文件，文件存在追加内容
	#'r+'读写操作，不会创建文件
	#file_txt = open(file_name)
	
	#read读取文件
	#读取到的文件默认会将文件中的所有内容返回，若文件过大则会造成内存溢出
	#read中有size属性，可以控制读取的数量，默认是-1
	#读取一行文件，readline
	#readlines一行一行读取文件，直到全部读取完成，以列表的形式返回
	#content = file_txt.read()
	#print(content)
	
	#close关闭文件
	#file_txt.close()
	
	#with...as语句,不用再手动关闭，语句会自动关闭文件
	with open(file_name) as file_txt:
		content = file_txt.read()
		print(content)
	
	#一行一行读取文件readlines
	with open(file_name) as file_txt:
		content = file_txt.readlines()
		for t in content:
			print(t,end='')
	
	#写入文件
	with open('hello1.txt','w',encoding='utf-8') as file_txt:
		file_txt.write('每个夜晚来临的时候\n')
		file_txt.write('孤独总在我左右\n')
	
	#追加文件
	with open('hello1.txt','a',encoding='utf-8') as file_txt:
		file_txt.write('每个黄昏心跳的等候\n')
		file_txt.write('是我无情的温柔\n')
	
	#异常处理
	file_name = 'hello.txt'
	try:
		with open(file_name,encoding='utf-8') as file_txt:
			content = file_txt.read()
			print(content)
	except FileNotFoundError:
		print(f"{file_name}文件不存在")
	
	#读取大文件，分批读取
	file_name = 'hello.txt'
	try:
		with open(file_name,encoding='utf-8') as file_txt:
			#每次读取字符数
			count = 6
			#存放读取内容
			content_txt = ''
			while True:
				content = file_txt.read(2)
				#读完跳出循环
				if not content:
					break
				content_txt += content
	except FileNotFoundError:
		print(f"{file_name}文件不存在")
	
	print(content_txt)
	
	#读取写入二进制文件
	file_name = 'C:/Users/Administrator/Desktop/aa.jpg'
	with open(file_name,'rb') as file_obj:
	
		with open('a.jpg','wb') as file_jpg:
			count = 1024 * 1000
			while True:
				content = file_obj.read(count)
				if not content:
					break
				file_jpg.write(content)
	
	#指定插入位置
	file_name = r'hello\hello.txt'
	#读取二进制文件,读取为本文件要注意每个汉字为3个字节
	with open(file_name,'rb') as file_obj:
		file_obj.read(10)
		#seek()指定当前读取的位置
		#有两个参数，第一个参数指代个数，第二个参数指起点（0：默认为0，从开始读取；1：从当前位置读取；2：从末尾读取）	
		file_obj.seek(20)#这儿指代的是字节
		file_obj.seek(20,1)
		#file_obj.seek(-1,2)
		print(file_obj.read(10))
		#tell()获取当前读取的个数
		print(file_obj.tell())
	
	#文件其他相关操作
	import os
	from pprint import pprint
	
	#获取指定目录的目录结构,以列表的形式返回
	r = os.listdir()
	#r = os.listdir('.')
	#r = os.listdir('..')
	pprint(r)
	
	#获取当前所在的目录
	r = os.getcwd()
	
	#切换当前所在的目录，相当于cd
	#os.chdir('../')
	r = os.getcwd()
	print(r)
	
	#创建目录
	#os.mkdir('aaa')
	
	#删除目录
	#os.rmdir('aaa')
	
	#删除文件
	#os.remove('hello1.txt')
	
	#重命名
	os.rename('hello.txt','aa.txt')        

    #异常处理=====================================================
    #通过try except来处理可能存在异常的情况
	try:#异常代码块
		print(10/0)
		print(a)
		1 + 'hello'
	except ZeroDivisionError:#针对每一种异常类单独做处理,出现异常时执行的代码块
		print('我是ZeroDivisionError异常')
	except NameError:
		print('我是NameError异常')
	except TypeError:
		print('我是TypeError异常')
	except Exception as e:#Exception是所有异常的父类，所有异常都会收集，e为异常的别名
		print('出错了呀',e,type(e))
	else:#没有出错时执行的代码块
		print('没有出错')
	finally:
		print('有没有异常都会执行')
	
	#try必须有，else可有可无，except和finally至少有一个
	
	#异常传播
	#由函数异常处向函数调用处传播，传播的是异常对象，所有的异常都会存储到一个异常对象中
	def fn1():
		print('我是fn1函数')
		try:
			print(10/0)
		except:
			print('出错了呀')
	def fn2():
		print('我是fn2函数')
		fn1()
	def fn3():
		print('我是fn3函数')
		fn2()
	fn3()
	
	#自主抛出异常
	#自定义异常类,必须要继承Exception
	class AddError(Exception):
		pass
	
	def add(a,b):
		if a < 0 or b < 0:
			#通过raise Exception来抛出异常
			#raise Exception('两个参数存在小于0的情况')
			#通姑自定义异常类抛出异常
			raise AddError('两个参数存在小于0的情况')
		else:
			r = a + b
			return r
	print(add(-1,2))
    
    #常见异常
    '''
    Exception 所有异常的基类 
    AttributeError 特征引用或者赋值失败时引发的 
    IOError 试图打开不存在的文件（包括其他情况） 
    IndexError 使用序列中不存在的索引 
    KeyError 使用映射中不存在的键 
    NameError 找不到名字（变量） 
    SyntaxError 在代码为错误形式时引发 
    SystemExit 系统异常退出 
    TypeError 在内建操作或者函数应用与错误类型的对象时 
    ValueError 正确的类型对象，但是对象使用不合适的值 
    ZeroDivisionError 除法，第二参数为0
    
    '''