Python基础入门

本文介绍Python入门的基础知识。

一、基本数据类型

Python中常见的数据类型有：

  • Number（数字）
  • String（字符串）
  • bool（布尔类型）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

不可变数据（3 个） ：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个） ：List（列表）、Dictionary（字典）、Set（集合）。

# coding:utf-8
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "zhangsan"     # 字符串

print (counter)
print (miles)
print (name)

二、注释和运算符

（一）注释

1、单行注释

# 这是一个注释
print("Hello, World!")

2、多行注释

#!/usr/bin/python3 
"""
这是多行注释（字符串），用三个双引号
这是多行注释（字符串），用三个双引号 
这是多行注释（字符串），用三个双引号
"""
print("Hello, World!")

（二）运算符

1、算术运算符

运算符 描述 实例
+ 加法运算符 3 + 2
- 减法运算符 5 - 2
* 乘法运算符 4 * 2
/ 除法运算符 10 / 2
% 取模运算符 10 % 3
** 幂运算符 2 ** 3
// 整除运算符 10 // 3

2、比较运算符

运算符 描述 实例
> 大于 5 > 3
< 小于 2 < 3
== 等于 3 == 3
!= 不等于 3 != 2
>= 大于等于 4 >= 4
<= 小于等于 2 <= 3

3、赋值运算符

运算符 描述 实例
= 简单赋值 x = 5
+= 加法赋值 x += 3 (相当于 x = x + 3)
-= 减法赋值 x -= 2 (相当于 x = x - 2)
*= 乘法赋值 x *= 4 (相当于 x = x * 4)
/= 除法赋值 x /= 2 (相当于 x = x / 2)
%= 取模赋值 x %= 3 (相当于 x = x % 3)
**= 幂赋值 x **= 2 (相当于 x = x ** 2)
//= 整除赋值 x //= 2 (相当于 x = x // 2)

4、位运算符

运算符 描述 实例
& 按位与 3 & 2 (结果为 2)
` ` 按位或
^ 按位异或 3 ^ 2 (结果为 1)
~ 按位取反 ~3 (结果为 -4，在Python中，整数使用补码形式存储)
<< 左移 3 << 1 (结果为 6)
>> 右移 3 >> 1 (结果为 1)

5、逻辑运算符

运算符 描述 实例
and 逻辑与 True and False (结果为 False)
or 逻辑或 True or False (结果为 True)
not 逻辑非 not True (结果为 False)

6、成员运算符

运算符 描述 实例
in 检查序列中是否包含指定的成员 'a' in ['a', 'b', 'c'] (结果为 True)
not in 检查序列中是否不包含指定的成员 'x' not in ['a', 'b', 'c'] (结果为 True)

7、身份运算符

运算符 描述 实例
is 判断两个标识符是不是引用自一个对象 x = [1, 2, 3]; y = x; x is y (结果为 True)
is not 判断两个标识符是不是引用自不同对象 x = [1, 2, 3]; y = [1, 2, 3]; x is not y (结果为 True)

三、数字

1、Python 支持三种不同的数值类型

  • 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
  • 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

2、数字类型转换

输入图片说明

3、常用数学函数

输入图片说明
输入图片说明

四、字符串

1、字符串格式化方式

类型 描述 示例
%格式化 使用%操作符进行格式化，类似于 C 语言的格式化方式。 name = “Alice”，age = 25，print(“My name is %s and I am %d years old.” % (name, age))，输出为”My name is Alice and I am 25 years old.”
str.format() 使用 format 方法进行格式化，更加灵活和强大。 name = “Bob”，age = 30，print(“My name is {} and I am {} years old.”.format(name, age))，输出为”My name is Bob and I am 30 years old.”
f-strings 在 Python 3.6 及以上版本中引入，简洁直观，在字符串前加上 f，可在字符串中直接使用变量。 name = “Charlie”，age = 35，print(f”My name is {name} and I am {age} years old.”)，输出为”My name is Charlie and I am 35 years old.”

2、常用函数

函数名 描述 实例
str.upper() 将字符串转换为大写 s = “hello”.upper()，此时 s 的值为”HELLO”
str.lower() 将字符串转换为小写 s = “WORLD”.lower()，此时 s 的值为”world”
str.strip() 去除字符串两端的空白字符 s = “ hello world “.strip()，此时 s 的值为”hello world”
str.replace(old, new) 将字符串中的 old 替换为 new s = “hello world”.replace(“world”, “python”)，此时 s 的值为”hello python”
str.split(sep=None) 以指定分隔符将字符串分割为列表 s = “hello world”.split()，此时 s 的值为[‘hello’, ‘world’]，如果指定 sep 为”,”，s = “a,b,c”.split(“,”)，则 s 的值为[‘a’, ‘b’, ‘c’]
str.join(iterable) 将可迭代对象中的元素以指定字符串连接起来 s = “-“.join([“a”, “b”, “c”])，此时 s 的值为”a-b-c”
str.find(sub) 查找子字符串在字符串中的位置，如果未找到返回 -1 s = “hello world”.find(“world”)，此时 s 的值为 6
str.startswith(prefix) 判断字符串是否以指定前缀开头 s = “hello world”.startswith(“hel”)，此时 s 的值为 True
str.endswith(suffix) 判断字符串是否以指定后缀结尾 s = “hello world.txt”.endswith(“.txt”)，此时 s 的值为 True
str.len() 返回字符串的长度 s = “hello”，len(s) 的值为 5

五、列表

函数名 描述 实例
len(list) 返回列表的长度。 lst = [1, 2, 3, 4]，len(lst) 的值为 4。
append(item) 在列表末尾添加一个元素。 lst = [1, 2, 3]，lst.append(4)，此时 lst 变为[1, 2, 3, 4]。
extend(iterable) 将可迭代对象中的元素添加到列表末尾。 lst = [1, 2, 3]，lst.extend([4, 5])，此时 lst 变为[1, 2, 3, 4, 5]。
insert(index, item) 在指定位置插入一个元素。 lst = [1, 2, 3]，lst.insert(1, 4)，此时 lst 变为[1, 4, 2, 3]。
remove(item) 移除列表中第一个值为 item 的元素。 lst = [1, 2, 3, 2]，lst.remove(2)，此时 lst 变为[1, 3, 2]。
pop(index=-1) 移除并返回指定位置的元素，默认移除最后一个元素。 lst = [1, 2, 3]，lst.pop()，返回 3，此时 lst 变为[1, 2]。
index(item) 返回列表中第一个值为 item 的元素的索引。 lst = [1, 2, 3, 2]，lst.index(2)，返回 1。
count(item) 返回列表中值为 item 的元素的个数。 lst = [1, 2, 3, 2]，lst.count(2)，返回 2。
sort(key=None, reverse=False) 对列表进行排序。 lst = [3, 1, 2]，lst.sort()，此时 lst 变为[1, 2, 3]。
reverse() 反转列表中的元素。 lst = [1, 2, 3]，lst.reverse()，此时 lst 变为[3, 2, 1]。

六、元组

函数名 描述 实例
len(tuple) 返回元组的长度。 tup = (1, 2, 3)，len(tup) 的值为 3。
max(tuple) 返回元组中的最大值。 tup = (1, 3, 2)，max(tup) 的值为 3。
min(tuple) 返回元组中的最小值。 tup = (1, 3, 2)，min(tup) 的值为 1。
tuple(iterable) 将可迭代对象转换为元组。 lst = [1, 2, 3]，tuple(lst) 的值为(1, 2, 3)。

七、字典

函数名 描述 实例
len(dict) 返回字典中键值对的数量。 d = {‘a’: 1, ‘b’: 2}，len(d) 的值为 2。
keys() 返回字典中所有的键。 d = {‘a’: 1, ‘b’: 2}，d.keys() 的值为 dict_keys([‘a’, ‘b’])。
values() 返回字典中所有的值。 d = {‘a’: 1, ‘b’: 2}，d.values() 的值为 dict_values([1, 2])。
items() 返回字典中所有的键值对。 d = {‘a’: 1, ‘b’: 2}，d.items() 的值为 dict_items([(‘a’, 1), (‘b’, 2)])。
get(key, default=None) 返回指定键的值，如果键不存在则返回默认值。 d = {‘a’: 1, ‘b’: 2}，d.get(‘a’) 的值为 1，d.get(‘c’, 3) 的值为 3。
pop(key, default=None) 移除并返回指定键的值，如果键不存在则返回默认值。 d = {‘a’: 1, ‘b’: 2}，d.pop(‘a’) 的值为 1，此时字典变为 {‘b’: 2}。
update(other_dict) 将另一个字典的键值对更新到当前字典中。 d1 = {‘a’: 1, ‘b’: 2}，d2 = {‘c’: 3, ‘d’: 4}，d1.update(d2)，此时 d1 变为 {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}。
clear() 清空字典。 d = {‘a’: 1, ‘b’: 2}，d.clear()，此时字典变为 {}。

八、集合

函数名 描述 实例
len(set) 返回集合的长度。 s = {1, 2, 3}，len(s) 的值为 3。
add(item) 向集合中添加一个元素。 s = {1, 2, 3}，s.add(4)，此时集合变为{1, 2, 3, 4}。
remove(item) 从集合中移除一个元素，如果元素不存在会引发 KeyError。 s = {1, 2, 3}，s.remove(2)，此时集合变为{1, 3}。
discard(item) 从集合中移除一个元素，如果元素不存在不会引发错误。 s = {1, 2, 3}，s.discard(4)，集合不变。
pop() 随机移除并返回集合中的一个元素，如果集合为空则引发 KeyError。 s = {1, 2, 3}，s.pop()，假设返回 2，此时集合变为{1, 3}。
clear() 清空集合。 s = {1, 2, 3}，s.clear()，此时集合变为 set()。
union(*others) 返回多个集合的并集。 s1 = {1, 2, 3}，s2 = {3, 4, 5}，s1.union(s2) 的值为{1, 2, 3, 4, 5}。
intersection(*others) 返回多个集合的交集。 s1 = {1, 2, 3}，s2 = {2, 3, 4}，s1.intersection(s2) 的值为{2, 3}。
difference(*others) 返回两个集合的差集。 s1 = {1, 2, 3}，s2 = {2, 3, 4}，s1.difference(s2) 的值为{1}。
symmetric_difference(other) 返回两个集合的对称差集。 s1 = {1, 2, 3}，s2 = {2, 3, 4}，s1.symmetric_difference(s2) 的值为{1, 4}。
isdisjoint(other) 判断两个集合是否没有交集。 s1 = {1, 2}，s2 = {3, 4}，s1.isdisjoint(s2) 的值为 True。
issubset(other) 判断一个集合是否是另一个集合的子集。 s1 = {1, 2}，s2 = {1, 2, 3}，s1.issubset(s2) 的值为 True。
issuperset(other) 判断一个集合是否是另一个集合的超集。 s1 = {1, 2, 3}，s2 = {1, 2}，s1.issuperset(s2) 的值为 True。

九、函数

1、函数作用域

在 Python 中，作用域决定了变量的可见性和生命周期。Python 中有四个主要的作用域：locals、enclosing function、globals和__builtins__。

Locals（局部作用域）

局部作用域包含在函数内部定义的变量。这些变量只能在函数内部访问，并且在函数执行完毕后会被销毁。

def local_scope_example():
    x = 10
    print(locals())  # 打印局部变量
    return x

local_scope_example()

在这个例子中，变量x是在函数local_scope_example内部定义的局部变量。通过locals()函数可以查看局部作用域中的变量。

Enclosing function（闭包作用域或嵌套函数作用域）

当一个函数嵌套在另一个函数内部时，内部函数可以访问外部函数的变量。这些变量构成了闭包作用域。

def outer_function():
    y = 20
    def inner_function():
        print(y)
    return inner_function

inner_func = outer_function()
inner_func()

在这个例子中，函数inner_function嵌套在函数outer_function内部。inner_function可以访问外部函数outer_function中的变量y。

Globals（全局作用域）

全局作用域包含在模块级别定义的变量。这些变量可以在整个模块中访问。

z = 30

def global_scope_example():
    print(globals())  # 打印全局变量
    print(z)

global_scope_example()

在这个例子中，变量z是在模块级别定义的全局变量。函数global_scope_example可以访问这个变量。通过globals()函数可以查看全局作用域中的变量。

__builtins__（内置作用域）

内置作用域包含 Python 的内置函数和类型，如print、len、int等。这些可以在任何地方使用，无需导入。

def builtins_scope_example():
    print(dir(__builtins__))

builtins_scope_example()

这个例子中，函数builtins_scope_example打印了内置作用域中的所有名称。

总之，理解 Python 的作用域对于编写正确的代码非常重要。在使用变量时，Python 会按照局部作用域、闭包作用域、全局作用域和内置作用域的顺序查找变量。如果在一个作用域中找不到变量，它会继续在更广泛的作用域中查找，直到找到为止或者引发NameError异常。

2、匿名函数

什么是匿名函数

在 Python 中，匿名函数是一种没有名称的函数，通常使用lambda关键字来创建。匿名函数也被称为 lambda 函数。

匿名函数的语法如下：
lambda arguments: expression

其中，arguments是函数的参数，可以是一个或多个，用逗号分隔。expression是函数的返回值，可以是一个表达式或一个语句块。

应用场景

（1）作为函数参数

当需要将一个简单的函数作为另一个函数的参数时，匿名函数非常有用。例如，在排序函数中，可以使用匿名函数来指定排序的依据。

students = [('Alice', 20), ('Bob', 18), ('Charlie', 22)]
sorted_students = sorted(students, key=lambda x: x[1])
print(sorted_students)

在这个例子中，sorted函数的key参数接受一个函数，用于指定排序的依据。这里使用匿名函数lambda x: x[1]来根据学生的年龄进行排序。

（2）与内置函数一起使用

匿名函数可以与 Python 的内置函数如map、filter和reduce一起使用，以简洁的方式处理数据。

# 使用 map 函数将列表中的每个元素加 1
numbers = [1, 2, 3, 4, 5]
new_numbers = list(map(lambda x: x + 1, numbers))
print(new_numbers)

# 使用 filter 函数筛选出列表中的偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)

在这个例子中，map函数将匿名函数lambda x: x + 1应用于列表numbers中的每个元素，返回一个新的列表。filter函数使用匿名函数lambda x: x % 2 == 0筛选出列表中的偶数。

（3）临时函数

在某些情况下，只需要一个简单的函数来执行一次性的任务，此时可以使用匿名函数而不是定义一个完整的函数。

result = (lambda x, y: x * y)(3, 4)
print(result)

在这个例子中，匿名函数lambda x, y: x * y被立即调用，传入参数 3 和 4，返回结果 12。

匿名函数在 Python 中是一种非常有用的工具，可以使代码更加简洁和易于阅读。它们特别适用于需要简单函数作为参数或临时函数的情况。通过合理地使用匿名函数，可以提高代码的效率和可读性。

十、文件

文件常用操作参考： Python文件操作 。

十一、面向对象

1、面向对象与面向过程

面向对象(object-oriented ;简称:OO)至今还没有统一的概念我这里把它定义为:按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法。
面向对象编程(Object Oriented Programming-OOP)是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。
以买电脑为例，面向过程（查资料，预算，配置，砍价，成交等），面向对象（找个电脑高手，给钱交易）

2、类和对象

类：飞机设计图纸
对象：你看到的某架飞机

（1）类(Class)由3个部分构成

类的名称 ：类名
类的属性 ：一组数据
类的方法 ：允许对进行操作的方法(行为)
举例:
人类设计，只关心3样东西:
事物名称(类名)：人(Person)
属性：身高(height)、年龄(age)
方法(行为/功能)：跑(run)、打架(fight)

（2）类的定义

输入图片说明

（3）类与对象的区别

面向对象编程的2个非常重要的概念： 类和对象 。
对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的 一组对象 抽象定义，提出了另外一个新的概念–类。
类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象。

（4）__init__方法

在创建对象的时候，顺便设置属性可以使用__init__方法。__init__方法在创建对象后，就立刻被默认调用了。

# 汽车类
class Car:
    def __init__(self, newWheelNum, newColor):
        self.wheelNum = newWheelNum
        self.color = newColor

    def move(self):
        print('车在移动')


BMW = Car(4, 'green')
print('车的颜色为:%s' % BMW.color)
print('车轮子数量:%d' % BMW.wheelNum)

输入图片说明
总结：
__init__()方法，在创建一个对象时默认被调用，不需要手动调用；
__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么_init__(self)中出了self作为第一个形参外还需要2个形参，例如_init__(self ,x,y)；
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去。

（5）self

  • 所谓的self，可以理解为自己；
  • 可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思；
  • 某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可。

（5）魔法方法

__str__方法:
定义后打印对象按照自定义的格式输出。
__del__方法:
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为 __del__方法

（6）对象属性保护

Python中没有像C++中public和private这些关键字来区别公有属性和私有属性；
它是以属性命名方式来区分，如果在属性名前面加了2个下划线””，则表明该属性是私有属性，否则为公有属性(方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的)

3、继承

（1）单继承

输入图片说明

（2）多继承

输入图片说明

4、重写

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法。

# coding=utf-8
class cat(object):
    def sayHello(self):
        print("halou-----1")

class Bosi(cat):
    def sayHello(self):
        print("halou-----2")
bosi = Bosi()
bosi.sayHel1o()

打印：halou-----2

5、调用父类方法

super()._init_(name)

6、多态

class S1(F1):
    def show(self):
        print 'S1.show'

class S2(F1):
    def show(self):
        print 's2.show'

def Func(obj):
    print obj.show()

s1_obj = S1()
Func(s1_obj)
s2_obj = s2()
Func(s2_obj)

换言之，不要检查它是不是一个鸭子：检查它像不像一个鸭子地叫，等等。取决于你需要哪个像鸭子的行为的子集来使用语言。

7、类属性和实例属性

如果需要在类外修改 类属性 ，必须通过 类对象 去引用然后进行修改。
如果通过实例对象去引用，会产生一个同名的 实例属性 ，这种方式修改的是 实例属性 ，不会影响到 类属性 ，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是 实例属性 ，除非删除了该 实例属性。

class People(object):
    country ='China'

# 类属性
print(People.country)
p = People()
print(p.country)
p.country ='US'
print(p.country)
# 实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country
# 删除实例属性
print(p.country)

输入图片说明

8、静态方法和类方法

（1）静态方法

需要通过修饰器 @staticmethod 来进行修饰，静态方法不需要多定义参数。

class People(object):
    country ='china'
    @staticmethod
    #静态方法
    def getcountry():
        return People.country

print(People.getcountry())

（2）类方法

是类对象所拥有的方法，需要用修饰器 @classmethod 来标识其为类方法对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数(当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了)，能够通过实例对象和类对象去访问。

class People(object):
    country ='china'
    #类方法，用classmethod来进行修饰
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls, country):
        cls.country = country

p = People()
# 可以用过实例对象引用
print(p.getCountry())
# 可以通过类对象引用
print(People.getCountry())

p.setCountry('US')
print(p.getCountry())
print(People.getCountry())

结果
总结：
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法，而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性(这个需要具体分析)，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。

十二、异常

在 Python 中，异常是在程序执行过程中发生的错误情况。当出现异常时，程序的正常执行流程会被中断，并跳转到异常处理代码块中进行处理。

1、异常的使用形式

（1）捕获特定异常

以下是一个捕获特定异常的例子：

try:
    num = int(input("请输入一个整数："))
    result = 10 / num
    print(f"结果是：{result}")
except ValueError:
    print("输入不是整数，请重新输入。")
except ZeroDivisionError:
    print("不能除以零。")

在这个例子中，try语句块中包含可能引发异常的代码。如果用户输入的不是整数，会捕获ValueError异常并输出相应提示；如果用户输入的是零，会捕获ZeroDivisionError异常并输出提示。

（2）捕获多个异常

可以使用一个except语句捕获多个异常，如下所示：

try:
    num = int(input("请输入一个整数："))
    result = 10 / num
    print(f"结果是：{result}")
except (ValueError, ZeroDivisionError):
    print("输入错误或不能除以零。")

（3）捕获所有异常

如果想要捕获所有异常，可以使用except Exception as e，如下：

try:
    num = int(input("请输入一个整数："))
    result = 10 / num
    print(f"结果是：{result}")
except Exception as e:
    print(f"发生了错误：{e}")

（4）异常处理中的else和finally

  • else：只有在try语句块中没有引发异常时才会执行。
  • finally：无论是否发生异常，都会执行。
try:
    num = int(input("请输入一个整数："))
    result = 10 / num
    print(f"结果是：{result}")
except Exception as e:
    print(f"发生了错误：{e}")
else:
    print("没有发生异常。")
finally:
    print("这部分总是会执行。")

2、自定义异常

在 Python 中，你可以通过创建一个新的类来定义自己的异常。以下是一个自定义异常的例子：

class MyException(Exception):
    def __init__(self, message):
        self.message = message

try:
    raise MyException("这是一个自定义异常。")
except MyException as e:
    print(e.message)

在上面例子中，我们创建了一个名为MyException的自定义异常类，它继承自Exception类。在try语句块中，我们使用raise关键字抛出了这个自定义异常。在except语句块中，我们捕获了这个异常并输出了异常消息。

赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

👩‍💻本人程序员一枚！<br> 🏢国企待过，侥幸参与国标制定✨<br> 💼私企混过，荣获“反内卷达人”称号<br> 😴目前对打工的日常失去了兴趣😴<br> 🔍作为编程路上的探索者<br> 📚日常中分享技术干货📚<br> 🤝与志同道合的你共同进步🤝<br> 🙏感谢你的支持与关注！💖<br>