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)) # 
   
   # 单个数据元组
   t2 = (1,)
   print(type(t2)) # 
   
   # 单个数据元组，不加逗号
   t3 = (1)
   print(type(t3)) # 
   
   t4 = ('abc')
   print(type(t4)) # 
   

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)) # 
   
   s5 = {}
   print(type(s5)) # 
   

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
      

公共操作

运算符

运算符	描述	支持容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

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
   

公共方法

函数	描述
len()	计算容器中元素个数
del 或 del()	删除
max()	返回容器中元素最⼤值
min()	返回容器中元素最⼩值
range(start, end, step)	⽣成从start到end的数字，步⻓为 step，供for循环使⽤
enumerate()	函数⽤于将⼀个可遍历的数据对象(如列表、元组或字符串)组合为⼀个索引序 列，同时列出数据和数据下标，⼀般⽤在 for 循环当中。

• 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内存地址  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)  # 
   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)  # 
   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