[Python知识库]Python基础笔记

Python基础笔记

pycharm的使用

Debug

1. step into：Debug时会进入函数内部
2. step over：Debug时直接执行完函数，不会进入函数内部

注释

• 注释的分类
  • 单?： # 注释内容 ，快捷键ctrl+/
  • 多?： “”" 注释内容 “”" 或 ‘’’ 注释内容 ‘’’

变量

1. 定义变量

   • 变量 = 值

2. 标识符

   • 由数字、字?、下划线组成

   • 不能数字开头

   • 不能使?内置关键字

   • 严格区分??写

3. BUG

   • Debugger：显示变量和变量的细节

   • Console：输出内容

4. 数据类型

   1. 整型：int
   2. 浮点型：float
   3. 字符串：str
   4. 布尔型：bool
   5. 元组：tuple
   6. 集合：set
   7. 字典：dict

输出

• 格式化输出

  • %s：字符串
  • %d：有符号的?进制整数
  • %f：浮点数

• 注：

  • %06d，表示输出的整数显示位数，不?以0补全，超出当前位数则原样输出
  • %.2f，表示?数点后显示的?数位数。

• f’{表达式}'的用法

  print(f'我的名字是{name}, 我今年{age}岁.')
  

• 转义字符

  • \n ：换?。
  • \t ：制表符，?个tab键（4个空格）的距离.

• 结束符

  • 在Python中，print()， 默认?带 end=“\n” 这个换?结束符，所以导致每两个 print 直接会换?展示，?户可以按需求更改结束符

  • # 默认以换行结束
    print('Hello', end='\n') 
    # 以制表符结束
    print('World', end='\t') 
    # 自定义结束
    print('Hi', end='...') 
    print('python')
    

输入

1. 语法

   input("提示信息")
   

2. 特点

   1. 当程序执?到 input ，等待?户输?，输?完成之后才继续向下执?。
   2. 在Python中， input 接收?户输?后，?般存储到变量，?便使?。
   3. 在Python中， input 会把接收到的任意?户输?的数据都当做字符串处理。

转换数据类型

1. 转换数据类型的函数

   函数	说明
   int(x [,base])	将x转换为?个整数
   float(x)	将x转换为?个浮点数
   str(x)	将对象 x 转换为字符串
   eval(str)	?来计算在字符串中的有效Python表达式,并返回?个对象(转换成原本类型)
   tuple(s)	将序列 s 转换为?个元组
   list(s)	将序列 s 转换为?个列表

2. 代码示例

    # 转换成浮点型
   num1 = 10
   print(float(num1))
   
   # 转换成字符串类型
   num2 = 110
   print(type(str(num2)))
   
   # 转换成元组类型
   list1 = [10, 9, 8]
   print(tuple(list1))
   print(type(tuple(list1)))
   
   # 将字符串转换成原本形式
   print('.............')
   str1 = '10'
   str2 = '[1, 2, 3]'
   str3 = '(1000, 2000, 3000)'
   print(type(eval(str1)))
   print(type(eval(str2)))
   print(type(eval(str3)))
   

运算符

1. 算数运算符

   • +，-，*，/，//(整除)，%，**(指数)，()

   • 注：混合运算优先级顺序： () ?于 ** ?于 * / // % ?于 + -

2. 赋值运算符

   运算符	描述	赋值实例
   =	赋值	将=右侧的结果赋值给等号左侧的变量

   1. 单个变量赋值：num = 1
   2. 多个变量赋值：num1, num2, str1 = 10, 10.10, ‘hello’
   3. 多个变量赋相同值：num1 = num2 = 10

3. 复合赋值运算符

   运算符	描述
   +=	加法赋值运算符
   -=	减法赋值运算符
   *=	乘法赋值运算符
   /=	除法赋值运算符
   //=	整除赋值运算符
   %=	取余赋值运算符
   **=	幂赋值运算符

   • 注：先算赋值运算符右边的表达式，再算赋值运算符

     d = 10
     d *= 1 + 2
     # 结果为30
     

4. 比较运算符

   运 算 符	描述
   ==	判断相等。如果两个操作数的结果相等，则条件结 果为真(True)，否则条件结果为假(False)
   !=	不等于 。如果两个操作数的结果不相等，则条件为 真(True)，否则条件结果为假(False)
   >	运算符左侧操作数结果是否?于右侧操作数结果， 如果?于，则条件为真，否则为假
   <	运算符左侧操作数结果是否?于右侧操作数结果， 如果?于，则条件为真，否则为假
   >=	运算符左侧操作数结果是否?于等于右侧操作数结 果，如果?于，则条件为真，否则为假
   <=	运算符左侧操作数结果是否?于等于右侧操作数结 果，如果?于，则条件为真，否则为假

5. 逻辑运算符

   运 算 符		描述
   and	x and y	布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。
   or	x or y	布尔"或"：如果 x 是 True，它返回 True，否则 它返回 y 的值。
   not	not x	布尔"?"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

   • 代码示例

     a = 1
     b = 2
     c = 3
     print((a < b) and (b < c)) # True
     print((a > b) and (b < c)) # False
     print((a > b) or (b < c)) # True
     print(not (a > b)) # True
     

   • 数字之间的逻辑运算

     a = 0
     b = 1
     c = 2
     # and运算符，只要有?个值为0，则结果为0，否则结果为最后?个?0数字
     print(a and b) # 0
     print(b and a) # 0
     print(a and c) # 0
     print(c and a) # 0
     print(b and c) # 2
     print(c and b) # 1
     # or运算符，只有所有值为0结果才为0，否则结果为第?个?0数字
     print(a or b) # 1
     print(a or c) # 2
     print(b or c) # 1
     

条件语句

1. if 语法

   if 条件:
    条件成?执?的代码1
    条件成?执?的代码2
    ......
   

   • 代码示例

     if True:
      print('条件成?执?的代码')
     # 下?的代码没有缩进到if语句块，所以和if条件?关
     print('我是?论条件是否成?都要执?的代码')
     

2. if…else…

   # 注意input接收的数据类型是字符串类型需要转换
   age = int(input('请输入你的年龄：'))
   if age >= 18:
       print(f'您的年龄为{age}，已成年')
   else:
       print('你还未成年，滚去学习吧！')
   

   • 注：如果执行了条件成?相关的代码，那么其他情况的代码解释器不会执?。

3. 多重判断

   1. 语法

      if 条件1:
       条件1成?执?的代码1
       条件1成?执?的代码2
       ......
      elif 条件2：
       条件2成?执?的代码1
       条件2成?执?的代码2
       ......
      ......
      else:
       以上条件都不成?执?执?的代码
      

      注：多重判断也可以和else配合使?。?般else放到整个if语句的最后，表示以上条件都不成?的时候执?的代码

   2. 代码示例

      # 输入年龄
      age = int(input('请输入你的年龄：'))
      
      # 进行判断
      if age < 18:
          print(f'你的年龄为{age},未成年。')
      #  (age >= 18) and (age < 60):
      elif 18 <= age < 60:
          print((f'你的年龄为{age},已成年还未退休。'))
      else:
          print(f'你的年龄为{age},已退休。')
      

      • 拓展： age >= 18 and age <= 60 可以化简为 18 <= age <= 60 。

4. if嵌套

   1. 语法

      if 条件1：
       条件1成?执?的代码
       条件1成?执?的代码
       
       if 条件2：
       条件2成?执?的代码
       条件2成?执?的代码
      

   2. 应用

   import random
   '''
   猜拳小游戏
       0-石头
       1-剪刀
       2-布
   '''
   # 电脑随机出拳
   pc = random.randint(0, 2)
   print(pc)
   
   # 玩家出拳
   player = int(input('请出拳：0-?头，1-剪?，2-布：'))
   
   # 玩家胜利
   if((player == 0) and (pc == 1)) or ((player == 1) and (pc == 2)) or ((player == 2) and (pc == 0) ):
       print('玩家获胜')
   elif player == pc:
       print('平局')
   else:
       print('电脑获胜')   
   

   • 注：random模块中的随机整数功能：random.randint(开始,结束)
   6. 三目运算符
   • 语法：条件成?执?的表达式 if 条件 else 条件不成?执?的表达式

循环

1. while循环

   1. 语法

      while 条件:
       条件成?重复执?的代码1
       条件成?重复执?的代码2
       ......
      

   2. 应用

      • 计数器：计数一般从0开始，例如计数100，从0-99，判断条件为<100。

   3. break和continue

      1. break：终?此循环
      2. continue：退出当前?次循环继?执?下?次循环代码

2. while循环嵌套

   • 语法

     while 条件1:
      条件1成?执?的代码
      ......
      while 条件2:
      条件2成?执?的代码
      ......
     

     总结：所谓while循环嵌套，就是?个while??嵌套?个while的写法，每个while和之前的基础 语法是相同的。

   • 应用：打印99乘法表

     # 重复打印9?表达式
     j = 1
     while j <= 9:
      # 打印????的表达式 a * b = a*b
      i = 1
      while i <= j:
      print(f'{i}*{j}={j*i}', end='\t')
      i += 1
      print()
      j += 1
     

3. for循环

   • 语法

     for 临时变量 in 序列:
         重复执?的代码1
         重复执?的代码2
         ......
     

4. else

   • 循环可以和else配合使?，else下?缩进的代码指的是当循环正常结束之后要执?的代码。

5. while…else

   while 条件:
    条件成?重复执?的代码
   else:
    循环正常结束之后要执?的代码
   

   • 退出循环的方式

     1. break

        • 如果是break终?循环的情况，else下?缩进的代码将不执?

     2. continue

        • 因为continue是退出当前?次循环，继续下?次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执?了else缩进的代码。

6. for…else

   for 临时变量 in 序列:
    重复执?的代码
    ...
   else:
    循环正常结束之后要执?的代码
   

   • break终?循环不会执?else下?缩进的代码
   • continue退出循环的?式执?else下?缩进的代码

字符串

1. 字符串特征

   1. ?对引号字符串：单引号、双引号。
   2. 三引号字符串
      • 注意：三引号形式的字符串?持换?。

   # 单引号
   name1 = 'Tom'
   print(name1)
   
   # 双引号
   name2 = "Bob"
   print(name2)
   
   # 三引号
   str1 = '''Hello World!'''
   print(str1)
   
   '''
   输出：
   Hello
    Python!
   '''
   str2 = """Hello 
    Python!"""
   print(str2)
   
   # 输出：Hello Pop!
   str3 = 'Hello ' \  
          'Pop!'
   print(str3)
   
   str4 = 'I\'m Bob' #使用'\'转义
   print(str4)
   

2. 字符串输出：%s

3. 字符串输入：input

4. 下标

   • 字符串默认带有一个下标，下标从0开始。可通过下标访问字符串中的某个字符，如：str1[0] (访问字符串str1中的第0个字符)

5. 切片

   1. 概念：切?是指对操作的对象截取其中?部分的操作。字符串、列表、元组都?持切?操作。

   2. 语法

      序列[开始位置下标:结束位置下标:步?] # 结束位置不会选取[开始位置下标,结束位置下标)
      

   3. 注

      1. 不包含结束位置下标对应的数据， 正负整数均可；
      2. 步?是选取间隔，正负整数均可，默认步?为1。
      3. 如果不写开始，默认从0开始选取
      4. 如果不写结束，表示选取到最后
      5. 如果不写开始和结束，表示选取所有
      6. 如果步长为负数，则表示倒序选取
      7. 如果选取方向(下标开始到结束的方向)和步长的方向冲突，则无法选取数据。

6. 常用操作方法

   1. 查找

      1. find()：检测某个?串是否包含在这个字符串中，如果在返回这个?串开始的位置下标，否则则返回-1。

         字符串序列.find(?串, 开始位置下标, 结束位置下标)
         

         注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

         2. index()：检测某个?串是否包含在这个字符串中，如果在返回这个?串开始的位置下标，否则则报异常。

            字符串序列.index(?串, 开始位置下标, 结束位置下标)
            

            注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

            	3. rfind()： 和find()功能相同，但查找?向为右侧开始。 
            
            	4. rindex()：和index()功能相同，但查找?向为右侧开始。
            
            	5. count()：返回某个?串在字符串中出现的次数
            

            字符串序列.count(?串, 开始位置下标, 结束位置下标)
            

            注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

   2. 修改

      1. replace()：替换

         字符串序列.replace(旧?串, 新?串, 替换次数)
         

         注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候 不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

      2. split()：按照指定字符分割字符串。返回一个列表。

         字符串序列.split(分割字符, num)
         

         注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。

         注意：如果分割字符是原有字符串中的?串，分割后则丢失该?串。

      3. join()：??个字符或?串合并字符串，即是将多个字符串合并为?个新的字符串。

         字符或?串.join(多字符串组成的序列)
         

      4. 代码示例

         str1 = 'hello and python and world'
         
         # replace
         my_str = str1.replace('and', '')
         print(my_str) # hello  python  world
         
         # split 分割，返回一个列表，丢失分割字符
         my_list = str1.split('and', 1)
         print(my_list) # ['hello ', ' python and world']
         
         # join 合并列表里面的字符串数据为一个大字符串
         list1 = ['aa', 'bb', 'cc']
         str3 = '...'.join(list1)
         print(str3) # aa...bb...cc
         

      5. capitalize()：将字符串第?个字符转换成?写。

      6. title()：将字符串每个单词?字?转换成?写。

      7. lower()：将字符串中?写转?写。

      8. upper()：将字符串中?写转?写。

      9. rstrip()：删除字符串右侧空?字符。

      10. lstrip()：删除字符串左侧空?字符。

      11. strip()：删除字符串两侧空?字符

      12. ljust()：返回?个原字符串左对?,并使?指定字符(默认空格)填充?对应?度的新字符串。

      13. rjust()：返回?个原字符串右对?,并使?指定字符(默认空格)填充?对应?度 的新字符串，语法和 ljust()相同。

      14. center()：返回?个原字符串居中对?,并使?指定字符(默认空格)填充?对应?度 的新字符串，语 法和ljust()相同。

          字符串序列.ljust(?度, 填充字符) # 表示在该长度内左对齐
          

   3. 判断

      1. startswith()：检查字符串是否是以指定?串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

         字符串序列.startswith(?串, 开始位置下标, 结束位置下标)
         

      2. endswith()：：检查字符串是否是以指定?串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

         字符串序列.endswith(?串, 开始位置下标, 结束位置下标)
         

      3. isalpha()：如果字符串?少有?个字符并且所有字符都是字?则返回 True, 否则返回 False。(都是字母)

      4. isdigit()：如果字符串只包含数字则返回 True 否则返回 False。(都是数字)

      5. isalnum()：如果字符串?少有?个字符并且所有字符都是字?或数字则返 回 True,否则返回 False。(数字或字母或组合)

      6. isspace()：如果字符串中只包含空?，则返回 True，否则返回 False。(都是空白)

列表

1. 列表

   [数据1, 数据2, 数据3, 数据4......]
   

   注：列表可以?次性存储多个数据，且可以为不同数据类型。

2. 列表的常用操作

   1. 查找

      1. 下标

      2. 函数

         1. index()：返回指定数据所在位置的下标 。

            列表序列.index(数据, 开始位置下标, 结束位置下标)
            

         2. count()：统计指定数据在当前列表中出现的次数。

         3. len()：访问列表?度，即列表中数据的个数。

      3. 判断

         1. in：判断指定数据在某个列表序列，如果在返回True，否则返回False

         2. not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。

            数据 in|not in 列表
            

   2. 增加

      1. append()：列表结尾追加数据。

         1. 语法

            列表序列.extend(数据)
            

            列表追加数据的时候，直接在原列表??追加了指定数据，即修改了原列表，故列表为可变类型
            数据。

            注意：如果append()追加的数据是?个序列，则追加整个序列到列表

         2. 代码示例

            name_list = ['Tom', 'Bob', 'Jay']
            # 列表为可变类型
            name_list.append('liming')
            # 结果：['Tom', 'Bob', 'Jay', 'liming']
            print(name_list)
            
            name_list.append([11, 110])
            # 结果：['Tom', 'Bob', 'Jay', 'liming', [11, 110]]
            print(name_list) 
            

      2. extend()：列表结尾追加数据，如果数据是?个序列，则将这个序列的数据逐?添加到列表。

         1. 语法

            列表序列.extend(数据)
            

         2. 代码示例

            name_list = ['Tom', 'Bob', 'Jay']
            name_list.extend('Liming')
            # 结果：['Tom', 'Bob', 'Jay', 'L', 'i', 'm', 'i', 'n', 'g']
            print(name_list)
            
            name_list.extend([10, 20])
            # 结果：['Tom', 'Bob', 'Jay', 'L', 'i', 'm', 'i', 'n', 'g', 10, 20]
            print(name_list)
            

      3. insert()：指定位置新增数据。

         1. 语法

            列表序列.insert(位置下标, 数据) # 位置下标从零开始
            

         2. 代码示例

            name_list = ['Tom', 'Bob', 'Jay']
            name_list.insert(2, 'Liming')
            # 结果：['Tom', 'Bob', 'Liming', 'Jay']
            print(name_list)
            

   3. 删除

      1. del

         1. 删除列表：del 列表名
         2. 删除指定数据：del 列表名[下标]

      2. pop()：删除指定下标的数据(默认为最后?个)，并返回该数据。

         列表序列.pop(下标)
         

      3. remove()：移除列表中某个数据的第?个匹配项。

      4. clear()：清空列表

      name_list = ['Tom', 'Bob', 'Jay']
      
      del name_list
      # name 'name_list' is not defined
      print(name_list)
      
      del name_list[2]
      # ['Tom', 'Bob']
      print(name_list)
      
      # pop
      pop_name = name_list.pop()
      # ['Tom', 'Bob']
      print(name_list)
      pop_name = name_list.pop(1)
      # ['Tom', 'Jay']
      print(name_list)
      
      # remove
      name_list.remove('Bob')
      # ['Tom', 'Jay']
      print(name_list)
      
      # clear
      name_list.clear()
      # []
      print(name_list)
      

   4. 修改

      1. 修改指定下标数据

         列表[i] = x 
         

      2. 逆置：reverse()

      3. 排序：sort()

         列表序列.sort( key=None, reverse=False)
         

         注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

   5. 复制：copy()

3. 列表的循环遍历

   1. while
   2. for

   name_list = ['Tom', 'Bob', 'Jay']
   
   # while循环实现
   i = 0
   while i < len(name_list):
       print(name_list[i])
       i += 1
   
   print()
   
   # for循环实现
   for i in name_list:
       print(i)
   

4. 列表嵌套

   • 列表中嵌套列表

     name_list = [['?明', '?红', '?绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
     
     print(name_list)
     # ['?明', '?红', '?绿']
     print(name_list[0])
     # ?红
     print(name_list[0][1])
     

元组

• ?个元组可以存储多个数据，元组内的数据是不能修改的。而列表中的数据可更改。

1. 定义元组

   1. 元组特点：定义元组使??括号，且逗号隔开各个数据，数据可以是不同的数据类型。
   2. 注意：如果定义的元组只有?个数据，那么这个数据后?必须添加逗号，否则该数据类型为唯?的这个数据的数据类型

   # 多个数据元组
   t1 = (1, 2, 3)
   print(type(t1)) # <class 'tuple'>
   
   # 单个数据元组
   t2 = (1,)
   print(type(t2)) # <class 'tuple'>
   
   # 单个数据元组，不加逗号
   t3 = (1)
   print(type(t3)) # <class 'int'>
   
   t4 = ('abc')
   print(type(t4)) # <class 'str'>
   

2. 元组常见的操作

   元组数据不?持修改，只?持查找。

   1. 按下标查找数据
   2. index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index ?法相同。
   3. count()：统计某个数据在当前元组出现的次数。
   4. len()：统计元组中数据的个数。

   tuple1 = ('aa', 'bb', 'cc', 'bb', [10, 22])
   
   # 按下标查找
   print(tuple1[3]) # bb
   
   # index
   print(tuple1.index('cc')) # 2
   # print(tuple1.index('ccc')) # ValueError: tuple.index(x): x not in tuple
   
   # count
   print(tuple1.count('bb')) # 2
   print(tuple1.count('bbb')) # 0
   
   # len
   print(len(tuple1)) # 4
   
   tuple1[4][1] = 'a'
   print(tuple1) # ('aa', 'bb', 'cc', 'bb', [10, 'a'])
   

   注意：元组内的直接数据如果修改则?即报错，但是如果元组??有列表，修改列表??的数据则是?持的。

字典

字典??的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不?持下标， 后期?论数据如何变化，只需要按照对应的键的名字查找数据即可。

1. 创建字典

   1. 字典的特点
      1. 符号为?括号
      2. 数据为键值对形式出现
      3. 各个键值对之间?逗号隔开

   注意：?般称冒号前?的为键(key)，简称k；冒号后?的为值(value)，简称v。

2. 字典常见操作

   1. 增

      • 写法：字典序列[key] =

      注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

      注意：字典为可变类型。

   2. 删

      1. del() / del：删除字典或删除字典中指定键值对。
      2. clear()：清空字典

   3. 改

      写法：字典序列[key] = 值

      注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。

   dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
   
   # 增
   dict1['id'] = '10'
   print(dict1)
   
   # 覆盖原有值
   dict1['name'] = 'Liming'
   print(dict1)
   
   # 删除字典
   del(dict1)
   print(dict1) # NameError: name 'dict1' is not defined
   
   # 删除键值对
   del dict1['gender'] # {'name': 'Tom', 'age': 20}
   print(dict1)
   del  dict1['id'] # KeyError: 'id'
   print(dict1)
   
   # 清除字典
   dict1.clear()
   print(dict1) # {}
   
   # 改
   dict1['name'] = 'Lay'
   dict1['id'] = 10
   print(dict1) # {'name': 'Lay', 'age': 20, 'gender': '男', 'id': 10}
   

   4. 查

      1. key值查找：如果当前查找的key存在，则返回对应的值；否则则报错。

      2. get()

         字典序列.get(key, 默认值)
         

         注意：如果当前查找的key不存在则返回第?个参数(默认值)，如果省略第?个参数，则返回None。

      3. keys()：查找字典中所有的key,返回可迭代对象

      4. values()：查找字典中所有的value,返回可迭代对象

      5. items()：查找字典中所有的键值对，返回可迭代对象，里面的数据为元组，元组数据1是字典的key,元组数据2是字典key对应的值。

      dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
      
      # 键值对
      print(dict1['name']) # Tom
      # print(dict1['names']) # KeyError: 'names'
      
      # get()
      print(dict1.get('name')) # Tom
      print(dict1.get('names')) # None
      print(dict1.get('names', 'Lili')) # Lili
      
      # keys()
      print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
      
      # values()
      print(dict1.values()) # dict_values(['Tom', 20, '男'])
      
      # items()
      print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
      

   5. 字典update

      1. 字典不存在键值update

         • 字典不存在键值，使用update会添加键值对到字典中

           account = "optics"
           decrypt_passwd = "12345abc"
           
           accountDict = {}
           accountDict.update({account:decrypt_passwd})
           print(accountDict)  # {‘optics’: ‘12345abc’}
           

      2. 字典已经存在键值update

         • 字典已经存在键值update会更新键的值

           account = "optics"
           decrypt_passwd = "abcdef"
           
           accountDict = {'optics': '12345abc'}
           accountDict.update({account:decrypt_passwd})
           print(accountDict)  # {‘optics’: ‘abcdef’}
           

3. 字典的循环遍历

   1. 遍历字典的key
   2. 遍历字典的value
   3. 遍历字典的元素
   4. 遍历字典的键值对

   dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
   
   # key遍历
   for key in dict1.keys():
       print(key)
   
   # value遍历
   for value in dict1.values():
       print(value)
   
   # 键值对遍历
   for item in dict1.items():
       print(item)
   
   # 遍历字典的键值对(c)
   for key, value in dict1.items():
       print(f'{key} = {value}')
   

集合

1. 创建集合

   • 创建集合使? {} 或 set() ， 但是如果要创建空集合只能使? set() ，因为 {} ?来创建空字典。

   # 创建有数据的集合
   s1 = {10, 20, 30, 40}
   print(s1) # {40, 10, 20, 30}
   
   s2 = {10, 10, 20, 30, 20}
   print(s2) # {10, 20, 30}
   
   s3 = set('12abc')
   print(s3) # {'2', '1', 'a', 'b', 'c'}
   
   # 创建空集合
   s4 = set()
   print(s4) # set()
   print(type(s4)) # <class 'set'>
   
   s5 = {}
   print(type(s5)) # <class 'dict'>
   

2. 集合常见操作方法

   1. 增加数据

      1. add()

         因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进?任何操作。

      2. update(), 追加的数据是序列。

      s1 = {10, 20}
      
      # 增加数据
      s1.add(100)
      s1.add(10)
      print(s1) # {100, 10, 20}
      
      # 增加数据序列
      # s1.update(100) # TypeError: 'int' object is not iterable
      s1.update([10, 30, 50])
      print(s1) # {100, 10, 50, 20, 30}
      

   2. 删除数据

      1. remove()，删除集合中的指定数据，如果数据不存在则报错。
      2. discard()，删除集合中的指定数据，如果数据不存在也不会报错。
      3. pop()，随机删除集合中的某个数据，并返回这个数据。

      s1 = {10, 20, 30, 40, 50}
      
      # remove
      s1.remove(10)
      print(s1) # {40, 50, 20, 30}
      
      s1.remove(60)
      print(s1) # KeyError: 60
      
      # discard
      s1.discard(20)
      print(s1) # {40, 50, 30}
      s1.discard(70)
      print(s1) # {40, 50, 30}
      
      # pop
      del_num = s1.pop()
      print(del_num) # 40
      print(s1) # {50, 30}
      

   3. 查找数据

      1. in：判断数据在集合序列
      2. not in：判断数据不在集合序列

      s1 = {10, 20, 30, 40, 50}
      
      print(10 in s1) # True
      print(10 not in s1) # False
      

公共操作

运算符

1. # 1. 字符串
   str1 = 'aa'
   str2 = 'bb'
   
   # 2. 列表
   list1 = [1, 2]
   list2 = [10, 20]
   
   # 3. 元组
   t1 = (1, 2)
   t2 = (10, 20)
   
   print(str1 + str2) # aabb
   print(list1 + list2) # [1, 2, 10, 20]
   print(t1 + t2) # (1, 2, 10, 20)
   
   # 4. 字典
   dict1 = {'name': 'lili'}
   dict2 = {'age': '18'}
   print(dict1 + dict2) # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
   

2. # 1. 字符串
   print('-' * 10) # ----------
   # 2. 列表
   list1 = ['hello']
   print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
   # 3. 元组
   t1 = ('world',)
   print(t1 * 4) # ('world', 'world', 'world', 'world')
   
   

3. in & not in

   # 1. 字符串
   str1 = 'aa' 
   print('a' in str1) # True
   print('a' not in str1) # False
   print()
   
   # 2. 列表
   list1 = [1, 2]
   print(1 in list1) # True
   print(1 not in list1) # False
   print()
   
   # 3. 元组
   t1 = (1, 2)
   print(2 in t1) # True
   print(2 not in t1) # False
   print()
   
   # 4. 字典
   dict1 = {'name': 'Lili', 'age': '11'}
   print('name' in dict1) # True
   print('name' not in dict1) # False
   print('name' in dict1.values()) # False
   print('name' in dict1.keys()) # True
   print('name' in dict1.items()) # False
   print(('name', 'Lili') in dict1.items()) # True
   

公共方法

• range代码示例

  # 1 2 3 4 5 6 7 8 9
  for i in range(1, 10, 1):
   print(i)
  # 1 3 5 7 9
  for i in range(1, 10, 2):
   print(i)
  # 0 1 2 3 4 5 6 7 8 9
  for i in range(10):
   print(i)
  

  注意：range()?成的序列不包含end数字。

• enumerate()

  • 语法：

  enumerate(可遍历对象, start=0)
  # 返回结果是元组，元组的第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据。
  

  注意：start参数?来设置遍历数据的下标的起始值，默认为0。

  • 代码示例

  list1 = ['a', 'b', 'c', 'd', 'e']
  
  '''
  (0, 'a')
  (1, 'b')
  (2, 'c')
  (3, 'd')
  (4, 'e')
  '''
  for i in enumerate(list1):
      print(i)
      
  '''
  (1, 'a')
  (2, 'b')
  (3, 'c')
  (4, 'd')
  (5, 'e')
  '''
  for i in enumerate(list1, start=1):
      print(i)
  

容器转换类型

1. tuple()：将某个序列转换成元组

2. list()：将某个序列转换成列表

3. set()：将某个序列转换成集合

   • 注意：
     1. 集合可以快速完成列表去重
     2. 集合不?持下标

4. 代码示例

   t1 = ('a', 'b', 'c', 'd', 'e')
   list1 = [10, 20, 30, 40, 50, 20]
   s1 = {100, 200, 300, 400, 500}
   
   # 转换成元组
   print(tuple(list1))
   print(tuple(s1))
   y
   # 转换成列表
   print(list(t1))
   print(list(s1))
   
   # 转换成集合(列表中重复的数据不会打印)
   print(set(list1))
   print(set(s1))
   

推导式

列表推导式

作?：??个表达式创建?个有规律的列表或控制?个有规律列表

1. 带if的列表推导式

   需求：创建0-10的偶数列表

   list1 = [i for i in range(0, 10, 2)]
   print(list1)
   
   # for循环实现
   i = 0
   list2 = []
   for i in range(10):
       if i % 2 == 0:
           list2.append(i)
   print(list2)
   
   # 带if的推导式
   list3 = [i for i in range(10) if i % 2 == 0]
   print(list3) # [0, 2, 4, 6, 8]
   

2. 多个for循环实现列表推导式

   需求：创建列表如下：

   ? [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

   注：多个for的列表推导式等同于for循环嵌套

   list1 = []
   for i in range(1, 3):
       for j in range(3):
           list1.append((i, j))
   print(list1)
   
   # 用列表推导式实现
   list2 = [(i, j) for i in range(1, 3) for j in range(3)]
   print(list2)
   
   

字典推导式

字典推导式作?：快速合并列表为字典或提取字典中?标数据。

# 创建?个字典：字典key是1-5数字，value是这个数字的2次?。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}

• 将两个列表合并为一个字典

  list1 = ['name', 'age', 'gender']
  list2 = ['Tom', 20, 'man']
  
  dict1 = {list1[i]: list2[i] for i in range(len(list1))}
  print(dict1)  # {'name': 'Tom', 'age': 20, 'gender': 'man'}
  
  # 注意：
  # 1. 如果两个列表中的数据个数相同，则使用len统计任何一个列表都可以
  # 2. 如果两个列表中的数据个数不同，则使用len统计数据多的列表数据个数会报错，统计数据少的列表数据个数不会报错
  

• 提取字典中的目标数据

  counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
  print(counts.items()) # 返回键值对
  dict3 = {key: value for key, value in counts.items() if value >= 200}
  print(dict3) # {'MBP': 268, 'DELL': 201}
  

集合推导式

# 需求：创建?个集合，数据为下?列表的2次?。
list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1) # {1, 4} 注：集合去重

函数一

函数的作用

函数就是将?段具有独?功能的代码块 整合到?个整体并命名，在需要的位置调?这个名称即可完成对 应的需求。

函数在开发过程中，可以更?效的实现代码重?。

函数的使用步骤

1. 定义函数

   def 函数名(参数):
    代码1
    代码2
    ......
   

2. 调用函数

   函数名(参数)
   

3. 注意

   1. 不同的需求，参数可有可?。
   2. 在Python中，函数必须先定义后使?。

函数的参数作用

• 分类：
  • 形参：函数定义时书写的参数(?真实数据)
  • 实参：函数调?时书写的参数(真实数据)

# 定义函数时同时定义了接收?户数据的参数a和b，a和b是形参
def add_num2(a, b):
 result = a + b
 print(result)
# 调?函数时传?了真实的数据10 和 20，真实数据为实参
add_num2(10, 20)

函数的返回值作用

• 作用：
  • 负责函数返回值
  • 退出当前函数，导致return下方的所有代码(函数体内部)不执行。

函数的说明文档

• 定义函数的说明文档

  def 函数名(参数):
      """ 说明?档的位置 """
   	代码
   	......
  

• 查看函数的说明文档：help(函数名)

# 加法
def add(a, b):
    """求和函数"""
    return a + b

help(add)

# 函数说明文档的高级使用
def add2(a, b):
    """
    求和函数
    :param a: 参数1
    :param b: 参数2
    :return: 返回值
    """
    return a + b

help(add2)

函数嵌套调用

函数嵌套调?指的是?个函数???调?了另外?个函数。

函数二

变量作用域

变量作?域指的是变量?效的范围，主要分为两类：局部变量和全局变量。

• 局部变量

  • 局部变量是定义在函数体内部的变量，即只在函数体内部?效。
  • 局部变量的作?：在函数体内部，临时保存数据，即当函数调?完成后，则销毁局部变量。

• 全局变量

  • 所谓全局变量，指的是在函数体内、外都能?效的变量。
  • 利用global关键字声明全局变量

  # 声明全局变量
  a = '全局变量'
  
  def A():
      # 声明局部变量
      b = '局部变量'
      print(b)
      print(a)
  
  def B():
      # a = '修改后的变量' # 仍然是局部变量
      # print(a) # 修改后的变量
      global a # 将a定义为全局变量
      a = '修改为全局变量'
  
  A()
  B()
  print(a) # 修改为全局变量
  

多函数程序执行流程

• 共用全局变量

  # 声明全局变量
  global_num = 0
  
  def A():
      '''修改全局变量'''
      global global_num
      global_num = 10
      print(global_num)
  
  def B():
      '''打印全局变量'''
      print(global_num)
  
  B() # 0
  A() # 10
  B() # 10
  print(global_num) # 10
  

• 返回值作为参数传递

  def A():
      return 50
  
  def B(num):
      print(num)
  
  B(A()) # 50
  

函数的返回值

def test():
    # return 1, 2 # 以元组形式返回
    # return (10, 20) # 返回元组
    # return ['你好', 10] # 返回列表
    # return {'name': 'Lili'} # 返回字典
    return [10, 20], {10, 15} # ([10, 20], {10, 15})

num = test()
print(num)

注意：

1. return a, b 写法，返回多个数据的时候，默认是元组类型。
2. return后?可以连接列表、元组或字典，以返回多个值。

函数的参数

1. 位置参数

   • 位置参数：调?函数时根据函数定义的参数位置来传递参数。

     注意：传递和定义参数的顺序及个数必须?致。

2. 关键字参数

   • 函数调?，通过“键=值”形式加以指定。可以让函数更加清晰、容易使?，同时也清除了参数的顺序需求。

     注意：函数调?时，如果有位置参数时，位置参数必须在关键字参数的前?，但关键字参数之间不存在 先后顺序。

3. 缺省参数

   • 缺省参数也叫默认参数，?于定义函数，为参数提供默认值，调?函数时可不传该默认参数的值（注 意：所有位置参数必须出现在默认参数前，包括函数定义和调?）。

     注意：函数调?时，如果为缺省参数传值则修改默认参数值；否则使?这个默认值。

   def user_info(name, age, gender = '男'):
       print(f'您的姓名是{name}，年龄为{age}，性别是{gender}')
   
   
   # 位置参数
   user_info('Lili', 20, '女')
   user_info(20, 'Lili', '女')  # 无意义
   # test('Lili', 20)  # TypeError: test() missing 1 required positional argument: 'gender' Test()缺少1个必需的位置参数:'gender'
   
   
   # 关键字参数
   user_info(gender='女', age='15', name='Lili') # 关键字参数不分先后顺序
   user_info('Lili', gender='女', age='15')  # 位置参数必须写在关键字参数前面
   # user_info(gender='女', age='15', 'Lili')  # positional argument follows keyword argument
   
   
   # 缺省参数
   user_info('liming', 20)  # 没有为缺省参数传值，使用默认值
   user_info('Lihao', 18, '女')  # 为缺省参数传值，使用该值代替默认值
   

4. 不定长参数

   • 不定?参数也叫可变参数。?于不确定调?的时候会传递多少个参数(不传参也可以)的场景。此时，可?包裹(packing)位置参数，或者包裹关键字参数，来进?参数传递，会显得?常?便。

   • 包裹位置传递

     # 接收所有位置参数，返回一个元组
     def user_info(*args):
         print(args)
     
     user_info('Lili')  # ('Lili',)
     user_info('Lili', 20)  # ('Lili', 20)
     user_info('Lili', 20, '男')  # ('Lili', 20, '男')
     user_info()  # ()
     

     注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为?个元组(tuple)， args是元组类型，这就是包裹位置传递。

   • 包裹关键字传递

     # 包裹关键字传递
     # 收集所有关键字参数，返回一个字典
     def user_info1(**kwargs):
         print(kwargs)
     
     
     user_info1()  # {}
     user_info1(name='Tom')  # {'name': 'Tom'} 
     user_info1(name='Tom', age=20)  # {'name': 'Tom', 'age': 20}
     

   综上：?论是包裹位置传递还是包裹关键字传递，都是?个组包的过程。

拆包和交换两个变量的值

1. 拆包

   1. 拆包：元组

      def num():
          return 100, 200
      
      num1, num2 = num()
      print(num1)
      print(num2)
      

   2. 拆包：字典

      dict1 = {'name': 'TOM', 'age': 18}
      a, b = dict1
      
      # 对字典进?拆包，取出来的是字典的key
      print(a) # name
      print(b) # age
      
      print(dict1[a]) # TOM
      print(dict1[b]) # 18
      

2. 交换变量值

   需求：有变量 a = 10 和 b = 20 ，交换两个变量的值。

   # 方法一：借助中间变量
   a = 10
   b = 20
   
   c = a
   a = b
   b = c
   print(a)
   print(b)
   
   # 方法二：简便方法
   c = 30
   d = 40
   c, d = d, c
   print(c)  # 40
   print(d)  # 30
   

引用

1. 了解引用

   在python中，值是靠引?来传递来的。 可以?id() 来判断两个变量是否为同?个值的引?。可以将id值理解为那块内存的地址标 识。

   a = 1
   b = a
   
   print(id(a))  # 140717864313680
   print(id(b))  # 140717864313680
   
   a = 10
   print(id(a))  # 140717864313968
   print(id(b))  # 140717864313680 整型为不可变类型
   
   aa = [10, 20, 30]
   bb = aa
   print(id(aa))  # 3014536290952
   print(id(bb))  # 3014536290952
   
   aa.append(40)
   print(id(aa))  # 3014536290952
   print(id(bb))  # 3014536290952 列表为可变类型
   

2. 引用当作实参

   def test1(a):
       print(a)
       # b:140717864314288 c:1850972988040
       print(id(a))
       
       a += a
       # b:140717864314288 c:1850972988040
       print(id(a))
   
   # int:计算前后的id值不同
   b = 10
   test1(b)
   
   # 列表:计算前后的id值相同
   c = [10, 20]
   test1(c)
   

可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进?修改，如果能直接修改那么就是可变，否则是不可变。

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • 整型
  • 浮点型
  • 字符串
  • 元组

函数加强

应用：学生信息管理系统

# 显示菜单
def print_info():
    print('-' * 20)
    print('欢迎登录学员管理系统')
    print('1: 添加学员')
    print('2: 删除学员')
    print('3: 修改学员信息')
    print('4: 查询学员信息')
    print('5: 显示所有学员信息')
    print('6: 退出系统')
    print('-' * 20)

# 用列表存储所有学员的信息
info = []

# 添加学员信息
def add_info():
    """添加学员函数"""
    # 用户输入学生信息
    new_id = input('请输入学号：')
    new_name = input('请输入姓名：')
    new_tel = input('请输入手机号：')

    # 判断是否已经添加学生信息
    global info

    # 学生姓名重复，则报错
    for i in info:
        if new_name == i['name']:
            print('该用户已经存在')
            # 退出当前函数，使得增加函数不执行
            return

    # 不存在，新增数据
    info_dict = {}

    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel

    info.append(info_dict)
    print(info)


# 删除学员
def del_info():
    """删除学员"""
    del_name = input('请输入要删除的学员的姓名：')
    # 判断删除的学员是否存在，存在则删除，否则提示不存在
    for i in info:
        if i['name'] == del_name:
            info.remove(i)
            break
        else:
            print('该学员不存在')
    print(info)

# 修改学员函数
def modify_info():
    """修改学员信息"""
    modify_name = input('请输入要修改的学员的姓名：')

    # 判断学员是否存在
    for i in info:
        if i['name'] == modify_name:
            i['tel'] = input('请输入新的手机号：')
            break
    else:
        print('该学员不存在')
    print(info)

# 查询学员信息
def search_info():
    """查询学员信息"""
    search_name = input('请输入要查询的学员的姓名：')
    global info
    for i in info:
        if search_name == i['name']:
            print(f"该学员的姓名为{i['name']}，id为{i['id']}，手机号为{i['tel']}")
            break
    else:
        # 循环正常结束，查找失败
        print('该学员不存在')

# 显示所有学员的信息
def print_all():
    """显示所有学员的信息"""
    print("学号\t姓名\t手机号")
    # 打印所有学员
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")

while True:
    # 1. 显示功能界?
    print_info()

    # 2. ?户选择功能
    user_num = input('请选择您需要的功能序号：')
    # 3. 根据?户选择，执?不同的功能
    if user_num == '1':
        # print('添加学员')
        add_info()
    elif user_num == '2':
        # print('删除学员')
        del_info()
    elif user_num == '3':
        # print('修改学员信息')
        modify_info()
    elif user_num == '4':
        # print('查询学员信息')
        search_info()
    elif user_num == '5':
        # print('显示所有学员信息')
        print_all()
    elif user_num == '6':
        # print('退出系统')
        exit_flag = input('确定要退出？yes or no')
        if exit_flag == 'yes':
            break
    else:
        print('输?错误，请重新输?!!!')

递归

1. 特点：

   1. 函数内部??调???
   2. 必须有出?

2. 应?：3以内数字累加和

def sum_numbers(num):
    # 递归出口
    if num == 1:
        return 1
    return num + sum_numbers(num - 1)


print(sum_numbers(3))

lambda表达式

应用场景

如果?个函数有?个返回值，并且只有?句代码，可以使? lambda简化。

lambda语法

lambda 参数列表 ： 表达式

注意：

1. lambda表达式的参数可有可?，函数的参数在lambda表达式中完全适?。
2. lambda函数能接收任何数量的参数但只能返回?个表达式的值

# 函数实现
def fn1():
    return 10

print(fn1())  # 10

# lambda 表达式实现匿名函数
fn2 = lambda : 100
print(fn2)  # lambda内存地址 <function <lambda> at 0x0000014D2E943B70>
print(fn2())  # 100
 print((lambda a, b: a + b)(1, 2))  # 3

注意：直接打印lambda表达式，输出的是此lambda的内存地址

lambda参数

# 无参数
fn1 = lambda : 100
print(fn1())

# 一个参数
fn2 = lambda a: a
print(fn2('Hello Python!'))

# 默认参数
fn3 = lambda a, b, c = 100: a + b + c
print(fn3(10, 20))
print(fn3(10, 20, 30))

# 可变参数
fn4 = lambda *args: args
print(fn4(10, 20, 30))  # (10, 20, 30)
print(fn4(10))  # (10,)

# 可变参数 **kwargs
fn5 = lambda **kwargs: kwargs
print(fn5(name='Lili', age=11)) # {'name': 'Lili', 'age': 11}

lambda应用

带判断的lambda

fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))   # 1000

列表数据按字典key的值排序

students = [
 {'name': 'TOM', 'age': 20},
 {'name': 'ROSE', 'age': 19},
 {'name': 'Jack', 'age': 22}
]

# 按name值升序排列
students.sort(key=lambda x: x['name'])  # 元组中的每一个字典作为x传入，得到其name, 再a
print(students)

# 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)

# 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

高阶函数

高阶函数举例

# 将函数作为参数传入，化简代码
def add1(a, b, f):
    return f(a) + f(b)


# 绝对值求和
print(add1(-1, -5, abs))  # 6

# 四舍五入求和
print(add1(1.2, 3.6, round))  # 5

内置高阶函数

1. map()

   map(func, lst)，将传?的函数变量func作?到lst变量的每个元素中，并将结果组成新的列表(Python2)/ 迭代器(Python3)返回。

   # 需求：计算 list1 序列中各个数字的2次?。
   
   list1 = [1, 2, 3, 4, 5]
   
   def func(x):
       return x**2
   
   result = map(func, list1)
   print(result)  # <map object at 0x0000022794B83358>
   print(list(result))  # [1, 4, 9, 16, 25]
   
   

2. reduce()

   reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下?个元素做累 积计算。

   # 需求：计算 list1 序列中各个数字的累加和。
   
   import functools
   
   list1 = [1, 2, 3, 4, 5]
   
   def func(a, b):
       return a + b
   
   result = functools.reduce(func, list1)
   print(result)
   

   注意：reduce()传?的参数func必须接受2个参数。

3. filter()

   filter(func, lst)函数?于过滤序列, 过滤掉不符合条件的元素, 返回?个 filter 对象,。如果要转换为列表, 可以使? list() 来转换。

   # 需求：过滤列表中的偶数
   
   list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   
   def func(x):
       return x % 2 == 0
   
   # 满足func()函数的数据全都过滤掉
   result = filter(func, list1)  
   
   print(result)  # <filter object at 0x0000015B4E403320>
   print(list(result))  # [2, 4, 6, 8, 10]
   

文件操作

文件操作的作用

?件操作的作?就是把?些内容(数据)存储存放起来，可以让程序下?次执?的时候直接使?，?不必重新制作?份，省时省?。

文件的基本操作

文件操作步骤

1. 打开

   在python，使?open函数，可以打开?个已经存在的?件，或者创建?个新?件，语法如下：

   open(name, mode)
   

   name：是要打开的?标?件名的字符串(可以包含?件所在的具体路径)。

   mode：设置打开?件的模式(访问模式)：只读、写?、追加等。

   • 打开文件模式(+号代表可读可写，b代表二进制格式访问)

     模式	描述
     r	以只读?式打开?件。?件的指针将会放在?件的开头。这是默认模式。
     rb	以?进制格式打开?个?件?于只读。?件指针将会放在?件的开头。这是默认模式。
     r+	打开?个?件?于读写。?件指针将会放在?件的开头。
     rb+	以?进制格式打开?个?件?于读写。?件指针将会放在?件的开头。
     w	打开?个?件只?于写?。如果该?件已存在则打开?件，并从开头开始编辑，即原有内 容会被删除。如果该?件不存在，创建新?件。
     wb	以?进制格式打开?个?件只?于写?。如果该?件已存在则打开?件，并从开头开始编 辑，即原有内容会被删除。如果该?件不存在，创建新?件。
     w+	打开?个?件?于读写。如果该?件已存在则打开?件，并从开头开始编辑，即原有内容 会被删除。如果该?件不存在，创建新?件。
     wb+	以?进制格式打开?个?件?于读写。如果该?件已存在则打开?件，并从开头开始编 辑，即原有内容会被删除。如果该?件不存在，创建新?件。
     a	打开?个?件?于追加。如果该?件已存在，?件指针将会放在?件的结尾。也就是说， 新的内容将会被写?到已有内容之后。如果该?件不存在，创建新?件进?写?。
     ab	以?进制格式打开?个?件?于追加。如果该?件已存在，?件指针将会放在?件的结 尾。也就是说，新的内容将会被写?到已有内容之后。如果该?件不存在，创建新?件进 ?写?。
     a+	打开?个?件?于读写。如果该?件已存在，?件指针将会放在?件的结尾。?件打开时 会是追加模式。如果该?件不存在，创建新?件?于读写。
     ab+	以?进制格式打开?个?件?于追加。如果该?件已存在，?件指针将会放在?件的结 尾。如果该?件不存在，创建新?件?于读写。

     • 主访问模式

       # r: 若文件不存在，则报错，且不支持写入操作，表示只读
       f = open('text1.txt', 'r') # No such file or directory: 'text1.txt'
       f = open('text.txt', 'r')
       f.write('abc')
       f.close()
       
       # w: 只写，若文件不存在，则新建文件，执行写入，并且会覆盖原有内容
       f = open('t1.txt', 'w')
       f.write('aaa')  # 原文件内容会被覆盖
       f.close()
       
       # a: 追加，若文件不存在，新建文件，并在原有内容上追加新的内容
       f = open('t2.txt', 'a')
       f.write('bbb')  # 追加至原文件内容后面
       f.close()
       
       # 访问模式参数可以省略，若省略则表示访问模式为r
       f = open('t1.txt')
       f = open('t3.txt')  #  No such file or directory: 't3.txt'
       f.close()
       

     • 次访问模式

       # # r+特点: r没有该文件则报错，文件指针在开头，故能读取出来数据
       # f = open('text.txt', 'r+')
       # # f = open('text1.txt', 'r+')  # [Errno 2] No such file or directory: 'text1.txt'
       
       # w+: 没有该文件会新建文件，w特点：文件指针在开头，用新内容覆盖原内容
       # f = open('text.txt', 'w+')
       
       # a+：没有该文件会新建文件，文件指针在结尾，无法读取数据(文件指针后无数据)
       f = open('text.txt', 'a+')
       
       contend = f.read()
       print(contend)
       

2. 文件对象方法

   1. 写

      文件对象.write('内容')
      

      # 1. 打开?件
      f = open('test.txt', 'w')
      # 2.?件写?
      f.write('hello world')
      # 3. 关闭?件
      f.close()
      

      注意：

      1. w 和 a 模式：如果?件不存在则创建该?件；如果?件存在， w 模式先清空再写?， a 模式直接末尾追加。
      2. 2. r 模式：如果?件不存在则报错。

   2. 读

      • read()

        ?件对象.read(num)
        

        num表示要从?件中读取的数据的?度（单位是字节），如果没有传?num，那么就表示读取? 件中所有的数据。

        f = open('text.txt', 'r')
        
        # 读取文件内容
        # 不写参数
        print(f.read()) 
        # 写参数，若文件内容换行，则默认包含换行符\n，读取时会算作一个字符。
        print(f.read(10))
        
        f.close()
        

      • readlines()

        • readlines可以按照?的?式把整个?件中的内容进??次性读取，并且返回的是?个列表，其中每??的数据为?个元素。

      • readline()

        • readline()?次读取??内容。

        f = open('text.txt', 'r')
        
        content = f.readlines()
        print(content)  # ['aaaaa\n', 'bbbbb\n', 'ccccc\n', 'ddddd\n', 'eeeee']
        
        content = f.readline()
        print(content)  # aaaaa
        
        f.close()
        

   3. seek()函数

      • 作?：?来移动?件指针。

      • 语法：

        ?件对象.seek(偏移量, 起始位置)
        

        起始位置： 0：?件开头； 1：当前位置； 2：?件结尾

   4. 关闭文件

      ?件对象.close()
      

文件备份

# 需求：?户输?当前?录下任意?件名，程序完成对该?件的备份功能(备份?件名为xx[备份]后缀，例
# 如：test[备份].txt)。

# 用户输入目标文件
old_name = input('请输入您要备份的文件名：')


# 提取备份文件名字
index = old_name.rfind('.')  # 找到文件后缀

# 有效文件才备份
if index > 0:
    postfix = old_name[index:]

# 组织新名字
print(old_name[:index])  # 名字
print(old_name[index:])  # 后缀

new_name = old_name[:index] + '[备份]' + postfix
print(new_name)

# 给备份文件写入数据
# 打开源文件和备份文件
old_f = open(old_name, 'rb')
new_f = open(new_name, 'wb')

# 循环写入，以防止读取数据过大
while True:
    con = old_f.read(1024)
    # 数据读取出来为空，则终止循环
    if(len(con) == 0):
        break
    new_f.write(con)

# 关闭文件
old_f.close()
new_f.close()

文件和文件夹的操作

在Python中?件和?件夹的操作要借助os模块??的相关功能，具体步骤如下：

1. 导?os模块

import os

2. 使? os 模块相关功能

   os.函数名()
   

3. 文件重命名

   os.rename(?标?件名, 新?件名)
   

4. 删除文件

   os.remove(?标?件名)
   
   

5. 创建文件夹

   os.mkdir(?件夹名字)
   

6. 删除文件夹

   os.rmdir(?件夹名字)
   

7. 获取当前目录

   os.getcwd()
   

8. 改变默认目录

   os.chdir(?录)
   

9. 获取目录列表

   os.listdir(?录)
   

import os

# 重命名
# os.rename('t1.txt', 't3.txt')

# 删除文件
# os.remove('t3.txt')

# 创建文件夹
# os.mkdir('aaa')  # 当前目录下创建

# 删除文件夹
# os.rmdir('aaa')

# 获取当前文件所在路径
print(os.getcwd())

# 切换目录路径
# os.chdir('aaa')
# 在aaa文件加中创建新文件夹
# os.mkdir('bbb')

# 获取某个文件夹下的所有文件，并以列表的形式返回
# print(os.listdir())  # 没有参数则获取根目录下的所有文件信息
# print(os.listdir('aaa'))

# 重命名文件夹
# os.chdir('aaa')  # 切换到aaa文件夹下
# os.rename('bbb', 'bb')   # 将aaa文件夹下的bbb重命名

应用案例

# 需求：批量修改?件名，既可添加指定字符串，?能删除指定字符串。
import os

# 设置重命名标识：如果为1则添加指定字符，flag取值为2则删除指定字符
flag = 1

# 获取指定?录
dir_name = './'

# 获取指定?录的?件列表
file_list = os.listdir(dir_name)
# print(file_list)

# 遍历?件列表内的?件
for name in file_list:
    # 添加指定字符
    if flag == 1:
        new_name = 'Python-' + name
    # 删除指定字符
    elif flag == 2:
        num = len('Python-')
    new_name = name[num:]
    # 打印新?件名，测试程序正确性
    print(new_name)

    # 重命名
    os.rename(dir_name + name, dir_name + new_name)

面向对象

?向对象就是将编程当成是?个事物，对外界来说，事物是直接使?的，不?去管他内部 的情况。?编程就是设置事物能够做什么事。

一. 类和对象

类和对象的关系：?类去创建(实例化)?个对象。

理解类和对象

1. 类

类是对?系列具有相同特征和?为的事物的统称，是?个抽象的概念，不是真实存在的事物。

• 特征即是属性

• ?为即是?法添加和获取对象属性

2. 对象

对象是类创建出来的真实存在的事物。

注：先有类才能创建对象。

面向对象实现方法

1. 定义类

   Python2中类分为：经典类 和 新式类

   • 语法

     class 类名():
      代码
      ......
     

     注意：类名要满?标识符命名规则，同时遵循?驼峰命名习惯。

   • 拓展：经典类

     不由任意内置类型派?出的类，称之为经典类

     class 类名:
      代码
      ......
     

2. 创建对象

   对象?名实例。

   • 语法

     对象名 = 类名()
     

   • 实例

     class Washer():
         def wash(self):
             print('洗衣服')
     
     # 创建对象
     haier = Washer()
     
     print(haier)  # <__main__.Washer object at 0x00000206FDE43358>
     # 实例方法/对象方法 -- 对象名.wash()
     haier.wash()  # 洗衣服
     

     注意：创建对象的过程也叫实例化对象。

3. self

   self指的是调?该函数的对象。

   • 实例

     # 1. 定义类
     class Washer():
      def wash(self):
      print('我会洗?服')
      # <__main__.Washer object at 0x0000024BA2B34240>
      print(self)
     
     # 2. 创建对象
     haier1 = Washer()
     # <__main__.Washer object at 0x0000018B7B224240>
     print(haier1)
     # haier1对象调?实例?法
     haier1.wash()
     
     haier2 = Washer()
     # <__main__.Washer object at 0x0000022005857EF0>
     print(haier2)
     

     注意：打印对象和self得到的结果是?致的，都是当前对象的内存中存储地址。

二. 添加和获取对象属性

属性即是特征，?如：洗?机的宽度、?度、重量…

对象属性既可以在类外?添加和获取，也能在类??添加和获取。

1. 类外?添加对象属性

   • 语法

     对象名.属性名 = 值
     

2. 类外?获取对象属性

   • 语法

     对象名.属性名
     

3. 实例

   # 类外?添加对象属性
   haier1.width = 500
   haier1.height = 800
   
   # 类外?获取对象属性
   print(f'haier1洗?机的宽度是{haier1.width}')
   print(f'haier1洗?机的?度是{haier1.height}')
   

4. 类??获取对象属性

   • 语法

     self.属性名
     

   • 示例

     # 定义类
     class Washer():
     	def print_info(self):
          # 类??获取实例属性
          print(f'haier1洗?机的宽度是{self.width}')
          print(f'haier1洗?机的?度是{self.height}')
         
     # 创建对象
     haier1 = Washer()
     
     # 添加实例属性
     haier1.width = 500
     haier1.height = 800
     
     haier1.print_info()
     

三. 魔法方法

在Python中，__xx__()的函数叫做魔法?法，指的是具有特殊功能的函数。

3.1 __init__

1. 体验__init__()

   • __init__() ?法的作?：初始化对象。

     class Washer():
          # 定义初始化功能的函
     	def __init__(self):
              # 添加实例属性
              self.width = 500
              self.height = 800
                 
         def print_info(self):
              # 类??调?实例属性
              print(f'洗?机的宽度是{self.width}, ?度是{self.height}')
             
     haier1 = Washer()
     haier1.print_info()    
     

     注意：

     • __init__() ?法，在创建?个对象时默认被调?，不需要?动调?

     • __init__(self) 中的self参数，不需要开发者传递，python解释器会?动把当前的对象引 ?传递过去。

2. 带参数的__init__()

   对初始化函数传递参数可以对不同的对象设置不同的初始化属性

   class Washer():
    	def __init__(self, width, height):
            self.width = width
            self.height = height
   	def print_info(self):
            print(f'洗?机的宽度是{self.width}')
            print(f'洗?机的?度是{self.height}')
           
   haier1 = Washer(10, 20)
   haier1.print_info()
   
   haier2 = Washer(30, 40)
   haier2.print_info()
   

3.2__str__()

当使?print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ?法，那么就会打印从 在这个?法中 return 的数据。

class Washer():

    def __init__(self, wigth, height, name):
        self.wigth = wigth
        self.height = height
        self.name = name

    def info(self):
        print(f'{self.name}的宽度为{self.wigth}')
        print(f'{self.name}的高度为{self.height}')

    def __str__(self):
        return f'这个洗衣机的名称是{self.name}'


haier1 = Washer(100, 200, 'haier1')
haier1.info()  # haier1的宽度为100

haier2 = Washer(400, 500,'haier2')
haier2.info()  # haier2的宽度为400
print(haier2)  # 这个洗衣机的名称是haier2

3.3 __del__()

当删除对象时，python解释器也会默认调?__del__()?法。

class Washer():

    def __init__(self, wigth, height, name):
        self.wigth = wigth
        self.height = height
        self.name = name

    def info(self):
        print(f'{self.name}的宽度为{self.wigth}')
        print(f'{self.name}的高度为{self.height}')

    def __str__(self):
        return f'这个洗衣机的名称是{self.name}'

    def __del__(self):
        print(f'{self.name}已经删除成功！')

del haier2  # haier2已经删除成功！
# haier1已经删除成功！

若不使用del手动删除对象，则当代码执行完毕后会自动调用__del__()方法删除对象。`

3.4 __call__()

__call__可以把类实例当做函数调用。

import time
# 类中的__call__魔法方法，只要类对象中实现了__call__方法，
# 创建实例对象test = Test() 后，实力对象后面加括号会自动调用__call__里的方法。
class Test():
    def __init__(self):
        print('一旦创建实例对象，自动调用__inni__()')
 
    def __del__(self):
        print('一旦销毁实例对象或者函数程序停止运行，自动调用__del__()')
 
    def __call__(self):
        print('实力对象后面加(),自动调用__call__()')
 
 
test = Test()
# del test  # 删除对象
test()
time.sleep(5)
 
# 运行结果
# 一旦创建对象，自动调用__inni__()
# 实例对象后面加(),自动调用__call__
# 。。。。。（5s后）。。。。。。
# 一旦销毁实力对象或者函数程序停止运行，自动调用__del__()

实现了__call__方法的类的实例化对象可以像函数一样去调用它。

3.5 __getitem__()

__getitem__ 可以让对象实现迭代功能，这样就可以使用for...in... 来迭代该对象了。调用对象的属性可以像字典取值一样使用中括号[‘key’]

class Animal:
    def __init__(self, animal_list):
        self.animals_name = animal_list

    def __getitem__(self, index):
        return self.animals_name[index]

animals = Animal(["dog","cat","fish"])
for animal in animals:
    print(animal)
    
# 输出结果
'''
dog
cat
fish
'''

当一个类.中定义了getitem方法，那么它的实例对象便拥有了通过下标来索引的能力。即实例对象（假设为P）可以P[key]这样取值。当实例对象做P[key]运算时，就会调用类中的__getitem__()方法。

class A(object):
    def __getitem__(self, item):
        return item

a = A()
print(a[5], a[12])

# 5 12