Python基础|W3school学习笔记

• 三个双引号或三个单引号可以将多行字符串赋值给变量

• 字符串方法

  • strip() 删除开头和结尾的空白字符串
  • lower() 返回小写的字符串
  • upper() 返回大写的字符串
  • replace() 用另一段字符串来替换字符串

  a = "Hello, World!"
  print(a.replace("World", "Kitty"))#  Hello, Kitty!
  

  • split() 方法在找到分隔符的实例时将字符串拆分为子字符串

  a = "Hello, World!"
  print(a.split(",")) # returns ['Hello', ' World!']
  

• 检查字符串：in/not in 关键字

txt = "China is a great country"
x = "ina" in txt
print(x)#True

• 字符串格式

  • 不能直接用+连结字符串和数字→报错
  • 使用format()组合字符串和数字,format()方法接受不限数量的参数，并放在各自的占位符中,可以使用索引号{}确保参数被放在正确的占位符中

  age = 63 
  txt = "My name is Bill, and I am {}"
  print(txt.format(age)) #My name is Bill, and I am 63
  quantity = 3
  itemno = 567
  price = 49.95
  myorder = "I want {} pieces of item {} for {} dollars."
  print(myorder.format(quantity, itemno, price))#I want 5 pieces of item 789 for 24.36 dollars.
  quantity = 3
  itemno = 567
  price = 49.95
  myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
  print(myorder.format(quantity, itemno, price))#I want to pay 24.36 dollars for 5 pieces of item 789.
  

• 字符串方法

方法	描述
capitalize()	把首字符转换为大写。
casefold()	把字符串转换为小写。
center()	返回居中的字符串。
count()	返回指定值在字符串中出现的次数。
encode()	返回字符串的编码版本。
endswith()	如果字符串以指定值结尾，则返回 true。
expandtabs()	设置字符串的 tab 尺寸。
find()	在字符串中搜索指定的值并返回它被找到的位置。
format()	格式化字符串中的指定值。
format_map()	格式化字符串中的指定值。
index()	在字符串中搜索指定的值并返回它被找到的位置。
isalnum()	如果字符串中的所有字符都是字母数字，则返回 True。
isalpha()	如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal()	如果字符串中的所有字符都是小数，则返回 True。
isdigit()	如果字符串中的所有字符都是数字，则返回 True。
isidentifier()	如果字符串是标识符，则返回 True。
islower()	如果字符串中的所有字符都是小写，则返回 True。
isnumeric()	如果字符串中的所有字符都是数，则返回 True。
isprintable()	如果字符串中的所有字符都是可打印的，则返回 True。
isspace()	如果字符串中的所有字符都是空白字符，则返回 True。
istitle()	如果字符串遵循标题规则，则返回 True。
isupper()	如果字符串中的所有字符都是大写，则返回 True。
join()	把可迭代对象的元素连接到字符串的末尾。
ljust()	返回字符串的左对齐版本。
lower()	把字符串转换为小写。
lstrip()	返回字符串的左修剪版本。
maketrans()	返回在转换中使用的转换表。
partition()	返回元组，其中的字符串被分为三部分。
replace()	返回字符串，其中指定的值被替换为指定的值。
rfind()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust()	返回字符串的右对齐版本。
rpartition()	返回元组，其中字符串分为三部分。
rsplit()	在指定的分隔符处拆分字符串，并返回列表。
rstrip()	返回字符串的右边修剪版本。
split()	在指定的分隔符处拆分字符串，并返回列表。
splitlines()	在换行符处拆分字符串并返回列表。
startswith()	如果以指定值开头的字符串，则返回 true。
strip()	返回字符串的剪裁版本。
swapcase()	切换大小写，小写成为大写，反之亦然。
title()	把每个单词的首字符转换为大写。
translate()	返回被转换的字符串。
upper()	把字符串转换为大写。
zfill()	在字符串的开头填充指定数量的 0 值。

• 布尔值为False的值包括：False None 0 “” () [] {}——即对象带有__len__函数的类生成的，且该函数返回0或False

• 运算符

  • ** 幂
  • // 地板除（取整除）
  • & 按位与
  • and 从左到右计算表达式,若所有的都为真,则返回最后一个值,若存在假,返回第一个假值.
  • or 从左到右计算表达式,只要遇到真值就返回那个真值,如果表达式结束依旧没有遇到真值,就返回最后一个假值.
  • ^ 按位异或：如果两个位只有1位为1，则将每个位设置为1

  • 和<<都是位运算符，<<高位丢弃、低位补零——记忆：左移是乘，右移是除

  a = 2
  print(a << 3)  # 相当于a 乘2的3次方
  a = 32
  print(a >> 3)  # 相当于a 除2的3次方
  

• 身份运算符

  • is/is not 如果两个变量是(不是)同一个对象，则返回 true

• 成员运算符

  • in/not in 如果对象中(不)存在具有指定值的序列，则返回 True

• python集合（数组）

  • ***列表（List）***是一种有序和可更改的集合。允许重复的成员

    • []
    • 通过引用索引号来访问列表项;负索引表示从末尾开始，-1 表示最后一个项目以此类推
    • 索引范围为[a:b]是返回第a+1到第b项的新列表；负索引如[-4:-1]返回的是-4（包括）到索引-1（排除）的项目
    • 可以使用索引号更改特定项目的值
    • 用for循环遍历列表项 for x in thislist:
    • 列表长度：len()
    • 将项目添加到列表末尾：append()
    • 在指定索引处添加项目:insert()
    • 删除项目:
      • remove() 删除指定的项目
      • pop() 删除指定的索引，如果未指定索引则删除最后一项
      • del thislist[] 删除指定的索引
      • del thislist 完整地删除列表
    • clear() 清空列表
    • 复制列表
      • copy()方法
      • 使用内建的方法list()
    • 合并列表
      • • 运算符
      • extend() 直接将一个列表中所有元素添加到另一个列表中
    • 构造列表

    thislist = list(("apple", "banana", "cherry")) # 请注意双括号
    print(thislist)#  ['apple', 'banana', 'cherry']
    

    • 列表方法

    方法	描述
    append()	在列表的末尾添加一个元素
    clear()	删除列表中的所有元素
    copy()	返回列表的副本
    count()	返回具有指定值的元素数量。
    extend()	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
    index()	返回具有指定值的第一个元素的索引
    insert()	在指定位置添加元素
    pop()	删除指定位置的元素
    remove()	删除具有指定值的项目
    reverse()	颠倒列表的顺序
    sort()	对列表进行排序

  • ***元组（Tuple）***是一种有序且不可更改的集合。允许重复的成员

    • ()
    • 访问索引同列表访问
    • 无法更改元组值。但可以先转换为列表再转回元组

    x = ("apple", "banana", "cherry")
    y = list(x)
    y[1] = "kiwi"
    x = tuple(y)
    print(x)
    

    • 使用for遍历
    • 元组不可改变，无法添加项目
    • 创建仅包含一个项目的元组，必须在项目后添加逗号，否则会被识别为字符串
    • 完全删除元组使用del
    • 使用tuple()构造元组
    • 元组方法

    方法	描述
    count()	返回元组中指定值出现的次数。
    index()	在元组中搜索指定的值并返回它被找到的位置

  • ***集合（Set）***是一个无序和无索引的集合。没有重复的成员

    • {}
    • 无法更改项目，但可以添加新项目
      • 将一个项添加到集合 add()
      • 添加多个项目 update()
    • 删除项目
      • remove() 当删除的项目不存在时会引发错误
      • discard() 当删除的项目不存在时不会引发错误
      • pop() 用于删除最后一项——由于无序性而不知道删除的究竟是哪一项
    • 清空集合
      • clear()
    • 彻底删除集合
      • del
    • 合并集合
      • union() 返回包含两个集合中所有项目的新集合
      • update() 将一个集合中的所有项目插入另一个集合中
    • 构造集合
      • set()
    • 内建方法

    方法	描述
    add()	向集合添加元素。
    clear()	删除集合中的所有元素。
    copy()	返回集合的副本。
    difference()	返回包含两个或更多集合之间差异的集合。
    difference_update()	删除此集合中也包含在另一个指定集合中的项目。
    discard()	删除指定项目。
    intersection()	返回为两个其他集合的交集的集合。
    intersection_update()	删除此集合中不存在于其他指定集合中的项目。
    isdisjoint()	返回两个集合是否有交集。
    issubset()	返回另一个集合是否包含此集合。
    issuperset()	返回此集合是否包含另一个集合。
    pop()	从集合中删除一个元素。
    remove()	删除指定元素。
    symmetric_difference()	返回具有两组集合的对称差集的集合。
    symmetric_difference_update()	插入此集合和另一个集合的对称差集。
    union()	返回包含集合并集的集合。
    update()	用此集合和其他集合的并集来更新集合。

  • ***词典（Dictionary）***是一个无序，可变和有索引的集合。没有重复的成员

    • {},拥有键和值

    • 访问项目：在方括号内引用其键名来访问字典的项目；get()方法

    • 引用其键名来更改特定项的值

    • for直接循环遍历字典时返回的是字典的键

      • 返回值的方法

      for x in thisdict:
        print(thisdict[x])
      或
      for x in thisdict.values():
        print(x)
      

    • items()遍历键和值

    for x, y in thisdict.items():
      print(x, y)
    

    • in用于检查字典中是否存在指定的键
    • 使用新的索引键并为其赋值，可以将项目添加到字典中
    • 删除项目
      • pop() 删除具有指定键名的项
      • popitem() 删除最后插入的项目
      • del 删除具有指定键名的项目/完全删除字典
    • 清空字典：clear()
    • 复制字典不能直接通过=赋值：
      dict2=dict1中，dict2只是对 dict1的引用，而 dict1中的更改也将自动在 dict2中进行；因此需要使用copy（）内建方法进行复制
    • 制作副本：dict()
    • 嵌套字典：词典中可以包含许多词典
    • 使用dict构造函数创建新的字典

    thisdict = dict(brand="Porsche", model="911", year=1963)
    # 请注意，关键字不是字符串字面量(区别于之间赋值)
    # 请注意，使用了等号而不是冒号来赋值
    print(thisdict)
    

    • 字典方法

    方法	描述
    clear()	删除字典中的所有元素
    copy()	返回字典的副本
    fromkeys()	返回拥有指定键和值的字典
    get()	返回指定键的值
    items()	返回包含每个键值对的元组的列表
    keys()	返回包含字典键的列表
    pop()	删除拥有指定键的元素
    popitem()	删除最后插入的键值对
    setdefault()	返回指定键的值。如果该键不存在，则插入具有指定值的键。
    update()	使用指定的键值对字典进行更新
    values()	返回字典中所有值的列表

  • 注：上述无特殊说明皆可以前类类比

• 条件语句

  • elif相比else:捕获相关条件
  • and/or 组合条件语句
  • pass:当由于某种原因写了无内容的if语句时，需要用pass避免错误

• 循环语句

  • break和continue的区别

• for循环

  • 用于迭代序列（即列表，元组，字典，集合或字符串）
  • 循环遍历字符串

  for x in "banana":
    print(x)#用于循环遍历banana的字母(每行一个字母)
  

  • 如需循环一组代码指定的次数，可使用range()函数，可以通过添加第三个参数指定增量值
  • for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误

• 函数

  • 默认参数值：调用了不带参数的函数，则使用默认值

  def my_function(country = "China"):
    print("I am from " + country)
  

  • 关键字参数：使用 key = value 语法发送参数时，参数的顺序无关紧要
  • 任意参数：
    如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *，函数将接收一个参数元组，并可以相应地访问各项。

  def my_function(*kids):
    print("The youngest child is " + kids[2])
  
  my_function("Phoebe", "Jennifer", "Rory")
  

  • 函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误
  • 函数递归

• Lambda

  • 一种小的匿名函数，可以接受任意数量的参数，但只能有一个表达式

  lambda arguments : expression
  

  x = lambda a, b : a * b
  print(x(5, 6))#一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果
  

  • 把 lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力
    假设您有一个带一个参数的函数定义，并且该参数将乘以未知数字，创建一个总是使所发送数字加倍的函数

  def myfunc(n):
    return lambda a : a * n
  
  mydoubler = myfunc(2)
  
  print(mydoubler(11))
  

• 数组

  • Python 没有内置对数组的支持，但可以使用 Python 列表代替
  • 添加 append()
  • 删除 pop() / remove()
  • 数组方法

  方法	描述
  append()	在列表的末尾添加一个元素
  clear()	删除列表中的所有元素
  copy()	返回列表的副本
  count()	返回具有指定值的元素数量。
  extend()	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
  index()	返回具有指定值的第一个元素的索引
  insert()	在指定位置添加元素
  pop()	删除指定位置的元素
  remove()	删除具有指定值的项目
  reverse()	颠倒列表的顺序
  sort()	对列表进行排序

• 类 / 对象

  • 创建类：class

  • 创建对象：使用创建的类名()

  • init()函数

    • 所有类都有一个名为__init__()的函数，始终在启动类时执行
    • 使用__init__()函数将值赋给对象属性，或者在创建对象时需要执行的其他操作
      每次使用类创建新对象时，都会自动调用init() 函数

    class Person:#创建名为 Person 的类，使用 __init__() 函数为 name 和 age 赋值
      def __init__(self, name, age):
        self.name = name
        self.age = age
    
    p1 = Person("Bill", 63)
    
    print(p1.name)
    print(p1.age)
    

  • 对象方法

    • 对象中的方法是属于该对象的函数

  • self参数

    • self 参数是对类的当前实例的引用，用于访问属于该类的变量。不必被命名为 self
      ，您可以随意调用它，但它必须是类中任意函数的首个参数

  • 删除对象属性：del关键字

  • 删除对象：del关键字

  • 类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误

• 继承

  • 父类是继承的类，也称为基类；子类是从另一个类继承的类，也称为派生类
  • 创建子类：
    要创建从其他类继承功能的类，需要将父类作为参数发送

  class Student(Person):#创建一个名为 Student 的类，它将从 Person 类继承属性和方法
    pass
  

  • 当为子类添加__init__()函数时，子类将不再继承父的__init__()函数；如需保持父的 init() 函数的继承，请添加对父的 init() 函数的调用

  class Student(Person):
    def __init__(self, fname, lname):
      Person.__init__(self, fname, lname)
  

  • super()函数：使子类从其父继承所有方法和属性

  class Student(Person):
    def __init__(self, fname, lname):
      super().__init__(fname, lname)
  

  class Student(Person):
    def __init__(self, fname, lname, year):
      super().__init__(fname, lname)
      self.graduationyear = year
  
  x = Student("Elon", "Musk", 2019)
  #添加 year 参数，并在创建对象时传递正确的年份：
  

• 迭代器

  • 迭代器是一种对象，包含值的可计数数字；可以遍历所有值，包含方法__iter__()和__next__()
  • 列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器;所有这些对象都有用于获取迭代器的 iter()方法

  mytuple = ("apple", "banana", "cherry")
  myit = iter(mytuple)
  
  print(next(myit))
  print(next(myit))
  print(next(myit))
  

  • 字符串也是可迭代的对象，包含一系列字符串
  • 遍历迭代器：for
  • 创建迭代器，必须为对象实现__iter__()和__next__()两个方法

  class MyNumbers:#创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）
    def __iter__(self):#可以执行操作（初始化等），但必须始终返回迭代器对象本身
      self.a = 1
      return self
  
    def __next__(self):#允许您执行操作，并且必须返回序列中的下一个项目
      x = self.a
      self.a += 1
      return x
  
  myclass = MyNumbers()
  myiter = iter(myclass)
  

  • StopIteration:防止迭代永远进行

  class MyNumbers:
    def __iter__(self):
      self.a = 1
      return self
  
    def __next__(self):#添加终止条件引发错误
      if self.a <= 20:
        x = self.a
        self.a += 1
        return x
      else:
        raise StopIteration
  

• 作用域

  • 要在函数内部更改全局变量的值，请使用 global 关键字引用该变量

  x = 100
  
  def myfunc():
    global x
    x = 200
  
  myfunc()
  
  print(x)#200
  

• python模块

  • 创建模块

    • 如需创建模块，只需将所需代码保存在文件扩展名为 .py的文件中

  • 使用模块

    • import语句

    import mymodule#导入名为 mymodule 的模块(对应mymodule.py文件)
    
    mymodule.greeting("Bill")#调用模块中的函数
    

  • 模块可以包含已经描述的函数，但也可以包含各种类型的变量（数组、字典、对象等）

  • 重命名模块：as

  • dir()函数：列出模块中的所有函数名（变量名）

  • from 仅从模块导入部件
    在使用 from 关键字导入时，请勿在引用模块中的元素时使用模块名称。示例：person1[“age”]，而不是 mymodule.person1[“age”]

• 日期

  • datetime模块

  import datetime#显示当前日期
  x = datetime.datetime.now()#包含年、月、日、小时、分钟、秒和微秒
  print(x)
  print(x.year)#显示年份
  print(x.strftime("%A"))#显示weekday的名称
  

  • 创建日期对象

  import datetime
  
  x = datetime.datetime(2020, 5, 17)#需要至少年月日三个参数
  
  print(x)
  

  • strftime() 方法

    把日期对象格式化为可读字符串的方法
    

  指令	描述	实例
  %a	Weekday，短版本	Wed
  %A	Weekday，完整版本	Wednesday
  %w	Weekday，数字 0-6，0 为周日	3
  %d	日，数字 01-31	31
  %b	月名称，短版本	Dec
  %B	月名称，完整版本	December
  %m	月，数字01-12	12
  %y	年，短版本，无世纪	18
  %Y	年，完整版本	2018
  %H	小时，00-23	17
  %I	小时，00-12	05
  %p	AM/PM	PM
  %M	分，00-59	41
  %S	秒，00-59	08
  %f	微妙，000000-999999	548513
  %z	UTC 偏移	+0100
  %Z	时区	CST
  %j	天数，001-366	365
  %U	周数，每周的第一天是周日，00-53	52
  %W	周数，每周的第一天是周一，00-53	52
  %c	日期和时间的本地版本	Mon Dec 31 17:41:00 2018
  %x	日期的本地版本	12/31/18
  %X	时间的本地版本	17:41:00
  %%	A % character	%

• JSON

  • 用于存储和交换数据的语法
  • json内置包用于处理json数据
  • JSON字符串可使用json.loads()方法进行解析，结果是python字典

  import json
  
  # 一些 JSON:
  x =  '{ "name":"Bill", "age":63, "city":"Seatle"}'
  
  # 解析 x:
  y = json.loads(x)
  
  # 结果是 Python 字典：
  print(y["age"])
  

  • 将python对象转换为JSON字符串：json.dumps()

  import json
  
  # Python 对象（字典）：
  x = {
    "name": "Bill",
    "age": 63,
    "city": "Seatle"
  }
  
  # 转换为 JSON：
  y = json.dumps(x)
  
  # 结果是 JSON 字符串：
  print(y)#{"name": "Bill", "age": 63, "city": "Seatle"}
  

  • 能转换为json字符串的python对象：dict list tuple string int float True False None
  • python转换为json时python对象转换为json(javascript)的等效项：

  Python	JSON
  dict	Object
  list	Array
  tuple	Array
  str	String
  int	Number
  float	Number
  True	true
  False	false
  None	null

  • 格式化结果

  json.dumps(x, indent=4, separators=(". ", " = "),sort_keys=True)
  #indent参数定义缩进数，seperators更改分隔符（前两个分隔对象，第三个将键和值分隔开）,sort_keys指定是否最结果排序
  

• RegEx

  • RegEX或正则表达式是形成搜索模式的字符序列，可用于检查字符串是否包含指定的搜索模式
  • re模块
  • 函数

  函数	描述
  findall	返回包含所有匹配项的列表
  search	如果字符串中的任意位置存在匹配，则返回 Match 对象;如果有多个匹配，则返回首个匹配项
  split	返回在每次匹配时拆分字符串的列表；可以使用maxsplit参数控制出现次数
  sub	用字符串替换一个或多个匹配项；可使用count参数控制替换次数

  • 元字符

  字符	描述	示例
  []	一组字符	“[a-m]”
  \	示意特殊序列（也可用于转义特殊字符）	“\d”
  .	任何字符（换行符除外）	“he…o”
  ^	起始于	“^hello”
  $	结束于	“world$”
  *	零次或多次出现	“aix*”
  +	一次或多次出现	“aix+”
  {}	确切地指定的出现次数	“al{2}”
  		两者任一
  ()	捕获和分组

  • 特殊序列（\后跟下表中的某个字符，拥有特殊含义）

  字符	描述	示例
  \A	如果指定的字符位于字符串的开头，则返回匹配项	“\AThe”
  \b	返回指定字符位于单词的开头或末尾的匹配项	r"\bain"r"ain\b"
  \B	返回指定字符存在的匹配项，但不在单词的开头（或结尾处）	r"\Bain"r"ain\B"
  \d	返回字符串包含数字的匹配项（数字 0-9）	“\d”
  \D	返回字符串不包含数字的匹配项	“\D”
  \s	返回字符串包含空白字符的匹配项	“\s”
  \S	返回字符串不包含空白字符的匹配项	“\S”
  \w	返回一个匹配项，其中字符串包含任何单词字符（从 a 到 Z 的字符，从 0 到 9 的数字和下划线 _ 字符）	“\w”
  \W	返回一个匹配项，其中字符串不包含任何单词字符	“\W”
  \Z	如果指定的字符位于字符串的末尾，则返回匹配项	“Spain\Z”

  • 集合

  集合	描述
  [arn]	返回一个匹配项，其中存在指定字符（a，r 或 n）之一
  [a-n]	返回字母顺序 a 和 n 之间的任意小写字符匹配项
  [^arn]	返回除 a、r 和 n 之外的任意字符的匹配项
  [0123]	返回存在任何指定数字（0、1、2 或 3）的匹配项
  [0-9]	返回 0 与 9 之间任意数字的匹配
  [0-5][0-9]	返回介于 0 到 9 之间的任何数字的匹配项
  [a-zA-Z]	返回字母顺序 a 和 z 之间的任何字符的匹配，小写或大写
  [+]	在集合中，+、*、.、

  • Match对象：包含搜索和结果信息的对象；如果没有匹配则返回值None
    • span() 返回的元组包含了匹配的开始和结束位置
    • .string 返回传入函数的字符串
    • group() 返回匹配的字符串部分

• PIP

  • Python 包或模块的包管理器
  • 包中包含模块所需的所有文件，模块是您可以包含在项目中的 Python 代码库
  • 查找包：

  PyPI · The Python Package Index

  • 下载包：pip install 安装包后可通过import导入项目使用

• Try Except

  • try 块允许您测试代码块以查找错误
  • except 块允许您处理错误
  • finally 块允许您执行代码，无论 try 和 except 块的结果如何
  • raise 抛出（引发）异常，能够定义所引发异常的类型、以及打印给用户的文本

• 命令行输入

  • python2.7 raw_input()方法
  • python3.0 input()方法

• 字符串格式化

  • format{} 允许格式化字符串的选定部分

  price = 52
  txt = "The price is {} dollars"
  print(txt.format(price))
  

  • 花括号中可添加参数以指定如何转换值：

  txt = "The price is {:.2f} dollars"  #化为带有两位小数的数字
  

  • 命名索引
    • 在花括号中输入名称使用命名索引，但在传递参数值时，必须使用名称

• 文件处理

  • 文件打开

    • open()函数有两个参数：文件名和模式
      • 四种打开文件的不同方法（模式）
        • "r" - 读取 - 默认值。打开文件进行读取，如果文件不存在则报错
        • "a"- 追加 - 打开供追加的文件，如果不存在则创建该文件
        • "w" - 写入 - 打开文件进行写入，如果文件不存在则创建该文件
        • "x"- 创建 - 创建指定的文件，如果文件存在则返回错误
      • 指定文件是应该作为二进制还是文本模式进行处理
        • "t"- 文本 - 默认值。文本模式
        • b" - 二进制 - 二进制模式（例如图像）

  • 文件读取

    • read() 读取文件内容
    • read()中指定数字作为参数指定要返回的字符数
    • readline() 返回一行
    • 通过循环遍历文件中的行，您可以逐行读取整个文件

    f = open("demofile.txt", "r")
    for x in f:
      print(x)
    

    • 关闭文件 close()

  • 文件写入

    • 如需写入已有的文件，必须向 open() 函数添加参数：
      • "a" - 追加 - 会追加到文件的末尾
      • "w" - 写入 - 会覆盖任何已有的内容
    • 创建新文件
      • "x" - 创建 - 将创建一个文件，如果文件存在则返回错误
      • "a" - 追加 - 如果指定的文件不存在，将创建一个文件
      • "w" - 写入 - 如果指定的文件不存在，将创建一个文件

  • 文件删除

    • 导入OS模块，运行os.remove()函数
    • 检查文件是否存在：os.path.exists()
    • 删除整个文件夹：os.rmdir()——注：只能删除空文件夹