python基础学习笔记

  本文是我在学习Python过程当中的心得和学习笔记，包含了Python的入门知识，控制结构，列表，字典，元组，集合，字符串，函数等等Python基础内容，并附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。本篇是Python基础知识，另外一篇是关于 Python的具体应用。

1、Python入门知识

1.1 print函数

#输出数字
print(520)
print(38.5)
#输出字符串
print("HelloWorld")
print('HelloWorld')
#输出运算符表达式
print(3+1)
#输出到文件中，1.指定盘符存在，2.使用file = fp
#a+表示若文件不存在则创建，若存在则在原有基础上追加
fp = open('C:/text.txt','a+')
print('helloworld',file = fp)
fp.close()
#不换行输出
print('hello','world','python')

1.2 转义字符

#转义字符
    print('hello\nworld')   #\  +转义功能的首字母，例如n-->newline的首字母表示换行
    print('hello\tworld')   #\t表示一个制表位，tab占四个字节
    print('helloooo\tworld')
    print('hello\rworld')   #world将hello进行了覆盖
    print('hello\bworld')   #\b是退一个格，将o退没了

    print('http:\\\\www.baidu.com')
    print('老师说:\'大家好\'')   #将单引号输出需要加\

    #原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r,或R
    print(r'hello\nworld')
    #注意事项，最后一个字符不能是反斜杠,以下代码会报错
    #print(r'hello\nworld\')

1.3 变量定义规则

1.字母，数字，下划线_
2.区分大小写
3.不能以数字开头，不能是保留字
变量有三种属性：标识，类型，值

name = '玛利亚'
print(name)
print('标识',id(name))		#类似于C当中的内存地址
print('类型',type(name))
print('值',name)
a=3.1415926
print(a,type(a))

1.4 数据类型

整数类型 int，其中，十进制为默认进制，二进制以0b开头，八进制以0o开头，十六进制以0x开头
浮点数类型 float

n1=1.1
n2=2.2
n3=2.1
print(n1+n2)         #计算机采用二进制存储，存在精度问题
print(n1+n3)        #有时能够正常输出，有时不能

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))        #正常输出

布尔类型 bool

print(f1,type(f1))
print(f2,type(f2))

#布尔值可以转成整数运算
print(f1+1)     #2
print(f2+1)     #1

字符串类型 str

str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = '''人生苦短，     
我用Python'''         #可以换行赋值
str4 = """人生苦短，    
我用python"""          #可以换行赋值
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

1.5 数据类型转换

str(), int(), float()
任何数据都可以通过str()函数转换为str类型

s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(int(s1),type(int(s1)))    #将str转成int类型，字符串为数字串
print(int(f1),type(int(f1)))    #将float转成int类型，只截取整数部分，舍掉小数部分
#print(int(s2),type(int(s2)))    #将str转成int类型，报错，因为字符串为小数串
print(int(ff),type(int(ff)))    #将str转成int类型，字符串为数字串
#print(int(s3),type(int(s3)))    #将str转成int类型，字符串必须为整数数字串
print(int(s1),type(int(s1)))    #将str转成int类型，字符串为数字串

1.6 各类运算符

算术运算符：
加减乘除：+ - * /
整除运算：//
取余运算：%
次幂运算：m**n, 表示m的n次幂

print(11//2)    #整除运算
print(2**3)     #2*2*2=8

print(9//4)     #2
print(-9//-4)   #2

#一正一负整除向下取整
print(-9//4)    #-3
print(9//-4)    #-3

#一正一负要用公式，公式：余数 = 被除数-除数*商
print(-9%4)    #3      -9-4*(-3)=3
print(9%-4)    #-3      9-(-4)*(-3)=-3

赋值运算符 ‘=’：

#链式赋值
a=b=c=20
#参数赋值，+=，-=，/=，*=，%=，//=
#解包式赋值
a,b,c=10,20,30

#数值交换
a,b = 10,20
print('交换之前：',a,b)
a,b = b,a
print('交换之后：',a,b)

比较运算符有：>, <, >=, <=, ==, !=

a = 10
b = 10
#==, !=是对象值得比较
#is, is not是对象id的比较，即标识的比较

print(a==b)         #True   说明，a与b的value相等
print(a is b)       #True   说明，a与b的标识相等， 标识相当于c中的内存地址

布尔运算符：
and: 与运算
or: 或运算
not: 非运算
in 和 not in

#   in 和 not in
s = 'helloworld'
print('w' in s)     #True
print('k' in s)     #False
print('w' not in s) #False
print('k' not in s) #True

 一般对象的布尔值

#测试对象的布尔值
print("---------以下对象的布尔值为False,其余的均为True--------")
print(bool(False))  #False
print(bool(0))      #False
print(bool(0.0))    #False
print(bool(None))   #False
print(bool(''))     #False
print(bool(""))     #False
print(bool([]))     #空列表
print(bool(list())) #空列表
print(bool(()))     #空元组
print(bool(tuple()))    #空元组
print(bool({}))     #空字典
print(bool(dict())) #空字典
print(bool(set()))  #空集合

位运算符
位与&：转换成二进制，按位与
位或 |：转换成二进制，按位或
右移位运算符>>： 低位溢出舍弃，高位补0
左移位运算符<<：高位溢出舍弃，低位补0
Python运算符的优先级如下图所示，一般我们如果理不清运算符的优先级可以加上括号，括号内部优先运算。

1.7 input()函数

  双引号内部为输入提示内容，input()函数输入为字符串，然后赋值给输出，返回输出值。这里注意input()函数的返回值为字符串类型。

#input()函数
present = input("大圣想要什么礼物呢？")	
print(present,type(present))

#从键盘录入两个整数，计算两个整数的和
a = int(input('请输入一个加数：'))
b = int(input('请输入另一个加数：'))
print(type(a),type(b))
print(a+b)

1.8 注释书写规范

#单行注释
"""嘿嘿，
我是
多行
注释"""

 中文编码声明注释，在Python文件的开头加上中文声明注释，指定源码文件的编码格式

#coding:gbk   

1.9 开头文件注释和函数标准注释

  文件开头注释，Pythoncharm中file->settings->editor->code style->file and code templates->python script中输入以下代码：

# @Author: 小黄
# @Time: ${DATE} ${TIME}
# @Code Name: 
# @Code Function:

函数标准注释：

"""
				FunctionName:			函数名
				Purpose:				函数目的
				Parameter:				函数参数
				Return:					函数返回值    	
"""

2、控制结构

2.1 if-else型控制结构

 这里注意Python不等式书写方式和C语言略有不同，Python也支持C语言的写法。

score = int(input('请输入一个成绩：'))
if 90<=score<=100:	%C语言当中，应写为:score>=90&&score<=100
    print('A级')
elif 80<=score<90:
    print('B级')
elif 70<=score<80:
    print('C级')
elif 60<=score<70:
    print('D级')
elif 0<=score<60:
    print('E级')
else:
    print('请输入一个0-100之间的数')

  Python当中if-else语句的另一种用法，在print函数当中，若表达式为真，则输出前面语句的值，否则输出后面的语句。

num_a = int(input('请输入第一个整数'))
num_b = int(input('请输入第二个整数'))
print(str(num_a)+'大于等于'+str(num_b)  if num_a>=num_b else str(num_a)+'小于'+str(num_b))

2.2 pass语句

  pass语句什么都不做，只是一个占位符。一般我们在还没想好代码怎么写的时候、仅仅搭建语法结构的时候使用。如以下代码，可以运行，但不会报错。

answer = input('您是会员吗y/n')
if answer == 'y':
    pass
else:
    pass

2.3 range函数

  range()函数的返回值是一个迭代器对象，产生的是一定范围的整数型序列。
  range类型的优点:不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的,因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素。注意range[start,stop)是产生从start开始，到stop结束的整数序列，但不包括stop。
  可以使用in与not in 判断整数序列中是否存在（不存在)指定的整数

#解包式赋值
start,stop,step= 1,10,2

r = range(stop)   #默认起始值为0，步长为1，给定结束值为stop
print(r)
print(list(r))

r = range(start,stop) #给定起始值为start，步长默认为1，给定结束值为stop
print(list(r))

r = range(start,stop,step) #给定起始值为start，给定步长为step，给定结束值stop
print(list(r))

2.4 while函数

  这里要注意，print函数要顶格写，否则就包含在while循环当中。再说说C和python的区别，C使用{}来表示语句的包含关系，而Python用缩进来表示{}。
  另外，在C语言当中有a++，因为在 C 语言中，值的存储以变量名来区分，一个变量具有单独的地址空间；但是在Python当中，只要值是相同的，不管你的变量名是什么，它们的地址都是相同的，也就是说， Python 允许一个值被多个变量名称绑定。
  在脚本式编程环境中是这样，但是在交互式编程环境下，Python 为了优化速度，使用了小整数对象池， 避免为整数频繁申请和销毁内存空间，编译器会有一个小整数池的概念，小整数的定义是 [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收，也就是说，变量在这个范围内是会按照前面所说的，共用内存地址，超过这个值则使用单独的内存地址。

sum = 0
a = 0
while a<100:
    sum = sum+a
    a+=1
print('和为',sum)

2.5 for-in遍历结构

for item in 'python':   #依次取出字符串中的单个字符赋值给item,第一次取出的是p,以此类推
    print(item)
#range()产生整数序列
for i in range(10):   #依次将range(10)当中的数赋值给i
    print(i)
#如果循环体内不需要用到自定义变量，那么用‘_’代替，如下所示
for _ in range(3):
    print('人生无常，大肠包小肠')

2.6 break和continue语句

执行break语句后，程序就会退出循环。注意如有多层循环，则break仅是退出最内层的循环，然后进入外一层的循环。

#输入密码，共有三次机会
for num in range(3):
    password = input('请输入密码：')
    if password == '8888':
        print('密码正确')
        break
    else:
        print('密码错误')

执行continue语句后，程序就会跳出当次循环，直接进行下一次循环。

#输出5的倍数
for i in range(1,51):
    if i%5 != 0:
        continue
    print(i)

2.7 else和while for-in联合使用

  这里的第二个else视为循环语句的一部分，在循环结束后自动运行，而当程序从break语句退出循环后，第二个else后面的内容也就不再运行了。

for i in range(3):
    password = input('请输入密码：')
    if password == '8888':
        print('密码正确')
        break
    else:
        print('密码错误，您还有'+str(2-i)+'次机会尝试。')
else:
    print('对不起，三次密码均错误，请在3分钟后继续尝试。')

这里的while-else语句的原理和for-in-else一样。

a = 0
while a<3:
    password = input('请输入密码：')
    if password == '8888':
        print('密码正确')
        break
    else:
        print('密码错误，您还有'+str(2-a)+'次机会尝试。')
    a+=1
else:
    print('对不起，三次密码均错误，请在3分钟后继续尝试。')

2.8 多层嵌套循环

  这里的end='\t’表示以\t结尾，即输出一个制表位

#输出乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(str(j)+'*'+str(i)+'='+str(i*j),end='\t')
    print()	#输出一个换行符

3、列表

3.1列表

  列表类似于C语言当中的数组，只是Python的列表当中，列表的元素可以是整型、浮点型、布尔型、字符串型。同样的，列表对象也具有三个属性：标识，类型，值，这个和变量类似。

lst = [98,'人生苦短，我学Python',True,3.14]  #定义列表第一种方式
lst2 = list([98,'人生苦短，我学Python',True,3.14])  #定义列表第一种方式
print(type(lst))        
print(lst[0],lst[-1])   #索引可以从0开始，也可以从-1开始

3.2列表的索引

  正向索引，从0开始，到n-1；逆向索引，从-1开始，到-n结束。

lst = ['hello','人生苦短，我学Python',True,'hello']  #定义列表第一种方式
print(lst.index('hello'))   #打印hello元素的索引，如果有多个相同元素，则输出第一个索引
print(lst.index('hello',1,4))   #加上查找的区域，从索引1找到索引3，不包括4
print(lst.index('hello',1,5))   #加上查找的区域，从索引1找到索引4，列表最大索引只有3，但是不会报错
#print(lst.index('hello',1,3)) #如果找不到该元素就会报错，ValueError: 'hello' is not in list

  这里注意切片区间是在[start, stop)内，即包括start在内，但不包括stop在内的区间，若stop为空，则切片区间包含最后一个元素。

lst = [10,20,30,40,50,60,70,80]
#print(lst[start:stop:step])
print(lst[1:6:])    #切片默认步长为1
print(lst[1:6])     #切片默认步长为1
print(lst[1:6:1])
print(lst[:6:2])    #切片的第一个元素默认从索引0开始，不包括索引为6的元素
print(lst[1::2])    #切片的最后一个元素默认以索引N-1结束
#step为负数情况
print(lst[::-1])    #step = -1， 列表逆转
print(lst[7::-1])   #start = 7， step = -1， 列表逆转
print(lst[6:0:-2])  #不包括索引为0的元素
#列表的遍历
for item in lst:
    print(item);

3.3列表添加、删除元素

  python使用append、extend、insert、切片式添加列表元素

lst1 = [10 ,20 ,30]
lst1.append(100)        #在列表末尾添加这个元素
print(lst1)
lst2 = ['hello','world']
lst1.append(lst2)       #把lst2当做一个元素添加近lst1中
print(lst1)
lst1.extend(lst2)       #在列表末尾添加至少一个元素(可以多个)
print(lst1)
lst1.insert(1,90)        #在列表索引为1的位置添加元素90，之前的元素按顺序后移
print(lst1)
lst3 = [True, False, 'hello']
#在任意位置添加N多个元素，切片式添加
lst1[1:] = lst3
print(lst1)

删除元素

lst = [10,20,30,40,50,60,70,80,90]
lst.remove(30)  #从列表中移除一个元素，如果有重复元素则移除第一个元素
print(lst)
#lst.remove(100) #若列表中不存在该元素，则抛出异常list.remove(x): x not in list

lst.pop(1)      #删除索引为1的元素
print(lst)
lst.pop()       #不给参数，就删除列表的最后一个元素
print(lst)

#切片操作，至少删除一个元素，产生一个新的列表对象
new_lst = lst[1:3]  #将原列表的索引1-3赋值给新列表
print('new_lst=',new_lst)
#不产生新列表
lst[1:3] = []
print(lst)
lst.clear()
print(lst)

del lst

修改元素

lst = [10,20,30,40,50]
lst[2] = 100    #修改列表单个元素
print(lst)
#修改列表多个元素，此处修改索引1和索引2，不包括索引3
#剩下的元素直接添加在后面，其余元素后移
lst[1:3] = [100,200,300,400,500]
print(lst)

3.4列表排序

使用sort()进行排序：

lst = [20,40, 10, 98, 54]
print('排序前的列表',lst,'id=',id(lst))
lst.sort()
print('排序后的列表',lst,'id=',id(lst))
#对比二者id,可以看出sort()是在原列表上做修改，没有产生心的列表
#指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  #reverse=True表示降序，reverse=False表示升序
print(lst)
lst.sort(reverse=False)
print(lst)

使用内置函数sorted()进行排序：

#使用内置函数进行排序，会产生一个新的列表变量
lst = [20,40, 10, 98, 54]
print('原列表',lst)
new_lst = sorted(lst)#默认是升序
print(lst)
print(new_lst)
descend_list = sorted(lst,reverse=True)
print(descend_list)

3.5列表生成式

lst = [i for i in range(1,10)]
print(lst)

4、 字典

  字典是顺序不可变的序列，无需考虑元素顺序，用{ }表示，同时字典当中的元素是key-value成对存在。
  相比之下，列表是可变序列，列表需要考虑元素顺序，用[ ]表示，元素用index和element表示。

d = {'name':'张三','name':'李四'}
print(d)    #key值不允许重复,这里虽然定义了两个字典元素，但key值重复了，因此最终只输出一个

lst = [10,20,30]
lst.insert(1,100)
print(lst)
d = {lst:100}
print(d)    #key值必须是不可改变的，这里会报错unhashable type: 'list'

4.1 字典的创建

字典的实现原理：
  字典的实现原理与查字典类似，Python中的字典是根据key查找value所在的位置。

"""使用{}创建字典"""
scores = {'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

"""第二种创建dict()"""
student = dict(name='jack',age=20)
print(student)

"""空字典"""
d = {}
print(d)

4.2 字典元素的获取

  这里需要注意的是字典的key用[ ]，列表的索引用（ ），例如scores[‘张三’]，lst(1)

scores = {'张三':100,'李四':98,'王五':45}
"""第一种方式，使用[]"""
print(scores['张三'])
#print(scores['陈六']) #KeyError: '陈六'

"""第二种方式，使用get()方法"""
print(scores.get('张三'))
print(scores.get('陈六'))     #None
print(scores.get('麻七',99))  #99是在查找‘麻七’所对value不存在是的默认值

4.3 字典元素的增、删、改

scores = {'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']    #删除指定的key-value对
#scores.clear()      #清空字典的元素
print(scores)
scores['陈六']=98     #新增元素
print(scores)

scores['陈六']=100     #新增元素
print(scores)

4.4获取字典的视图

scores = {'张三':100,'李四':98,'王五':45}
#获取所有的key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))    #将所有的key组成的视图转换为列表

#获取所有的value
values = scores.values()
print(values)
print(type(values))
print(list(values)) #将所有的values组成的视图转换为列表

#获取所有的key-value对
items = scores.items()
print(items)
print(list(items)) #转换之后的列表元素是由元组（‘key’:value）组成
#字典的遍历
for item in scores:
    print(item,scores[item],scores.get(item))	
    #scores[item],scores.get(item)的作用是一样的
    #唯一的区别是，若找不到该元素，是否抛出异常，get（）不会抛出异常，返回None

4.5 字典生成式

#字典生成式
items = ['Fruits','Books','Others']
prices = [98,78,85,100,120]

d = {item.upper() : price for item , price in zip(items,prices) }
#将items和prices列表内的元素依次赋值给item和price
#然后打包成item:price类型，存入字典当中
#这里upper()是将item内的字母全部换成大写
print(d)

5、 元组

  我们可以通过对比对象增、删、改操作前后的id,确定是否可变，若一样，则为可变对象，不一样，则为不可变对象。

"""可变序列：列表，字典"""
lst = [10,26,45]
print(id(lst))
lst.append(300)
print(id(lst))
#这里前后输出的lst的id是不变的，说明改变前后是同一个列表，说明列表是可变的
"""不可变序列：字符串，元组"""
s = 'hello'
print(id(s))
s = s+'world'
print(id(s))
print(S)

5.1 元组的创建方式

'''第一种创建方式，使用()'''
t = ('python','world',98)
print(t)
print(type(t))

t1 = 'python','world',98    #省略了小括号
print(t1)
print(type(t1))

t2 = ('python',)    #元组仅有一个元素时要加,
print(t2)
print(type(t2))

'''第二种创建方式，使用内置函数tuple()'''
t3 = tuple( ('python','world',98) )
print(t3)
print(type(t3))

'''空列表、空字典、空元组的创建方式'''
lst = []
lst1 = list()

d = {}
d2 = dict()

t4 = ()
t5 = tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

5.2 元组为不可变序列的原因

t = (10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1] = 100     #这里直接报错
'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
t[1].append(100)    #向列表中添加元素
print(t,id(t[1]))   #可以看出t[1]的id地址没有变

5.3 元组的遍历

t = ('python','world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #tuple index out of range
'''遍历元组'''
for item in t:
    print(item)

6、集合

6.1 集合的创建

"""第一种创建方式使用{}"""
s = {2,3,4,5,5,6,7} #集合中的元素不允许重复
print(s)        #可以看到虽然集合定义中有两个5，但实际上只存在一个

"""第二种创建方式使用内置函数set()"""
s1 = set(range(6))  #使用range()产生[0,6)之间的整数序列，再通过set()将序列转成集合
print(s1,type(s1))

s2 = set([1,2,4,5,5,5,6,6]) #将[]构成的序列转成集合
print(s2,type(s2))

s3 = set((1,2,4,4,5,65))    #将元组中的元素转成集合
print(s3,type(s3))  #集合中的元素是无序的

s4 = set('python')
print(s4,type(s4))  #这里多运行几次，每次结果都不同，很容易看出集合元素是无序的

s5 = set({1,2,4,4,5,65})    #{}集合类型使用set()后还是集合类型
print(s5,type(s5))
#定义一个空集合
s6 ={}  #行不通，这样定义出来是dict字典类型
print(type(s6))

s7 = set()  #这个才是空集合的定义方法
print(type(s7))

6.2 集合的判断及增、删

s = {10,20,30}
"""集合元素的判断操作"""
print(10 in s)  #True
print(100 in s) #False
print(10 not in s)  #False
print(100 not in s) #True
"""集合元素的新增操作"""
s.add(1)   #add一次添加一个元素
s.update({2,3})  #updata一次至少添加一个元素
s.update([4,5])
s.update((6,7))
print(s)

"""集合元素的删除操作"""
s.remove(1) #移除1
#s.remove(100)   #不存在key值为100的元素，抛异常，KeyError: 100
print(s)
s.discard(2)    #删除元素2
s.discard(100)  #不存在的元素，不抛异常
print(s)
s.pop()
#s.pop(5)#pop()函数没有参数，TypeError: set.pop() takes no arguments (1 given)
print(s)    #随机删除一个元素，不过这个随机也不是那么随机，应该是伪随机删除
s.clear()   #清空集合当中的所有元素
print(s)    #输出为set()，因此可以看出，set()就是空集合

6.3 集合之间的关系

"""两个集合是否相等(元素相同，就相等)"""
s = {10,20,30,40}
s2 = {30,40,20,10}
print(s==s2)    #True
print(s!=s2)    #False
"""一个集合是否是另外一个集合的子集"""
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1))    #True
print(s3.issubset(s1))    #False
"""一个集合是否是另外一个集合的超集(母集)"""
print(s1.issuperset(s2))    #True
print(s1.issuperset(s3))    #False
"""两个集合是否含有交集"""
print(s2.isdisjoint(s3))    #False  有交集为FALSE
s4 = {100,200,300}
print(s2.isdisjoint(s4))    #True   没有交集为TRUE

6.4 集合的数学操作

#1、交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print('s1和s2的交集：',s1.intersection(s2))
print('s1和s2的交集：',s1 & s2)  #与intersection()与 & 等价，交集操作
print(s1)
print(s2)   #求交集操作不会影响原来的集合，以下的集合操作同样如此
#2、并集操作
print('s1和s2的并集：',s1.union(s2))
print('s1和s2的并集：',s1 | s2)  #union与 | 等价，并集操作
#3、差集操作
print('s1和s2的差集：',s1.difference(s2))
print('s1和s2的差集：',s1 - s2)
#4、对称差集操作
print('s1和s2的对称差集：',s1.symmetric_difference(s2))
print('s1和s2的对称差集：',s1 ^ s2)

6.5 集合生成式

  集合生成式与列表生成式类似，将[ ]改为{ }即为集合生成式，如下：

s = {i for i in range(1,10)}
print(s,type(s))

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

7、字符串

7.1 字符串的驻留机制

a = 'python'
b = "python"
c = '''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
#从输出结果可以看出，虽然创建了三个字符创， 但其ID都是一样的，这就是Python的驻留机制。

  这里的交互模式就是在cmd当中输入Python进行操作。

  运行以下代码，可以看出，创建a后在创建b，python使用了驻留机制，即a b的ID相同。而后面再用join( )创建c，可以看出c的ID与a b不同。驻留机制是在编译器编译是起效，join( )函数是在代码运行时起效，因此在创建c时驻留机制不起效。

a = 'abc'
b = "ab"+'c'
c = ''''''.join(['ab','c'])
print(a is b)
print(a is c)
print(a,id(a),type(a))
print(b,id(b),type(b))
print(c,id(c),type(c))

7.2 字符串的查找

s = 'hello,hello'
#字符创对应索引
#           h  e  l  l  o  ,  h  e l  l  o
#正向索引    0   1  2  3  4  5  6  7  8  9 10
#逆向索引   -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
print(s.index('lo'))    #3，子串第一次出现的索引
print(s.find('lo'))     #3
print(s.rindex('lo'))   #9，子串最后一次出现的索引
print(s.rfind('lo'))    #9

#print(s.index('k'))     #3，找不到就报错，ValueError: substring not found
print(s.find('k'))      #-1，找不到不报错，返回-1
#print(s.rindex('k'))    #3，找不到就报错，ValueError: substring not found
print(s.rfind('k'))     #-1

7.3 字符串的各种操作

7.3.1 字符串对齐

对齐操作和填充操作

s = 'hello,python'  #原字符串长度为12
"""居中对齐"""
print(s.center(20,'*')) #字符串长度设置为20，居中对齐，然后以*进行填充
"""左对齐"""
print(s.ljust(20,'*'))  #左对齐
print(s.ljust(10))      #设置宽度小于原字符，返回原字符
print(s.ljust(20))      #默认以空格进行填充
"""右对齐"""
print(s.rjust(20,'*'))  #右对齐
print(s.rjust(20))      #默认以空格进行填充
print(s.rjust(10))      #设置宽度小于原字符，返回原字符
"""右对齐，使用0进行填充"""
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8)) 

7.3.2 字符串比较和切片操作

  这里的ordinal value指的就是ASCII码。

print('apple'>'app')    #True，字符依次比较，到第四个时是'l'>'',因此结果为True
print('apple'>'banana') #False，相当于比较第一个字符'a'和'b'，相当于97>98，结果为False
#字符对应ASCII值
print(ord('a'),ord('b'))
print(ord('黄'))
#根据ASCII值得到字符
print(chr(97),chr(98))
print(chr(40644))
"""==与is的区别
    ==比较的是value
    is比较的是ID
"""
a = b = 'python'
c = 'python'
print(a==b,b==c) #True，值相等
print(a is b,a is c)#True，内存地址相等
print(id(a),id(b),id(c))

字符串的切片操作

'''字符串的切片操作'''
s = 'hello,python'
# [start:end:step]
s1 = s[:5]  #从0开始，5结束，不包含5，默认步长为1
s2 = s[6:]  #从6开始，直至字符串末尾，默认步长为1
s3 = '!'
newstr = s1 + s2 + s3
print(s1)
print(s2)
print(s3)
print(newstr)
s4 = s[ : : -1] #字符串倒序
print(s4)

7.3.3 字符串的格式化输出

'''字符串格式化输出（占位符的使用）'''
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name,age))
print('我叫{0},今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁') #f-string方法
'''数字输出精度和字符串宽度'''
print('%10d' % 99)  #10表示的是宽度,不足的部分用空格替代
print('%.3f' % 3.1415926)  #.3表示取三位小数，四舍五入制
print('%10.3f' % 3.1415926)  #两者混合使用
print('hellohello') #一共十个字符，作为上述输出的对比
#与保留三位小数.3f不同，这里使用的是.3表示一共有效数字为3位（包含整数和小数）
print('{0:.3}'.format(3.1415926))
#宽度为10，小数保留三位
print('{0:10.3f}'.format(3.1415926))

7.4 字符串的各种函数

7.4.1 大小写转换函数

s = 'hello,python'
a = s.upper()   #转换成大写之后，会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b = s.lower()   #转换成小写之后，同样会产生一个新的字符创对象
print(b,id(b))
print(s,id(s))
print( b == s ) #True,比较的是value
print(b is s)   #False,比较的是ID
s2 = 'hello,Python'
print(s2.swapcase())
print(s2.title())

7.4.2 分割函数split( )

s = 'hello world python'
lst = s.split() #默认以空格进行分割
print(lst)
s1 = 'hello|world|python'
print(s1.split(sep = '|'))  #以|进行分割
print(s1.split(sep = '|',maxsplit=1))   #以|进行分割，只分割一次
"""rsplit()从右侧开始分割"""
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit('|',1))

7.4.3 判断函数 isidentifier( )

  这些Python的内置函数主要用在开发时，判断用户输入的字符串是否合法。

s = 'hello,python'
#标识符由字母、下划线和数字组成，但第一个字符不能是数字
print('1',s.isidentifier()) #False
print('2','hello'.isidentifier()) #True
print('3','张三_'.isidentifier()) #True，说明Python可以将汉字作为合法的标志符
print('4','张三_123'.isidentifier()) #True

print('5','\t'.isspace()) #True

print('6','abc'.isalpha()) #True
print('7','张三'.isalpha()) #True,Python将汉字看作字母
print('8','张三1'.isalpha()) #False

print('9','123'.isdecimal()) #True
print('10','123四'.isdecimal()) #False,四不是十进制数
print('11','Ⅱ'.isdecimal()) #False，罗马数字不是十进制数

print('12','123'.isnumeric()) #True
print('13','123四'.isnumeric()) #True，Python将‘四’看作数字
print('14','Ⅱ'.isnumeric()) #True，罗马数字是数字
#alnum = alpha + num
print('15','abc1'.isalnum()) #True
print('16','张三123'.isalnum()) #True
print('17','abc!'.isalnum()) #False

7.4.4 替换和合并 / replace( )和joint( )

替换与合并

s = 'hello,python'
print(s.replace('python','jave'))   #用jave去替换Python
s1 = 'hello,python,python,python'
print(s1.replace('python','jave',2))    #替换两次
#使用join()函数，将列表转化为字符串
lst = ['hello','jave','python']
print('|'.join(lst))    #用|隔开
print(''.join(lst))     #不隔开
#元组转化为字符串
t = ('hello','jave','python')
print(''.join(t))
print('*'.join('python'))   #'python'字符串用*隔开

7.5字符串的编码与解码

'''字符串编码与解码'''
s = '天涯共此时'
print(s.encode(encoding='GBK')) #在GBK这种编码格式当中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) #在GBK这种编码格式当中，一个中文占三个字节
byte = s.encode(encoding='GBK') #GBK格式编码
#byte代表一个二进制数据
print(byte.decode(encoding='GBK')) #GBK格式解码

8、函数

函数的定义

8.1 函数的参数调用

参数赋值

'''函数的参数调用'''
def calc(a,b):      #这里a和b称为形参
    c = a+b
    return c
#10和20称为实参,按位置参数赋值，即形参分别赋值为a = 10, b = 20
result = calc(10,20)
print(result)
#按关键字赋值，赋值前后顺序任意，一般用在参数过多的情况下，顺序赋值太复杂
#即形参分别赋值为a = 20，b=10
res =  calc(b=10,a=20)
print(res)

默认参数
这里将形参b的默认值设置为10
若函数调用时没有给定b对应的实参，那么b就为默认值；反之，则b的值为给定的实参

def fun(a,b=10):
    print(a,b)
fun(100)
fun(20,30)

未定参数：在不知道具体会输入多少参数时使用

def fun(*args): #函数定义时，个数可变的位置参数
    print(args)     #输出是元组
    print(args[0])
fun(10)
fun(20,30)

def fun(**args): #函数定义时，个数可变的关键字形参
    print(args)     #输出是字典
fun(a=10)
fun(a=20,b=30)

'''在一个函数定义当中，既有个数可变的位置参数，又有个数可变的关键字形参
那么，可变的位置参数定义必须放在可变的关键字形参之前，否则程序都会报错
另外，不允许定义两个或两个以上的连续可变的位置参数或者连续变的关键字形参，程序均会报错
'''
def fun2(*arg1,**arg2):
    pass

8.2 函数的返回值

'''函数的返回值
1、如果函数没有返回值，则return可以不写或者写个return然后没有返回参数
2、函数返回值仅有一个，直接返回该函数return的类型
3、函数返回值如果为多个， 则返回结果为元组
'''
def fun1():
    print('hello')
    return  #可省略
fun1()

def fun2():
    return  'hello' #return单参数
res = fun2()
print(res)

def fun3():
    return 'hello','world'  #return多参数
print(fun3())   #输出值为元组类型

8.3 实参对象进入函数后的变化

'''可变对象和不可变对象进入函数后的变化'''
def fun(arg1,arg2):
    print('arg1',arg1)
    print('arg2', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1', arg1)
    print('arg2', arg2)
    return  #此函数没有返回值也可以不写return
n1 = 11
n2 = [22,33,44]
#进入函数前的值
print('n1', n1)
print('n2', n2)
fun(n1,n2)  #这里表明形参和实参名字可以不一样
#进入函数后的值
print('n1', n1)
print('n2', n2)
'''在函数调用过程当中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，那么则会影响实参的值
本例当中n1和n2分别是可变对象和不可变对象
对arg1的值修改为100，不会影响n1的值
对arg2的值修改，append(10)，会影响到n2的值
'''

全局变量与局部变量

def fun():
    '''
    函数内部定义的变量如name为局部变量，
    若用global声明,则变为全局变量，
    全局变量在函数外部也可以使用
    '''
    global age
    name = '小黄'
    age = 23
fun()
#print('name=',name) #报错，'name' is not defined
print('age=',age)

8.4 函数的传参

def fun1(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
fun1(10,20,30)   #位置传参
lst = [1,2,3]
fun1(*lst) #在函数调用时，将列表中的每个元素转化为位置实参传入
fun1(a=100,b=200,c=300) #关键字传参
dic = {'a':11, 'b':22, 'c':33}
fun1(**dic) #在函数调用时，将字典中的每个元素转化为位置实参传入
fun1(-1,-2,c=-3)    #位置和关键字传参混合
'''需求：cd只能采用关键字实参传递'''
def fun2(a,b,*,c,d):
    #从*之后的参数，在函数调用时，只能采用关键字实参传递
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
'''函数定义时的形参的顺序问题'''
def fun3(a,b,*,c,d,**args):
    pass
def fun4(*args1, **args2):
    pass
def fun5(a,b = 10,*args1, **args2):
    pass

8.5 异常捕获

try-excep-else-finally结构
  这个结构主要用在可能出现异常的语句当中。若有多个except结构，捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException，当实际出现的异常不在列出的异常当中是，执行BaseException后面的语句。
  若try语句出错，执行except中的语句；try语句没有出错，则执行else中的语句。无论try语句是否出错，finally中的语句必定执行，常用来释放try块中申请的资源。

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入第二个整数'))
    result = a/b
except ZeroDivisionError:
    print('对不起，除数不允许为0')
except ValueError:
    print('对不起，不能将字符串转换为数字')
except BaseException as e:
    print(e)
else:
    print('结果为:', result)
finally:
    print('谢谢您的使用！')

常见异常

traceback 打印输出异常：

import traceback    #导入包
try:
        print('-------------------')
        #这个横线有时候在上有时候在下，多运行几次就能发现。
        print(1/0)
except:
    traceback.print_exc()

9、面向对象编程

  Python当中一切皆为对象，Python是面向对象的编程语言。
  类一般指数据类型，不同的数据类型属于不同的类，例如int类，float类等等。对象一般指类具体化之后的事物，例如100,99，520都是int类之下包含的相似的不同个例，这些个例专业术语成为实例或者对象。
  类的组成：类属性、实例方法、静态方法、类方法。
  类属性：类中方法以外的变量成为类属性，被该类所有对象所共享。
  实例方法：在类当中定义的普通函数，在类外面定义的称为函数，在类内部定义的称为类的方法。
  类方法：使用@classmethod修饰的方法， 使用类名直接访问的方法。
  静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法。

9.1类的定义和调用

#类名由一个或多个单词组成，每个单词的首字母大写，其余字母小写
class Student:  #Student为类的名称
    native_place = '福建' #直接写在类里面的变量，称为类的属性
    def __init__(self,name,age):    #这是一个实例方法，初始化函数，默认输入的值到这个函数进行操作
        self.name = name    #self.name 称为实体属性，进行了一个赋值操作，将局部变量的name的值赋值给实体属性
        self.age = age
    #实例方法
    def eat(self):  #默认里面加self
        print('学生正在吃饭...')
    #静态方法
    @staticmethod
    def method():   #默认里面什么都不加
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):    #默认里面要加cls
        print('我是类方法，因为我使用了classmethod进行修饰')
#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

#创建Student类的对象
stu1 = Student('张三',23) #这里的默认调用初始化函数，两个参数默认输入到这个函数中进行操作
stu1.eat()      #调用类的方法，对象名.方法名()
print(stu1.name)    #调用类的属性
print(stu1.age)

Student.eat(stu1)   #这行代码与stu1.eat()功能相同，都是调用Student类中的eat方法
                    #类名.方法名(类的对象)-->实际上就是调用方法定义处的self
print(stu1.native_place)
Student.native_place = '北京' #改变类的属性
print(stu1.native_place)
print('-------类方法的使用方式--------')
Student.cm()
print('-------静态方法的使用方式--------')
Student.method()

#动态绑定类的属性和方法
stu2 = Student('李四',30)
print(id(stu1))
print(id(stu2))
stu1.gender = '女'
print(stu1.name, stu1.age, stu1.gender)
print(id(stu1)) #绑定属性前后stu1的ID（内存地址）不变
#print(stu2.name, stu2.age, stu2.gender) #报错，因为stu2没有绑定gender属性

def show():
    print('定义在类之外的，称为函数')
stu1.show = show
stu1.show()
#stu2.show() #报错，因为stu2没有绑定show方法

9.2 封装和多态

封装

class Student:
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #年龄不希望在类的外部被使用，所以加了__
    def show(self):
        print(self.name,self.__age)
stu = Student('张三',20)
print(stu.name) #在类的外部使用name,可以访问
#print(stu.__age)   #在类的外部使用__age,不能访问，报错
stu.show()  #使用类的内置方法去调用，属于内部访问，可以访问

#强行访问__age的方法
print(dir(stu))             #打印出类的全体属性
print(stu._Student__age)    #在类的外部可以使用__age

9.3 继承和方法重写

  以下图为例老虎、猴子等为子类；哺乳动物为父类；动物为祖先类。

  语法格式为：

class 子类类名(父类类名1,父类类名2...):
    pass

  需要注意的是：
    1.Python支持多继承（属于Python特色了），即一个子类可以继承多个父类。

class A(object):#A类继承object
    pass
class B(object):#B类继承object
    pass
class C(A,B):#C类继承A, B
    pass

    2.定义子类时，必须在其构造函数当中调用其父类的构造函数。
  方法重写：父类的方法在子类当中重新编写（即更改的意思）

    3.如果一个类没有继承任何类，那么默认继承object类。使用内置函数dir( )可以察看指定对象的所有属性和方法。

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
        #字符串格式化输出

stu = Student('张三',20)
print(dir(stu)) #输出类的所有属性和方法
print(stu)      #若不在Student中重写__str__()方法，则输出的是Student类的地址
#这里我们重写了，则输出的是return中的语句

class Person(object):   #Person继承object，object也可以不写
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def info(self):
        print(self.name,self.age,end='\t')

class Student(Person):  #Student继承Person类
    def __init__(self, name, age,stu_no):
        # 先初始化父类属性，然后在对子类的属性进行幅值，super().可以理解为调用了父类的方法
        # super().是为了解决多继承当中多个父类的问题，倘若父类当中的方法名称相同，则可以在super().当中说明调用的是哪个父类的方法
        super().__init__(name,age)
        self.stu_no = stu_no
    def info(self):     #方法重写
        super().info()
        print('学号:{0}'.format(self.stu_no))

class Teacher(Person):  #Teacher继承Person类
    def __init__(self, name, age,teach_of_year):
        super().__init__(name,age)
        self.teach_of_year = teach_of_year
#创建实例对象
stu = Student('张三',20,'1001')
teacher = Teacher('李四',34,10)
#调用父类的方法
stu.info()
teacher.info()

9.4 多态

  Java是静态语言，Python是动态语言

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')

class Person:
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数，这里就使用了多态
#先判定obj的类型，然后在根据其类型调用其方法
def fun(obj):
    obj.eat()
#调用函数
cat1 = Cat()
cat1.eat()
print('----------------')
fun(Cat())
fun(Dog())
fun(Animal())
fun(Person())
'''Dog和Cat是重写了父类当中的方法，Person虽然和Animal没有继承关系
但是通过多态，我们可以利用一个函数就将他们的输出联系起来
在Python当中，我们只关注对象的行为（方法）是否类似，而不关注对象类型是否相同'''

9.5 特殊属性和特殊方法

#特殊属性__dict__
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age
#创建C类的对象
x = C('Jack',20)    #x是C类的一个实例对象
print(x.__dict__)   #实例对象的属性字典
print(C.__dict__)   #C类的属性字典
print(x.__class__)  #,，表明属于C类
print(C.__bases__)  #C类的父类类型元素
print(C.__base__)   #输出C类的父类，AB谁写前面就输出谁，这里是A
print(C.__mro__)    #C类的层次结构，即输出所有父类和祖先类（包括object）
print(A.__subclasses__())   #输出A的所有子类，仅C类一个

#特殊方法
class Student:
    def __init__(self,name):
        self.name = name
    def __add__(self,other):    #实现两个对象相加
        return self.name+other.name
    def __len__(self):
        return len(self.name)
stu1 = Student('Jack')
stu2 = Student('李四')
s = stu1+stu2
print(s)    #报错，显示不能相加
#倘若非得相加，那么在Student类当中定义__add__函数
s2 = stu1.__add__(stu2) #和前面的功能相同，实现相加操作
print(s2)

lst = [11,22,33,44]
print(len(lst))     #输出列表长度
print(lst.__len__())
print(len(stu1))

'''总结：执行实例创建：
    1.先将类名(Person)传给new的cls，开新空间(obj)用于后续实例对象创建
    2.接受到obj的self，实例对象p1指向self
    3.new在前为实例创建对象，init为实例的属性赋值，因此在我们创建一个实例对象(如p1)时，首先调用的是new创建,然后在调用init赋值
    （可以使用debug逐步观察）
'''
class Person(object):
    def __new__(cls,*args,**kwargs):    #传入参数为Person类对象(观察id可以看出)
        print('__new__被调用了，cls的id值为{0}'.format(id(cls)))
        obj = super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))
        return obj

    def __init__(self,name,age):    #传入参数为实例对象p1，self=p1(观察id可以看出)
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))
        self.name = name
        self.age = age
print('object这个类的对象的id为：{0}'.format(id(object)))
print('Person这个类的对象的id为：{0}'.format(id(Person)))

#创建Person类的实例对象
p1 = Person('张三',20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

9.6 拷贝

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu
        self.disk = disk
#变量赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))    #cpu1和cpu2 id相同，体现了Python赋值的驻留机制，即虽然形成两个变量，但是实际上还是指向同一个对象
#浅拷贝
import copy
disk = Disk()   #创建一个硬盘类对象
computer = Computer(cpu1,disk)
computer2 = copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
print('----------------------------------')
#深拷贝
computer3 = copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
'''
总结：
computer和computer2的cpu disk id相同，但是本身的id不同，这就称为浅拷贝
浅拷贝后对象的属性（这里是id变化了）改变，但子对象（被调用的类）不变（这里是cpu和disk）。
深拷贝是对象的属性和子对象全部发生改变，所有属性和子对象的id改变
'''

10、 模块化编程

  一个模块当中可以包含多个函数、类、语句。在Python当中一个.py文件就是一个模块。
使用模块的好处有：
  方便其它程序和脚本的导入并使用；
  避免函数名和变量名冲突；
  提高代码的可维护性；
  提高代码的可重用性。

10.1 模块调用

  导入模块的两种方法

import math #关于数学运算的模块,可以使用模块中的所有函数、类
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('----------------------')
print(dir(math))
print(math.pow(2,3))

from math import pi #仅仅导入一个特定的对象
print(pi)
#print(math.pow(2,3))    #报错

  定义自定义模块calc.py

#自定义模块calc.py
def add(a,b):
    return a+b

  调用自定义模块calc.py

import calc
print(calc.add(10,20))

  在主程序当中调用

#自定义模块calc.py
def add(a,b):
    return a+b

if __name__ == '__main__':
    print(add(10,20))
'''只有执行calc.py文件时，才会输出这个语句'''

10.2 Python中的包

  包类似于C语言当中的多个头文件组成的头文件，其中调用了多个模块。为了避免名称相同的模块冲突，而设置的包。

#导入package1包中的module_A模块
import package1.module_A
print(package1.module_A.a)
'''
import package1.module_A as ma  #ma是package1.module_A的别名
print(ma.a)
#二者作用相同
'''

#导入带有包的模块时的注意事项
import package1
import calc
#使用import方式进行导入时，只能跟包名或者模块名

from package1 import module_A
from package1.module_A import a
#使用from ...import可以导入包、模块、函数、变量等等

10.3 Python当中常用的模块

  shcedule模块需要下载，在pycharm中左下角点击小正方形，然后再点击packages，最后在搜索框中搜索schedule，下载即可。

import schedule
import time

def job():
    print('哈哈 --------')

schedule.every(3).seconds.do(job)
#每3秒执行一次job()
while True:
    schedule.run_pending()
    time.sleep(1)   #休眠1秒

10.4 文件读写

file = open('a.txt','r',encoding='UTF-8')
print(file.readlines())
file.close()

  with语句（上下文管理器），with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确的关闭，以此来达到释放资源的目的。
  如下代码所示，使用with语句打开文件，就不再需要 file.close( )。

with open('a.txt','r',encoding='UTF-8') as file:
    print(file.read())

10.5 OS模块的常见函数

  os模块是Python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
  os模块与os.path模块用于对目录或文件进行操作。

#os模块是与操作系统相关的一个模块
import os
os.system('notepad.exe')    #打开记事本
os.system('calc.exe')       #打开计算器
#直接调用可执行文件(.exe文件)
os.startfile('D:\\QQ\\Bin\\QQScLauncher.exe')
#打开QQ

import os
print(os.getcwd())

lst = os.listdir('../chap12')
print(lst)

#os.mkdir('newdir2')
#os.makedirs('A/B/C')
#os.rmdir('newdir2')
#os.removedirs('A/B/C')

import os.path
print(os.path.abspath('demo12.py'))
print(os.path.exists('demo12.py'),os.path.exists('demo18.py'))  #判断文件是否存在
print(os.path.join('E:\\python','demo12.py'))   #仅仅是单纯的拼接，文件没有复制，没有其他操作
print(os.path.split('D:\\software\\pycharm\\project\\hi\\chap12\\demo12.py'))   #将文件名和路径名分开
print(os.path.splitext('demo12.py'))    #将文件名和后缀名分开
print(os.path.basename('D:\\software\\pycharm\\project\\hi\\chap12\\demo12.py'))    #从路径当中将文件名+后缀名提取出来