Python基础

文章目录

• 思维导图
• 运算符
• for else结构
• 字符串
• 切片
• 列表
• • 列表推导器
• 元组
• 函数
• • 返回值
  • 参数传递
  • 缺省参数（默认参数）
  • 不定长参数
  • 函数形参的完整格式
  • print中的 sep 参数
  • 拆包和组包
  • 类型的可变和不可变
  • 匿名函数
  • 自定义排序器
• 面向对象
• 封装
• • 类属性
  • 魔法方法
  • • `__init__`
    • `__str__`
    • `__repr__`
    • `__del__`析构函数
  • 魔法属性
  • • `__mro__`
    • `__dict__`
    • `__all__`
    • `__name__`
• 继承
• • 子类调用父类中的被重写的方法
  • 多继承
  • 私有权限
  • 类对象 / 类属性
  • 类方法
  • 静态方法
• 异常
• • 捕获异常
  • 打印异常
  • 打印所有异常
  • 异常的完整结构
• 模块
• • 嵌套目录导入模块报红
• 包
• 注意

思维导图

运算符

// 代表除取商

for else结构

• else 会在 for 循环正常结束后执行，如果 break 退出，则不执行

字符串

• 字符串 * num = 字符串重复num次连起来

  ‘hello’ * 3 = ‘hellohellohello’

• 下标从左到右从 0 开始，从右到左从 -1 开始

• find(substr, start, end) & rfind() 找不到返回 -1

• index() & rindex() 找不到直接报错 count(substr) 统计 substr 的出现次数

• replace(old_str, new_str, count)替换指定串中的 old_str 成 new_str, 默认全部替换

• my_str.split(sub_str, count)按照 sub_str 进行切割，如果都不写默认切割 空格和Tab

• join 方法需要每个可迭代对象每个都是字符串

切片

• 字符串、元组、集合都有切片
• 格式：str[start: end: step] 左闭右开 start、end 和 step 都可以省略，但是至少要有一个冒号
• str[:]得到和原来一样的字符串
• str1[::-1] 表示字符串翻转

列表

• 定义：list1 = [] & list2 = list() 定义空列表，列表中可以存放不同数据类型的数据

• append() 结尾添加列表元素 insert(下标, 元素) extend(可迭代对象) 将可迭代元素的每个元素逐个添加到末尾

• pop(下标)根据下标删除，默认删最后一个，返回删除值； remove(值)根据值删除，返回删除值 ；del 列表[下标]与pop类似

• index(值) 根据值查找下标；count(值)根据值查找出现次数；xxx in / not in list 判断是否存在

• 排序：

  必须要列表是全部是同一数据类型才能排序

  列表.sort(reverse = True) 直接在原列表中进行排序（从大到小）

  sorted(列表, reverse = True)得到一个新的排序后的列表，不改变原列表

  列表.reverse() 直接在原列表逆置

列表推导器

• list = [生成数据的规则 for 临时变量 in xxx (for 临时变量2 in xxx)]

  list = [i for i in range(5)]
  # list = [0, 1, 2, 3, 4]
  

• 加上第二个循环类似于循环嵌套

• 字典中也有推导器，语法类似 如 dict = {f'name{i}':i for i in range(5)}

  不过字典中要注意 key 值的相同引起的数据覆盖，所以要使 key 的生成也是随变量改变

元组

• 不能修改，其他和列表一样
• 定义元组使用 ()
• 定义单个数据的元组使用(3,)要记得加逗号

函数 返回值

• 如果返回多个返回值，那么将以元组的形式返回

参数传递

• 位置传参：按照实参的位置顺序将实参的值传递给形参
• 关键字传参：指定实参给到哪个形参（关键字必须是函数的形参名）
• 混合使用：先写位置传参再写关键字传参

缺省参数（默认参数）

• 在函数定义时，给参数一个默认值，这个参数就是缺省参数
• 缺省参数必须定义在实参后面
• 不给缺省参数值就默认，修改了就按修改的值

不定长参数

• *args：不定长元组形参，可以接收所有的位置实参，类型是元组
• **kwargs:不定长字典形参，可以接收所有的关键字实参，类型是字典
• 不定长参数可以不填
• 约定俗称叫 args 和 kwargs，其他标识符名称也可以，只需要加上 *或者**

函数形参的完整格式

• 普通形参 不定长元组形参 缺省形参 不定长字典形参

print中的 sep 参数

• 规定 print 中的变量之间的分隔符，默认sep = ' '

拆包和组包

• 拆包：将容器(元组 / 字典 / 列表)的数据分给多个变量，数据的个数必须要和容器中变量的个数一致，字典拆包拆出来的是 key 值
• 组包：将多个数据值，组成元组，给到一个变量
• a, b = b, a巧妙使用拆包和组包进行变量值 的交换
• *list拆包 相当于 list[0], list[1], list[2], list[3] ...

类型的可变和不可变

• 可变类型：不修改引用的情况下，修改变量值。如：int，float，tuple，str，bool
• 不可变类型：修改引用才能修改变量值。如：list, dict

匿名函数

• lambda [arg1], [arg2]... : 函数体

  冒号前面是要传入的参数，冒号后面是函数内容

• 不能使用 for while if 等结构

自定义排序器

• 类似于 Java 中的自定义排序器，只需要在 sort 函数中添加 key 参数，给与 key 一个匿名函数即可

• list.sort(key = lambda 形参 : (排序规则1, 排序规则2...))

  • 形参 代表列表中的每一个参数

• 如对列表中的每个字典排序

  list1 = [{'name':'shjdas'},
            {'name':'a'},
            {'name':'m'}]
  list1.sort(key = lambda x : x['name'])
  print(list1)
  

面向对象 封装 类属性

• self：作为类中的第一个形参，在通过类调用方法的时候，不需要手动的传递实参值， python 解释器自动的将调用该方法的对象传递给 self ，所以 self 这个形参代表的是对象

  class Dog():
      def play(self):
      ...
  dog = Dog()
  dog.play() # python 自动将 dog 对象传递给 self 参数，然后调用 play 方法
  

魔法方法 __init__

• 类似于 Java 中的 构造函数，用于对对象进行初始化

  class Human(object):
      def __init__(self, name, age):
          self.name = name
          self.age = age
  
          
  human = Human(”张三“, 18)
  

__str__

• 类似于 Java 中的 toString() 函数，用于字符串形式输出对象

  class Human(object):
      def __str__(self):
          return f“姓名{self.name}, 年龄{self.age}”
  
          
  human = Human(”张三“, 18)
  

• 注意：

  • 返回值必须是 str
  • 一般没有形参

__repr__

• 与 __str__十分类似，也是返回字符串，不过更加准确

• 将对象放到容器里输出，调用的是__repr__。如：

  class Dog(object):
      ...
      def __str__(self):
          return f"{self.name}, {self.age}"
      def __repr__(self):
          return f"{self.name}"
      
  list = [Dog("大黄", 1), Dog("大白", 2), Dog("大红", 3)]
  print(list) # ["大黄", "大白", "大红"]
  

• 如果没有重写__str__方法，但重写了__repr__方法时，所有调用__str__的时机都会调用__repr__方法。

__del__析构函数

• 引用计数：python 的一种内存管理机制，是指一块内存，有多少个变量在引用
  • 当一个变量引用一个内存时，引用计数加 1
  • 当删除一个变量 或 这个变量不再引用这块内存，引用计数减 1
  • 当内存的引用计数为 0 时，这块内存被删除，内存中的数据被销毁
• 调用时机：对象在内存中被销毁删除的时候（引用计数为 0 ）会自动调用 __del__ 方法，
  • 程序代码结束，运行过程中创建的所有对象和变量都会被销毁，即调用__del__ 方法
  • 使用 del 变量 ，将这个对象的引用计数变为 0 ，会自动调用 __del__方法

魔法属性 __mro__

• 获得类的继承关系链

__dict__

• 获得类的所有属性的一个字典，key 代表 属性名，value 代表属性值

__all__

• 可以在每个代码文件（模块中）定义，类型是 元组 / 列表
• 作用：只影响 from ... import *导入行为
• 如果没有定义 __all__ 变量，模块中的所有功能，都可以被导入
• 如果定义了，只能导入__all__ 变量中定义的内容
• 元组/列表中必须是字符串

__all__ = ("num", 'func', 'Dog')

__name__

• 可以显示一个模块的某功能是被自己执行还是被别的文件调用执行

• 假设模块A、B，模块A自己定义了功能C,模块B调用模块A，现在功能C被执行了：

  • 如果C被A自己执行，也就是说模块执行了自己定义的功能，那么 __name__ == '__main__'

  • 如果C被B调用执行，也就是说当前模块调用执行了别的模块的功能，那么__name__==‘A’（被调用模块的名字）

    其实换一种说法也就是表示当前程序运行在哪一个模块中

• 常用 __name__ == '__main__' 来表示整个工程开始运行的入口

继承 子类调用父类中的被重写的方法

• 方法 1 ：父类.方法名(self)

• 方法 2 ：super(子类, self).方法名(参数)

• 方法 3 ：super().方法名(参数) （是方法 2 的简写）

  class Dog(object):
      def bark(self):
          print("汪汪汪")
  
  class XTQ(Dog):
      def bark(self):
          print("嘤嘤嘤")
      def see_master(self):
          # Dog.bark(self) 方法 1 
          # super(XTQ, self).bark() 方法 2 
          super().bark() # 方法 3 
  xtq = XTQ()
  xtq.see_master()
  

多继承

• class A(B, C, ...)

• 如果调用的方法父类 B C 中都有，那么会优先调用 前一个父类 B 中的方法

• 如果想要在子类中调用继承链中其他的方法，可以通过 父类名.方法名(self) 来调用，或 super(要调用的类的子类名，self).方法()

私有权限

• 格式：__属性名 在属性或方法的前面加上__即可

• python 中的私有属性的本质是修改属性的名字，在创建对象的时候，会自动的修改属性名

  在属性名的前面加上 _类名

  如：class People self.__name 实际上是属性名是_People__name

类对象 / 类属性

• 类对象：一个类就是一个类对象

  作用：定义实例对象； 存储类属性

• 类属性：类中的属性，只有一份，类似于 Java 中的 static 定义的变量

  格式：定义在类中，方法外

• 类属性可以通过对象修改，但是如果 实例对象 有重名的属性，那么用对象修改不了类属性，只会修改对象中的属性

类方法

• 格式：使用@classmethod定义的方法

  class xxx():    ...    @classmethod    def xxx(cls):        return cls.xxx
  

• 默认第一个参数是 cls ，指类对象自身

• 前提：如果一个方法不需要使用实例属性，而使用类属性，那么就需要定义类方法

静态方法

• 使用 staticmethod定义的方法，对参数没有要求，可以有，可以无
• 前提：不需要使用实例属性，同时也不需要使用类属性，此时可以定义静态方法

异常

• 格式：异常类型名：异常描述
• raise 异常名抛出异常

捕获异常

• 方式 1

  try:    可能发生异常的代码except 异常类型 1 :    发生异常 1 ，执行的代码except 异常类型 2 :    发生异常 2 ，执行的代码    ...
  

• 方式 2

  try:    可能发生异常的代码except (异常类型 1， 异常类型 2，...)	发生异常执行的代码
  

打印异常

• except (异常类型 1， 异常类型 2，…)后面添加 as 异常变量名

  然后再print一下即可

打印所有异常

try:    ...except Exception as e:    print(e)

异常的完整结构

try:    ...except Exception as e:    发生了异常执行else:    没有发生异常执行的代码finally:    不管发不发生都要执行的代码

模块

• 模块就是一个 python 文件
• 导入模块
  • import 模块名
  • form 模块名 import 功能1, 功能2,...
  • form 模块名 import * 注意：这种方式容易使同名变量或方法发生覆盖
• as重命名模块/功能名，不过重命名之后就不能用原始的名字

嵌套目录导入模块报红

• Mark Directory as -> sources root

包

• __init__.py文件每个包都有
• from 包名 import * 导入的是 __init__.py中的内容

注意

• python 中没有自增(++)自减(–)运算符

• python 中有三目运算符，但是与 C 和 Java 中的语法不一样

  • 错误使用：判断条件 ? 正确结果 : 错误结果

  • 正确使用：正确结果 if 判断条件 else 错误结果

  • 例如斐波那契数列

    def fun():	return n if n < 2 else fun(n - 1) + fun(n - 2)
    

  • 或者使用 numpy 中的 np.where()

• 元组 tuple, 列表 list, 集合 set 之间可以相互转换

• 在函数中使用 = 修改全局变量，需要先使用 global 声明全局变量，而 insert 、append 等不需要声明