万字文肝Python基础知识，PM面试突击课

最新推荐文章于 2024-05-06 17:23:22 发布

imtokenmax合约众筹

最新推荐文章于 2024-05-06 17:23:22 发布

阅读量1k

点赞数 15

分类专栏： 2024年程序员学习文章标签： python 面试服务器

本文链接：https://blog.csdn.net/imtokenmax/article/details/137936612

版权

2024年程序员学习专栏收录该内容

307 篇文章 1 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

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

如果你需要这些资料，可以添加V获取：vip1024c （备注Python）

正文

官方规定的具有某种特定意义的单词
标识符不能用保留字
Python有33个保留字
也叫关键字
所有符号都用英文半角符号

诸如def class等不是内置函数的单词

def class if for while 等等等

5. 常量变量运算符

5.1 常量

值无法改变的量

例如数字1
例如字符串"hello world"
等等

print(1)

5.2 变量

值能改变的量

名字为标识符
使用赋值符号 = 给变量复制
- a = 1这样

a = 1
b = "www"
print(a,b)
# 1www

5.3 运算符

5.3.1 算术运算符

加：+
减：-
乘：*
除：/

print(1+1)  # 2
print(10-2) # 8
print(10\*2) # 20
print(10/2) # 5

5.3.2 比较运算符

大于：>
小于：<
大于等于：>=
小于等于：<=

print(1==2) # False
print(1>2) # False
print(10>=5) # True
print(5<=1)  # Fasle

5.3.3 赋值运算符

直接赋值：=
相加赋值：+=
相乘赋值：*=
…

i = 10  # 给i赋值为10
print(i+=1)  # 让i加1
print(i\*=2)  # 让i乘2

6. 数据类型

6.1 基本数据类型

整型
- 1
- 100
浮点型
- 1.1
- 10.1
布尔型
- True
- False
复数类型
- 5j+1
- 1+3j

6.2 高级数据类型

6.2.1 字符串

“hello”
‘hello’
‘’‘hello’’’
“”“hello”“”

"""
例子：给出一个变量a = 1 怎么让输出的结果为：“a的值为：1”

第一个方法：print(“a的值为：”, a)
第二个方法：print(“a的值为：{}”.format(a))
第三个方法：print(“a的值为：%d”%a)
第四个方法：print(f"a的值为：{a}")
其实就是让我们的字符串中可以添加变量，而第一种的方法在处理一个字符串中的多个变量时是较为麻烦的，这时候就需要用到下面三个，比较简单，我最喜欢的是第四个方法。因为写出来简单
"""
a = 1
print(“a的值为：”, a)
print(“a的值为：{}”.format(a))
print(“a的值为：%d”%a)
print(f"a的值为：{a}")
# 原生字符串和非原生字符串
# 看代码看差异
# 1. 原生字符串
print(r'\n\t')
# 2. 非原生
print('\n\t')

6.2.2 列表

[1, 2, 3, 4]
[‘a’, ‘b’, ‘c’, ‘d’]
[True, False, False]

增删改查：

li = [1, 2, 3, 4]
li.append(5)  # [1, 2, 3, 4, 5]
li.remove(5)  # [1, 2, 3, 4]
li[0] = 10  # # [10, 2, 3, 4]
print(li[0], li[1])

6.2.3 元组

(1, 2, 3, 4)
(‘a’, ‘b’, ‘c’, ‘d’)

增删：

tu = (1, 2, 3, 4)
tu1 = (5,)
tu2 = tu+tu1  # (1, 2, 3, 4, 5)
del tu  # 全部删除

6.2.4 字典

{‘a’: 1, ‘b’: 2}
{1: ‘a’, 2:‘b’}

增删改查：

dic = {'a': 1, 'b': 2}
dic['c'] = 3  # {'a': 1, 'b': 2, 'c': 3}
del dic['c']  # {'a': 1, 'b': 2}
dic['a'] = 10 # {'a': 10, 'b': 2}
print(dic['a']) # 10

6.2.5 集合

(1, 2, 3, 4)
(‘a’, ‘b’,‘c’)

增删：

se = {1, 2, 3, 4}
se.add(5)  # {1, 2, 3, 4, 5}
se.remove(5)  # {1, 2, 3, 4}
se.clear() # 全部删除

6.2.6 下标

下面的可以用下标来访问该下标的值，下标从0开始

print("hello"[0])  # h
print([1, 2, 3, 4][1]) # 2
print({1, 2, 3, 4}[2]) # 3
print((1, 2, 3, 4)[3]) # 4
# 下标：0 1 2 3
print({'a': 1, 'b': 2}['a']) # 1
# 字典以键取值，前面是键，后面是值

6.2.7 切片，步长

对这些类型取某些值，而不是单一的值

print("hello"[0:2])  # 切片出he
print([1, 2, 3, 4][0:3:2]) # 从下标0到3每二个取[1, 3]
# print({1, 2, 3, 4}[0:1] # 会报错，因为集合具有无序性
print((1, 2, 3, 4)[3])

7. 分支控制语句

7.1 循环控制语句

7.1.1 for循环

for i in range(10):
    print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
for i in range(10):
    print(a)

7.1.2 while循环

i = 0
while i<10:
    print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
i = 0
while i<10:
    print(a[i])
    i+=1

7.2 条件控制语句

7.2.1 if单支

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")

7.2.2 if…else…

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")
else:
    print("两数之和大于10")

7.2.3 if…elif…elif…else…

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")
elif c==10:
    print("两数之和等于10")
else:
    print("两数之和大于10")

7.3 break

打破分支语句
使分支语句终止

while True:
    a = input()
    if a == "q":
        break
    else:
        print(a + " 输入成功，输入 'q' 退出程序")

7.4 continue

跳过分支语句
进行下一次分支语句

for i in range(10):
    if i % 5 == 0:        
        continue
    else:        
        print(i)

8. 函数式编程

8.1 作用

减少代码重用率
加快开发效率

8.2 定义

使用关键字：def定义

8.2.1 无参函数

# 定义
def Qinghua():
    print("我爱你")
    print("我要给你生猴子")
    print("啊啊啊，好喜欢你")
# 调用
Qinghua()
def fun():
    print("我是无参函数")
fun()

8.2.2 有参函数

def PinJie(a, b):
    str_ = str(a)+str(b)
    print(str_)
    for i in str_:
        print(i)

PinJie("sasa", 4564)
#也可以这么写
"""
PinJie(a="sasa",b=4564)
这样写的好处是
就算你的位置写错了
参数传递的也还是对的
也就是说，参数传递的位置不固定
就像这样
PinJie (b=4564, a='sasa')
是完全一样的
"""

8.3 返回值

return
用于将函数变成变量使用

函数名字(参数)就是返回的值

def PinJie(a, b):
    str_ = str(a)+str(b)
    return str_

p = PinJie("sasa", 4564)
print(p)

8.4 优点

效率高
简单

8.5 缺点

不易维护
开发效率较面向对象低

9. 面向对象编程

9.1 作用

提升开发效率
增加维护性

9.2 使用

定义抽象化的类
既实例化对象

9.3 定义

使用class关键字定义

三种定义方法

class Person1:    
    pass

class Person2():    
    pass

class Person3(object):    
    pass
# 使用实例化对象
p1 = Person1()
p2 = Person2()
p3 = Person3()

9.4 构造方法

def \_\_init\_\_(self):   
    pass
# 给类传参
class Person3(object):
    def \_\_init\_\_(self, name, age):   
        pass
p3 = Person3('a', 12)

9.5 封装

在构造方法里self.属性 = 属性
在属性名前面加 _
在方法名前面加 _

# 在构造方法里self.属性 = 属性
class Person1(object):
    def \_\_init\_\_(self, name, age):
        self.name = name
        self.age = age

Menger = Person("萌杰尔", 20)

name = Menger.name
age = Menger.age
print("姓名：{} \n年龄：{}".format(name, age))
# 在属性名前面加 \_
class Person2(object):
    _weight = 70
    def \_\_init\_\_(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
 
    def weightPrint(self):
        print("我的体重是：", self._weight)

person = Person("布小禅", 20, 180)
person.weightPrint()
# 在方法名前面加 \_
class Person3(object):
    def \_love(self):
        print("我暗恋Xxx")
    
    def speakLove(self):
        self._love()

9.6 继承

在定义类的时候，写在类名后面的括号里
Python支持多继承
class Person(object, class1, class2): pass
继承后，该类拥有所继承的类里面的所有方法和属性

class Person(object):

    def \_\_init\_\_(self, name, age):
        self.name = name
        self.age = age
            
    def speak(self):
        print(f"{self.age}岁的{self.name}会说话")
class Boy(object,Person):
    pass
boy = Boy ("Menger", 20)
boy.speak()

9.7 魔术方法

_init_ 构造方法
_str_ 使实例化对象变成字符串
_new_ 先于构造方法被执行
_call_ 使实例化对象拥有函数性质
_del_ 实例化对象被删除时执行

class Person(object):
    def \_\_str\_\_(self):
        return "我是\_\_str\_\_方法的返回值，显示在打印实例化对象时"
    def \_\_del\_\_(self):
        print("我没用了，我被删除了")
    def \_\_new\_\_(cls):
        print("我是\_\_new\_\_方法")
        return super().__new__(cls)
    def \_\_call\_\_(self):
        print("执行了\_\_call\_\_方法")
        return "我是返回值"

p = Person()
print(p)

10. 进阶操作

10.1 异常处理

try:…except:…finally:…

冒号后面接回车

+ try后面跟有可能错误的代码
+ except后面跟如果错了怎么办
+ finally后面跟不管错没错都要执行的代码

try:
    print(a)
except:
    print("小伙子，我不认识什么是a啊")
finally:
    print("好好写代码，不要老是报错了啊")

10.2 文件操作

内置函数open()
- open(“文件名”, “读取方式”)
  - w只写
r只读
- w+读写
wb以二进制写
- rb以二进制读
wa追加写入

"""
测试文件为text.txt
内容为：
我是text.txt
我的作用是测试文件操作
"""
f = open('text.txt', 'r', encoding='utf-8')
# 用变量接收，以便于后面的操作
ree = f.read()  # 读取全部
li = f.readlines()  # 按行读取全部行
rre = f.readline()  # 只读取一行
# 测试三个函数，运行的时候，记得把别的注释掉
# 原因是第一个函数已经把文件的指针挪到最后了，第二个函数就读不到东西
print(ree)
f.close()
# 使用完记得关闭文件，免得消耗资源，使得程序报个内存溢出的错
f = open('text.txt', 'w', encoding='utf-8')
f.write("我是使用write函数写入的")
f.close()
# 这个方法会覆盖原来的，想继续写，只能使用追加方式
f = open('text.txt', 'wa', encoding='utf-8')
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.close()

10.3 常用模块

10.3.1 os模块

路径，文件，sys

参考我之前的博客：os模块的简单使用

10.3.2 time模块

计时，时间

import time
start = time.time() # 当前时间戳
a = 1000\*\*100000
end = time.time() # 获取计算完成的时间戳
runTime = end - start # 计算所花的时间
print("本次计算耗时：{}".format(runTime))

10.3.3 random模块

随机数

import random
# 生成10个0-10的证书
for i in range(10):
    print(random.randint(0,10))

# 生成10个0-1的数
for i in range(10):
    print(random.random())

10.3.4 re模块

正则表达式

"""
正则表达式用于提取字符串中的某些数据
"""
import re
# 定义一个字符串
a = "大连科技动拉网红豆味"
# 提取科技两个字
print(re.findall("大连(.\*?)动", a))

10.4 多线程

要先了解进程，线程的区别

进程：

拿电脑举例子的话，进程就是QQ，微信等不同的程序

拿py文件举例子的话，就是你的多几个py文件

线程：

拿电脑举例子的话，就是QQ，微信里你能和好多人一起聊天

拿py文件举例子的话，就是你在py文件里的许多函数

10.4.1 无序性

多线程具有无序性：

既任务不会按顺序完成

代码：

import threading
def speak(a=list):
    for i in a:
        print("我是",i,"\n")

li = [1, 2, 3, 4, 5, 6, 7]
li2 = ['1', '2', '3', '4', '5', '6', '7']

s1 = threading.Thread(target=speak, args=(li,))
s2 = threading.Thread(target=speak, args=(li2,))
s1.start()
s2.start()

运行结果：

"""


现在能在网上找到很多很多的学习资源，有免费的也有收费的，当我拿到1套比较全的学习资源之前，我并没着急去看第1节，我而是去审视这套资源是否值得学习，有时候也会去问一些学长的意见，如果可以之后，我会对这套学习资源做1个学习计划，我的学习计划主要包括规划图和学习进度表。



分享给大家这份我薅到的免费视频资料，质量还不错，大家可以跟着学习

![](https://i-blog.csdnimg.cn/blog_migrate/98c5857428d568b2753fcc95f0b326ed.png)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）**
![img](https://img-blog.csdnimg.cn/img_convert/be503f5bb4edca26aa262e73a3e8293c.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**


#### 10.4.1 无序性


多线程具有无序性：


既任务不会按顺序完成


代码：

import threading
def speak(a=list):
for i in a:
print(“我是”,i,“\n”)

li = [1, 2, 3, 4, 5, 6, 7]
li2 = [‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’]

s1 = threading.Thread(target=speak, args=(li,))
s2 = threading.Thread(target=speak, args=(li2,))
s1.start()
s2.start()