python编程技术课程记录笔记
作者：互联网
目录：
一、变量
二、字符串
三、列表和元组
四、布尔值
五、条件语句if
六、函数
七、对象的方法
八、格式化字符串
九、循环
十、文件的读写
十一、字典和json
十二、编程的思路
十三、模块与包
十四、yaml文件操作
十五、pycharm的使用技巧
十六、request与爬虫
十七、面向对象基础
十八、反射与单例模式
一、变量
# 变量与对象,一切皆为对象,可变的量都是变量
print(type('123fff')) # str
print(2 / 3) # 0.6666666666666666
print(2 ** 100) # 2的100次方
# 字符串
print("""hello""") # hello
print('''hello''') # hello
print('hello') # hello
print("hello") # hello
welcome = '欢迎来学习自动化' # python定义变量要给初始值
a = '小刘'
print(a, ',', welcome)
# 数字不能开头，用字母开头
b = 1
b = b + 1
b += 1 # 等于b=b+1
b -= 1 # 等于b=b-1
b *= 1 # 等于b=b*1
b /= 1 # 等于b=b/1
二、字符串
# 字符串,单引号和双引号都可表示字符串
url = 'https://www.baidu.com'
url2 = "https://www.baidu.com"
print(url, ',', url2)
# 当句子中有单引号，外面就用双引号引起来；当句子中有双引号，外面就用单引号引起来；当句子中有单、双引号，外面就用三引号引起来
str1 = "It's OK"
print(str1)
# 三引号也可以表示换行
str2 = ''' 飞流直下三千尺，
疑是银河落九天'''
print(str2)
# 转义符 \n换行符；\t制表符
filepath = 'D:\soft\note.txt' # \n表示换行了
print(filepath)
''' D:\soft
ote.txt '''
# 解决1：
filepath = 'D:\\soft\\note.txt' # 用双\\，表示后面的\是普通字符
print(filepath)
# 解决2：在字符串前加上r，表示后面的字符串中，所有的转义符均无效
filepath = r'D:\soft\note.txt'
print(filepath)
# 解决3：表示路径时，用/代替\。（对于电脑来说，路径用\ 、 /都可以）
filepath = 'D:/soft/note.txt'
print(filepath)
# 字符串的拼接
print(1 + 1) # 2
# print(1 + '1') # int和str会报错
print('1' + '2') # 11,字符串拼接
print('1' * 6) # 结果是111111，表示将字符串1打印6次
a = 9
b = '6'
print(9 + int(b)) # 使用int()函数，将字符串转化为数字，得到15
print(str(9) + b) # 使用str()函数，将int类型转化为字符串，进行拼接，得到96
# 字符串的下标
str3 = 'adhjhhfuerhfkjfkjfer'
print(str3[1]) # d ,下标从左边0开始
print(str3[-3]) # f ,下标右边从-1开始
# str3[1] = 'a' # 会报错，'str' object does not support item assignment。因为str类型是不可变的对象，不能只修改一个值
# 字符串的切片 [起始值：终止值：步长]：包含起始值，不包含终止值，所以终止值要+1。步长默认为1，代表每次走一步
id_card = '320150199802254422' # 18位身份证
# 取出生日期19980225
birthday = id_card[6:14] # 从第6位到14位，正下标
print(birthday)
birthday1 = id_card[-12:-4] # 从第6位到14位，负下标
print(birthday1)
# 如果要取到最后一位 id_card[-12:]
# 步长为2,得到19980225里面的1，3，5，7位1902
birthday2 = id_card[-12:-4:2] # 从第6位到14位，负下标，步长为2
print(birthday2)
# 步长为-1,从-12位开始向左取全部的数，3201501
birthday3 = id_card[-12::-1] # 从第6位到14位，负下标，步长为2
print(birthday3)
三、列表和元组
# 列表 元组
# 列表类似java里面的数组，与数组不同的是可以包含各种类型的对象;列表是可变对象，可以增删改
list_a = [1, 'a', [1, 2, 3], (4, 5, 6), {"name": "zhang"}]
print(list_a)
# 增
list1 = [1, 2, 3]
list1.insert(0, 999) # 在第0位增加一个999
print(list1)
# 拼接
list2 = [4, 5, 6]
list1.extend(list2) # 将list1和list2拼接到一起，得到[999, 1, 2, 3, 4, 5, 6]，list2没有变
print(list1)
print(list2)
# 改
list1[0] = 88 # 把list1的第0位改成88，得到[88, 1, 2, 3, 4, 5, 6]
print(list1)
# 删除
print(list1.pop()) # pop()默认删除最后一位下标，也可以指定下标进行删除，有返回值
print(list1) # 得到[88, 1, 2, 3, 4, 5]
list1.pop(0)
print(list1) # 把88删掉，得到[1, 2, 3, 4, 5]
list1.remove(4) # 把4删掉，remove（）是直接删除值，如果有多个4，那也只删除从左开始碰到的第1个
print(list1) # 得到[1, 2, 3, 5]
del list1[0] # 删除下标的元素1，也可以直接删除list1
print(list1) # 得到[2，3，5]
# 切片---也是一个新对象
list3 = [11, 22, 33, 44, 55, 66, 77]
list3_new = list3[0:3] # 从下标0开始切片，到第三位，也可以写成[:3]，得到[11，22，33]；负下标list3[-7:-4]
list3_new1 = list3[-7:-4]
print(list3_new1)
# 元组，属于不可变对象，也可以使用下标和切片，但是不能增删改
tuple_1 = (100, 200, 300, 400)
# 元组中只有一个元素时，要加一个逗号
tuple_2 = (100)
print(type(tuple_2)) # 得到int类型
tuple_3 = (100,)
print(type(tuple_3)) # 得到tuple类型
# 如果元组中有子列表，子列表里面的值可以修改，但是不能直接替换掉子列表
tuple_4 = (100, 200, 300, 400, [11, 22, 33])
tuple4_new = tuple_4[4][1] # 取到列表的第一位22
print(tuple4_new)
tuple_4[4][2] = 99 # 修改列表的第二位33为99 ，得到(100, 200, 300, 400, [11, 22, 99])
print(tuple_4)
四、布尔值
# 布尔类型、布尔表达式、条件组合
# 布尔值：True False （真 假 、 0 1）
# python中，=表示赋值，==表示判断恒等，!=表示判断不相等
print(1 == 2) # 得到False
print(1 != 2) # 得到True
print('a' == 'A') # 得到False;字符串之间的比较用ASCII值，a=97，A=65
# in ， not in
list1 = [1, 2, 3, 4, [999, 888]]
print(1 in list1) # 得到True
print(9 not in list1) # 得到True
print(888 in list1) # 得到False,888属于子列表，应该写成888 in list1[-1]
# and ， or 执行程序时，第一、二、三个式子只要它能判断式子是假/真，后面式子就可以不再执行，直接返回False/True
print(3 > 2 and 2 > 1 and 5 > 3) # True，用and都为真就是真。全真为真
print(3 > 2 and 2 > 1 and 5 > 9) # False，用and有一个假就是假。一假全假
print(3 > 2 or 0 > 1) # True,用or的时候有一个为真就是真，全部是假的就是假。一真为真，全假为假。
# not and or 组合语句。不同情况按照优先级分析，not>and>or，相同情况按照从左到右
print(2 > 1 and 1 > 2 and not True or 3 > 2) # 得到True。
'''
1.先分析not： not True=false，所以假
2.分析and：2>1 and 1>2，是假。
3.分析or，or前面都是假，3>2是真，所以结果是真
2 > 1 and 1 > 2 and not True or 3 > 2
真 假 假 真
'''
print(2 > 1 and 1 > 2 and (not True or 3 > 2)) # 得到False
'''
通过括号改变运算优先级，先算括号里面的，所以是not>or>and
(2 > 1 and 1 > 2 and (not True or 3 > 2))
真 假 假 真
1.括号里是真
2.and是假
得到结果就是假
'''
# 浅拷贝 深拷贝
# 赋值--对列表赋值相当于起了一个别名，2个对象指向的是同一个对象。比如小张有1个外号张总，小张改变了，那张总也对应改变
list2 = [11, 22, 33]
list2_new = list2
list2[0] = 99
print(list2, id(list2))
print(list2_new, id(list2_new))
print('---------------分界线--------')
# 浅拷贝，等价于完整切片
import copy
# 浅拷贝
list3 = [91, 95, 66, 44, [1000, 200, 300]]
list3_new = copy.copy(list3) # 浅拷贝，生成了新的对象，子列表仍然是同一个对象
list3[0] = 100
list3[-1][0] = 000
print('------浅拷贝', list3, id(list3), id(list3[-1])) # list3改变了,子列表一起改变
print('------浅拷贝', list3_new, id(list3_new), id(list3_new[-1])) # list3_new没变,子列表一起改变
print('---------------分界线--------')
# 完整切片
list5 = [91, 95, 66, 44, [1000, 200, 300]]
list5_new = list5[:]
list5[0] = 100
list5[-1][0] = 123
print('------切片', list5, id(list5), id(list5[-1])) # list5改变了,子列表一起改变
print('------切片', list5_new, id(list5_new), id(list5_new[-1])) # list5_new没变,子列表一起改变
print('---------------分界线--------')
# 深拷贝
list4 = [91, 95, 66, 44, [1000, 200, 300]]
list4_new = copy.deepcopy(list4) # 浅拷贝，生成了新的对象，子列表也是新的对象
list4[0] = 100
list4[-1][0] = 456
print('-----深拷贝', list4, id(list4), id(list4[-1])) # list4改变了,子列表一起改变
print('-----深拷贝', list4_new, id(list4_new), id(list4_new[-1])) # list4_new没变,子列表没变
五、条件判断
# 条件判断
# 分支语句：顺序结构，分支结构，循环结构
# python对于缩进有严格的要求，对于缩进的空格没有要求，一般默认缩进4格
if 10 > 9:
print('hello') # 如果10>9为真，执行输出hello；如果是假，就不执行
# 写一个程序，用户输入分数，如果分数大于等于60，打印合格
score = input('请输入分数：') # input（）是从键盘获取到用户输入的值，返回的值是string类型。如果用户输入的是数字，要转成int型才能做比较
# 如果用户输入的是字符串，那么用int也不能转，可以写判断语句
if not score.isdigit(): # isdigit()判断对象是否是纯数字,如果输入的不是纯数字，就打印
print('您输入的不是数字')
else:
score = int(score)
if score >= 60:
print('合格')
else:
print('不及格')
# 写一个程序，用户输入分数，如果分数大于等于90，打印优秀；如果大于等于80，打印良好；如果大于等于60，打印合格；小于60不合格
score1 = input('请输入分数：') # input（）是从键盘获取到用户输入的值，返回的值是string类型。如果用户输入的是数字，要转成int型才能做比较
# 如果用户输入的是字符串，那么用int也不能转，可以写判断语句
if not score1.isdigit(): # isdigit()判断对象是否是纯数字,如果输入的不是纯数字，就打印
print('您输入的不是数字')
else:
score1 = int(score1)
if score1 >= 90:
print('优秀')
elif score1 >= 80: # 如果不用elif，都用if，那么输入62时，会打印出优秀、良好和合格。每个if都是独立的分支语句。用elif起到分支的作用
print('良好')
elif score1 >= 60:
print('合格')
else:
print('不合格')
# 复合条件语句
# 例：如果一个人年龄大于60岁，且是男性，我们称他为老先生
age = 62
sex = '男'
# 写法1：
if age >= 60 and sex == '男': # 用==判断恒等
print('他是老先生1')
# 写法2：
if age >= 60:
if sex == '男':
print('他是老先生2')
六、函数
# 函数的定义与调用，参数和返回值
# 函数是一段封装的代码，需要它的时候可以调用
def fun1(): # 1.def是define，定义函数的关键字 2.fun1是函数名，函数名尽量用小写
print('这是一个函数') # 函数主体语句，必须有；没有语句用pass占位符代替
def fun2():
return 'hello'
# 调用函数
# 方法一，直接调用
fun1()
print(fun1()) # 先打印’这是一个函数‘，再返回None，因为函数没有返回值
fun2() # 返回显示是空的，因为没有print打印，实际的返回值hello已经写入
print(fun2()) # 打印返回值hello
# sin(30*) = 0.5, sin(90*) = 1,sin(45*) = 2**0.5/2,括号里面的30 90 45 就是函数的参数，后面的结果就是函数的返回值
# 写一个函数，可以计算两数之和
def add_func(x, y): # x，y是形式参数，简称形参
return x + y
# 方法二，赋值调用
a = add_func(5, 6) # 调用，把返回值赋给a ； 5和6是实际参数，简称实参
print(a) # 11
# 如果调用add_func(5)，少参数会报错，因为实参数量小于形参数量；多参数也会报错
def add_func1(c=100, b=90): # a和b有默认值
return c + b
print(add_func1(60)) # 只传一个参数，默认替代第一个参数a，b还是90，打印150
print(add_func1()) # 不传参数，使用默认值，打印190
print(add_func1(b=10)) # 只传一个参数，指定替代b，a还是100，打印110
print(add_func1(10, 20)) # 传2个参数，都替代函数里的默认值，打印30
print(add_func1(b=110, c=120)) # 传2个参数，位置可以指定，都替代函数里的默认值，打印230
# 函数中可以出现多个return，但是没必要
# 写一个函数，返回数的绝对值
def abs_value(n):
if n >= 0:
return n
return '34344' # 在第一个return执行完毕之后，程序跳出，后面的renturn不执行，称为不可达语句
else:
return -n
print(abs_value(-5))
# 函数能否return多个值？-------可以，以元组的形式返回
def add_func2(e=100, f=90):
return e, f, e + f, e - f
print(add_func2()) # 得到元组(100, 90, 190, 10)
def add_func3(e=100, f=90):
return [e, f, e + f, e - f] # [e, f, e + f, e - f]是一个对象，是一个值，不会组合成元组
print(add_func3()) # 得到list[100, 90, 190, 10]
# 可变长度参数
# 自己写的函数叫做自定义函数，python里自带的叫做内置函数
# print(1, 2, 3, 4, 5, 6, 7) # 不管传几个参数，都能打印处理
# *args：允许用户输入任意个参数
def fun_change(*args):
# print(args)
return args
print(fun_change(1, 2, 3, 4, 5, 6, 7)) # 打印出(1, 2, 3, 4, 5, 6, 7)
# 关键字参数:**kwargs:允许用户输入任意个参数，用户传的参数必须是a=b的格式，相当于键值对，返回值是字典类型
def fun_arbitrary(**kwargs):
return kwargs
print(fun_arbitrary(name='九九', age=18)) # 得到{'name': '九九', 'age': 18}
# def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
# print(）函数中的sep=' '表示每个参数的间隔符，默认用空格分割，end='\n'表示打印完就换行
print(1, 2, 3, 4, 5, 6, 7, sep='=') # 得到1=2=3=4=5=6=7
print(1, end='')
print(2, end='') # 把换行符去掉，打印完不换行，得到12
七、对象的方法
# 对象的方法，其实就是函数，只不过是写在类里面的
str1 = 'abchdjdj' # str1是一个字符串，可以直接使用类str中的函数
str1.isdigit()
str1.format()
# def index(self, sub, start=None, end=None):返回值是数字
a = str1.index('d') # 返回某个或某些字符串中的位置，默认从头查找，也可以指定起始位置进行查找
print(a)
print(str1.index('d', 5)) # 从第五位开始查找
# index()方法，找不到键值会报异常：
# print(str1.index('c', 4)) # 报错，substring not found
# find()方法找不到键值会返回-1
# strip() :默认是去掉字符串前后的空格，也可以指定去掉字符，但是只能去掉字符串外面的字符
print(str1.find('c', 4))
str2 = ' whdwehfkwef'
str2_new = '*********fjdk***fhkjd********'
print(str2.strip()) # whdwehfkwef
print(str2_new.strip('*')) # fjdk***fhkjd，字符串里面的*不会被去掉
# relace(oldstr,newstr) ：oldstr是需要替换的字符，newstr是替换后的字符，返回值是str型，可以一直替换
print(str1.replace('d', 'k').replace('abc', 'KKK')) # 把所有的d替换成k后，再把abc替换成KKK
# 如果没有找到要替换的字符，就保持原样不进行替换
# startswith() ：判断字符串是否以某个或某些字符开头，返回值是true或false
# 根据身份证号判断是否是南京的身份证
id_card = '320104199905024422'
if id_card.startswith('3201'):
print('南京的身份证')
# endswith() ：判断字符串是否以某个或某些字符结尾，返回值是true或false
# 根据身份证号最后一位是否是X
if id_card.endswith('X'):
print('最后一位是X')
# split() 切割字符串，它有一个参数，以参数作为切割符，将字符分隔成多个值，返回值是列表
str4 = '你好，中国'
print(str4.split('中')) # ['你好，', '国']，中字消失
# 如果切割符位于首位或结尾，会产生空值
print(str4.split('国')) # ['你好，中', '']
# 如果没有找到切割符，会把原来的字符串转成列表
print(str4.split('1')) # ['你好，中国']
八、格式化字符串
# 格式化字符串
# 输出10+5=15
a = 10
b = 5
print(str(a) + '+' + str(b) + '=' + str(a + b)) # 字符串拼接方式实现
print('%d+%d=%d' % (a, b, a + b)) # 格式化字符串实现
# 方案一
# %s：字符串 %d：整数 %f：浮点数
info1 = '我是%s，你是%s，他是%s，今年是%d年' % ('刘德华', '古天乐', '刘青云', 2022)
print(info1)
# 前面的空位比后面的值多，会报错not enough arguments for format string
# info2 = '我是%s，你是%s，他是%s，今年是%d年' % ('刘德华', '古天乐', 2022)
# 前面的空位比后面的值少，报错：not all arguments converted during string formatting
# info3 = '你是%s，他是%s，今年是%s年' % ('刘德华', '古天乐', '刘青云', 2022)
# 前面用%d，后面用字符串，会报错 ：%d format: a number is required, not str
# info4 = '我%d岁' % ('刘德华')
# 前面用%s，后面用数字，不会报错
info4 = '我叫%s' % 100
# 自动补齐%n，n是任意正整数，不足n位，用空格补齐到n位；默认右对齐；超过n位则全部显示
# %5n代表这个字符串有5位，格式化提供的只有3位，所以会补齐2个字符的空格
# 得到：我是刘德华上天下地霹雳无敌雷劈电视动画，你是 古天乐，他是刘青云，今年是2022年
info5 = '我是%6s，你是%5s，他是%s，今年是%s年' % ('刘德华上天下地霹雳无敌雷劈电视动画', '古天乐', '刘青云', 2022)
print(info5)
# 如果想补0，就写成%0位数d
info6 = '我的编号是%05d' % 7 # 我的编号是00007
print(info6)
# 补齐时左对齐显示，空格在后面。但是前面补的0会消失，只会在后面补空格
# 得到：我是刘德华上天下地霹雳无敌雷劈电视动画，你是古天乐 ，他是刘青云，今年是2022 年
info7 = '我是%s，你是%-5s，他是%s，今年是%-08s年' % ('刘德华上天下地霹雳无敌雷劈电视动画', '古天乐', '刘青云', 2022)
print(info7)
# %f浮点型，默认保留6位小鼠
number1 = '你输入的数字是%f' % 3.6
print(number1) # 得到你输入的数字是3.600000
# 保留2位小数，%.小数位f
number2 = '你输入的数字是%.2f' % 3.6
print(number2) # 得到你输入的数字是3.60，如果是最少要显示10位，可以%10.2f，得到 3.60，格式化时小数点占一位
# 方案二,参数用{}代替，不用关注类型
str1 = 'My name is {},your name is {},age is {}.'.format('clark', 'ralf', 20)
print(str1) # My name is clark,your name is ralf,age is 20.
# 前面的空位比后面的值少，不报错，多的不显示
# 前面的空位比后面的值多，报错
# {}没有写数字时，称为顺序取值法，写了数字，称之为下标取值法，下标从0开始，{}都要写下标，2种方法不能混用，不然会报错
str2 = 'My name is {1},your name is {0},age is {2}.'.format('clark', 'ralf', 20)
print(str2) # My name is ralf,your name is clark,age is 20.
# 补齐{：n} n是任意整数，不足n位时补齐到n位,字符是左对齐，数字是右对齐
str3 = 'My name is {:8},your name is {:9},age is {:5}.'.format('clark', 'ralf', 20)
print(str3) # 得到My name is clark ,your name is ralf ,age is 20.
# 改变对齐方式：左对齐：<，居住对齐^，右对齐>。{0:>8}：第0个参数右对齐显示8位
str4 = 'My name is {:>8},your name is {:^9},age is {:<5}.'.format('clark', 'ralf', 20)
print(str4) # 得到My name is clark,your name is ralf ,age is 20 .
# 补0，字符串补0没意义
str5 = 'My name is {:>08},your name is {:^09},age is {:>05}.'.format('clark', 'ralf', 20)
print(str5) # 得到My name is 000clark,your name is 00ralf000,age is 00020. 居中对齐就是2边都补0
# 在python3.6以后的版本，f’{}’ 用法等同于 format用法的简单使用，更加方便。：后面跟位数
name1 = 'clark'
name2 = 'Ralf'
print(f'my name is {name1:10},your name is {name2:8}.') # my name is clark ,your name is Ralf .
九、循环
# 循环语句
# while循环，打印0到10的数字
i = 0
while i <= 10: # while后面的布尔表达式为真，则一直执行循环内的语句，直到表达式的值为假，循环才结束
print(i)
i += 1
# for循环实现从1到10的打印，左闭右开
for a in range(1, 11): # range（起始值，终止值，步长） 包含起始值，不包含终止值，步长默认为1
print(a)
# 利用步长打印1-100的奇数：
for b in range(1, 100, 2):
print(b)
# for循环的起始值，不写时默认为0；终止值必须写
for c in range(10):
print(c) # 打印了0-9的数
# 遍历列表
'''
list1 = ['张飞', '刘备', '关羽', '马超']
for d in range(len(list1)):
print(list1[i])
'''
list1 = ['张飞', '刘备', '关羽', '马超']
for d in list1:
print(d)
# break:终止循环（强制性终止） continue：跳出当此循环
for e in range(1, 11):
if e == 5:
# break
continue
print(e) # break打印出1-4，continue打印出1，2，3，4，6，7，8，9，10，去掉了5，因为5跳出循环
else: # 循环语句也可以带一个else语句，当循环中没有出现break，则循环结束时，运行else部分
print('循环执行完毕')
# 写一个倒计时程序，循环实现
import time # 加载time模块
for i in range(10, 0, -1): # 起始值是10，终止值是0，从大到小，步长是负的
print(f'\r倒计时{i}秒', end='') # \r：光标回到行首；end=‘’：不换行
time.sleep(1) # 让程序等待1秒
else:
print('\r倒计时结束')
十、文件的读写
# 文件的读写，正反斜杠都能识别，防止有转义符，就用反斜杠。open()读取的是文本类的文档
filepath = 'D:/note/note1.txt' # 文件路径
file1 = open(filepath) # 打开一个文件，默认mode='r'，读取模式，不可写入
# print(file1.read()) # 读取并打印文件的内容：1111
file1.close() # 关闭文件，使用open()时，必须要用close(0，否则会一直占用内存
file2 = open(filepath, 'w') # 以写入的模式打开，不可读取
file2.write('ABC') # 文本内容被替换成ABC
file2.close() # 关闭文件
# w+ 可以同时读写，如果文件不存在，则新建文档，写入时是清空写入
# r+ 可以同时读写，如果文件不存在，则报错，写入时是覆盖写入
# a+ 可以同时读写，如果文件不存在，则新建文档，写入时是追加写入
file3 = open('D:/note/note2.txt', 'w+') # 以w+的模式打开，新建了一个文本
file3.write('ABC') # 文本内容写入ABC
file3.close() # 关闭文件
file4 = open('D:/note/note2.txt', 'r+') # 以w+的模式打开，新建了一个文本
file4.write('9') # 文本内容变成9BC，9覆盖了A
file4.close() # 关闭文件
file5 = open('D:/note/note2.txt', 'a+') # 以w+的模式打开，新建了一个文本
file5.write('888') # 文本内容变成9BC888，888追加在后面
file5.close() # 关闭文件
'''
模式 原始 写入 结果
r+ ABC Q QBC
w+ ABC Q Q
a+ ABC Q ABCQ
'''
file6 = open(filepath, 'w+')
file6.write('春风得意马蹄疾，\n一日看尽长安花。') # 第二句换行显示
file6.seek(0) # 要让光标回到首位，不然就默认在末尾，读取不了内容。
'''
注意：中文一般占2个字节，如果seek（2），春字不读取，如果是1，报错
seek()其实有2个参数，第二个参数默认为0，表示回到文件首位
如果第二个参数为1，表示保持光标在当前位置
如果第二个参数为2，表示光标会移到文件末尾
第二个参数为1，2时，只有wb模式可以使用
'''
print(file6.read()) # 输出
file6.close()
# 读取文件
'''
1.print(file1.read()) 一次性把文本内容全读取，返回值是字符串
2.print(file1.readline()) 每次读取一行的内容，返回值是字符串
3.print(file1.readlines()) 读取文件所有内容，但是是用每行内容做为列表形式展示，会出现\n
返回值是列表：['春风得意马蹄疾，\n', '一日看尽长安花。']
4.print(file1.read().splitlines()) 读取文件所有内容，但是是用每行内容做为列表形式展示,没有\n
返回值是列表：['春风得意马蹄疾，', '一日看尽长安花。']
'''
# 打开文件,用with...open打开不用关闭，可以处理多个文件
with open(filepath) as a:
a.read()
# 新建一个文件，写入
with open('D:/note3.txt', 'w+') as file7, open(filepath) as file8:
print(file8.read().splitlines())
file7.write('9999')
# 性能测试，要求快速生成1000个账号，密码可以一样，账号格式：sq001，123456
with open('D:/zhanghao.txt', 'w+') as f:
for i in range(0, 1001):
f.write(f'sq{i:03},123456\n') # 最少3位数字，不足3位补0
标签：name,python,list1,笔记,字符串,print,new,编程技术,id 来源： https://www.cnblogs.com/dydxw/p/16241560.html