Python 基础 学习笔记(1)

2. 数字不可以开头；
3. 区分大小写
4. 不可以使用关键字2

1.3 注释

1.3.1 单行注释

#号

# 注释内容
...

1.3.2 多行注释

三个双引号"""

""" 
多行注释
"""

1.3.3 方法注释

快捷输入：在方法内部第一行打三个双引号回车

def funcTest()
	"""回车"""
	TODO...

1.4 运算符

加、减、乘、除、整除、取余、指数幂(开方)、赋值运算符、复合运算符

+、-、\*、/、//、%、\*\*、=、+=、-=、\*=、/=、%=、\*\*=、//=

1.4.1 除的类型转换

Python中除不尽，会自动转换类型，不想转换类型就需要用//(整除)

a = 10
b = 3
c = a / b
print(c, type(c))
# 打印：3.3333333333333335 <class 'float'>

a = 10
b = 3
c = a // b
print(c, type(c))
# 打印：3 <class 'int'>

1.4.2 指数幂

a = 10
b = 2
c = a \*\* b
print(c, type(c))
# 打印：100 <class 'int'>

1.5 模块

类似于C的include导入的头文件，是用于组织和管理代码的一种方式。

一个模块是一个包含Python代码的文件，它可以包含变量、函数、类和其他可执行代码。

模块的主要目的是将相关的代码组织在一起，以便在需要时进行导入和重用。

1.5.1 导入格式

[from 模块名] import [模块 | 类 | 变量 | 函数 | \*] [as 别名]

1.5.2 常用组合形式

import 模块名
from 模块名 import 类、变量、方法
from 模块名 import \*
import 模块名 as 别名
from 模块名 import 功能名 as 别名

1.5.3 基本使用

# 导入time模块(模块)
import time
time.sleep(5)

# 使用\*导入time模块的全部功能
from time import \*
# 注意这里可以直接使用sleep方法
sleep(5)

# as加别名(模块)
import time as t
t.sleep(5)

# as加别名(方法\函数)
from time import sleep as t
t(5)

1.5.4 自定义模块

可以直接访问方法，而无需通过类的实例

from 类名 import 方法名

注意

1.导入外部包的时候，运行会把导入的外部模块中的方法也运行了，解决方案__main__3

# MyTestPackage
def test(a, b)
	print(a + b)
test(1, 2)

# MyRunPackage
# 导入外部包
from MyTestPackage import test
# 没有其他代码...运行MyRunPackage会输出(3)，也就是外部模块MyTestPackage的test方法被调用了

2.导入不同模块的同名方法，优先以最后导入的模块方法为准

from package import test
from package2 import test
# 调用package2的test()方法
test()

1.5.5 __ main __

解决导入包自动运行的问题，(类似)是Java的作用域private

# 打main自动提示
if _ _name_ _ == "\_ \_main\_ \_":
	方法名

实例

def test(a, b)
	print(a + b)
if _ _name_ _ == "\_ \_main\_ \_":
	test(1, 2)

1.5.6 __ all __

限制外部模块使用*导入该模块后可以访问的方法，只限制*号，手动导入可以正常导入

# 限制外部包只能使用testA方法
_ _ all _ _ = ["testA"]

def testA():
	print("testA")
	
def testB():
	print("testB")

1.6 包

类似Java的maven package，打包成Jar文件，就可以从依赖中引入Jar

1.6.1 概念

包由模块和__ init __.py组成，有就是包，没有就是文件夹

1.6.2 导入包

import 包名.模块名

1.6.3 导入第三方包

PIP：Python安装内置的程序，负责安装第三方包

CMD导入

pip install 包名称

网络优化

pip因为是连接的国外的网站，有的时候速度会很慢，可以通过如下命令配置镜像站(清华大学提供)

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名

Pycharm导入

1. 右下角Interpreter Settings

2. 显示导入的第三方包

3. 安装

4. 搜索安装

1.6.4 使用

包名.模块名.目标

1.6.5 创建包

右键 → New → Python Package

1.6.6 __ init __.py

配置模块的访问权限：main/all

1.N 控制台输入/输出

1.N.1 输出

# 打印单个，直接打印
print("123")

# 打印多个，用逗号分隔
num = 50
str = "String"
f = 1.23
print(num,str,f)

1.N.2 输入

就是从键盘接收，Java中的type x = new Scanner(System.in).next();

但是Python中从键盘接收的值，永远是String类型

变量名 = input()

实例

# 从键盘接收数据
# 提前print打印提示语
print("你的名字是？")
name = input();
print(f"好的，{name}")

# 将提示语放到input方法中，作为参数，区别是没有换行
name = input("你的名字是？\n");
print(f"好的，{name}")

user_name = input("请输入用户名: \n")
user_type = input("请输入账号身份: \n")
print(f"您好:{user\_name},您是尊贵的{user\_type}")

---

二、数据类型

在Python中，变量的类型是根据赋给它的值来确定的，而不是在声明变量时进行定义。

2.1 数字(Number)

2.1.1 整数(int)

正、负整数，1、-1

2.1.2 浮点数(float)

带小数点的数，3.14

2.1.3 复数(complex)

1+2j，以j结尾表示负数

2.1.4 数字精度控制

假如使用m.n控制数据的宽度和精度

m：控制宽度，要求是数字(很少使用)，设置的宽度小于数字自身则不生效，小数点和小数部分也参与宽度计算

n：控制小数点精度，要求是数字，会进行小数的四舍五入

实例

%5d：表示将宽度控制在五位，不足用空格补齐。

比如541，设置为5d：[空格] [空格] 541，用空格补齐宽度

%7.2f：表示将宽度控制为七位，将小数点精度控制为2，同样空格补齐宽度

比如54.156，设置%7.2f：[空格] [空格] 54.16，总长度7位，保留小数点后两位，第三位四舍五入，变成54.16

%.2f：表示不限制宽度，保留小数点后两位

# 输出：修改精度后的值为： 54.16(包含两个空格)
num1 = 54.155
print("修改精度后的值为：%7.2f" %num1)

2.2 字符串(String)

字符组成，单个字符也是字符串，没有char字符类型

2.2.1 定义

三引号定义和多行注释的写法一样，使用变量接收它，它就是字符串，不接收就是注释

# 单引号、双引号、三引号
str1 = 'String1'
str2 = "String2"
str3 = """String3"""

2.2.2 字符串拼接

同Java，使用+号拼接，拼接的内容必须是String类型

str1 = "Te"
str2 = "st"
print(str1 + str2 + "!")

2.2.3 格式化

占位符

跟C语言一样通过 %占位符占位，后面的字母代表不同的意思

# 单占位符
name = "刘"
name2 = "君主刘备姓%s" %name
print(name2)

# 多占位符
name = "刘备"
name2 = "刘"
name2 = "君主 %s 姓 %s" % (name, name2)
print(name2)

占位符	含义
%s	表示将变量变成字符串放入占位的地方
%d	表示十进制整数类型的占位符
%f	表示浮点数类型的占位符
%c	表示单个字符类型的占位符
%o	表示八进制整数类型的占位符
%x	表示十六进制整数类型（小写字母）的占位符
%X	表示十六进制整数类型（大写字母）的占位符
%%	表示百分号字符 % 自身的占位符

format

没法配置精度

name = "Alice"
age = 25
message = "My name is {} and I am {} years old.".format(name, age)
print(message)

f-strings

没法配置精度

name = "Alice"
age = 25
# 在字符串前面添加一个标记f，参数通过{}花括号配合变量名处理
message = f"My name is {name} and I am {age} years old."
print(message)

表达式

str1 = "String"
print("1 \* 1的结果是：%d" % (1 \* 1))
print(f"1 \* 1的结果是：{1 \* 1}")
print(f"变量str的类型是：{type(str1)}")

实例

数字精度控制配合字符串格式化

# 公司名
company = "蜀国"
# 当前股价
stock_price = 5.41
# 股票代码
stock_code = 521
# 股票每日增长系数
stock_price_daily_growth_factor = 1.3
# 增长天数
gorwth_days = 7
print(f"公司：{company},股票代码：{stock\_code},当前股价：{stock\_price}")
print("每日增长系数：%f，经过%d的增长后，股价达到了:%4.2f" % (
stock_price_daily_growth_factor, gorwth_days, 5.41 \*\* stock_price_daily_growth_factor))

2.2.4 大小比较

字符串是根据ASCII码按位比较大小：ASCII值越大越大，小写大于大写

例如，azz : baa，baa大，先比较字符串的第一个字符，如果相等，比较第二个，以此类推

2.3 布尔(bool)

True、False

2.4 空值(NoneType)

n = None
print(n)
print(type(n))

---

三、数据容器

所有容器对应API(增删改查)参阅Python API.md

3.1 列表(List)

有序、可重复、可变的数据结构，用方括号[]表示。它可以包含任意类型的元素，并且允许元素重复。列表可以通过索引访问、添加、删除和修改元素。列表常用于存储和处理多个相关的元素。

最接近数组的类型，区别是列表可以存储不同类型的元素，并且可以动态调整大小，不需要事先指定长度。

3.1.1 定义

普通列表

# 空列表
[]

# 空列表
myList = []

# 可以在创建列表时初始化元素：list(range(1,5)) --- [1,2,3,4]
myList = list()
myList = [1, 2, 3, 4, 5]

嵌套列表

类似于二维数组(矩阵)

myList = [[1, 2, 3], [4, 5, 6]]

3.1.2 索引

索引从0开始，注意下标越界异常(index outbound Exception)

myList = [1, 2, 3, 4, 5]
# 打印1
print(myList[0])

反向索引

从-1开始，就是-1为0号元素，依次类推-2、-3…，可以理解为倒排索引(从后往前取值)

myList = [1, 2, 3, 4, 5]
# 打印5
print(myList[-1])

矩阵索引

两个索引值

myList2 = [[1, 2, 3], [4, 5, 6]]
print(myList2[0][1])

3.1.3 遍历

while

index = 0
myList = [1, 2, 3, 4, 5]
while index < len(myList):
    print(myList[index])
    index += 1

for

index = 0
myList = [1, 2, 3, 4, 5]
for i in myList:
    print(i)

3.2 元组(Tuple)

有序、可重复、不可变的数据结构，用圆括号()表示。类似于列表，可以包含任意类型的元素，但一旦创建，就不能修改。元组常用于存储不可变的数据，如坐标、日期等。

只读的List列表，一旦创建不支持增删改。

3.2.1 定义

普通元组

注意：只有一个数据的时候，这个数据的后面要添逗号

# 空元组
(元素1, 元素2, 元素3)
my_tuple = (元素1, 元素2, 元素3)

# 创建元组(初始化)的两种方式
my_tuple = ()
my_tuple = tuple()

嵌套元组

my_tuple = ( (1, 2, 3), (4, 5, 6) )
# 打印1
print(my_tuple[0] [0])

3.2.2 索引

索引从0开始，注意下标越界异常(index outbound Exception)

my_tuple = (1, 2, 3, 4, 5)
# 打印1
print(my_tuple[0])

反向索引

从-1开始，就是-1为0号元素，依次类推-2、-3…，可以理解为倒排索引(从后往前取值)

my_tuple = (1, 2, 3, 4, 5)
# 打印5
print(my_tuple[-1])

矩阵索引

两个索引值

my_tuple = ( (1, 2, 3), (4, 5, 6))
print(my_tuple[0][1])

3.2.3 遍历

while

index = 0
myArray = (1, 2, 3, 4, 5)
while index < len(myArray):
    print(myArray[index])
    index += 1

for

index = 0
myArray = (1, 2, 3, 4, 5)
for i in myArray:
    print(i)

3.3 集合(Set)

无序、不可重复、可变的数据结构，用花括号 {} 表示。集合中的元素是唯一的，不允许重复。集合提供了快速的成员检查和数学集合操作，如交集、并集、差集等。

通过哈希表实现的，其元素没有固定的顺序，不支持索引。

集合中的元素不可以是list列表，因为集合是存储不重复的元素容器；可以存储元组(tuple)。

3.3.1 定义

my_set = {1, 2, 3, 4, 5}
# 使用set()函数时，参数为可迭代对象，这里给的是数组
my_set = set([1,2,3,4,5])

3.3.2 遍历

集合不支持下标索引，不能用while循环

for i in 集合名
print(i)

3.4 字典(Dictionary)

无序、Key唯一、可变的键值对数据结构，用花括号 {} 表示。字典中的元素由键（key）和对应的值（value）组成，键必须是唯一的。字典常用于存储和检索具有关联关系的数据。

重复key，保存最后一个key的值。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

3.4.1 定义

普通字典

# 定义空字典
dic = {}
dic = dict()
dic = {"key1": value2, "key2": value2}

嵌套字典

# 定义字典中，字典的value是一个新的字典
dic = {
	"key1": {
		"key1a": key1avalue,
		"key1b": key1bvalue,
		"key1c": key1cvalue,
	},
	"key2": {
		"key2a": key2avalue,
		"key2b": key2bvalue,
		"key2c": key2cvalue,
	}
}
# 取值就是：dic[key1] [key1a]

3.4.2 遍历

myDic = {"1": 10, "2": 20, "3": 30}
# 根据key遍历
keys = myDic.keys()
for key in keys:
	print(myDic[key])


# 根据字典遍历
for key in myDic
	print(myDic[key])

3.5 序列(Sequence)

序列是指：内容连续、有序且可以用下标访问的数据容器，列表(List)、元组(Tuple)、字符串(String)

3.5.1 切片

从一个序列中取出一个子序列

实例

"""
 从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
 起始下标表示从何处开始，可以留空，留空视作从头开始
 结束下标表示何处结束，可以留空，留空视作截取到结尾，不包含当前
"""
# 步长表示依次取元素的间隔：
# 1表示一个个取元素(默认是1)，2表示每次跳过一个取，N表示每次跳过N-1个取，
# 步长为负数，表示反向取(注意起始下标和结束也要反向)
序列[起始下标:结束下标:步长]

3.6 JSON(非内置容器)

3.6.1 概念

json是键值对结构，常用于前后端数据的传输

3.6.2 处理

列表嵌套字典转JSON

import json

data = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
# 将数据转换为JSON字符串，配置ensure\_ascii不使用ASCII码转换中文
jsonStr = json.dumps(data, ensure_ascii=False)
# String类型
print(type(jsonStr))
print(jsonStr)

字典转JSON

import json

dic = {"name": "周杰伦", "addr": "台北"}
jsonStr = json.dumps(dic, ensure_ascii=False)
print(type(jsonStr))
print(jsonStr)

JSON字符串转List

import json

jsonStr = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
listA = list([{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}])
print(type(listA))
print(listA)

JSON字符串转字典

import json

jsonStr = {"name": "周杰伦", "addr": "台北"}
dictA = dict([{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}])
print(type(dictA))
print(dictA)

---

四、流程控制

4.1 分支

4.1.1 if…

if 条件:
    # 四个空格/tab
	条件成立TODO

实例

age = 24
if age < 25:
    print("Success!")

4.1.2 if…in…

判断元素x是否在y里，是返回True，否返回False

if x in y:
	条件成立 TODO

4.1.3 if…else…

if 条件:
    # 四个空格/tab
	条件成立 TODO
else:
    条件不成立 TODO

实例

# if-else
age = 24
if age < 25:
    print("Success!")
else:
    print("Error!")

4.1.4 if…elif…

if 条件:
    # 四个空格/tab
	条件成立 TODO
elif 条件2:
    条件2不成立 TODO
else:
	TODO

实例

age = 25
if age < 25:
    print("lt!")
elif age > 25:
    print("gt!")
else:
    print("True!")

4.1.5 if嵌套

if 条件:
    print("xxx")
	if 条件:
		条件成立 TODO
	elif 条件2:
    	条件2不成立 TODO
	else:
		TODO
elif 条件2:
    条件2不成立 TODO
else:
	TODO

4.2 循环

4.2.1 for

for 临时变量 in 数据集:
	循环体...

实例

# 判断字符串中有几个a
num = 0
str = "panda is big animal"
for i in str:
    if (i == "a"):
        num += 1
print(f"该字符串中有{num}个a字符")

# 九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        # if j <= i:
            print(f"{j}\*{i}={i \* j}\t", end='')
    print()

注意

for循环的临时变量是可以被外部访问到的，是全局变量

for i in range(10)
	print(i)
print(i)
# 打印0 - 9和9，9打印了两遍

符合规范：先定义一个同名的全局变量

i = 0
for i in range(10)
	print(i)
print(i)
# 打印

4.2.2 while

while 条件:
	条件为True，执行...
...

实例

age = 10
while age < 100:
    age += 1
print(age)

4.2.3 循环中断

continue

跳出此次循环

# continue
for i in range(1, 4):
    print(i)
    continue
    print("Success!")
# 打印123，没有Success！

break

跳出当前循环

for i in range(1, 10):
    print(i)
    break
# 打印1,后面都不执行了

---

五、函数

函数可以直接用，如果在类中，跟Java一样，先创建实例，用实例调用方法

5.1 定义

5.1.1 函数结构

def 函数名(参数):
	函数体
	return 返回值

实例

# 函数Demo
def hello(text):
    print(text)
hello("Success！")

5.2 传参方式

5.2.1 位置参数

调用函数时根据函数定义的参数位置传递参数，传递的参数和方法的参数个数、参数顺序必须一致

def testFunction(id, name, age)
	print(id + "-" name + "-" + age)
testFunction(1, "刘备", 18)

5.2.2 关键字参数

传递参数的时候通过”键 = 值“的方式传递参数，不需要按顺序传递了

def testFunction(id, name, age)
	print(id + "-" name + "-" + age)
testFunction(name = "刘备", age = 18, id = 1)

注意

函数调用时，如果有位置参数，位置参数必须在关键字参数的前面，且匹配参数顺序

5.2.3 缺省参数(默认参数)

就是给方法的参数设定一个默认值，调用方法时可以不传该参数，如果传了，则覆盖默认参数

def testFunction(id, name = "刘备", age)
	print(id + "-" name + "-" + age)
testFunction(age = 18, id = 1)

注意

所有位置参数必须出现在默认参数前，包括函数定义和调用

5.2.4 不定长参数

也叫可变参数，表示参数的个数不固定，适用于不确定要传多少个参数的场景

位置传递

一个*号，所有的参数都会被args收集，args是一个元组(tuple)

def testFunction(\*args)
	print(args)
testFunction("刘备", 18, 1)

关键字传递

两个*号，参数是"键=值"的形式，所有的键值对都会被kwargs收集，kwargs(keyword)是一个字典(dir)

def testFunction(\*\*kwargs)
	print(kwargs)
testFunction(name = "刘备", age = 18, id = 1)

5.3 高阶函数

本质上是将一个函数作为参数传递给另一个函数

作用是传入计算逻辑，而非传入数据，逻辑固定参数不固定 → 逻辑不固定参数不固定

实例

# 定义一个计算器函数
def compute(x, y):
	return x + y

# 新的函数调用需要一个计算器函数作为参数，函数内部使用了这个计算器函数
def function(compute):
	result = compute(1, 2)
	print(result)

5.4 匿名函数(lambda)

函数定义中，def可以定义一个带有名称的函数，可以基于名称重复使用

lambda关键字，可以定义匿名函数(无名称)，只可以使用一次

写多行代码的情况，不可以使用lambda，比如for、if、while这种

# lambda是关键字，表示定义的是匿名函数
# 传入参数表示匿名函数的形式参数：x, y 表示接收两个形式参数
# 函数体，就是执行逻辑，注意只能写一行，无法写多行代码
lambda 传入参数: 函数体(一行代码)

实例

在使用函数作为参数传递的时候，避免了需要定义一个函数的复杂过程，类似于Java

# 新的函数调用需要一个计算器函数作为参数，函数内部使用了这个计算器函数
def function(compute):
	result = compute(1, 2)
	print(result)
function(lambda x, y: x + y)

5.5 返回值

5.5.1 不返回(return)

返回None，方法依然可以使用变量来接受这个None类型的返回值

5.5.2 返回单/多个参数

# 单个参数，直接返回
return x

# 多个参数，用逗号分隔，接收按照返回值的顺序，写对应顺序的变量接收
return x, y

x, y = funcReturn()

---

六、面向对象

6.1 类

6.1.1 概念

同样包含属性，以及方法，通过创建类对象访问属性和方法

class 类名:
    # 类属性(成员变量)
	属性1 = None
	属性2 = None
	属性3 = None
    
    # 类方法(成员方法)
    def 方法名(self,参数列表):
        执行体...

6.2 对象

6.2.1 概念

6.2.2 创建

# 括号可以理解为构造方法
对象(实例)名 = 类名()

6.2.3 属性赋值

对象名.属性名 = 属性值

6.2.4 获取属性值

对象名.属性名

6.2.5 生命周期(作用域)

局部变量的作用域一般是以空格/Tab为界，也就是伪大括号(Python中没有大括号)

局部变量(成员变量)

方法内部的变量

def funcTest():
    num = 1
funcTest()
# 报错，局部变量
print(num)

在方法中声明全局变量

def funcTest():
    # 必须先定义，后使用，且不能定义同时赋值
    global num
    num = 1
funcTest()
print(num)
# 打印1

6.3 方法

6.3.1 方法调用

对象名.方法名

实例

class Student
	def hello(text)
	print(text)
# 先创建实例，再通过实例调用方法
student = Student()
hello("Success!")

6.3.2 构造方法

_ _ init _ _，创建对象时传入参数，使用构造方法可以不写属性，会自动创建并赋值，写则只赋值

class Person:
    
    # 属性(成员变量)
	id = None
	name = None
	
	# 构造方法
	def \_\_init\_\_(self, id, name):
		self.id = id
		self.name = name
		

person = Person(1, "刘备")

6.3.3 魔术方法

Python中类内置了一些方法，有不同的特殊功能，_ _ init _ _就是其中之一，这些方法统称为魔术方法

前面两个下划线后面两个下划线包裹起来的方法都是内置的魔术方法

_ _ str _ _

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

建

# 括号可以理解为构造方法
对象(实例)名 = 类名()

6.2.3 属性赋值

对象名.属性名 = 属性值

6.2.4 获取属性值

对象名.属性名

6.2.5 生命周期(作用域)

局部变量的作用域一般是以空格/Tab为界，也就是伪大括号(Python中没有大括号)

局部变量(成员变量)

方法内部的变量

def funcTest():
    num = 1
funcTest()
# 报错，局部变量
print(num)

在方法中声明全局变量

def funcTest():
    # 必须先定义，后使用，且不能定义同时赋值
    global num
    num = 1
funcTest()
print(num)
# 打印1

6.3 方法

6.3.1 方法调用

对象名.方法名

实例

class Student
	def hello(text)
	print(text)
# 先创建实例，再通过实例调用方法
student = Student()
hello("Success!")

6.3.2 构造方法

_ _ init _ _，创建对象时传入参数，使用构造方法可以不写属性，会自动创建并赋值，写则只赋值

class Person:
    
    # 属性(成员变量)
	id = None
	name = None
	
	# 构造方法
	def \_\_init\_\_(self, id, name):
		self.id = id
		self.name = name
		

person = Person(1, "刘备")

6.3.3 魔术方法

Python中类内置了一些方法，有不同的特殊功能，_ _ init _ _就是其中之一，这些方法统称为魔术方法

前面两个下划线后面两个下划线包裹起来的方法都是内置的魔术方法

_ _ str _ _

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-83YYYoS5-1713607648727)]

[外链图片转存中…(img-Q4J6uCnC-1713607648728)]

[外链图片转存中…(img-fofeZjRN-1713607648728)]

[外链图片转存中…(img-32IJGeSu-1713607648728)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）