Python 基础笔记

提示：80%的成功只是出席，不定期更新，欢迎交流指正！

目录

一、题外话

二、基本信息

三、运算符（operator）

四、控制结构（control structure）

五、函数（function）—— 1函数1件事

六、方法（method）

七、容器

八、字符串

九、模块（module）   

N、异常处理

---

一、题外话

        作为一个闲人，一直有学没学都在基础阶段打转，GPT 让人压力山大，希望这次能有所突破！

        也没啥大志向，就想把公司那 5、6 个套表在年底实现办公自动化。

        基础知识网上搜了一圈，好像什么都有，又好像都缺点什么，打算按自己的习惯编一个，当做学习总结，不定期整理，其他书里看到的东西也会往里填充，温故知新。

        关于实例，没有采用参考书目中的，而是用了简化实例，与参考书的引导性目的不同，这里主要为了快速复习。

        最后，推荐个插件CodeGeeX，像我这样的小白用不到什么高大上的功能，主要在某些语法点或者关键字想不起来的时候，这种提示能节省很多查询的时间，国产+免费必须安利一波！

参考：

《Python编程无师自通——专业程序员的养成 》

二、基本信息

1. 注释（comment）：单行 #（快捷键Ctrl+/），多行（三个双引号）""" """，
2. 缩进：必须要有，1个缩进4个空格（建议），不强制使用空格，考虑到不同编译器对Tab的设置不尽相同
3. 对象——3属性：标识（identity，唯一）、数据类型（data type，唯一）和值
4. 数据类型
   1. type()函数：查询对象的数据类型
   2. 字符串str、布尔数bool、NoneType、整型int、浮点数float、复数类型complex
5. 变量——需要时才用
   • 命名只能用字母、数字、下划线（“_”分隔单词）
   • 不能用数字开头、不能用关键字、不包含空格符
   • 赋值：可以多个连续赋值

     a, b = 1, 2
     #等价于
     a = 1
     b = 2

三、运算符（operator）

1. 算术操作符（arithmetic operator）：加（+）、减（-）乘（*）、除（/）
   1. 取整（//，地板除，商）
   2. 取模（%，求余数）：没有余数，返回 0
   3. 指数（**，乘方，幂运算）
   4. 运算顺序（order of operation）：括号（parentheses）、指数（exponents）、乘法（multiplication）、除法（division）、加法（addition）和减法（subtraction）
   5. 增强的赋值操作符
      1. a += 1
      2. a -= 1
      3. a *= 1
      4. a /=1
      5. a %= 1
2. 比较运算符（comparison operator）：>、<、
   1. >=（大于等于）、<=（小于等于）、
   2. ==（等于）、!=（不等于）
3. 逻辑操作符（logical operator）：and（与）、or（或）、not（非）

四、控制结构（control structure）

1. 语句—— 条件 + 代码块（子句）
   1. 简单语句（simple statement，一行）
   2. 复合语句（compound statement，多行）：一个或多个从句（clause）组成，从句包括 ≥ 2 行代码——代码头（header，包含关键字）及紧随其后的配套代码（suite）
   3. 所有控制流语句都以冒号 “ : ” 结尾，后面跟一个新的代码块（子句）。
2. 条件语句（conditional statement）——注意 elif 次序

   1. if condition1: 
          a = x 
      else:
          a = y
      # 等价，三元操作符
      a = x if condition1 else y
      
      #三元运算符
      max = a if a > b  else b

   2. if condition1:
          code1
      elif condition2:
          code2
      else:
          code3

3. 循环语句（loop statement）
   1. for循环
      1. for [变量名] in [可迭代对象名]: [指令]
      2. 推导式comprehensions，即解析式
         1. for循环快速生成列表：[生成表达式 for 变量 in 序列或选代对象]
         2. 列表推导式（list comprehensions）

            aList = [x**2 for x in range(4)]

            1. 过滤原始序列中不符合条件的元素

               a_list = [1, '4', 9, 'a', 0, 5, 'H']
               squared_ints = [x**2 for x in a_list if type(x)==int]
               # 等价于
               for x in a_list :
                   if type(x)==int :
                   squared_ints.append(x**2)

            2. 平铺嵌套的列表

               #[1, 2, 3, 4, 5, 6, 7, 8, 9]
               vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
               flat_vec = [num for elem in vec for num in elem]
               # 等价于
               for elem in vec :
                   for num in elem :
                       flat_vec.append(num)

            3. 多条件组合构造特定列表

               new_list = [(x,y) for x in [1, 2] for y in [3, 1, 4] if x != y]
               #[(1 ,3), (1, 4), (2, 3), (2, 1), (2, 4)]

         3. 字典推导式

            # 交换键值
            mcase = {'a': 10, 'b': 30, 'c': 50}
            kv_exchange = {v : k for k, c in mcase.items()}
            # kv_exchange {10: 'a', 30: 'b', 20: 'c'}

         4. 集合推导式——自动去重

            # {1, 4, 9}
            squared = {x**2 for x in [1, -1, 2, -2, 3]}

      3. 通过索引变量（index variable）遍历（iterating）
      4. range()函数
         1. 创建数字序列并遍历，执行固定次数
         2. 三个参数：[ 开始，结束 ），步长
      5. enumerate()函数，以枚举的对象    返回索引与对应的值

         for i in range(10):  # range(2:4) 也可以划定数字范围  
         
         # i 索引，show = list1[i]
         for i show in enumerate(list1):
         

   2. while循环
      1. while [表达式]: [执行代码]
      2. 表达式为 True 时继续循环，否则结束循环；如果永远为真，不会停止进入死循环（infinite loop）按Ctrl+c强制终止

         #按 Ctrl + c 跳出死循环
         while True:  
             print("Pass Ctrl + C !!!")

   3. break语句，终止内层循环，执行外层循环
   4. continue语句，跳过本次循环的余下部分，开始下一轮循环
   5. 只能在while和for循环内使用break和continue语句
   6. 循环嵌套：外循环（outer loop）内循环（inner loop）
   7. 结束程序

      import sys
      #代码段
      sys.exit()

五、函数（function）—— 1函数1件事

1. 目的：将需要多次执行的代码放在一起
2. 定义函数：关键字def

   def [函数名]([必选参数],[可选参数]=[参数值]):
       global [全局变量]
       [函数定义]
       return [返回值]

3. 关键字return —— 所有函数调用都需要有返回值
   1. 需要返回值，指定返回值
   2. 不需要返回值，返回None（NoneType数据类型），就是没有值
   3. 没有return语句，系统会直接返回None
4. 参数（用“ , ”隔开）：
   1. 必选参数（required parameter）无默认值，必须在可选参数前，无数据传入会报错
   2. 可选参数（optional parameter）有默认值，无数据传入，使用默认值
5. 常用内置函数（builtin function）：input()、print()、int()向下取整、float()、str()
   1. print()
      1. 可选参数end，默认以换行符结尾，传入参数end=""修改
      2. 可选参数sep，默认空格分隔多个字符串，传入参数sep=""修改
   2. round(数值，精度)：进度就是保留小数点后位数，保留2位就是2
6. 作用域（scope）
   1. 全局作用域（global scope）：关键字global引入全局变量，可以改变全局变量，非必要不使用；
   2. 局部作用域（local scope）：仅函数内部
   3. 避免局部变量与全局变量或其他局部变量同名，虽然这样做完全合法   
   4. 全局变量可以在局部作用域中读取，反之则不行。

六、方法（method）

1. 面向对象编程范式，用对象来保存状态，来消除全局状态，解决程式编程不易维护的问题。
   1. 鼓励代码复用，从而减少了开发和维护的时间
   2. 鼓励拆解问题，使代码更容易维护
   3. 设计复杂，要做很多的事前规划
2. 类（class）定义一系列相互之间可进行交互的对象
   1. 定义：class [类名]:[代码主体]
   2. 命名：每个单词大写字母开头，多个单词连续编写，不使用下划线
   3. 直接打印对象，返回内存地址
3. 方法（method）
   1. 类似函数，命名规则同函数（小写+下划线）
   2. 必须在类内部定义，只能有类创建的对象调用
   3. 必须接受一个参数，第一个参数一般被命名为 self ，系统会自动传入
   4. 可使用 self 定义实例变量（instance variable）：self.[变量名] = [变量值]

      class Orange:
          def _init_(self, w, w=c):
              self.weight = w
              self.color = c
              print("Created ! ")

4. 对象
   1. 每个对象是类的实例，都拥有类中定义的属性，都能使用类定义的方法。
   2. 创建：[类名]([参数]) ——self 可不写
   3. 取值：[对象名].[变量名]
   4. 改变值：[对象名].[变量名] = [新的值]

      or1 = Orange(10,"dark orange")
      print(or1.weight)
      # 10
      print(or1)
      # <_main_.Orange object at 0x101a787b8>

七、容器

1. 列表（list）：[ ]
   1. 元素（表项）可变，固定顺序，索引（index）从0开始，负数索引从后往前，最后一个为-1，查、改也通过索引来实现；索引溢出，会报IndexError出错信息；索引为整数，如果是浮点数，会报TypeError出错信息。

      no_letter = []      # 空列表
      letters = ["a"]    # 单个元素列表
      
      letters[0]="z"      # 改，修改第一个元素
      letters.index("a")  # 返回元素"a"的索引
      
      #多重赋值，变量的数量与列表的长度必须严格相等，否则报ValueError错误信息
      cat = ['fat','black','loud']
      
      size, color, disposition = cat
      #等价于
      size = cat[0]
      color = cat[1]
      disposition = cat[2]

   2. 增：3个方法

      letters.append("b")              # 增，在最后加入新元素
      letters.insert(1，"c")           # 增，在第2的位置插入元素
      letters.extend(other_letters)    # 增，在最后加入另一个列表
      #上述操作均不改变列表对象的内存地址
      
      [1,2,3] + ['a','b','c']    #[1,2,3,'a','b','c']
      

   3. 删：3个方法，1个内置函数

      letters.pop()       #删，删除最后一个元素，索引为-1
      letters.pop(2)      #删，删除索引为2的元素
      letters.remove("c") #删，删除第一个值为“c”的元素
      letters.clear()     #删，清空所有元素
      
      # 内置函数del 删除索引为3的元素
      del letters[3]

   4. 判断：1个方法，2个关键字

      letters.count("a")    # 元素"a"出现的次数
      letters.index('a')    # 元素"a"出现的位置
      
      #判断是否包含，返回True 或 False
      "a" in letters
      "f" not in letters

   5. 排序

      #改变原列表，按ASCII字符顺序排序，大写字母在前ABab
      letters.sort()               #顺序
      
      letters.sort(reverse=True)   #逆序
      letters.reverse()            #逆序
      
      #返回新列表
      sorted(letters)                #顺序
      sorted(letters,reverse=True)   #逆序
      
      #同时包含数字、字符串的列表排序，返回TypeError错误

   6. 常见内置函数

      len(letters)          #获取元素数量
      cmp(list1, list2)     #比较2个列表元素
      max(letters)          #返回最大的列表元素
      min(letters)          #返回最小的列表元素

   7. 多列表元素组合成元素为元祖的列表，以下两者实现结果相同

      #zip可以拼接多个列表，元素个数以最短的为准，功能更强大
      list1 = ["A","B","C","D"]
      list(zip(list1,range(len(list1))))
      # [("A",0),("B",1),("C",2),("D",3)]
      
      #enumerate只提供 索引+内容 的组合
      list(enumerate(list1, start = 1)) #start 可以不写，默认从0开始
      # [("A",1),("B",2),("C",3),("D",4)]
      
      

   8. 引用：
      1. 可变数据类型的值（列表、字典）引用会传递地址，改变新的变量，原变量也会受到影响；
      2. 不可变的数据类型的变量（字符串、整型、元组）保存值本身，改变新的变量，不影响原变量。
      3. 传递用用，又不变动原列表或字典，copy模块，普通复制使用copy()，列表中包含列表使用deepcopy()

      4. a=1
         b=a
         b=2
         print(a)
         # 1
         # 不可变类型引用不改变原变量
         
         list1 = [1,2]
         list2 = list1
         list2.append(3)
         print(list1)
         # [1,2,3]
         # 可变类型引用可以改变原列表中元素
         
         import copy
         list3 = [1,2]
         list4 = copy.copy(list3)
         list4.append(3)
         print(list3)
         # [1,2]
         # 用了copy的可变类型引用不改变原列表中元素

2. 元组（tuple）：( )
   1. 元素不可变：常用于地理坐标等永远不变的信息
   2. 固定顺序，不能增删改，索引（index）从0开始
   3. 只有1个元素，必须在后面加上逗号“ , ”
   4. 元组不能用作字典的键
   5. 与列表一致的操作：获取元素、判断是否包含
   6. 与列表可以互为元素，当列表作为元组元素时，列表中的元素依然可以改变

      tup_0 = ()
      tup_1 = (1,)
      
      #列表作为元组的元素
      tup_n = (1,2,3,4,[5,6,7])
      

3. 字典（dictionary）：{ }
   1. 键（key）、值（value）映射（mapping）→  键值对（key-value pair）
   2. 每个键key，都是独一无二的
   3. 应用：判断 键 是否包含在字典中再进行操作，判断方式同列表
   4. 元素可变，无序，随机打印，通过[字典名][[键]]查找值
   5. 嵌套：列表、字典或元组都可以成为字典中的值，字典也可以是列表、元祖的元素

      #1、创建字典,2种创建方式
      dict_0 = dict()
      dict_0 = {}
      
      #2、创建字典
      fruits = {"Apple":"Green","Banana":"Yellow"}

   6. 增

      fruits["Peach"] = "pink"  # 没有的元素直接填写即为添加
      fruits.update(fruits1)    # 加到原字典最后

   7. 删

      fruits.pop("Peach")    # 删除最后一项
      del fruits["Apple"]
      
      pop_fruit = fruits.popitem()
      # 删除最后加入的键值对，拆分出2个元素的元组       
      # pop_fruit 的值为 ("Peach","pink")

   8. 改

      fruits["Apple"] = "Red"

   9. 查

      fruits["Apple"]
      fruits.get("Apple")

4. 集合（set）：{ }
   1. 同一集合中的元素不能重复，有重复会自动去重
   2. 集合元素，不可变元素
      1. 数值、字符串、元组
      2. 不可以作为集合元素：列表、字典、集合
   3. 列表、元组等转集合，内置方法set()

      list1 = [1,2,3]
      a_set = set(list1)
      # {1,2,3}

   4. 集合操作并集（Union）、并集（Union）、差集（Difference）、对称差集（Difference）

      a_set = {1,2,3}
      b_set = {3,4,5,6}
      a_set | b_set       # 并集 {1，2，3，4，5，6}
      a_set & b_set       # 交集 {3}
      a_set - b_set       # 差集 {1，2}               在a中不在b中
      a_set ^ b_set       # 对称差集 {1，2，4，5，6}  不同时出现在两者中
      a_set.symmetric_difference(b_set)    # 对称差集

八、字符串

1. 字符串可以通过索引（负索引，反向查找）查找相应位置的字符
2. 字符串的值可以改变，但不能修改其中的单个字符
3. 拼接 +，重复*

   "a" + "b"  # ab     拼接
   "a" * 3    # aaa    重复

4. 改变大小写：大写upper()，小写lower()，首字符大写capitalize()

   "aBc".upper()        # ABC  全大写
   "aBc".lower()        # abc  全小写
   "aBc".capitalize()   # ABc  首字母大写

5. 格式化format()：字符串替换{}，可以按顺序替换多个；如果输入序号，替换特定字符串；也可以输入格式内容，确定输出形式

   b1 = "b"
   "a {} c {}.".format(b1, "d")     # a b c d  多位置替换
   "a {0} c {1} {0}.".format(b1, "d")     # a b c d b 替换指定位置

6. 分割split()：以传入的字符串为基准进行分割，返回列表，该字符串不在出现；如果想保留字符，就用“选字符+无效字符”替换，然后用无效字符分割

   "a.b.c".split(".")    #["a","b","c"]  分割

7. 连接join()：用传入的字符串连接各个列表或字符串内容

   result = "+".join("abc")            # a+b+c  字符串
   result = "-".join(["a","b","c"])    # a-b-c  列表

8. 去空strip()：去除首尾空白字符，中间不影响

   "   a b  ".strip()   # a b  去除空格

9. 替换replace()：把所有与第一个字符串一样的内容，替换成第二个字符串

   "aAbca".replace("a","@")  # @Abc@  替换

10. 查找索引index()：返回第一次出现的位置，没有找到会报错，可以使用异常处理

    try:
        "abc".index("b")     # 2      索引
    except:
        print("Not Found!")  # 返回异常提示

11. 字符串转义（escaping）
    1. 特殊字符前加上反斜杠“ \ ”，使其没有特殊意义
    2. 单引号中使用双引号，或相反，不需要进行转义就能直接使用

       'a\'b\'c'    # a'b'c    \转义
       'a"b"c'      # a"b"c    无需转义
       "a'b'c"      # a'b'c    无需转义

12. 换行符\n
13. 切片（slicing）：[可迭代对象][[起始索引：结束索引]]，字符串、列表

    str1 = "abcdefg"
    str1[0:3]  # abc
    str1[:3]   # abc
    str1[5:7]  # fg
    str1[5:]   # fg
    str1[1:2]  # b
    str1[:]    # abcdefg

九、模块（module）   

1. import [模块名] as [别名]：引入模块后，即可使用其中所有的函数
2. 文件顶部导入所有模块
3. 所内置模块说明：https://docs.python.org/3/py-modindex.html
4. math模块
5. random模块：random.randint(1,10) 生成1-10之间的随机整数，必须要有起、止数

N、异常处理

1. #单个异常
   try:
       code1
   except [异常]:
       code2
   
   #多个异常
   try:
       code1
   except ([异常1],[异常2]):
       code2

2. 正常情况，执行try后语句；捕获异常，执行except后语句；
3. 一旦发生异常，直接转入except子句的代码，异常代码后的代码将不再执行

   try:
       print(2/1)
       print(2/0)    #异常
       print(2/2)    #不执行
   except ZeroDivisionError:
       print("Error: Invalid argument.")