花了一周把之前Python基础知识复习了一下，后续还会进行一些补充。
# import sys
""" Python的sys模块提供访问由解释器使用或维护的变量的接口，并提供了一些函数用来和解释器进行交互，
操控Python的运行时环境。 """
from fractions import Fraction
import random
import math
import os
import string
import re
import pythonds
""" pycharm中 选中行 ctrl+/ 进行快速注释， 再 ctrl+/ 取消注释
批量修改变量名： 选中变量，ctrl+R 或者 ctrl+shift+alt+j """
"""
1、Ctrl + Enter：在下方新建行但不移动光标；
2、Shift + Enter：在下方新建行并移到新行行首；
3、Ctrl + /：注释(取消注释)选择的行；
4、Ctrl + Alt + L：格式化代码(与QQ锁定热键冲突，关闭QQ的热键)；
5、Ctrl + Shift + +：展开所有的代码块；
6、Ctrl + Shift + -：收缩所有的代码块；
7、Ctrl + Alt + I：自动缩进行；
8、Alt + Enter：优化代码，提示信息实现自动导包；
9、Ctrl + Shift + F：高级查找；
10、Alt + Shift + Q：更新代码到远程服务器；
11、Ctrl + N 查找所有的类的名称
12、Ctrl + Shift + N 查找项目中的任何文件
13、 移动语句向上/向下操作对于重新组织文件中的代码行非常有用，选择一个代码片段，然后按Ctrl + Shift +向上箭头或Ctrl + Shift +向下箭头。
"""
# x = 1
# print(type(x)) # type(object)来判断返回object的类型
# print(isinstance(x, int)) # 判断obj是否是指定的类型
# print(Fraction(3 / 7))
# print(7 // 3, '\n', 3 / 7, '\n', 3 % 7) # 整除 ； 浮点除法 ； 取余
# print(1 < 2 < 1, 1 < 2 and 2 < 1) # 这两种是等价的，连用时不考虑传递性，仅仅是相邻数之间的比较
# print(bool(100), bool(0)) # True等价于非0，False等价于0
# 三引号 ''' 或 """ 表示的字符串可以换行，用于长字符串，也用于在程序中表示较长的注释。
# 字符串界定符前面加字母r表示原始字符串，其中的特殊字符不进行转义，
# x = [random.randint(1, 100) for i in range(10)] # 1-100的任意整数
# print(x)
#
# x = [random.uniform(1, 100) for i in range(10)] # random.uniform(a, b) 在（a，b）之间任意取值 1-100间的任意浮点数
# print(x)
# a, b, c = 'Mike', '1', math.pi
# print(a, b, c, sep=', ') # 默认sep=' '
# a, b = 1, 2
# a, b = b, a
# print(a, b)
# a_list = [random.randint(1, 100) for i in range(10)]
# print(a_list)
# print(a_list.count(1)) # 某元素出现的次数
# a_list = [random.randint(1,100) for i in range(10)]
# a_list.sort() # 原地排序
# print(a_list)
# a_list.reverse()
# print(a_list) # 原地逆序
# a_list.clear()
# print(a_list) # 删除列表中所有元素，但保留列表对象
""" 列表 """
'创建列表'
# a_list = list('HelloWorld')
# b_list = list(range(1, 10, 1))
# c_list = list((1, 2, 3, 4, 5))
# print(a_list, b_list, c_list, sep='\n')
# 或者用列表推导式
'列表删除'
# del a_list
# print(a_list)
# NameError: name 'a_list' is not defined
# a_list = ['a','e','i','o','u']
# for i in range(5):
# del a_list[0]
# print(a_list) # 每次删除后，列表更新
# a_list = a_list.pop(1) # 删除指定 位置 的元素 默认为最后一个元素
# print(a_list) # 返回字母 e
# a_list.pop(1)
# print(a_list)
# a_list.remove('h') # 删去 首次出现 的指定元素h
# print(a_list)
# 删除列表【1,2,1,2,1,1,1】中的全部1
# x = [1,2,1,2,1,1,1]
# False:
# for i in x:
# if i == 1:
# x.remove(i)
# True: 浅拷贝
# for i in x[::]:
# if x[i]==1:
# x.remove(i)
'列表元素增加'
# insert append
# a_list.append(1) #添加元素1到列表尾部
# print(a_list)
# a_list.insert(0, 2) #选定位置添加元素2
# print(a_list)
# a_list = a_list + ["!"] # 大量元素不采用，相当于创建新的列表 建议用 append
# print(a_list)
# a_list.extend("python")
# print(a_list) # 在列表尾部添加元素，不改变其内存首地址
# a_list = a_list * 2
# print(a_list) # 利用*进行列表复制
# a_list = [a_list] * 2 # 创建多维数组
# print(a_list)
# a_list[0][0] = 'H'
# print(a_list)
# [['H', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '!'], ['H', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '!']]
# 通过乘法复制并不创建元素值的复制，而是创建已有元素对象的引用复制。因此，当修改其中一个值时，相应的引用也会被修改.
'列表元素访问与计数'
# count
# L.index(value, [start, [stop]]) 使用列表对象的index方法获取指定元素首次出现的下标
# a_list = [1, 2, 3]
# print(a_list.count(1)) # 使用列表对象的count方法统计指定元素在列表对象中出现的次数
'切片操作'
# [初值:终值:步长]
# 切片采用两个冒号分隔的3个数字来完成
# 第一个数字表示切片开始位置（默认为0）
# 第二个数字表示切片截至（但不包含）位置（默认为列表长度）
# 第三个数字表示切片的步长（默认为1）
# 当步长省略时可以顺便省略最后一个冒号
# 切片返回的是列表元素的 ！浅拷贝！
# a_list = [3, 5, 7]
# b_list = a_list
# b_list[1] = 1
# print(a_list, b_list) [3, 1, 7] [3, 1, 7]
# a_list[0] = 1
# print(a_list, b_list) [1, 1, 7] [1, 1, 7]
# print(a_list == b_list, a_list is b_list)
# a_list =[3,5,7]
# b_list = a_list[::]
# print(a_list is b_list) # False 说明是浅拷贝
# b_list[0] = 1
# print(a_list, b_list) [3, 5, 7] [1, 5, 7] , list里面的元素是不可变对象， b_list指向另一个地址了；若list里面是可变对象，则一起变
'附：切片操作'
'1.截取列表中任何部分，得到一个新列表 （切片操作不会因为选用的下标越界抛出异常）'
# a_list = [1,3,5,7,9]
# b_list = a_list[::-1] # 相当于reverse
# print(a_list, b_list)
'2.原地修改列表内容'
# 切片操作确实是返回原列表的副本，但是如果把切片作为左值使用的话（在赋值号左边出现），内核会对原件进行修改。
# a_list = [3, 5, 7]
# a_list[len(a_list):] = [9]
# print(a_list) [3, 5, 7, 9]
# a_list[:3] = [1, 2, 3]
# print(a_list) [1, 2, 3, 9]
# a_list[:3] = []
# print(a_list) [9]
'3.使用del与切片结合来删除列表元素'
# a_list = [3, 4, 5, 6, 7]
# del a_list[0:len(a_list):2]
# print(a_list)
'列表排序'
# list.sort() 无返回值，操作原列表；
# reversed(list) 对列表元素进行逆序排列并返回迭代对象
# sorted(list) 有返回值，生成新的列表
# a_list = [1,2,3,5,8,13,21,34]
# random.shuffle(a_list)
# print(a_list)
# a_list.sort() # 或者 a_list(reverse = True)
# print(a_list)
# a_list.reverse() # 将元素原地逆序
# print(a_list)
# print(sorted(a_list),reversed(a_list),list(a_list),sep=' \n')
'用于序列操作的常用内置内置函数'
# len返回元素个数； max min返回最大或最小元素； sum对数值型列表的元素进行求和运算
# zip
# enumerate
'列表推导式 利用其它列表创建新列表的一种方法'
# [表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]
# a_list = [x**2 for x in range(10)]
# print(a_list)
# b_list = [i for i in a_list if i % 2] # 过滤不符合条件的元素（过滤列表中的偶数）
# print(b_list)
# print([Python算法自学 for Python算法自学 in os.listdir('.') if Python算法自学.endswith('.py')]) # 列出文件夹下所有python文件
# c_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# print([num for elem in c_list for num in elem]) # 实现嵌套列表的平铺
# 等价于：
# d_list = []
# for elem in c_list:
# for num in elem:
# d_list.append(num)
# print(d_list)
# 使用多个循环
# 实现多序列元元素的任意组合，并且可以结合条件语句过滤特定元素
# print([(x,y) for x in [1,2,3] for y in [1,3,4] if x!=y])
# 一些复杂表达式: 列表推导式中可以使用函数或复杂表达式
# print([v**2 if v%2 == 0 else v+1 for v in [2, 3, 4, -1] if v>0])
# fp = open('C:\\Users\\xiaobingnan0224\\Desktop\新建文本文档.txt','r')
# print([line for line in fp])
# fp.close()
""" 元组,tuple """
# Y元组与列表类似，但属于不可变序列，一旦创建，用任何办法都不可以修改其元素
# 用 () 创建
'如果创建只有一个元素的数组，需要在元素后面加上一个逗号'
# a_tuple = (1,)
# a_tuple = tuple('2') 此时会报错，因为元组创建后不可修改
# a_tuple = () # 空元组
# b_tuple = tuple("hello world!") # 使用tuple函数将其他序列转换为元组
# print(b_tuple)
# a_list = [1,2,3]
# print(tuple(a_list))
# del b_tuple # del删除元组对象，不能删除元组元素
# print(b_tuple) # NameError: name 'b_tuple' is not defined
# tuple可以访问元素，但不可以赋值，同时其元素可以是可变对象
# a_tuple = tuple([random.randint(10, 100) for i in range(10)]) # 元素可变
# print(a_tuple, a_tuple[1], a_tuple[::2], sep='\n')
# tuple没有sort 用sorted吧
# b_tuple = (3, 2, 1)
# print(b_tuple * 2, b_tuple + (4, 5, 6), b_tuple, len(b_tuple), sum(b_tuple), b_tuple.count(1), b_tuple.index(1), sorted(b_tuple),
# sep='\n')
'元组元素不可变，但当元素指向的对象可变时，该对象的值可变'
# a_tuple = ([2,3],4)
# a_tuple[0][0] = 1
# print(a_tuple) ([1,3],4)
""" 序列解包 """
'用来对多个对象引用同时赋值' # 对象引用可以是变量名，可以是通过下标或者切片描述的多个list元素
# 对象引用可以通过圆括号、方括号来组织，通过逗号来分隔
# RHS可以是任何可迭代对象，包括tuple、list、dict、range、str等，逐个取该序列的元素赋予左边对应位置的对象引用
# 除了在有带星号的对象引用（*seq）外，要求RHS为与LHS对应的相同数量元素的可迭代对象
# 带星号的对象引用应该最多只出现一次，该引用前后的变量一一对应赋值后，剩余的变量转变为list然后赋予该引用
# x, y, z = ('hello', '!', 123)
# print((x, y, z), x, y, z)
# 'x,*y,z = range(1,7)'
# 'print(x,y,z) 1 [2, 3, 4, 5] 6'
" 补充：enumerate()：枚举元素，返回枚举对象，其每个元素为包含下标和值的‘元组’，函数对列表元组字符串均有效 "
" 补充：zip(iter1,iter2…): 返回zip对象，每次返回各个可迭代对象中对应的相同位置的各个元素组成的元组 "
# keys = ['a', 'b', 'c', 'd']
# values = [1, 2, 3, 4]
# for k, v in zip(keys, values):
# print(k, v)
# aList = [1, 2, 3]
# bList = [4, 5, 6]
# cList = [7, 8, 9]
# 1，4，7 为相同位置；2,5,8为相同位置；3,6,9为相同位置
# dList = zip(aList, bList, cList) # 将多个列表对应位置元素组合为元组，返回包含这些元组的zip对象
# list(dList) # Zip对象可以进一步用list()函数转换为列表对象
# for index, value in enumerate(dList):
# print(index, ':', value) # 其中 index 对应元素的下标， value 对应元素的值
# 生成器推导式
# 与列表推导式接近，使用圆括号
# 其结果是一个生成器对象
# 可将其转化为列表或元组
# 也可使用生成器对象的__next__()方法（Python 3.x）进行遍历，也可采用内置函数next(obj)
# g = ((i+2)**2 for i in range(3))
# for i in range(3):
# print(g.__next__()) # 或者 next(g)
# print(g)
# a_tuple = tuple(g)
# print(a_tuple)
# a_list = list(g)
# print(a_list)
# keys = [1, 2, 3]
# values = [4, 5, 6]
# for k, v in enumerate(zip(keys, values)):
# print(k, v)
# 0 (1, 4)
# 1 (2, 5)
# 2 (3, 6)
""" 毕达哥拉斯三元数组：存在{x,y,z}, 0<x<y<z,使得x^2+y^2=z^2。
求前10个毕达哥拉斯三元数组
"""
# pyt = [(x, y, z) for z in range(100) for y in range(2, z) for x in range(1, y) if x ** 2 + y ** 2 == z ** 2]
# print(pyt[:10])
# 'equals to:'
# a_list = []
# for z in range(100):
# for y in range(2,z):
# for x in range(1,y):
# if x ** 2 + y ** 2 == z ** 2:
# a_list.append((x, y, z))
# print(a_list)
""" 字典 """
# 包含 键——值 对的无序可变序列，也成为映射类型——键（keys）与值（values）的映射关系
# 键不允许重复，==关系
'可变对象不能作为key'
# 可以通过key查询到对应的值
# 字典创建与删除：
# a_list = [(1, 'java'), (2, 'C++'), (3, 'python')]
# d1 = {'values': 'Python', 'value2': math.pi}
# print(d1)
# print(dict(a_list)) #{1: 'java', 2: 'C++', 3: 'python'}
# z = zip(['one', 'two', 'three'], [1, 2, 3])
# d2 = dict(z)
# print(d2)
""" 字符串 """
# 字符串驻留机制： string interning
# a_str = 'FuDan'
# b_str = 'Fu' + 'Dan'
# print(id(a_str), id(b_str)) #2016720436080 2016720436080
# 字符串属于不可变序列类型
# 支持序列通用方法，包括切片操作
# 把一个字符串分m行输出 m由用户指定
# a_str = str(input('请输入一行字符：'))
# line = int(input('请输入行数：'))
# for i in range(line - 1):
# print(a_str[len(a_str) // line * i: len(a_str) // line * (i + 1)])
# print(a_str[len(a_str) // line * (line - 1):len(a_str):])
# 字符串联接函数 join函数
# li = ["apple", "peach", "banana", "pear"]
# sep = "**"
# s = sep.join(li)
# print(s)
# "apple**peach**banana**pear"
# print(" ".join(input('请输入一个字符串：')))
# 列出1000以内的所有的回文数
# a_list = []
# for i in range(1000):
# s = str(i)
# if s == s[::-1]: # 字符串切片
# a_list.append(s)
# print(a_list)
# 字符串对齐方法
# .center(.) • 返回指定宽度的新字符串，原字符串居中，并使用指定字符(默认空格)填充
# .ljust(.) • 返回指定宽度的新字符串，原字符串左对齐，并使用指定字符(默认空格)填充
# .rjust(.) • 返回指定宽度的新字符串，原字符串右对齐，并使用指定字符(默认空格)填充
# 字符串格式化
# a_str = 123
# print("%d" % a_str, "%b" % a_str, "%o" % a_str, "%x" % a_str)
# format()
# position = (5, 8, 13)
# print("X:{[0]}".format(position))
# 字符串查找 find() rfind() index() rindex() count()
'find分别查找一个字符串在另一个字符串指定范围首次、最后一次出现的位置，不存在返回-1'
'index方法用来返回一个字符串在另一个字符串指定范围中首次和最后一次出现的位置，如果不存在则抛出异常'
'count返回一个字符串在另一个字符串中出现的次数'
# a_str = 'aaa'
# print(a_str.find('a', 2))
# >>> s="apple,peach,banana,peach,pear"
# >>> s.find("peach")
# 6
# >>> s.find("peach",7)
# 19
# >>> s.find("peach",7,20)
# -1
# >>> s.rfind('p')
# 25
# >>> s.index('p')
# 1
# >>> s.index('pe')
# 6
# >>> s.index('pear')
# 25
# >>> s.index('ppp')
# Traceback (most recent call last):
# File "<pyshell#11>", line 1, in <module>
# s.index('ppp')
# ValueError: substring not found
# >>> s.count('p')
# 5
# >>> s.count('pp')
# 1
# >>> s.count('ppp')
# 0
# 字符串分割
# split() rsplit() 以指定字符为分隔符，返回包含分割结果的列表
# partition() rpartition() 以指定字符串为分隔符将原字符分割为三部分元组：“分隔符前的字符串、分隔符字符串、分隔符后的字符串” 若指定的分隔符不在原字符串中，则返回原字符串和两个空字符串
# rsplit() rpartition() 是从右端开始分割 split partition 是从左端
# a_str = "apple,banana,orange,peach"
# print(a_str.split('a'),a_str.split(','))
# print(a_str.partition('banana'),a_str.partition(','))
# s = 'My name is XiaoBingNan'
# # 还允许指定最大分割次数：
# print(s.split(None, 1), s.split(None, 2), s.split(None, 3))
# 字符串替换
# s = 'A and a'
# s1 = s.replace('a', 'b')
# print(s1)
# 字符串转换
'字符串消减 s.strip()'
# • strip()、rstrip()、lstrip()
# 这几个方法分别用来删除两端、右端或左端的空格或连续的指定字符。
# >>> s=" abc "
# >>> s2=s.strip( )
# >>> s2
# "abc"
# >>> "aaaassddf".strip("a")tt6
# "ssddf"
# >>> "aaaassddf".strip("af")
# "ssdd"
# >>> "aaaassddfaaa".rstrip("a")
# 'aaaassddf'
# >>> "aaaassddfaaa".lstrip("a")
# 'ssddfaaa'
# 字符串成员判断 in（返回ture false）
# s = 'a,b,c,d'
# print('a' in s, 'e' in s)
# print(int(False),int(True)) # 0 1
# s.startwith() s.endswith() 判断字符串是否以指定字符串开始或结束 返回True False
# s = 'aeiou'
# print(s.startswith('a'))
# print(s.endswith('u'))
# 检验字符串是否为字母数字等 返回True或False
# s.a_method()
# isalnum() —— 检验字符串是否为数字或字母
# isalpha() —— 检验字符串是否为字母
# isdigit() —— 检验字符串是否为数字字符
# isspace() —— 检验字符串是否为空白字符
# isupper() —— 检验字符串是否为大写字母
# islower() —— 检验字符串是否为小写字母
# 小练习 用户随意输入一串字符，程序依次在相邻位置插入一个空格，逐行输出。
# def StrOutput():
# s = str(input("请输入一串字符: "))
# t = ' '
# for i in range(1, len(s)):
# print(s[:len(s) - i:] + t + s[len(s) - i::])
# print('________')
# for i in range(1, len(s)):
# print(s[:i:] + t + s[i::])
#
#
# StrOutput()
# 连续输入若干行字符串（以空行结束） 输出最长的那些行
# '将输入的字符串写入列表：'
# a_list = []
# while True:
# s = input()
# a_list.append(s)
# if s == '':
# break
# print(a_list)
# '取得最大长度：'
# a_max = a_list[0]
# for i in range(1, len(a_list)):
# a = len(a_list[i])
# if a > len(a_max):
# a_max = a
# '输出等于最大长度的成员：'
# for j in range(len(a_list)):
# if len(a_list[j]) == len(a_max):
# print(a_list[j])
" map() 函数 :"
'''map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。
参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。'''
# https://blog.youkuaiyun.com/csdn15698845876/article/details/73321593?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.control
# 检查两个单词是否为相似词。两个单词如果包含相同的字母，则它们是相似词。例如：silent和listen是相似词
# print('请输入两个单词，以空格为分隔：', end='')
# a_str, b_str = map(str, input().split())
# state = False
# while True:
# for a_letter in a_str:
# for b_letter in b_str:
# if a_letter == b_letter:
# state = True
# break
# else:
# break
# if state:
# print('单词', a_str, '与单词', b_str, '是相似词！')
# else:
# print('单词', a_str, '与单词', b_str, '不是相似词！')
# 正则表达式—— import re
# ^ $ . * ? + - \ {} [] | () 作为正则表达式的元字符，若作为普通字符则需要转义
# print(re.findall('a', 'An eagle lives in a cave')) 以列表形式列出字符串中模式的所有匹配项
# 正则表达式元字符
""" 函数 """
'默认值参数' # 即可为形参设置默认值
# Python在定义函数时，支持默认值参数，即可为形参设置默认值。
# def 函数名(……，形参名=默认值)
# 调用带有默认值参数的函数时，可以不对默认值参数进行赋值，也可以赋值，具有较大的灵活性。
# 使用“函数名._defaults_” 以元组的形式查看函数所有默认值参数的当前值
# 默认值参数必须出现在函数参数列表的最右端，且任何一个默认值参数右边不能有非默认值参数。
# def test_func(a, b, c=5):
# print(a, b, c)
# test_func(1,2,3) 1 2 3
# test_func(1,2) 1 2 5
'使用指定分隔符将列表中所有字符串元素连接成一个字符串，默认空格'
# def Join(a_list, a_sep):
# return a_sep.join(a_list)
# b = ['f', 'u', 'c', 'k']
# print(Join(b, '!'))
'关键参数'
# 通过关键参数可以按参数名字传递值，实参顺序可以和形参顺序不一致，
# 但不影响传递结果，避免了用户需要牢记位置参数顺序的麻烦。
# >>> def demo(a,b,c=5):
# print (a,b,c)
# >>> demo(3,7)
# 3 7 5
# >>> demo(a=7,b=3,c=6)
# 7 3 6
# >>> demo(c=8,a=9,b=0)
# 9 0 8
'可变长度参数'
' *parameter：接收多个实参并将其放在一个元组中 '
' **parameter，接收字典形式的实参 '
# def demo(**p):
# for item in p.items():
# print(item)
# demo(x=1,y=2,z=3)
'参数传递的序列解包'
# 为含有多个变量的函数传递参数时，
# 可以使用Python列表、元组、集合、字典以及其他可迭代对象作为实参
# 并在实参名称前加一个星号*
# Python解释器将自动进行解包
# def demo(a,b,c):
# print(a+b+c)
# dic={1:'a',2:'b',3:'c'}
# demo(*dic) # 6
# demo(*dic.values()) # abc
'return语句'
# 如果函数没有return语句或者没有执行return语句，执行了不带任何值的return语句，
# 则函数都默认为返回空值None。
'调用内置数据类型的方法时，一定要注意该方法有没有返回值。'
'局部、全局变量'
# 一个变量已在函数外定义，如果在函数内需要为这个变量赋值，
# 并要将这个赋值结果反映到函数外，可以在函数内用global声明这个变量，将其定义为全局变量。
# 在函数内部直接将一个变量声明为全局变量，在函数外没有声明，
# 在调用这个函数之后，将增加为新的全局变量。
# pi = 3.141592653589793
# e = 2.718281828459045
# def my_func():
# global pi
# pi = 3.14
# print('global pi =', pi)
# e = 2.718
# print('local e=', e)
# print('module pi =', pi)
# print('module e=', e)
# my_func()
# print('module pi =', pi)
# print('module e=', e)
# module pi = 3.141592653589793
# module e= 2.718281828459045
# global pi = 3.14
# local e= 2.718
# module pi = 3.14
# module e= 2.718281828459045
'lambda表达式'
'文件操作'
# 文本分类：
# 文本文件： 存储的是常规字符串，由若干文本行组成，通常每行以换行符'\n'结尾。
# 二进制文件：不能使用记事本或其他文本编辑软件进行正常读写，也无法通过Python的文件对象直接读取和理解二进制文件的内容。
# 文件对象的操作：
# 打开：使用open()；
# 操作：读、写、删除等操作；
# 关闭：使用close()。
# 文件对象名 = open（文件名[，访问模式[，缓冲区]])
# 缓冲区：读写文件的缓存模式；
# 0表示不缓存，1表示缓存，大于1则表示缓冲区的大小，小于0则表示使用默认的缓冲区大小；
# 默认值是缓存模式。
# r 读模式
# w 写模式
# a 追加模式
# b 二进制模式
# + 读写模式
# 典型调用方式
# 以读模式打开文件：f = open('a.txt')
# 以读模式打开二进制文件：f = open('c.dat','rb')
# 以读写模式打开文件（文件不存在则创建文件，否则置文件指针到文件尾）：f = open('b.csv','a+')
# f = open('test.txt', 'a+')
# print(f.name,f.encoding,f.mode,f.closed)
# f.readlines() 把文本文件中的每行作为字符串插入列表中并返回该列表
# f.readline() 从文本文件中读取一行内容
# f.write(s) 把字符串s的内容写入文件 f.wirtelines(s) 则不添加换行符写入
# f.truncate(size) 删除从当前指针位置到文件末尾的内容，如果制定了size 则不论指针在什么位置都只留下前size个字节，其余的删除
# 文件操作模式
# lines=[]
# handler=open(”sample.txt”)
# try:
# lines = handler.readlines()
# finally:
# handler.close() # 保证资源的释放
# lines=[]
# with open(”sample.txt”) as handler:
# lines = handler.readlines()
# print(lines)
# def fa(fname):
# f = open(fname)
# while True:
# line = f.readline()
# if line == '':
# break
# print(line.strip())
# # end while
# f.close()
#
#
# fa('test.txt')
# f = open('sample.txt', 'a+')
# f.truncate(0)
# s1 = '1\tfudan\t复旦大学\t中国上海\t200433\n'
# s2 = '2\tsjtu\t交通大学\t中国上海\t200240\n'
# f.write(s1)
# f.write(s2)
# f.close()
# s1 = '1\tfudan\t复旦大学\t中国上海\t200433\n'
# s2 = '2\tsjtu\t交通大学\t中国上海\t200240\n'
# with open('sample.txt', 'a+') as f:
# f.write(s1)
# f.write(s2)
""" 异常处理结构与程序调试 """
# 抛出异常 raise 语句
' raise[SomeException[, args[,traceback]] '
# a_number = int(input("Enter a number: "))
# try:
# print(math.sqrt(a_number))
# except:
# print("Value is wrong")
# print("Using absolute value instead")
# print(math.sqrt(abs(a_number)))
# 常见的异常处理结构：
# try...except
# while True:
# try:
# x = int(input('Please enter an integer: '))
# break
# except ValueError:
# print('That was not an integer. Try again...')
# Please enter an integer: a
# That was not an integer. Try again...
# Please enter an integer: 1.2
# That was not an integer. Try again...
# Please enter an integer: -1
# try:
# raise Exception()
# try...except...else
# 带有多个except的try结构
# try...except...finally
'断言与上下文处理'
# 两种特殊的异常处理形式
# 形式上比通常的异常处理简单
# assert expression[,reason]
# 若为真，什么也不做；若未假，则抛出异常
# 使用with进行上下文管理
扫一扫
231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
