先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
===================================================================================
代码如下：
#include
#include
using namespace std;
class qwe123 {
private:
int lenth;
char* Fhao;
public:
qwe123() {
cout << “我是构造函数,但我不会初始化” << endl;
}
qwe123(char a[]) {//赋值操作重载实际上是深拷贝
this->lenth = strlen(a)+1;
// this->Fhao = a;//错误写法在此没有给this->指向的空间开辟内存不能在下面delete；
this->Fhao = new char[this->lenth];//在堆区给this-》申请一块空间
strcpy_s(Fhao, lenth, a);//将a数组中的东西拷贝到Fhao数组内
}
void print() {
cout << this->Fhao << endl;
}
qwe123& operator=(qwe123 &a);
~qwe123() {//析构函数无论对象有无初始化,无论对象怎样初始化,创建了对象就一定会析构
//所以析构函数判断如何析构对象的标准应是每一个对象的特征；
if (this->Fhao != NULL) {//有初始化的对象析构方式;因为创建对象时手动申请了内存
delete[] this->Fhao;//所以就在析构时手动关闭;
this->lenth = 0;
cout << “这里是析构函数，over” << endl;
}
else {//没有初始化对象的析构方式
cout << “这里是没有被初始化的对象被析构了” << endl;
}
}
};
qwe123& qwe123::operator=(qwe123 &a) {//赋值操作符的重载与深拷贝原理相同
if (this->Fhao != NULL) {
delete [] Fhao;//delete之前要有空间,如果是系统自己分配的空间就不能用delete
this->lenth = 0;
}
this->lenth = strlen(a.Fhao) + 1;
this->Fhao = new char[this->lenth];
strcpy_s(Fhao,this->lenth,a.Fhao);
return *this;
}
int main() {
char pp[] = “I am big man”;
char dd[] = “I am very kkl”;
qwe123 a1(pp),a2(dd),a3;
a1.print();
a1 = a2;
a2.print();
return 0;
}
==================================================================================
代码如下：
//流运算符,赋值运算符,下标运算符，等号不等号运算符的重载
#include
using namespace std;
class MyClass
{
public:
MyClass(int a,int b);
MyClass(char a[]);
~MyClass();
friend ostream& operator<<(ostream &out, MyClass& a);
bool operator==(MyClass& a);
bool operator!=(MyClass& a);
char& operator[](int i);
MyClass& operator=(MyClass& a);
void print() {
cout << (*this)[4] << endl;//运行成功实例,这里的(*this)等效于一个对象;
cout << "哟西 " << this->p<<endl ;
}
void printp(MyClass& a) {
int i = 0;
i = strlen(a.p) + 1;
for (int j = 0;j < i;j++) {
cout << a[j] << " ";
}
}
private:
int a;
int b;
int len;
char* p;
};
MyClass::MyClass(char a[]) {
this->len = strlen(a)+1;
this->p = new char[this->len];
strcpy_s(this->p, this->len, a);
}
MyClass::MyClass(int a=0,int b=0)
{
this->a = a;
this->b = b;
}
MyClass::~MyClass()
{
if (this->p != NULL) {
delete[] p;
}
cout << “这里是析构函数,over，over” << endl;
}
ostream& operator<<(ostream &out,MyClass &a) {//重载了输出流操作符
out << a.a << “” << a.b << endl;
return out;
}
MyClass& MyClass::operator=(MyClass &a) {
if (this->p != NULL) {
delete[] p;
this->len = 0;
}
this->len = strlen(a.p) + 1;
this->p = new char[this->len];
strcpy_s(this->p, this->len, a.p);
return *this;
}
//等号与不等号均只拿类里面一个成员变量（len）展开来说；
bool MyClass::operator==(MyClass& a) {//等号操作符重载；
if (this->len == a.len) {
return true;
}
else return false;
}
bool MyClass::operator!=(MyClass& a) {//不等号操作符重载；
if (this->len != a.len) {
return true;
}
else return false;
}
char& MyClass::operator[](int i) {//调用方式：对象名[]//得到的东西可以经过操作设置,
//在这里得到的是字符数组里面的某个字符
//cout << “this ok”<<endl;这句话用于测试该函数有没有被调用；
return (this->p)[i];//this->p代表this对象里面的一个成员变量,在这里是一个字符数组
//并且在这里return 时调用了默认的[]操作函数
}
int main_HH() {
char aa[] = “I am big shuai” ;
char bb[] = “I am zhu zhi chong”;
char dd[] = “Shuai bi”;
MyClass a1(1, 2), a2(3, 4);
MyClass b1(aa), b2(bb),b3(dd);
cout << a1 << a2;
b1 = b2=b3;//经过这里赋值函数之后,b1,b2,b3的len均相等;
// b1.print();
// b1.printp(b1);
cout << b1[4] << endl;//成功将对象里面的字符拿出来,并调用了重载的[]函数
if (b1 == b2) {//b1b2相等调用了这里
cout << “等号函数，重载成功over” << endl;
}
if (b1 != a1) {//b1,.a1的len不相等所以这里也进行了输出
cout << “这里是不等号,over” << endl;
}
return 0;
}
=============================================================================
代码如下：
#include
using namespace std;
class XLJ {
private:
int a;
int b;
public:
XLJ(int a=0, int b=0) {
this->a = a;
this->b = b;
cout << “这里是,构造” << endl;
}
void print() {
cout << “a:” << a << “b:” << b<<endl;
}
int operator()(int a, int b);
bool operator&&(XLJ& a) {//两个对象重的a都为0
if (this->a == 0 && a.a == 0) {
return true;
}
else {
return false;
}
}
bool operator||(XLJ& a) {//逻辑或只要两个对象里面有一个a是0就为真;
if (this->a == 0 || a.a == 0) {
return true;
}
else return false;
}
};
int XLJ::operator()(int a=0, int b=0) {
cout << “这里调用了，小括号运算符” << endl;
return a + b;
}
int main() {
XLJ a1(1, 2),a2,a3;//构造时调用的是构造函数;
a1.print();//构造出来对象后再用()就调用括号运算符
cout << a2(3,4) << endl;
cout << a1(1, 2) << endl;
if (a1 && a2) {
cout << “this cure &&” << endl;
}
if (a1 || a2) {
cout << “this || 运算” << endl;
}
if (a3 && a2) {
cout << “this && victor” << endl;
}
return 0;
}
============================================================================
可以根据需求对大于小于运算符进行重载;
这样可以很直观的对比出来两个对象的某一特征,找出哪个更胜一筹;
成员函数语法 bool operator(类名 &对象名){函数体进行对象的某一特征进行比较};
友元函数语法 bool operator(类名 &对象名，类名 &对象名){函数体同上};
代码如下：
//大于小于运算符重载
//判断条件运算符返回值一般就0,1两种;
//并且符合返回1,也就是真,因为调用的场景一般就是if语句:
//if语句中只有判断条件为真才会执行代码块里面的语句；
//如果if语句为真那么下面附属的else 语句将不再执行；
#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
class MyClass1
{
public:
MyClass1(char* b);
~MyClass1();
bool operator<(MyClass1& a);
bool operator>(MyClass1& a);
bool operator<=(MyClass1& a);
bool operator>=(MyClass1& a);
private:
int a;
char* m_p;
};
MyClass1::MyClass1(char *b)
{
a = strlen(b) + 1;
m_p = new char[a];
strcpy(m_p, b);
}
MyClass1::~MyClass1()
{
if (this->m_p != NULL) {
delete[] m_p;
a = 0;
cout << “这里是析构函数,over” << endl;
}
}
bool MyClass1::operator<(MyClass1& a) {//bool类型非零即1,strcmp()函数有三种返回值正,零,负数;
//也就是说,如果直接返回strcmp得到的结果肯定不正确：
//return strcmp(this->m_p, a.m_p);//(错误写法);
int k;
k = strcmp(this->m_p, a.m_p);
if (k > 0) {
return false;
}
else if (k < 0) {
return true;
}
}
bool MyClass1::operator<=(MyClass1& a) {
int k = 0;
k = strcmp(this->m_p, a.m_p);
if (k <= 0) {
return true;
}
else {
return false;
}
}
bool MyClass1::operator>(MyClass1& a) {
return !(this < a);//用<号,对>运算符重载进行简化;如果this<a那么两者就不满足>直接返回与
}//小于操作符的返回值也就是 !(*this<a);
bool MyClass1::operator>=(MyClass1& a) {
return !(*this <= a);
}
int main_DX() {
char aa[] = “aaaaa”;
char dd[] = “bb2222”;
MyClass1 a1(aa), a2(dd);
if (a1 > a2) {
cout << “这里是大于号” << endl;
}
if (a1 < a2) {
cout << “这里是小于号” << endl;
}
if (a1 <= a2) {
cout << “这里是小于等于号” << endl;
}
if ( a2>=a1 ) {
cout << “这里是大于等于号” << endl;
}
return 0;
}
=================================================================================
对含有字符串的对象进行赋值,下标不等号等号以及输入输出流运算符进行重载；
只有类的属性与方法的声明
#pragma once
#include
using namespace std;
class mystring
{
private:
int lenth;
char* p;
public:
mystring();
mystring(char *q);//构造
mystring(mystring &q);//拷贝构造
~mystring();//析构函数
mystring& operator=(mystring& q);//赋值操作符的重载；
char& operator[](int i);//下标运算符重载
bool operator==(mystring &q);//等号运算符重载
bool operator!=(mystring &q);//不等号运算符重载
bool operator<(mystring& q);//小于运算符重载
bool operator <= (mystring & q);//小于等于
bool operator>(mystring& q);//大于
bool operator>=(mystring& q);//大于等于
friend ostream& operator<<(ostream& out,mystring &q);//输出流
friend istream& operator>>(istream& in, mystring& q);//输入流
};
对前面类的声明中的方法进行了实现。
#define _CRT_SECURE_NO_WARNINGS
#include “mystring.h”
#include
using namespace std;
ostream& operator<<(ostream& out, mystring& q) {//输出流
out << q.p << endl;
return out;
}
istream& operator>>(istream& in, mystring& q) {//输入流
cin >> q.p;
q.lenth = strlen(q.p) + 1;
return in;
}
char& mystring::operator[](int i) {//下标运算符重载
return this->p[i];
}
bool mystring::operator==(mystring & q) {//等号运算符重载（字符串里面的内容是否相同为判断标准）
if (this->lenth != q.lenth) {
return false;
}
else {
return !strcmp(this->p, q.p);//相同为为零,但相同时返回值应为1所以是!strcmp(this->p,q.p);
}
}
bool mystring::operator!=(mystring & q) {//不等号运算符重载----利用==重载函数;
return !(*this == q);
}
bool mystring::operator<(mystring & q) {//小于运算符重载以P（字符串里面的ASCLL值）为判断标准
int k = 0;
k = strcmp(this->p, q.p);
if (k < 0) {
return true;
}
else if (k > 0) {
return false;
}
}
bool mystring::operator <= (mystring & q) {//小于等于
int k = 0;
k = strcmp(this->p, q.p);
if (k <= 0) {
return true;
}
else if (k > 0) {
return false;
}
}
bool mystring::operator>(mystring & q) {//大于
return !(*this<q);
}
bool mystring::operator>=(mystring & q) {//大于等于
return !(*this<=q);
}
mystring &mystring::operator=(mystring& q){//赋值运算符重载；
if (this->p != NULL) {
delete[] this->p;
this->lenth = q.lenth;
this->p = new char[this->lenth];
strcpy(this->p, q.p);
}
else {
this->lenth = 0;
p = new char[this->lenth + 1];
strcpy(p, “”);
}
return *this;
}
mystring::mystring() {
}
mystring::mystring(char *q) {//传进来字符数组的构造函数
if (q == NULL) {
this->lenth = 0;
p = new char[this->lenth + 1];
strcpy(p, “”);
}
else {
this->lenth = strlen(q) + 1;
p = new char[this->lenth];
strcpy(p, q);
}
}
mystring::mystring(mystring& q) {//拷贝构造函数
this->lenth = strlen(q.p) + 1;
p = new char[this->lenth];
strcpy(p, q.p);
}
mystring::~mystring() {
if (this->p != NULL) {
delete[] this->p;
this->lenth = 0;
}
}
测试分文件后实现类的效果【引入自己封装好的.h文件】
#include
#include"mystring.h"
using namespace std;
int main() {//测试区；
char aa[] = “I am a boy”;
char dd[] = “I am ZSC”;
mystring a1(aa),a2(dd),a3(aa);
if (a1 > a2) {
cout << “大于号” << endl;
最后
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
👉Python所有方向的学习路线👈
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
👉Python必备开发工具👈
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
👉Python全套学习视频👈
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
👉实战案例👈
学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。
因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。
👉大厂面试真题👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
👉Python必备开发工具👈
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
👉Python全套学习视频👈
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
👉实战案例👈
学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。
因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。
👉大厂面试真题👈
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
[外链图片转存中…(img-3v6tCWjT-1713442284216)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
1227
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
