python基础知识集合

　　Python基础知识
　　建议有程序语言基础的童鞋阅读，零基础阅读可能会有点费解
　　文章目录
　　Python基础知识注释方法数据类型输入和输出输入输出算数运算符常用运算函数比较运算符逻辑运算符成员运算符分支循环列表列表的取值获取元素的下标获取列表中多个元素（切片）列表的增删改操作增加删除修改列表的排序列表生成式列表常用函数字典（对象）字典的创建方式字典的常用操作获取字典的试图方法字典的遍历字典的生成式元组元组的创建方式元组的遍历集合集合的创建集合的常用操作集合间的关系字符串的常用操作字符串的查询操作方法字符串的大小写转换操作的方法字符串内容对齐操作的方法字符串分割操作的方法判断字符串操作的方法字符串操作的其他方法字符串格式化操作字符串编码和解码操作函数函数的定义和使用函数的返回值函数的默认值函数的参数定义python异常处理机制异常捕获异常捕获elsetry...except...else...finally结构python常见的异常类型类与对象类的创建类实例对象动态绑定属性和方法面向对象的三大特征模块和包导入模块包文件的读写内置函数open()创建文件对象常用的文件打开模式文件对象的常用方法with语句（上下文管理器）目录操作 （os 和 os.path）python内置模块注释方法
　　# 单行注释
　　＂＂＂ 多行注释 ＂＂＂  数据类型
　　关键字名称示例  chr  单个字符 ＂＂, ＂d＂str  字符串（多个chr）  ＂dd＂, ＂你好＂int  整数 1,2,3,4float  浮点数  3.1415926bool  布尔 Ture, Falselist  列表  [1,2,3,4]tuple  元组 (＂name＂, ＂age＂)dict  字典  {＂name＂:＂zzl＂}set  集合 {＂zzl＂, ＂age＂, ＂gender＂}
　　查看数据类型函数
　　type(变量)   返回该变量的数据类型
　　数据类型转换函数
　　int(num)   将num转换为整数类型
　　float(num)   将num转换为浮点数类型
　　bool(num)   将num转换为布尔类型
　　str(num)   将num转换为字符串类型
　　注： int bool float 任何两种类型都可相互转换任何类型都可以转换为字符串
　　注： str -> int 要求全部为数字str -> float 要求全部为数字，且可存在一个小数点
　　注：当布尔值False转换为str后， 在转换为bool会变成True 输入和输出输入
　　语法  inp = input(＂提示文本＂)
　　注：输入结果为str数据类型，如须做其他操作可进行数据转换 输出默认输出print(＂hello, world＂) 1占位符输出# %s 的s表示变量的数据类型 print(＂名字：%s，年龄：%s，性别：%s＂ % (name, age, sex))  12推荐使用print(f＂名字：{name}，年龄：{age}，性别：{sex}＂) 1算数运算符
　　+ - * / ** // %
　　前四个同其他编程语言用法相同
　　**   表示平方计算  5 ** 2 === 5的2次方
　　//   表示做除运算后取整
　　%   取余运算
　　简写形式
　　+= -= *= /= **= //+ %=
　　注：
　　+   也可用于字符串拼接
　　*   当任意一边为字符串时，则表示重复字符串 常用运算函数
　　round(num, count)   表示对num四舍五入，并保留小数点后count位 比较运算符
　　> < >= <= = !=
　　常用函数
　　ord(chr)   返回该chr的ASCII码(只能为单个字符)
　　chr(num)   返回该ASCII对应的字符逻辑运算符
　　and   ， or   ，  not
　　运算符含义  and  真真为真，其他为假（第一项为真则返回第二项的值，如第一项为假则返回第一项的值） or  假假为假，其他为真（第一项为真，则返回第一项的值，如第一项为假，则返回第二项的值）  not  取反 成员运算符
　　in   ， not in
　　运算符含义示例  in  判断某字符是否存在于某字符串 ＂h＂ in ＂hello＂not in  判断某字符是否不存在于某字符串  ＂h＂ not in ＂hello＂  分支
　　单分支 # 注意缩进 if bool表达式:       print(＂执行＂)   123
　　双分支 # 注意缩进 if bool表达式:       print(＂执行语句1＂)   else:     print(＂执行语句2＂) 12345
　　分支嵌套 # 注意缩进 if bool表达式:       if bool表达式2:         print(＂执行嵌套语句＂)     else:         print(＂执行语句1＂)   else:     print(＂执行语句2＂) 12345678
　　多分支 # 注意缩进 if bool表达式1:       print(＂执行语句1＂)   elif bool表达式2:     print(＂执行语句2＂) elif bool表达式...:     print(＂执行语句...＂) else:      print(＂如上都不满足，则执行这条语句＂) 123456789循环
　　循环控制
　　只能在循环语句中使用，只对距离最近的循环起作用  break # 跳出本循环 continue # 结束本次循环，执行下一次循环  12
　　while循环 # 注意判断条件 while bool表达式:     print(＂执行语句＂) 123
　　for循环  # range(start, end, rule) 从start开始，到end-1，间隔为rule,rule的正负表示正序或倒序 # range(1, 11) 输出1~10，不包括最大值11 # range(1, 11, 2) 输出1~10，不包括最大值11, 第三个参数表示为每次间隔2 # range(11, 1, -2) 输出11~2，不包括最小值值1, 第三个参数为负数，则表示为倒序且每次间隔2 # range(5) 简写形式，0~5的范围  for i in range(1,11):     print(i) 123456789
　　循环else结构
　　只有循环完整执行完毕后，才会执行else语句
　　当循环过程中执行break语句后，else将不执行  # while   while bool表达式:       print(＂执行语句＂) else:     print(＂while  else语句＂)      # for   for i in range(10):       print(＂执行语句＂) else:     print(＂for  else语句＂) 1234567891011列表
　　对象是存储单个数据的容器，而列表（数组）就是存储多个数据的容器，任何数据类型都可以存放  # 字面量创建新列表 lst = [1,＂2＂,＂三＂]  # 使用list函数创建新列表 lst = list([1,＂2＂,＂三＂]) 12345列表的取值通过索引下标取值使用for循环获取元素的下标list.index(‘元素’) 找不到元素则抛出异常， 可预先使用in方法判断是否存在 获取列表中多个元素（切片）
　　list[start:end:step]
　　从start索引位置开始，截取到end-1位置结束，步长为step
　　其中step可为负值，表示从start位置往左边截取开始
　　start默认值为0
　　end默认值为列表长度
　　step默认值为1
　　省略参数但 : 必须存在  list[::]  列表的增删改操作增加
　　append(item)
　　在原有的列表末尾添加一个元素lst = [10, 20, 30]  lst.append(100) print(lst) # [10, 20, 30, 100]  123
　　extend( [] )
　　在原有的列表末尾至少添加一个元素，添加元素必须是列表（添加多个）lst = [10, 20, 30]  lst.extend([99, 100]) print(lst) # [10, 20, 30, 99, 100]  123
　　insert(index, item)
　　在原有的列表指定位置添加一个元素lst = [10, 20, 30]  lst.insert(1, 99) print(lst) # [10, 99, 20, 30]  123切片添加多个元素(指定位置添加多个元素)
　　使用切片把选择到的元素替换掉lst = [10, 20, 30]  lst[1:] = [99] print(lst) # [10, 99] 123删除
　　remove(item)
　　在原有的列表删除一个元素，如果有重复元素只删除一个，如果元素不存在则抛出异常lst = [10, 20, 30]  lst.remove(20) print(lst) # [10, 30]  123
　　pop(index)
　　删除指定索引位置的元素，如果指定索引不存在则抛出异常
　　不传index，则删除末尾元素lst = [10, 20, 30]  lst.pop(1) print(lst) # [10, 30]  123
　　clear()
　　清空列表lst = [10, 20, 30]  lst.clear() print(lst) # []   123切片删除元素
　　使用切片把选择到的元素替换为空lst = [10, 20, 30]  lst[1:] = [] print(lst) # [10] 123删除列表，即释放内存（谨慎使用）lst = [10, 20, 30]  del lst print(lst) # 会抛出异常， lst is not defined 123修改直接重新赋值lst = [10, 20, 30]  lst[1] = 40 print(lst) # [10, 40, 30]   123切片修改（批量修改）lst = [10, 20, 30]  lst[1:3] = [40, 50, 60] print(lst) # [10, 40, 50, 60]   123列表的排序
　　sort()
　　在原列表的基础上排序
　　传入reserse=True降序排序
　　传入reserse=False生序升序
　　不传默认升序# sotr()   lst = [9, 3, 2, 8]  lst.sort()   print(lst) # [2, 3, 8, 9]    # sotr(reserse=True)   lst = [9, 3, 2, 8]  lst.sort(reserse=True)   print(lst) # [9, 8, 3, 2]  # sotr(reserse=False)   lst = [9, 3, 2, 8]  lst.sort(reserse=False)   print(lst) # [2, 3, 8, 9]   1234567891011121314
　　sorted(lst[,rule ])
　　使用内置函数sorted()进行排序，将产生一个新列表对象
　　传入第二参数reserse=True降序排序
　　传入第二参数reserse=False生序升序
　　不传第二参数默认升序# sorted(lst)   lst = [9, 3, 2, 8]  new_list = sorted(lst)   print(new_list) # [2, 3, 8, 9]    # sorted(lst, reserse=True)  lst = [9, 3, 2, 8]  new_lsit = sorted(lst, reserse=True)   print(new_list) # [9, 8, 3, 2]  # sorted(lst, reserse=False)   lst = [9, 3, 2, 8]  new_lsit = sorted(lst, reserse=False)    print(new_list) # [2, 3, 8, 9]   1234567891011121314列表生成式
　　[i for i in renge(1, 11)]
　　列表生成的表达式lst = [i*i for i in renge(1, 6)] print(lst) # [1, 4, 9, 16, 25] 12列表常用函数len(list)：列表元素个数max(list)：返回列表元素最大值min(list)：返回列表元素最小值字典（对象）
　　python的内置数据结构之一，以键值对的方式存储数据。在其他语言中也叫对象。 字典的创建方式
　　info = {＂name＂:＂zzl＂, ＂age＂:18}
　　info = dict(name=＂zzl＂, age=18)  字典的常用操作获取字典中的元素info = {＂name＂:＂zzl＂, ＂age＂:18}    # []方式 print(info[＂name＂]) # zzl   print(info[＂sex＂]) # error: keyError   # get()方式 print(info.get(＂name＂)) # zzl print(info.get(＂sex＂)) # None   print(info.get(＂sex＂, ＂男＂)) # 如果sex字段为None的话，则打印 ＂男＂ 默认值 12345678910key的判断
　　in  , not in  info = {＂name＂:＂zzl＂, ＂age＂:18}    # in print(＂name＂ in info) # True    # not in print(＂sex＂ nor in info) # True 1234567key的删除info = {＂name＂:＂zzl＂, ＂age＂:18}    del info[＂name＂] # 删除name字段 print(info) # {＂age＂:18}  info.clear() # 清空该字典   print(info) # {} 1234567新增keyinfo = {＂name＂:＂zzl＂, ＂age＂:18}   info[＂sex＂] = ＂男＂ print(info) # {＂name＂:＂zzl＂, ＂age＂:18, ＂sex＂:＂男＂}   123修改keyinfo = {＂name＂:＂zzl＂, ＂age＂:18}   info[＂age＂] = 20 print(info) # {＂name＂:＂zzl＂, ＂age＂:20}   123获取字典的试图方法
　　keys()
　　返回字典的所有key组成的列表info = {＂name＂:＂zzl＂, ＂age＂:18}   keys = info.keys() print(keys) # [＂age＂, ＂name＂] 123
　　values()
　　返回字典的所有value组成的列表info = {＂name＂:＂zzl＂, ＂age＂:18}   values = info.value() print(values) # [18, ＂zzl＂] 123
　　items()
　　返回字典的所有key:value组成的列表info = {＂name＂:＂zzl＂, ＂age＂:18}   itmes = info.items() print(items) # [(＂age＂, 18), (＂name＂, ＂zzl＂)] 123字典的遍历info = {＂name＂:＂zzl＂, ＂age＂:18}    for item in info:     print(item，info[item]) # age ＂zzl＂ # name 18 123456字典的生成式items = [＂Fruits＂, ＂Books＂, ＂Others＂]  prices = [98, 97, 95]  d = { item:price for item, price in zip(items, prices) } print(d) # {＂Others＂: 95, ＂Books＂: 97, ＂Fruits＂: 98} 1234
　　字典的特点 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复字典中的元素是无序的字典中的key必须是不可变对象，（即key不能为变量）字典也可以根据需要动态的伸缩字典会浪费较大的内存，是一种使用空间换时间的数据结构元组
　　列表的另一种形式，是不可变序列  元组的创建方式# 直接用小括号书写 t = (＂python＂, ＂world＂, ＂20＂)   # 使用内置函数tuple()  t1 = tuple( (＂python＂, ＂world＂, ＂20＂) )  t3 = (＂python＂,) # 如果元组只有一个元素，则在元素后面加上 ，    # 获取元组的元素 t[0] # python 12345678910元组的遍历t = (＂python＂, ＂world＂, ＂20＂)   for item in t:     print(item) # python # world  # 20  12345678
　　注： 如果元组中对象本身是不可变对象，则不能再引用其他对象如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变集合
　　python语言提供的内置数据结构
　　与列表、字典都属于可变类型的序列
　　集合是没有value的字典
　　集合的存储是无序的  集合的创建# 集合的value不能重复 s = {2, 3, 4, 5, 2, 4}  print(s)  # {2,3,4,5}  # set()函数   s1 = set(range(6))  print(s1) # set([0, 1, 2, 3, 4, 5])  s2 = set([1,2,3,5,6,4,3]) print(s2) # set([1, 2, 3, 4, 5, 6])  s3 = set((1,23,5,32,1)) print(s3) # set([32, 1, 5, 23])  s4 = set(＂python＂)   print(s4) # set([＂h＂, ＂o＂, ＂n＂, ＂p＂, ＂t＂, ＂y＂])  s5 = set({12,4,23,4,12})   print(s5) # set([12, 4, 23])  # 定义集合 s6 = set()  1234567891011121314151617181920212223集合的常用操作s = {10, 20, 30, 40, 50}     # 判断是否存在 print(10 in s) # True    print(70 in s) # False  # 新增   s.add(80)  print(s) # {10, 20, 30, 40, 50, 80}    # 新增多个   s.update({200, 400})   print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}    # 删除   s.remove(10)  print(s) # {20,, 200, 30, 40, 50, 400, 80}  s.remove(900) # error: keyError s.discard(900) # 如果有则删除900， 没有也不会报错 s.pop() # 随机删除一个， 不能传参   s.clear() # 清空集合 123456789101112131415161718192021集合间的关系
　　两个集合是否相等（判断集合中的元素是否完全相等） s1 = {10, 20, 30, 40} s2 = {20, 40, 10, 20}  print(s1 == s2) # True print(s1 != s2) # False 1234
　　一个集合是否是另一个集合的子集
　　假如集合s1的元素里包括集合s2的全部元素，则s2是s1的子集  s1 = {10, 20, 30, 40} s2 = {20, 40}  print(s2.issubset(s1)) # True 123
　　一个集合是否是另一个集合的超集
　　与上相反，假如集合s1的元素里包括集合s2的全部元素，则s1是s2的超集  s1 = {10, 20, 30, 40} s2 = {20, 40}  print(s1.issuperset(s2)) # True 123
　　一个集合和另一个集合是否无交集
　　如果一个集合里某个元素，在另一个集合里也有存储，则两个集合有交集  s1 = {10, 20, 30, 40} s2 = {80, 60}  print(s1.isdisjoint(s2)) # False 无交集 123字符串的常用操作字符串的查询操作方法
　　方法名称作用  index()查找子串第一次出现的位置，如果查找的子串不存在时，则抛出ValueError rindex()查找子串最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError  find()查找子串第一次出现的位置，如果查找的子串不存在时，则返回-1 rfind()查找子串最后一次出现的位置，如果查找的子串不存在时，则返回-1  字符串的大小写转换操作的方法
　　方法名称作用  upper()把字符串中所有字符都转成大写字母 lower()把字符串中所有字符都转成小写字母  swapcase()把字符串中所有大写字母转成小写字母，把所有小写字母转成大写字母 capitalize()把第一个字符转换为大写，其余字符小写  title()把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写 字符串内容对齐操作的方法
　　方法名称作用  center()居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串 ljust()左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串  rjust()右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度，则返回原字符串 zfill()右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果设置宽度小于实际宽度，则返回原字符串  字符串分割操作的方法
　　方法名称作用  split(cha, max)从字符串的左边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数 split(cha, max)从字符串的右边开始分割，默认分割符是空格，返回值是一个列表，第一个参数为分割符，第二个参数为最大分割次数  判断字符串操作的方法
　　方法名称作用  isidentifier()判断指定字符串是不是合法的标识符 isspace()判断指定字符串是否由空白字符组成（回车、换行、水平制表符tab）  isalpha()判断指定字符串是否全部由字母组成 isdecimal()判断指定字符串是否全部由十进制的数字组成  isnumeric()判断指定字符串全部由数字组成 isalnum()判断指定字符串是否全部由字母和数字组成  字符串操作的其他方法
　　方法名称作用  replace()第1个参数指定被替换的子串
　　第2个参数指定替换子串的字符串
　　该方法返回替换后的字符串，替换前的字符串不会发生变化
　　该方法的第3个参数可以指定最大替换次数 cha.join(lst)用  cha  将列表后元组的字符串合并成一个字符串。使用方法为  cha.join(lst)  字符串格式化操作# %s 的s表示数据类型  s:字符串  i:整数 print(＂我叫%s，我今年%i岁＂ % (＂zzl＂, 18)) # 我叫zzl，我今年18岁＂  # {}里的数字表示后面变量的索引，可重复使用 print(＂我叫{0}，我今年{1}岁，我真的叫{0}＂.format(＂zzl＂, 18)) # 我叫zzl，我今年18岁，我真的叫zzl＂  # 前面加f  可在{}中直接填写变量 print(f＂我叫{＂zzl＂}，我今年{18}岁＂) # 我叫zzl，我今年18岁＂  123456789字符串编码和解码操作# 编码  s = ＂好好学习，天天向上＂ # 使用GBK格式进行编码, 此格式中，一个中文占两个字节 print(s.encode(encoding=＂GBK＂)) #b＂ºÃºÃÑ§Ï ÌìÌìÏòÉÏ＂  # 使用UTF-8格式进行编码 此格式中，一个中文占三个字节 print(s.encode(encoding=＂UTF-8＂)) #b＂å ½å ½å ä¹ ï¼ å å å ä ＂    # 解码  （使用什么格式编码，就必须使用什么格式解码，否则会报错）  # 使用GBK格式进行编码 print(s.encode(encoding=＂GBK＂).decode(encoding=＂GBK＂)) # 好好学习，天天向上  # 使用UTF-8格式进行编码 print(s.encode(encoding=＂UTF-8＂).decode(encoding=＂UTF-8＂)) # 好好学习，天天向上  12345678910111213141516171819函数函数的定义和使用# 定义 def 函数名(a, b): # 参数a和b     函数体       return  # 返回值        # 使用   函数名()    # 代码演示   def cals(a, b):     c = a + b      return c      res = cals(20, 30) # 50   1234567891011121314
　　函数的参数传递
　　位置传参，cals(20, 30)   ，此时a的值是20， b的值是30
　　关键字传参， cals(b=70, a=30)   此时a的值是30， b的值是70函数的返回值如果函数没有返回值（函数执行完毕之后，不需要给调用处提供数据）,return可以省略不写函数的返回值，如果是1个，直接返回原值函数的返回值，如果是多个，返回的结果为元组def fun(lst):     odd = [] # 存放奇数       even = [] # 存放偶数     for i in lst:         if (i%2) :             odd.append(i)         else:             even.append(i)     return odd,even  lst = [10, 23, 65, 78, 32, 77]  print(fun(lst)) # ([23, 65, 77], [10, 78, 32]) 123456789101112函数的默认值
　　在定义函数的时候，可以给形参赋上默认值，当没传参数的时候，函数会取默认值，如果传参和默认值同时存在，传的参数会替换掉默认值 def cals(a, b = 10):     c = a + b      return c      res = cals(20) # 30   res = cals(20, 30) # 50 123456函数的参数定义个数可变的位置参数
　　定义函数时，可能无法确定传递的实参个数，这个时候就要使用可变的位置形参。使用*定义，结果为一个元组def fun(*args);     print(args)  fun(1)  # (1,) fun(1,2,3)  # (1, 2, 3) 12345个数可变的关键字参数（指定参数名传递参数）
　　定义函数时，可能无法确定传递的关键字实参个数，这个时候就要使用可变的关键字形参。使用*定义，结果为一个字典def fun(**args);     print(args)  fun(a=10)  # {＂a＂:10} fun(a=10, b=20, c=30)  # {＂a＂:10, ＂b＂:20, ＂c＂:30} 12345
　　以上参数在函数定义时，一种方式只能定义一次。
　　当两种参数定义方式同时存在时，位置形参必须在关键字形参前面 python异常处理机制异常捕获try:     可能出现异常的语句放在这里  except 你要捕获的异常类型:     捕获到异常后你想做什么 except 你要捕获的异常类型:     捕获到异常后你想做什么 ... except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码     print(＂出错了＂, e) print(＂程序照常执行＂) 12345678910异常捕获elsetry:     可能出现异常的语句放在这里  except 你要捕获的异常类型:     捕获到异常后你想做什么 except 你要捕获的异常类型:     捕获到异常后你想做什么 ... except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码     print(＂出错了＂, e) else:     print(＂如果没有异常则执行else部分＂) 1234567891011try…except…else…finally结构try:     a = int(input(＂请输入第一个整数＂))     b = int(input(＂请输入另一个整数＂))     res = a/b except BaseException as e:     print(＂出错了＂, e) else:     print(＂结果为:＂res) finlly:     print(＂无论是否产生异常，总会被执行的代码＂) 12345678910python常见的异常类型
　　异常类型描述  ZeroDivisionError除零or向零取余 IndexError序列中没有此索引  KeyError映射中没有这个键 NameError未声明or未定义  SyntaxError语法错误 ValueError传入无效的参数  类与对象类的创建类属性: 类中方法外的变量称为类属性，被该类的所有实例对象共享
　　类方法: 使用@classmethod  修饰的方法，可使用类名直接访问
　　静态方法: 使用@staticmethod  修饰的方法，可使用类名直接访问# Stubent为类的名称，由一个或多个单词组成。（建议类名书写方式为每个单词首字母大写） class Student:     native_pace = ＂河南＂ # 直接写在类里的变量，称为属性          # 初始化函数( 构造函数 )     def __init__(self, name ,age):         # 创建实例的时候 对name和age属性进行赋值         self.name = name         self.age = age          # 定义在类里面的方法为实例方法     def eat(self):         print(＂吃饭＂)          # 静态方法 （静态方法里不允许写self）     @staticmethod      def method():         print(＂使用staticmethod进行修饰，所以我是静态方法＂)                       # 类方法     @classmethod      def cm(cls):         print(＂使用calssmethod进行修饰，所以我是类方法＂)      12345678910111213141516171819202122232425类实例对象# 类实例创建语法  stu = Student() # 假设已存在上面的 Student 类    # stu1就是Student类的实例对象，该实例对象中可以访问到类中的属性和方法 stu1 = Student(＂zzl＂, 18) # 创建实例 print(stu1.name) # zzl print(stu1.age) # 18 stu1.eat() # 吃饭 12345678动态绑定属性和方法# 假设已存在Student类   stu = Student(＂zzl＂, 18)    # 绑定 gender 属性  stu.gender = ＂男＂  print(stu.gender) # 男  # 绑定 show 方法 def show():     print(＂show方法执行＂) stu.show = show stu.show() # show方法执行  12345678910111213面向对象的三大特征
　　封装 （提高程序的安全性）
　　将数据（属性）和行为（方法）封装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样无需关心方法内部的具体实现细节，从而隔离了复杂度。在python中没有专门的修饰符用户属性的私有化，如果该属性不想被类对象访问，可以在属性名前面加两个 ‘_’
　　继承
　　多态
　　代码演示 # 继承 class Person(object):     def __init__(self, name, age):         self.name = name         self.age = age      def info(self):         print(self.name, self.age)   class Student(Person):     def __init__(self, name, age, stu_no):         super().__init__(name, age)         self.stu_no = stu_no   class Teacher(Person):     def __init__(self, name, age, teachofyear):         super().__init__(name, age)         self.teachofyear = teachofyear   stu = Student(＂张三＂, 20, 10001) teacher = Teacher(＂李四＂, 35, 10)  stu.info() # 张三 20 teacher.info() # 李四 35  # python 支持多继承  class A(class1, class2):       pass      # 方法重写   # 方法重写就是在子类里定义与父类重名的方法，这样就会优先调用子类的定义的方法 12345678910111213141516171819202122232425262728293031323334模块和包
　　定义：每一个.py文件就是一个模块
　　使用模块化的好处 方便其他程序和脚本的导入使用避免函数名和变量名冲突提高代码的可维护性提高代码的可重用性导入模块# 导入模块 import 模块名称 [as 别名]    # 导入模块中的指定函数(or 变量 or 类) from 模块名称 import 函数/变量/类 12345包
　　包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
　　作用 代码规范避免模块名称冲突
　　包与目录的区别 包含__init__.py文件的目录称为包目录里通常不存在__init__.py文件
　　包的导入
　　import 包名.模块名  文件的读写内置函数open()创建文件对象# file = open( filename, [mode, encoding] )  # 假设有一个名为a的文本文件，里面有hello world file = open(＂a.txt＂, ＂r＂) print(file.readlines()) # [＂hello world＂] file.close() 123456常用的文件打开模式
　　打开模式描述  r以只读模式打开文件，文件的指针将会放在文件的开头 w以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头  a以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容 b以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb,后者wb  +以读写方式打开文件，不能单独使用，需要与其他模式一起使用，如a+ 文件对象的常用方法
　　方法名描述  read([size])从文件中读取size个字节或字符的内容返回，若省略size，则读取到文件末尾，即一次读取文件所有内容 readline()从文本文件中读取一行内容  readlines()把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回 write(str)将字符串str内容写入文件  writelines(s_list)将字符串列表s_list写入文本文件，不添加换行符 seek(offset[, whence])把文件指针移动到新的位置，offset表示相对与whence的位置：
　　offset：为正则往结束方向移动，为负则往开始方向移动
　　whence不同的值代表不同含义：
　　0：从文件头开始计算（默认值）
　　1：从当前位置开始计算
　　2：从文件末尾开始计算  tell()返回文件指针的当前位置 flush()把缓冲区的内容写入文件，但不关闭文件  close()把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源 with语句（上下文管理器）
　　with语句可以自动管理上下文资源，不论什么原因跳出with语句都能确保文件正确的关闭，以此来达到释放资源的目的  # with使用   with open(filename, mode) as file:     pass  123目录操作 （os 和 os.path）os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样os模块与os.path模块用于对目录或文件进行操作import os # 打开计算器 os.system(＂calc.exe＂) # 打开记事本 os.system(＂notepad.exe＂)  # 打开可执行文件 os.startfile(＂路径＂) 12345678
　　os模块操作目录相关函数
　　函数说明  getcwd()返回当前的工作目录 listdir(path)返回指定路径下的文件和目录信息  mkdir(path[, mode])创建目录 makedirs(path1/path2…[, mode])创建多级目录  rmdir(path)删除目录 removedirs(path1/path2…)删除多级目录  chdir(path)将path设置为当前工作目录
　　os.path模块操作目录相关函数
　　函数说明  abspath(path)用于获取文件或目录的绝对路径 exists(path)用于判断文件或目录是否存在，如果存在返回True,否则返回False  join(path, name)将目录与目录，或者目录与文件名连接起来 split(path)分离目录和文件名  splittext(name)分离文件名和扩展名 basename(path)从一个目录中提取文件名  dirname(path)从一个路径中提取文件路径，不包括文件名 isdir(path)判断是否为路径  python内置模块
　　使用 import  关键字引入
　　模块描述  random随机数生成 traceback处理异常  sys与python解释器及环境操作相关的标准库 time提供与时间相关的各种函数的标准库  os提供了访问操作系统服务功能的标准库 calendar提供与日期相关的各种函数的标准库  urllib用于读取来自网上（服务器）数据的标准库 json用于使用JSON序列化和反序列化对象  re用于在字符串中执行正则表达式匹配和替换 math提供标准算术运算函数的标准库  decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算 logging提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能