Python随笔
Stru99le Lv2
  2023-06-03 18:02:26 2023-06-03 18:02   2024-03-21 10:05:32      3.5k 字  14 分钟  

Python的一些不熟悉的知识

一些小知识，想到什么写什么

  • 列表与数组

    1. python中的列表可以包含不同类型的元素，如字符串、整数、浮点数等，而数组通常包含相同类型的元素
    2. python中列表是动态数组，可以自动调整大小，而数组再创建时需要指定大小，一旦创建后，大小就不能再改变，因此在插入或删除元素时需要手动。
    3. 数组相当于列表来说在访问元素时性能更好，以为列表是动态数组插入或删除元素可能会有些性能损失。

  • 元组
    元组是一个集合是有序的和不可改变的
    元组使用小括号(),列表使用方括号[]
    元组的创建很简单，只需要在括号中添加元素，使用逗号隔开即可

  • 集(Set)
    集合是无序和无索引的集合，可以用来快速判断一个元素是否在某个集合中，在py中用{}表示

    1. 添加一个项目到集合用add()

      1
      2
      thiset={"apple","banana","cherry"}
      thiset.add("orange")

    2. 添加多个项目用update()

      1
      2
        thiset={"apple","banana","cherry"}
      thiset.update(["orange", "mango", "grapes"])

    3. 删除用Remove()或discard()方法
      如果删除的项目不存在，remove()会引发错误，而discard()不会引发错误

    4. pop()删除最后一项

    5. clear()清空集合
      …

  • 字典

    1. 使用values()函数返回字典的值

      1
      2
      for x in thisdict.values():
        print(x)

    2. 使用items()循环遍历键和值

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

    3. dict()创建字典

      1
      2
      3
      4
      epdict = dict()
      print(epdict) # 输出{}
      print(len(epdict)) # 输出0
      print(type(epdict)) # <class 'dict'>
    • 字典的访问

      1. 使用中括号[ ] 

        1
        2
        dic = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        print(dic['key1'])  # 输出 value1

      2. 使用get( )方法
        dic.get(key,default=None)它用于从字典中获取指定键key对应的值，键不存在返回一个默认值deafult

        1
        2
        3
        dic = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        print(dic.get('key1')) # 输出value1
        print(dic.get('key4')) # 输出 None

      3. 除以上外，可以通过keys(),values()和items()方法获取字典中所有的键、值和键值对。例如:

        1
        2
        3
        4
        dic = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
        print(dic.keys()) # 输出 dict_keys(['key1', 'key2', 'key3'])
        print(dic.values()) # 输出 dict_values(['value1', 'value2', 'value3'])
        print(dic.items()) # dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])

        注意:keys()、values()、items()方法返回的是一种特殊的视图对象，而不是普通的列表。要转换成列表可以用list()函数

  • 频率
    看到计算频率等问题直接联想到以下代码:

    1
    2
    for i in nums:
      dic[i] = dic.get(i,0) + 1

  • 解包
    解包是指将一个序列或元组中的元素分别赋值给变量。可迭代对象是指可以被迭代器遍历的对象，例如列表、元组、字符串等。而解包则是指将一个序列或元组中的元素分别赋值给多个变量的操作。

  • *args和**kwargs

    1. *args（arguments）允许你传递零个或多个位置参数给一个函数。它会将传递给函数的位置参数收集到一个元组(tuple)中。在函数定义中，*args以星号(*)的形式出现，但你可以用任何变量名代替它。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    pythonCopy codedef example_function(*args):
        for arg in args:
            print(arg)

    example_function(1, 2, 3, 4, 5)
    # Output:
    # 1
    # 2
    # 3
    # 4
    # 5
    1. **kwargs（keyword arguments）允许你传递零个或多个带有关键字的参数给一个函数。它会将传递给函数的关键字参数收集到一个字典(dict)中，其中关键字作为字典的键，相应的值作为字典的值。在函数定义中，**kwargs以双星号(**)的形式出现，但你同样可以用任何合法的变量名代替它。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    pythonCopy codedef example_function(**kwargs):
        for key, value in kwargs.items():
            print(f"{key}: {value}")

    example_function(a=1, b=2, c=3)
    # Output:
    # a: 1
    # b: 2
    # c: 3

    区别总结：

    • *args用于接收位置参数，收集为一个元组(tuple)。
    • **kwargs用于接收关键字参数，收集为一个字典(dict)。
    • 你可以在同一个函数中同时使用*args和**kwargs，但是*args必须在**kwargs之前。
    • 参数名args和kwargs只是一种约定，你可以用其他任何合法的变量名替代它们，但通常使用它们是为了提高代码的可读性和清晰度。

  • 取整
    使用int取整大于0的数向下取整，小于0的数向上取整

  • 匿名函数
    lambda函数是个匿名函数，可以使用任意数量的参数，但是只有一个表达式。

    • 用法
    1
    2
    3
    4
    5
    6
    lambda arguments:expression
    # ep1.返回一个加10的数
    x=lambda a:a+10
    # ep2.可以使用任意数量的参数：
    x=lambda a,b,c:a+b+c
    print(x(1,2,3))

  • 迭代器
    列表、元组、字典都是可迭代的对象，对于这些对象都有一个获取迭代器iter()方法

    1
    2
    3
    4
    5
    6
    mytuple = ("apple", "banana", "cherry")
    myit = iter(mytuple)

    print(next(myit))
    print(next(myit))
    print(next(myit))

    创建一个返回数字的迭代器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    class MyNumbers:
      def __iter__(self):
        self.a=1
        return self
      def __next__(self):
        x=self.a
        self.a +=1
        return x

    myclass = MyNumbers()
    myiter = iter(myclass)

    print(next(myiter))
    print(next(myiter))
    print(next(myiter))
    print(next(myiter))
    print(next(myiter))

  • Stoplteration关键字
    如果有足够的next()语句，为了防止迭代继续进行，可以使用StopIteration语句
    ep1迭代20次后停止

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class MyNumbers:
      def __iter__(self):
        self.a=1
        return self
      
      def __next__(self):
        if self.a <= 20
          x = self.a
          self.a += 1
          return x
        else:
          raise StopIteration

    myclass = MyNumbers()
    myiter = iter(myclass)

    for x in myiter:
      print(x)

  • raise

    raise 关键字用于引发异常

    ep:如果x<0则引发错误并停止程序

    1
    2
    3
    x = -1
    if x < 0:
        raise Excpetion("error")

  • self
    在python中,self是一个惯用的参数名称。在定义一个类的方法时，需要将self作为第一个参数传递给方法，当我们定义一个类的方法时，那么在调用该方法时，实际上是通过类的实例对象来调用这个方法，因此不需要显式传递self参数；
    如果我们在类的方法中访问类的属性或者方法，那么必须使用self来访问(self.func)。如果我们在方法中直接访问属性或者方法，py会解释为局部变量或函数，从而导致错误。

  • 运算符

    • // –> 取整数-往小的方向取整数
      ep

      9//2
      4

    • ** –> 幂 返回x的y次幂
    • 逻辑运算符
    1. 与 and –> x and y
    2. 或 or –> x or y
    3. 非 not –> x not y

  • 二维数组初始化

    1
    2
    3
    4
    # 创建一个rows行cols列的二维数组，初始值为0
    matrix = [[0 for _ in range(cols)] for _ in range(rows)]
    # 创建一个rows行cols列的二维数组，初始值为
    matrix = [[0] * cols for _ in range(row)]

  • 字符串格式化
    例子:

    1
    2
    3
    name = "张三"
    age = 18
    print("我叫%s，今年%d岁。" % (name, age)) # 输出: "我叫张三，今年18岁。"

  • try
    try和except语句来处理异常，try语句块用于包裹可能会引发异常的代码，而except来处理可能引发的异常，除此之外还可以使用else和finally语句块来进一步处理异常。else语句块中的代码会在try语句块中没有发生异常时执行，而finally语句中的代码无论是否发生异常都会执行。

    1
    2
    3
    4
    5
    6
    7
    8
    try:
      x = 10 / 2
    except ZeroDivisionError:
      print("除数不能为零")
    else:
      print("结果为:", x)
    finally:
      print("无论是否发生异常，都会执行这里的代码")

    except异常由以下几种:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    Exception：所有异常的基类，可以捕获任何类型的异常。
    ZeroDivisionError：除以零时引发的异常。
    TypeError：类型不匹配时引发的异常。
    ValueError：值不合法或无效时引发的异常。
    IndexError：索引超出范围时引发的异常。
    KeyError：字典中使用不存在的键时引发的异常。
    FileNotFoundError：打开或读取文件时找不到文件时引发的异常。
    NameError：尝试访问不存在的变量或函数时引发的异常。
    ImportError：导入模块失败时引发的异常。
    IOError：输入/输出操作失败时引发的异常。

  • 推导式
    用于快速创建列表、字典、集合等可迭代对象，一般有以下几种:

    1. 列表推导式
      语法形式计为:[expression for item in iterable if condition]或者[expression for item in iterable]
      示例:

      • 过滤长度小于或者等于3的字符串列表，并将剩下的转换成大写字母:
      1
      2
      3
      4
      names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
      new_names = [name.upper()for name in names if len(name)>=3]
      print(new_names)
      # 输出['ALICE', 'JERRY', 'WENDY', 'SMITH']

    2. 字典推导式
      语法形式为:{key_expr:value for value in collction} 或者 {key_expr:value for value in collction if condition}
      示例:

      • 使用字符串及其长度创建字典
      1
      2
      3
      4
      listdemo = ['Google','Runoob', 'Taobao']
      newdic = {key:len(key) for key in listdemo}
      newdic
      # 输出{'Google': 6, 'Runoob': 6, 'Taobao': 6}

    3. 集合推导式
      语法形式为:{expression for item in Sequence} 或者 {expression for item in Sequence if condition}
      示例:

      • 判断不是abc的字母并输出
      1
      2
      3
      4
      5
      a = {x for x in 'abracadabra' if x not in 'abc'}
      a
      # 输出 {'d','r'}
      type(a)
      # 输出 <class 'set'>

    4. 元组推导式(生成器表达式)
      可以利用range区间、元组、列表、字典和集合等数据结构类型，快速生成一个满足指定需求的元组，语法形式为:(expression for item in Sequence) 或者 (expression for item in Sequence if condition)

      元组推导式和列表推导式用法完全相同，只是元组推导式是用()圆括号,列表推导式是用[]中括号，类外元组推导式返回的结果也是一个生成器对象
      示例:

      • 生成一个包含数字1-9的元组：
      1
      2
      3
      4
      5
      a= (x for x in range(1,10))
      a
      # <generator object <genexpr> at 0x7faf6ee20a50> 返回是是生成器对象
      tuple(a)
      # 转换为元组 (1, 2, 3, 4, 5, 6, 7, 8, 9)

  • stack下标问题
    正数索引(从0开始)，列表元素的顺序从左到右。而对于负数索引(从-1开始),元素顺序是从右到左；相当于一个是入栈一个是出栈

py函数

  • remove()
    用于从列表中删除指定元素；语法格式为: list_name.remove(element) #element 任意数据类型

    1. 删除普通类型元素
      删除列表中存在的数字或者字符串;不存在会报错，引发valueError异常

      1
      2
      3
      list1 = ['zhangsan', 'lisi', 1, 2]
      list1.remove(1)
      list1.remove('lisi')

    2. 删除对象类型元素 

      1
      2
      3
      4
      5
      list1=[1,2,[3,4],(5,6)]
      a=[3,4]
      b=(5,6)
      list1.remove(a) # 删除列表类型
      list1.remove(b) # 删除元组类型

    3. 删除多个元素，可以使用循环来实现

      1
      2
      3
      4
      5
      6
      7
      8
      # 创建一个列表
      fruits = ["apple", "banana", "orange", "peach", "banana", "kiwi"]
            
      # 删除所有的 "banana" 元素
      while "banana" in fruits:
          fruits.remove("banana")
            
      print(fruits)  # ["apple", "orange", "peach", "kiwi"]

    注意:在使用 remove() 函数时要谨慎，特别是在迭代列表的过程中,当删除一个元素后会导致后面的元素索引发生变化从而可能导致发生错误

  • enumerate()
    enumerate()是python中的一个内置函数，将一个可迭代对象转换为一个枚举对象，同时返回每个元素的索引和值，常用于for循环中获取中获取每个元素的位置信息。
    用法: enumerate(iterable,start=0)
    其中，iterable表示要枚举的可迭代对象，start表示起始索引

  • ord()
    ord()是一个内置函数，用于获取给定字符的Unicode码点值，ord()函数接受单个字符作为参数；

    1
    ord('a') # 返回97

  • defaultdict()
    defaultdict是python中的一个内置字典子类，重载了一个方法来实现默认值的设定。在创建defaultdict对象，需要提供一个参数作为默认值或者一个函数用来生成默认值。
    比如有一个字典对其中的值进行累加操作，如果某个键不存在，则将其值设置为0，使用defaultdict可以避免手动判断键是否存在的过程:

    1
    2
    3
    4
    5
    6
    7
    from collections import defaultdict

    d = defaultdict(int)
    # 对字典中的值进行累加操作
    for i in 'mississippi'：
      d[i]+=1
    print(d) # 输出：defaultdict(<class 'int'>, {'m': 1, 'i': 4, 's': 4, 'p': 2})

  • sorted()
    返回一个新的排好序的列表，而不改变原始列表
    例如有一个数字列表

    1
    num = [4, 2, 7, 1, 3]

我们可以使用sorted()进行排序、会返回一个新的列表，但是排序后会改变数字原有的索引值

1
sorted_list = sorted(nums)

若不想改变原数组的索引值可以用以下方法

1
2
3
4
# 对nums的元素进行排序，排序的依据是nums中对应的位置，对于nums中的每个元素k，使用nums[k]的值作为排序关键字
sorted(nums,key=lambda k:nums[k]])
# 使用enumerate()生产一个包含元素索引和值的可迭代对象，按照值进行排序，不改变原有元素的索引值
sorted_nums = soreted(enumerate(nums),key=lambda x:x[1])

对于上述第二种方法，enumerate(nums)会返回一个(index,value)的元组.

  • list()
    list()是一个空列表的构造函数。当调用list()时，它会返回一个空列表[]。这个空列表可以用来存储任意类型的元素，并且可以根据需要进行修改、添加或删除元素。

基本数据结构操作

  • python建立二叉树(递归)
  1. Python的一些不熟悉的知识
    1. 一些小知识，想到什么写什么
    2. py函数
    3. 基本数据结构操作