现在挺多小伙伴都在学Python，其中包括很多零基础的初学者，知识点这方面可能不熟悉。想必大家都想通过学习完成逆袭！
我找到了我当初学python的笔记，特地请教过当时我们学校的学霸级大佬学长，压箱底的都给你们翻出来了，我根据我笔记肝出万字Python知识点大总结！
文章篇幅有点长，请耐心读完吧！
一、Python基础必备
1、什么是Python
Python是门程序设计语言
-
自然语言：人能听懂的语言（汉语，英语，法语…）
-
机器语言：机器能听懂的语言（01010101）
-
程序设计语言：机器能够听懂，人能听懂的语言（Python，C，C++ C# Java）
-
语法规范
高级程序设计语言：越接近于人类的语言越高级
低级程序设计语言：越接近于机器语言越低级（汇编）
2、Python 的历史
- 创始人：Guido van Rossum --龟叔
- 时间：1989圣诞节期间，构思Python这门语言
- Python来自于《Monty Python’s Flying Circus》《蒙提·派森的飞行马戏团》–小品
- 2020.11.12加入微软的开发部门
3、Python的特点
- 语法简洁（通过文本缩进的形式）
- 有着非常强大的类库
- 胶水语言（调用其他语言的类库）
- 代码量较少
4、Python 运行机制
程序员：代码（源文件）
-
编译型
将源文件通过编译器，编译成机器码文件，当运行的时候直接执行机器码文件
缺点：不能跨平台
优点：执行快 -
解释型
将源文件通过解释器，逐行进行翻译并运行
缺点：执行慢
优点：可以跨平台（操作系统） -
Python的运行机制
- 解释运行（脚本）
- 先编译后解释
5、Python的安装
-
勾选add Python** to PATH
-
验证Python是否安装成功
通过黑窗口（cmd）输入Python测试
6、helloworld
-
开发工具：
idle 文本编辑器，支持交互式界面
pycharm 文本编辑器
-
创建源文件
*.py
-
编译源文件
print(“helloworld”)
-
运行Python文件
点击run run Module F5
7、print（）
输出函数（功能）
-
print(要输出的内容)
py2: print 要输出的内容
py3：print(要输出的内容) -
print()
默认有换行功能
print(输出的内容,end='\n') #end是以...结尾 “\n” 转义字符：换行
8、input()
输入语句
input(“提示信息”)
input(“请输入密码：”)
input接收到的内容全是字符串
9、变量
-
就是一个名字
-
先赋值在使用
-
变量要符合标识符(名字)的命名规范
10、标识符的命名规范
标识符–名字(变量名，函数名，类名…)
语法规范：硬性要求
-
合法的标识符:字母，数字(不能开头),下划线
py3可以用中文（不建议）
py2不可以 -
大小写敏感
-
不能使用关键字和保留字
关键字： if while for as import
保留字：input，print range -
没有长度限制
-
望文生义
看到名字就知道要表达的意思 -
大小写
1. 包名：全小写
2. 类名：每个单词的首字母大写其他的小写（驼峰命名法）大驼峰
3. 变量名/函数名:第一个单词的首字母小写，后面的单词的首字母大写(小驼峰)
4. 常量：全大写 -
其他命名方式
hello_world
11、数据类型
-
整型：int 整数
-
浮点型： float 小数
表现形式：
小数
科学计数法 e表示乘以10几次方
a=5e-1 b=1e10 #1*10的10次方 -
字符串：str
形式：’’ “” “”“xsxs”"" ‘’’‘xxx’’’
三引号特殊功能：表示注释：
#注释
三引号注释：
“”
xsx
xs
“”" -
布尔类型： bool
True: 真
False:假
1表示真
0表示假 -
None
-
列表，元组，字典，集合…
12、类型转换
- 字符串转整型
int(str)
user = int('304200780') #字符串必须是数字
- 浮点型转整型
int(float)
f = 20.1
ff = int(f) #直接抹去小数部分
- 字符串转浮点型
float(str) #字符串必须是数字和.
f = "203.4"
ff = float(f)
- 整型转浮点型
float(int)
f=30
float(f) #30.0
- 浮点型转字符串
str(float)
f = 30.5
ff = str(f) #字符串"30.5"
- 整型转字符串
str(int)
f=30
str(f) #字符串"30"
13、 获取类型信息
-
type()
type(对象)–返回对象的类型 -
isinstance(对象,class)
返回布尔值（True,False）
14、 表达式
表达式都有固定字面值
字面值：所有值 10+20 a+b（a=10,b=20） 10>30
10:整型int的字面值
例如：
b=“hehe”
a=“heiehi”
a+b
15、运算符
-
一般运算符
+，-，*，/（真除法）//（地板除，舍去小数部分）,%（取余数）,**（幂运算）
-
赋值运算符
=：等号右边的值赋值等号左边
增强赋值运算符：
+=，-=，*=，/=,%=,**=
连续赋值：
a=b=c=d=10 -
布尔运算法
== （等于），！=（不等于） ，>= （大于等于），<= （小于等于），>， < -
逻辑运算符
not 非
and 与
or 或
and：前后都为真则为真
or：有一个为真则为真
not:非真，非假
二、流程控制
1、 条件分支流程：当达到某种条件的时候才会触发的代码
语法1：
if 布尔表达式: #如果为真则执行内部的代码块
代码块
语法2：
if 布尔表达式：#如果为真则执行if内部的代码块,如果为假则执行else内部的代码
代码块
else:
代码块
实例： a = 10
b = 20
if a>b:
a = 30
print(a)
else:
print(1111)
语法3：
if 布尔表达式：#如果为真则执行if内部的代码块,如果为假则执行else内部的代码
代码块
elif 布尔表达式：
代码块
elif 布尔表达式：
代码块
....
else:
代码块
实例：
s = int(input("请输入分数:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("优秀")
elif 90<s<=100:
print("非常优秀")
else:
print("不及格")
语法4:
嵌套使用
s = int(input("请输入分数:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("优秀")
elif 90<s<=100:
print("非常优秀")
else:
print("不及格")
if s>50:
print("你的分数在60分左右")
else:
print("你的分数低于50分")
2、循环流程
重复运行某些代码
1. while
语法：
while 布尔表达式: #只要条件为真就执行
代码块
实例：
while 4<5:
s = int(input("请输入分数:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("优秀")
elif 90<s<=100:
print("非常优秀")
else:
print("不及格")
if s>50:
print("你的分数在60分左右")
else:
print("你的分数低于50分")
解决死循环问题：
a=3
while a<5:
s = int(input("请输入分数:"))
if 80>=s>=60:
print("及格")
elif 80<s<=90:
print("优秀")
elif 90<s<=100:
print("非常优秀")
else:
print("不及格")
if s>50:
print("你的分数在60分左右")
else:
print("你的分数低于50分")
a+=1
print(a)
print("while执行结束了")
案例：
#请输入一个整数，并计算各个位和 如：321=6
n = int(input("请输入一个整数:"))#将字符串转为整型
#sums累加器：m=10 m=10+5
sums = 0
while n!=0: #32 #3
sums=sums+n%10 #sums=1+2=3+3=6
n=n//10 #32
print(sums)
2. for循环 --计数循环
语法：l=[3,2,1]
for 变量 in l(可迭代对象):
代码块
3. range()
可迭代对象
(1)range(stop)
返回一个序列从0开始到stop-1为止
(2)range(start=0,stop,step=1)
for i in range(0,10,2):
print(i)
print("helloworld")
for i in range(10,2,-2):
print(i)
print("helloworld")
4. break
跳出循环，后面循环不在执行
a=5
for i in range(1,10):
if i==5:
break
print(i)
print("helloworld")
5. continue
跳过本次循环，后面的循环继续执行
a=5
for i in range(1,10):
if i==5:
continue
print(i)
print("helloworld")
三、列表(List)
可以存放任何数据，整型，浮点型，字符串，布尔型…
最常用的数据类型之一
1、 列表的创建
列表也是一个可迭代对象
-
普通形式
l = [1,2,3,4,5] —整型列表
l = [“a”,“b”,“c”] —字符串列表
l = [True,False,1>2,5<6]—布尔列表 -
混合列表
l = [1,2.5,“a”,True]
-
空列表
l = []
2、从列表中如何获取数据(元素)
列表是有下标的，并且下标从0开始
l = [5,4,3,2,1] 元素是指列表中每个数据
- 1.获取当个数据(元素)
语法：
变量[下标] #获取下标所对应的值
l = [1,2,3] #下标/索引：0开始
print(l[1])
- 列表的遍历
for i in l:
print(i,end=" ")
- 交换数据
l = [1,2,3,4,5] #下标/索引：0开始
l[2],l[3] = l[3],l[2]
print(l)
3、添加元素
- append(对象)
向列表中添加数据，并添加到末尾
变量.append(数据)
- extend(可迭代对象)
#将可迭代对象中数据分别添加到列表中，并添加到末尾
l.extend([6,7])
print(l)
- insert(下标,对象)
l.insert(3,6)
print(l)
4、 删除元素
-
clear()
清空列表
-
pop([下标])
删除下标指定的元素，如果不加下标则删除最后一个元素
l.pop(3)
print(l) -
remove(value)
删除指定的值
l.remove(4)
print(l) -
del 语句
del l ： 删除变量I
del l[3] ： 删除列表中下标为3的数据
print(l)
5、修改
修改列表中元素
语法：
变量[下标]=新值
l[2]=6
print(l)
6、列表高级特性的
切片操作,分片
-
语法：
变量[起始下标:结束下标] #结束下标取不到
如果下标从0开始可以省略不写 n = l[:4]
如果结束下标取的是最后一个元素，可以省略不写 n = l[3:]
如果列表中的元素都要 开始和结束下标都可以省略 n = l[:]
n = l[:-1] 从0开始-到数二个元素 -
列表的进阶操作
n = l[开始:结束:步长]
n = l[-9:-1:2]
n = l[-1:-9:-2]
7、列表的一些操作符
- 比较运算符
l = [1,2,3,4,5,6,7,8,9,10] #下标/索引：0开始
l2 = [2,3,4,6]
print(l < l2) #True
列表之间进行比较，以相同下标进行比较，从小到大进行比较，如果值相同则比较下一组元素，如果不同直接出结果
- 逻辑运算符
and not or - 拼接运算符
+
print(l + l2)
- 重复操作符
*
- 成员关系操作符
in not in
判断元素是否在列表中
print(5 not in l)
8、列表的其他方法
-
copy()
浅拷贝 -
count(value)
返回value在列表中出现的次数
n = l.count(6)
print(n) -
index(value,[开始下标],[结束下标])
元素出现的第一次下标位置，也可自定义范围
n = l.index(6,8,9)
print(n) -
reverse()
原地翻转
l.reverse()
print(l) -
sort（key=None，reverse=False）
快速排序
默认从小到大排序
key:算法
9、 冒泡排序
给定一个列表
l = [5,4,3,2,1],用冒泡排序的思想从小到大排序
让列表中两个相邻的元素，进行比较，如果不符合条件那么就互换位置
len():获取列表的长度（元素）
案例：
#给定一个列表
# l = [5,4,3,2,1],用冒泡排序的思想从小到大排序
l = [6,5,4,3,2,1]
for i in range(1,len(l)): #1,5 #循环4大次 4
for j in range(len(l)-i):
if l[j] >l[j+1]:
l[j],l[j+1] = l[j+1],l[j]
print(l)
10、选择排序
#给定一个列表
# l = [5,4,3,2,1],用选择排序的思想从小到大排序
选择排序：让列表中的元素，固定一个元素和其他元素进行比较，不符合条件互换位置
l = [6,5,4,3,2,1]
for i in range(0,len(l)-1):#0,4
for j in range(i+1,len(l)): #1,5
if l[i] >l[j]:
l[i],l[j]=l[j],l[i]
print(l)
11、二维列表
列表中的列表
l = [[1,2,3],[4,5,6],[7,8,9]]
语法：
变量[外层列表下标][内层列表的下标]
l[0][1] #2
for遍历：
l = [[1,2,3],[4,5,6],[7,8,9]]
for i in l:
for j in i:
print(j)
四、元组（tuple）
存放任何数据类型
- 不能修改，不可变类型
- 用（）的形式
- 元组也是可迭代对象
- 元组是有序的，下标操作,支持切面操作[:]
1、元组的创建及访问
-
创建：
直接创建： t = (1,2,3,4,5) -
访问：
t[下标] 获取元素 -
切片操作：
t[:] 返回元组
2、 修改和删除
- 修改：
#先转换成列表进行修改，然后再转换回来
t = (1,2,3,4,5)
print(t[1:4])
l = list(t)
print(l)
l[2]=6
print(l)
t=tuple(l)
print(t)
- 删除：
del t #删除变量
3、元组的操作符
-
比较运算符
< > >= <= == != -
逻辑运算符
and not or -
拼接运算符
+ -
重复操作符
* -
成员关系操作符
in not in
判断元素是否在列表中
print(5 not in l)
4、元组的方法
-
count(value)
value出现的次数
-
index(value,[start],[stop])
返回value再元组中出现的下标位置（第一次出现的下标）
五、字符串
1、 字符和字符串
Python中字符和字符串没有区别
字符：单个字符
字符串：一个字符串对象（）
Java：
字符：单引号’a’
字符串：双引号：“abc”
2、字符串的特点
-
字符串不可变类型
-
字符串是可迭代对象
-
字符串支持索引和切片操作
-
支持操作符;
拼接：+
重复操作符：*
比较运算符： > < <= >= == !=
逻辑运算符：not and or
成员关系： in not in
3、字符串的方法
-
capitalize()
把字符串的第一个字符改为大写，后面的小写
b = a.capitalize()
print(b) -
casefold()
把整个字符串都小写
b= a.casefold()
print(b) -
encode()
编码 str–bytes（二进制字符串） -
decode()
解码 -
count(sub,[start],[stop])
返回字符（sub）出现的次数
n = a.count(“L”)
print(n) -
find(sub,[start],[stop])
返回sub第一次出现的下标,查不到返回-1 -
index(sub,[start],[stop])
返回sub第一次出现的下标，报错 -
upper()
将字符串转为大写 -
lower()
将字符串转为小写
4、 格式化
按照某种格式输出
1.format
语法1：用数字占位（下标）
"{0} 嘿嘿".format("Python")
a=100
s = "{0}{1}{2} 嘿嘿"
s2 = s.format(a,"JAVA","C++")
print(s2)
语法2：
{} 占位
a=100
s = "{}{}{} 嘿嘿"
s2 = s.format(a,"JAVA","C++","C# ")
print(s2)
语法3：用字母占位
s = "{a}{b}{c} 嘿嘿"
s2 = s.format(b="JAVA",a="C++",c="C# ")
print(s2)
2. %s
“%s”%（值）
最常用的参数可以是任意值
九九乘法表:
for i in range(1,10):
for j in range(1,i+1):
print("%s * %s = %s"%(i,j,i*j),end="\t")
print()
5、转义字符
- “\n” ：换行符
- “’”:单引号
- “\“”:双引号
- “\” : \
反斜杠应用：
a= "sxsxsxsxsxsxsxs\
xsxsxsxs\
xsx"
print(a)
a= 1+2+3\
+4
print(a)
六、字典（dict）
存储数据，以映射关系存储
1、字典的特点
-
字典是Python中唯一的映射类型
name – “不良人” -
字典是无序的
-
字典是可迭代对象
-
字典的构成
键：key
值：value
映射：键–值
键-值：键值对（项）
2、创建字典
- 直接创建
d = {} #空字典
d = {"name":"不良人","apple":"苹果"}
- dict()
d = dict()
- dict(可迭代对象)
d3 = dict([("one",1),("two",2)])
print(d3)
- **dict(kwargs)
d4 = dict(a=3,b=4)
print(d4)
3、字典访问的
- 基本形式：
变量名[键名] #键所对应的值
d = {"name":"小黑"}
print(d["name "])
-
添加一个键值对
变量名[键名]=值
-
修改一个键值对的值
变量名[键名]=值
4、字典的方法
- clear()
清空字典 - copy()
浅拷贝 - fromkeys(可迭代对象，value=None)
根据可迭代对象中的元素去创建字典
d = {"name":"小黑"}
d2 = d.fromkeys([1,2,3,4],[4,5,6,7])
print(d2)
- get(key,[d])
key：键
d：提示信息
d = {"name":"小黑"}
print(d.get("name2","没有查到"))、
- items()
将字典中的键值对封装成元组并放到类集合中
d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
s = d2.items()
print(list(s))
-
keys()
同上，取键 -
pop(key,[d])
根据键删除字典中的键值对
d:提示信息 -
popitem()
删除某个键值对 -
values()
返回字典中的值（类集合对象）
d2={'c': 3, 'hehe': 100, 'b': 2, 'a': 1}
c= d2.values()
print(list(c))
5、补充
- 字典可以使用for循环
for i in d2:
print(i) #键，不包含值
- 输出一个键值对
for i in d2.items():
print(i)
-
成员关系操作符
in/not in
只能查询键
七、函数
由一组代码组成，完成某个特定的功能
-
创建函数：
语法：
def 函数名([参数]): #参数相当于变量,参数可以为多个，逗号隔开，还可以没有参数=无参
代码块（函数的实现/函数体） -
函数的调用
函数名(参数)
1、函数的运行机制
-
从函数调用开始执行
-
通过函数名字找到函数定义的位置（创建函数的位置）
-
执行函数体
-
执行完毕之后，返回到函数的调用处
2、函数的使用
def fun2(a,n):
print(a*n)
#打印古诗
print("白日依山尽")
fun2("+",5)
print("黄河入海流")
fun2("-",10)
print("欲穷千里目")
fun2("*",15)
print("更上一层楼")
fun2("/",20)
3、函数的特点
-
避免了代码的冗余
-
提高了代码的可维护性
-
提高了代码的可重用性
-
提高了代码的灵活性
4、 函数的参数
-
形式参数：形参
在定义函数的时候传递的参数 -
实际参数：实参
在调用函数时传递的参数 -
无参
没有任何参数
位置参数：
和位置有关系--一一对应，不能多也不能少
def fun4(a,b,c,d):
print(a,b,c)
fun4(10,20,30)
关键字参数：
定义关键字的参数--实参
def fun4(a,b,c):
print(a,b,c)
fun4(b=10,a=20,c=30)
位置参数和关键字参数混用：
当位置参数和关键字参数混用时，位置参数在前
def fun4(a,b,c):
print(a,b,c)
fun4(10,20,c=30)
默认参数：
给了默认值的参数--形参
如果传递了新的值，那么默认值就被覆盖了
def fun4(a=10,b=20,c=30):
print(a,b,c)
fun4()
fun4(20,30,40)
fun4(b=20,c=30,a=40)
可变成参数：
def 函数名(*a)
本质上封装成了元组
def fun5(*a):
print(a) #元组
fun5(10,20,30)
--------------
def 函数名(**kwargs)
将参数封装成了字典
def fun6(**a):
print(a)
fun6(b=10,c=20,d=30)
可变成参数和位置参数混用的时候：
def fun6(*a,b):
print(a,b)
fun6(10,20,b=30)
def fun6(b,*a):
print(a,b)
fun6(10,20,30)
5、 函数的文档
文档注释：#，三引号
函数的文档注释：
函数结构的第一行
def fun6(b,*a):
"""
fun6是个函数
a:可变成参数
b:位置参数
"""
print(a,b)
fun6(10,20,30)
print(fun6.__doc__)
1. 获取函数的文档内容: 函数名.__doc__
2. help(函数名) #查看函数文档
6、 函数的返回值
关键字：return
返回值谁调用就返回给谁
-
任何函数都有返回值
-
如果不写return ，也会默认加一个return None
-
如果写return ，不写返回值 也会默认加一个None
-
可以返回任何数据类型
-
return后面的代码不在执行，代表着函数的结束
7、函数的变量的作用域
-
局部变量
定义在函数内部的变量
先赋值在使用
从定义开始到包含他的代码结束
在外部无法访问 -
全局变量
定义在源文件的开头
作用范围：整个文件
局部变量和全局变量发生命名冲突时，以局部变量优先 -
global
声明全局变量
def fun1():
global b
b=100
print(b)
fun1()
print(b)
- nonlocal
声明的是局部变量
def fun1():
b=100
def fun2():
nonlocal b
b=300
print(b)
fun2()
print(b)
fun1()
- 函数内部不能进行a+=1,a=a+1这样的操作（全局变量）
解决饭方式1：
b=100
def fun1():
global b
b = b+1
print(b)
fun1()
解决饭方式2：
def fun1():
b=100
def fun2():
nonlocal b
b=b+1
print(b)
fun2()
print(b)
fun1()
7、内嵌函数
内部函数
内部函数的作用范围：从定义开始到包含给他的代码块结束
在内部函数中不能进行a+=1,a=a+1这样的操作，解决方案是nonlocal
8、 闭包
闭包：是函数式编程的重要语法结构，函数式编程是一种编程范式
编程范式：对代码进行提炼和抽象概括，使得重用性更高
如果内部函数调用了外部函数的局部变量，并外部函数返回内部函数的函数对象（函数名）
def fun1():
a=100
def fun2():
print(a)
return "哈哈"
return fun2
print(fun1()())
-
作用：
可以传递更少的形参，可以传递更多的实参—更加安全
def fun1(b):
a=100
print(b)
def fun2(c):
print(c)
return "哈哈"
return fun2
print(fun1(200)(300))
间接性的访问内部函数
-
条件
- 必须是一个内嵌函数
- 外部函数必须返回内部函数的函数对象
- 内部函数必须使用外部函数的局部变量
9、lambda表达式
-
匿名函数
没有名字的函数 -
使用时机：
只使用一次的时候 -
语法：
关键字： lambda
lambda 参数1，参数2:返回值 -
lambda的书写形式更加的简洁，优雅
l = lambda x:x
print(l(100))
- lambda的优先级最低
八、机器人实战
知识点总结完后，就来看看实例。
安装模块（功能）
语法:import 模块名
pip install itchat #微信功能
pip install request #发送请求
#导入相关模块，功能
import itchat
import requests
#1.生成机器人进行回复消息
KEY = "a7e21d94d4944e5ca6d4215f46a0339d"
#1. 实现机器人功能
def get_response(msg):
apiUrl = "http://www.tuling123.com/openapi/api" #要访问的网站
#key：机器人的key，info是要发送的消息
data = {'key':KEY,'info':msg,'userid':"WeChat-robot"}
#发送请求：
r = requests.post(apiUrl,data=data).json()
return r["text"]
#第二步：实现微信功能
#装饰器，用于查询哪个好友给你发消息
@itchat.msg_register(itchat.content.TEXT) #好友的信息
def tuling_reply(user_data):
print(user_data) #用户的信息包含给你发的消息
user = user_data["Text"] #用户发你的消息
return_user = get_response(user_data["Text"])
print(return_user)
return return_user or user
itchat.auto_login() #扫码登录
itchat.run() #循环执行上面的函数
我的Python基础知识点就总结到这了，每个人的学习方法和总结方法或许不一样，但是希望我的总结有一定的参考价值，给带来你们一定的帮助!
最后祝愿所有点赞收藏的小伙伴都能顺利通过学习完成人生逆袭。
感谢每一位愿意读完我文章的人，对于新媒体创作我也在不断学习中。创作是一件非常值得持续投入的事情，因为你们每一次的支持都是对我极大的肯定！
再次感谢大家的支持，在此我整理了一些适合大多数人学习的资料，免费给大家下载领取!
看！干货在这里↓ ↓ ↓
有需要的读者可以直接拿走，在我的QQ学习交流群。有学习上的疑问、或者代码问题需要解决的，想找到志同道合的伙伴也可以进群，记住哦仅限学习交流！！！
裙号是：298154825。
