提示：基础重点知识，是一些学习中很重要或者容易忽略的地方，适合Python学习者进行复习
目录
一、输入输出及判断语句
1、数据类型
2、内置输入函数input()
3、选择判断语句
4、内置打印函数print()
二、循环语句
三、函数
1、函数定义
2、参数类型
3、位置参数
4、默认参数
5、关键字参数
6、命名关键字参数
7、参数组合
8、匿名函数
四、类
1、面向过程编程
2、面向对象编程
3、类
4、对象
5、OPP面向对象的三大特征
6、类的创建
7、类的属性
8、类的方法
9、内部类
10、继承关系
前言
Python作为一个热门的方向，无论是作为兼职还是工作都是十分好的选择，打牢一个坚固的基础，对在这一行业能够走多远具有十分深远的意义，在本文，主要介绍Python主要的重点知识，适合Python学习者复习或者基础不牢的人群，大多数都会配以实例。接下来，就让我们一起走进Python的世界吧！
提示：以下是本篇文章正文内容，下面案例可供参考
一、输入输出以及选择判断语句
1、数据类型
字符串str，布尔类型bool，整数int，浮点数float，列表List，元组Tuple，集合Set，字典dic，复数类型complex
c1 = 1 + 3j
print(type(c1))
# 结果：<class 'complex'>这里着重演示一下复数类型
2、内置输入函数input()
作为基础的用户输入函数，input()的作用不言而喻。使用split()一次性输入多个值，不能使用int一次性转换过来，需要使用map()函数
# 用户控制输入input
text01 = input("请问你想要说什么？\n") # 内置函数input()，用户输入为字符串str类型
num = int(input("请输入一个整数:\n")) # 强制类型转换，将str转换为int类型
name01,name02,name03 = input("请输入"+str(3)+"个人的姓名，并以逗号隔开\n").split(',') # input()不能直接输出变量，需要将变量类型转换为str
"""input()可以使用split()进行一次多个输入，但输入的依旧是字符串类型"""
a,b,c = map(int,input("请输入三个数字，并以空格隔开：\n").split()) # map()有两个参数，一个数据类型，一个是数据序列，将数据类型作用到序列上
3、选择判断语句
条件表达式中除了常规的运算符，Python支持保留字not,and,or,in，需要注意表示等于需要用==，即两个等号，一个等号=表示负值。下面实例多分支选择结构：
# 判断语句
names_list01 = ["LiMing","DaMing","XiaoMing","XiaoHong"]
names_list02 = ["LiYing","DaKing","XiaoUing","XiaoPong"]
name = input("请输入学生姓名：\n")
if name in names_list01:
print(name+"很牛")
elif name in names_list02:
print(name+"是谁啊？\n")
else:
print("搞错了，再来")4、print()输出打印函数
print()默认输出为str字符串类型，数字等需要装换为字符串类型。除此之外，print()自带换行因此不必要情况下不需要在家换行符。输出字符串中两个%%打印出来是一个%。
# print()几种输出格式
# 加号拼接，但只针对字符串类型
num01 = 12
str01 = "haha"
print("我今年"+str(num01)+"岁嘞")
print("你好"+str01)
# format格式
a,b,c = 23,24,53
print("有这个数字：{}".format(a)) # 使用一个{}对应每次只能打印一个数
print("还有这些：{0}，{1}，{2}".format(a,b,c))
#print(f"{}")用法---认为这种方法比较好用
print(f"abc的值分别是{a},{b},{c}")
#使用百分比格式
#两个百分号%%输出一个百分号
print("a是%d" % (a))
print("abc分别是%d,%d,%d" % (a,b,c))
print("a的百分比是%d%%"% (a))
二、循环语句
基本循环语句while...else;for...else;其中else：后的语句是，前面循环结束后执行的，可以根据情况使用，可省略。continue跳出本次循环；break跳出整个循环；pass跳过，可用于替代暂时不打算写的代码，使他不报错。具体演示如下：
# 循环语句
# while...else
i = 0
sum = 0
while i <= 100:
sum = sum + i
i = i + 1
else:
print("循环已结束") # 这里使用几种不同的方式打印出来最终的结果，为了熟悉知识点
print(f"前一百个数字求和的结果为：{sum}")
print("前一百个数字求和的结果为"+str(sum))
print("前一百个数字求和的结果为：{}".format(sum))
print("前一百个数字求和的结果为：{0},{1}".format(sum,i))
# for...else
prime = 1
for i in range(1,10): # 内置函数range(start,end,step),三个参数，起始，终点，步长，生成这之间的一系列连续的整数
prime = prime * i
i = i + 1
else:
print("for循环结束")
print(f"连乘的结果是：{prime}")
# 运行结果：
# 循环已结束
# 前一百个数字求和的结果为：5050
# 前一百个数字求和的结果为5050
# 前一百个数字求和的结果为：5050
# 前一百个数字求和的结果为：5050,101
# for循环结束
# 连乘的结果是：362880三、函数
函数分为内置函数与自定义函数，内置函数指系统已经定义好的函数。自定义函数是我们自己定义以实现某种功能的函数。函数可以提高代码的复用率，以及代码的可维护性。一个简单的函数实例：
# 函数定义格式
"""
def function(形参列表): #形参是指定义函数时用于接收外部输入的变量，作用于仅限于函数内部
函数体 #函数体是函数具体用能的实现相应的代码
return 值 #return 用于返回某个值，Python可以同时返回多个值，但也需要多个变量去接收
#函数也可以没有返回值，默认返回值是None
"""
# 定义实现计算圆柱体体积的函数
def fun(height,r): # height,r是形式参数，作用范围仅在函数内部
pi = 3.141
area = 2*pi*r**2
volume = area*height
return area,volume
h,r = map(int,input("请输入圆柱体的高以及底面半径：\n").split(","))
area,volume = fun(h,r) # h,r为实参，传入参数，赋值给形参，并运行
print("圆柱体的底面积为：",area,"；体积为：",volume)
"""结果：
请输入圆柱体的高以及底面半径：
2,3
圆柱体的底面积为： 56.538 ；体积为： 113.076
"""根据函数传递参数种类不同，有以下分别：
1）可变类型：
如传递的参数是列表、字典等，则在函数内部对传入参数的修改会影响到外部变量，这时形参与实参使用的是同一地址。
2）不可变类型：
如整数、字符串、元组等，在函数内部对传入参数的修改不会影响到外部变量，这时形参与实参使用的不同的地址。
比如：
# 关于参数可变类型与不可变类型
def fun(fixed,varying):
fixed = fixed + 1;
varying.append([1,2,3])
print("形参的变量地址id(fix)", id(fixed), "\nid(vary)", id(varying))
fix = 12
vary = [4,5,6]
print("调用函数前的值：",fix,vary)
print("实参的变量地址id(fix)",id(fix),"\nid(vary)",id(vary))
fun(fix,vary)
print("调用函数后的值：",fix,vary)
"""
结果：
调用函数前的值： 12 [4, 5, 6]
实参的变量地址id(fix) 1974582248016
id(vary) 1974583600704
形参的变量地址id(fix) 1974582248048
id(vary) 1974583600704
调用函数后的值： 12 [4, 5, 6, [1, 2, 3]]
"""
很容易看出，实参fix对应的地址，在函数内外是不一样的，并且函数内对fix的加1并没有改变函数外的值；而vary的值函数内外的地址是一样的，并且函数内部对参数的操作对实参也起到了作用。
总结下来，看函数参数的相关知识点：
有以下几类参数：
1、位置参数：基于传入实参的顺序，将实参关联到函数内调用的形参。简单来说就是，传入实参的时候，调用函数时相同位置形参的值就是对应位置实参的值。
def fun(fixed,varying):
fixed = fixed + 1;
varying.append([1,2,3])
fix = 12
vary = [4,5,6]
fun(fix,vary) # 调用函数，fixed的值对应fix，vary对应varying的值
# 这就是位置参数的概念2、默认参数：
1）编写函数时，给形参提供了默认值，那么这个参数就是默认参数；
2）函数调用时，如果给默认参数提供实参，则默认参数使用提供的实参值，否则就使用默认值；
3）默认参数必须在必选参数的后面定义
4）如果默认参数不止一个，函数调用时，有需要就按顺序给默认参数提供实参，否则默认参数将使用默认值。
5）默认参数必须指向不可变对象，对于可变对象，假设第一调用函数已经改变了默认值，第二次就会沿用第一次的改变后的默认值，在整个程序中使用就会发生错误。
def fun(gender,age=18):
print("该用户的性别是"+gender)
print("该用户的年龄是"+str(age))
fun("男")
fun("女",22)
# 输出结果：
# 该用户的性别是男
# 该用户的年龄是18
# 该用户的性别是女
# 该用户的年龄是22
3、不定长参数：python语言中，可以定义不定长参数，也叫“可变参数”。即调用函数时传入的实参个数可以不定。
1）定义方式：在形参前加*，表示该参数是不定长参数
2）编写函数时，不定长参数集合为列表或元组形式，调用其中各个参数时，同列表元组调用时方式一样
def fun(*nums):
sum = 1
for n in nums:
sum = sum * n
return sum
sum = fun(1,2,3,4)
print(f"连乘的结果是：{sum}")
4、关键字参数：传递参数是使用“名称-值”的方式，在实参中将值与名称关联起来。因此调用函数时就无需考虑参数顺序。
def fun(name,age):
print(name,age)
fun(age=18,name="LiMing")5、命名关键字参数
1）如何理解：使用关键字参数时，对关键没有限制，也就是说每一个值的传递都可以用关键字，但是命名关键字参数就对此加以限制，在定义函数形参列表中，*号后面的参数才能用，且必须用关键字参数传递，否则会报错
def fun(height,name,*,age):
print(height,name,age)
fun(123,"LiMing",age=18)
# 结果：123 LiMing 18
fun(123,"liming",18)
# 结果报错
# Traceback (most recent call last):
# File "D:\Python\venv\复习Python\input_choose.py", line 153, in <module>
# fun(123,"liming",18)
# TypeError: fun() takes 2 positional arguments but 3 were given
6、参数组合
函数参数的定义是有严格的顺序的，定义的顺序必须是：必选参数，默认参数，可变参数，命名关键字参数和关键字参数
7、匿名函数
不再使用def这种标准形式定义的函数。使用lambda创建匿名函数，语法如下：
lambda 参数一，参数二：具体功能
recall = lambda a,b: a*b
print(recall(2,3))
# 结果： 6四、类
1、面向过程编程：重在步骤，将解决问题的步骤一步步分解出来用函数实现，使用时再依次调用，类似于流水线
2、面向对象：重在对象，将问题分解为各个对象，依靠对象之间的交互推动程序执行，从而解决问题。建立对象是为了描述某个事物解决完整问题步骤中的行为。简单来讲，面向对象是对变量和函数进行分类和封装。Python是偏向面向对象的编程语言。
3、类：对实体的抽象，泛指。比如动物，植物
4、对象：类的一个实例，特例。比如狗，花等
5、OPP面向对象的三大特征：封装，继承，多态
6、类的创建：使用class 类名:，或者class 类名（父类名）的方式
7、类的属性：总的来说，类的属性就是一个泛的对象有什么特征，比如身高年龄之类的。
1）公有属性：不加下划线的属性。公有属性在类的内部和外部都可以访问。
2）私有属性：以两个下划线开始，就表示私有属性。只能在类的内部访问私有属性。
3）实例属性：以self开头的，用来定义属性，定义实例对象后自动调用，用来赋值。
4）变量：不以self开头的是局部变量，只能在类内调用
8、类的方法：简单来说，就是类内部的一些用来实现特定功能的函数。
1）公有方法：可以被类的外部调用。
2）私有方法：在函数名前加上两条下划线，不能被类的外部调用。
3）静态方法：使用@staticmethod修饰器将普通方法装换为静态方法。静态方法没有self参数，可以不带任何参数，无法访问类的实例成员。调用时可以使用实例对象调用，也可以使用类名直接调用。
4）内置方法：在类内部定义，以__xx__结尾的方法，也就是任何类内默认存在的方法，比如初始化方法__init__，__new__等等
5）方法的重写：对继承父类的方法进行改写，def __init__(self,name,age,sex,city):就可以理解为对父类方法的重写
9、内部类：在类内定义类的方法
10、继承关系：就是让类与类之间产生父子关系，子类可以继承（直接使用或改写）父类的静态属性或方法。类的继承可以是一个或多个，父类又可以称为基类或超类（super()）。
简单举例如下：
class Person(): # 默认继承object,object是所有类的父类
num_family = 10 # 类属性,可以使用类名来访问
def __init__(self,name,age,sex,city): # 初始化函数，对象创建成功后自动调用，一般用于对象属性的赋值，self指的是刚刚创立好的的实例对象
self.name = name # 初始化name属性，实例属性
self.age = age # 初始化age属性，实例属性
self.sex = sex
self.city = city
def eat(self): # 定义实例方法，在类中定义的实例方法访问实例属性时，需要加self
print(f"{self.name}今年{self.age}岁了")
print(Person.num_family)
@staticmethod
def fun_sta(): # 静态方法可以没有任何参数
print(f"他家里有{Person.num_family}口人") # 静态方法不能访问实例属性，只能访问类属性，且不能调用其他类方法
# 实例
person = Person("熊",12,"男","xi'an")
person.eat()
person.fun_sta() # 使用实例名调用静态方法
Person.fun_sta() # 使用类名直接调用静态方法
总结
用了几个晚上对我认为的基础先总结了一番，当然还有很多的缺漏，比如文件的操作，基本数据类型这些，后期有时间会持续更进。希望大家带着批判的眼观看待，有问题可讨论。