Python这门语言涉及到了很多关键词：大数据，爬虫，人工智能，自动化运维，数据挖掘与数据分析等等，可见Python于一些高级领域的不可替代性，那么问题来了，我有必要学Python吗？
学python的必要性：
一、这门语言在GitHub上开源代码占较大，影响力强，可谓2021年最为流行的语言之一。
二、这门语言涉及到了我比较感兴趣的人工智能这个关键词,而且在ROS的程序编写中也有Python代码实现。
三、这门语言的简洁性以及难易程度也完全能够接受，而且好像也是物联网工程专业的专业课内容。

以下是语法的回顾（简单的就写一起了）
因为也是第二次过知识点了，希望在一个小知识点上不断的串烧，把一个小的知识点讲透讲难，也可能讲的比较乱，后面这篇文章可能会不断调整内容
python常用注释方法：
1.#（单行代码）
2.""" """（多行代码）

1.print()函数与文件IO流
#字符类型 ‘ ’ 或 “ ” 括起。

#代码功能：于D盘创建一个名为text的txt文件，并打印hello world输出到该文件中

filep = open('D:/text.txt','a+')#以下为a+的解释说明
                                //w：以写方式打开
                                  a+：以追加方式打开（不存在就创建，存在再追加一个）
                                  r+：以读写模式打开
                                  w+：以读写模式打开
                                  rb：以二进制读模式打开
                                  wb：以二进制写模式打开
                                  ab：以二进制追加模式打开
                                  rb+：以二进制读写模式打开
                                  wb+：以二进制读写模式打开
                                  ab+：以二进制追加模式打开//

print('hello world',file = filep)#把这个文件变量赋值给一个文件指针

filep.close()#关闭文件

2.转义字符（ /t , /n , /r , /b ,）
#前两个与C&Cpp中语法类似，不进行赘述。

print('hello\\rworld')#输出结果：world
print('hellow\\rworld')#输出结果：world
print('hello\\bworld')#输出结果：hellworld（退后一格）

3.id(),type()函数与Python内变量的理解
#参数i为变量名（标识符），其作用分别为输出变量id（地址）

name = "衾许"
print(id(name))
print(id("衾许"))

name = "默许"
print(id(name))

#输出结果：
2201372693392
2201372693392
2201372693584

这说明了什么?
1Python的变量类型之所以如此灵活且万能，是因为用户定义的每一个变量都为一个指向类似于C语言结构体的对象的一个指针变量
2这个对象中包含着三个元素：一个id（地址），一个type（变量类型），以及Data（数据域）
3数据域中存放的数据可以直接访问，而指针域（id）中的变量则需要id（）函数进行访问输出，变量类型同理

4.float，bool（布尔类型）
#这里说一下浮点数计算时的误差解决

a = 1.1
b = 2.2
print(1.1+2.2)#输出结果：3.3000000000000003
              #以上问题属于二进制的底层问题、
              #解决方法如下
              #decimal模块其他函数应用：https://www.cnblogs.com/xueweihan/p/5207959.html

from decimal import Decimal
 #decimal模块其他函数应用：https://www.cnblogs.com/xueweihan/p/5207959.html
print(Decimal('1.1') + Decimal('2.2'))#输出结果：3.3

c = True
d = Flase
print(c,type(c),d,type(d))#输出结果：True <class 'bool'> False <class 'bool'>

5.input()函数与算数运算符
#相当于C中的printf和scanf函数合成一句了#input其最大特点就是把程序变成了交互式

name = input('你叫什么名字？')#↓衾许
print(name)#输出结果：衾许

#交互案例
#计算F(x,y,z) = x^ymodz

x = int(input('请输入一个底数'))
y = int(input('请输入一个指数'))
z = int(input('请输入一个要除余的数'))
print(x**y%z)

#算法优化
def funtion_math(x,y,z):
    result = 1

    while(y):
        y = y-1
        result = result*x

    result = a%z
    return result

x = int(input('请输入一个底数'))
y = int(input('请输入一个指数'))
z = int(input('请输入一个要除余的数'))
print(funtion_math(x,y,z))

#但当x，y大起来的时候数据膨胀，int类型溢出，为了解决这个问题
#算法再次优化

def funtion_math(x,y,z):
    result = 1
#这里运用了数论的知识有:a^bmodz = (amodz)(bmodz)modz
    result = (x%z)*(y%z)%z
    return result

补充知识点：//为整除运算
如：
a = 5//1.5
b = 5/1.5
print(a)
print(b)
输出结果：
3.0
3.3333333333333335

6.and和or和not
#这个可以理解为C中的&&和||以及~，就不多赘述。
#另外python中&和|和<<以及>>为位运算符，对数据进行二进制处理。注意：（各运算符优先级：算数>位>比较>布尔）
7.if,else,while分支结构和pass语句
#分支结构的用法与C大致一致，下面是相关历程

if 逻辑运算:
           pass#这里的pass既是一个通过语句，使得编译器忽略这部分分支通过编译
else ：
        pass

对比C语言


if(逻辑运算)
{
    代码块
    
}
else
{
    代码块
}

#while的例子演示

8.range(start,stop,step)与for in循环遍历
#range作用：创建一个整数序列，可通过其内置的三个参数进行设置长度以及步长

for i in range(10):#遍历对象多样，既可以是一个整数的序列也可以是一串字符更可以是一个列表
    print(i)#这里自动换行

for i in 'python':
    print(i)#懂的都懂，不细说

9.列表（list）

lis=[1,'衾许',3.3]
print(id(lis))
print(id(1))
print(type(lis[0]))
print(id(2))
print(type(lis[1]))
print(id(3))
print(type(lis[2]))
输出结果：
2798858703872
2798853450032
<class 'int'>
2798853450064
<class 'str'>
2798853450096
<class 'float'>
#这说明了什么？
#这说明列表其实实质就如同C语言中一个指向结构体的指针，这个结构体中包含了n个结构体指针，这些指针都是指向一个拥有地址（id），类型（type）,数据（Data)三个元素成员的结构体

10.index()
#列表的元素索引函数，#用法index（list.成员名），返回值为该元素于此列表中的下标位置，当列表中存在多个用户要索引的元素时，将会返回第一个索引到的元素的下标，相应的解决这个问题可以通过index（list.成员名，start，stop）来确定索引范围
11.列表的切片，增添，删减，修改，排序操作

#列表的切片操作
lis = [1,2,3,4,5,6,7,8,9,0,]
print(lis)
new_lis = lis[1:6:1]#从一号元素开始到六号元素结束步长为一
print(new_lis)
输出结果：[2,3,4,5,6]

#列表的增添操作
lis = [1,2,3]#尾插法
lis.append(100)#append函数的作用相当于在列表的末尾添加一个指针变量指向一个变量结构体，
print(lis)
输出结果：[1,2,3,100]
lis = [1,2,3]#可用户控制插入位的插入法
lis.insert(1,100)
print(lis)
输出结果：[1,100,2,3]

#列表的删除操作
lis = [1,2,3,4,5,6,7]
lis.remove(7)#remove函数的作用则相当于C中的单链表，可任意的操作该列表中一个元素进行释放操作
print(lis)
输出结果：[1,2,3,4,5,6]

#列表的修改操作
lis = [1,2,3,4]
lis[2] = 100#其实质为对列表中存放的结构体中的Data成员进行修改
print(lis)
输出结果：[1，2,100,4]

#列表的排序操作
lis = [1,7,2,5,8,4,10]
lis.sort()
print(lis)
输出结果：[1, 2, 4, 5, 7, 8, 10]

12.字典（dict）
#与列表不同，其为无序序列#就是所谓的内存分布是‘离散’的，这就导致了字典需要消耗大量的内存，是一种用空间换时间的结构，与列表的下标不同，想要查找访问字典的元素则需要访问其关键字（key）
与列表对比，索引列表中的一个元素，其时间复杂度为o(n),而字典索引一个其内的元素其时间复杂度是o（1），索引效率极高，注意：字典的关键字是不可重复的（字典的关键字与其对应的元素的数据构成函数关系）

#字典的创建与字典元素的获取
scores = {'张三':10,'衾许':100,'默许':98}
print(scores['衾许'])#第一种方法
print(scores.get('衾许'))#输出结果一致
输出结果：100

13.字典的增添，删除，修改操作

#字典的删除操作
scores = {'张三':10,'衾许':100,'默许':98}
del scores['张三']
print(scores)
输出结果：{'衾许': 100, '默许': 98}

#字典的增添操作
scores = {'衾许':100,'默许':98}
scores['默殊'] = 97
print(scores)
输出结果：{'衾许': 100, '默许': 98, '默殊': 97}

#字典的修改操作
scores = {'衾许':100,'默许':98}
scores['衾许'] = 97
print(scores)
输出结果:{'衾许': 97, '默许': 98}

14.字典的视图获取（关键字，值，关键字-值对）与字典生成式

scores = {'衾许':100,'默许':98,'张三':10}
print(scores.keys())#输出字典中的关键字
print(scores.values())#输出字典中的值
print(scores.items())#输出字典中的关键字及值对

输出结果:
dict_keys(['衾许', '默许', '张三'])
dict_values([100, 98, 10])
dict_items([('衾许', 100), ('默许', 98), ('张三', 10)])

15.元组（tuple）
#不可变序列

#元组创建：
t = ('衾许','默许','默殊')#小括号是可以省略的
print(t)
输出结果:('衾许', '默许', '默殊')

16.元组的各类操作

# s1和s2都是元组
s1=(1,2,3)
s2=(4,5,6)

# 拼接生成新元组
s3 = s1+s2
s4 = s2.__add__(s1)
print(s3)
print(s4)
输出结果：
(1, 2, 3, 4, 5, 6)
(4, 5, 6, 1, 2, 3)

# 是否包含
s2 in s1#Flase
s1.__contains__(2)#Flase

# 统计元素包含的次数
print(s1.count(2))
输出结果：1

# 获取元素
s1[0]
s1.__getitem__(0)

# 找到2第一次出现的索引
s1.index(2)

# 获取长度
len(s1)

# 重复拼接
s1*n

17.元组作用
#就一开始一般人都会迷惑，这种不可修改的数据结构必然是很少被人使用的，那它存在的意义是什么呢？
参考这篇文章：https://blog.csdn.net/weixin_47197994/article/details/109103050?utm_term=python%E4%B8%AD%E5%85%83%E7%BB%84%E7%9A%84%E6%84%8F%E4%B9%89%E6%98%AF%E4%BB%80%E4%B9%88&utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~all~sobaiduweb~default-1-109103050&spm=3001.4430你能获得答案
18.集合（set）
#（没有值的字典）以及常用操作

#集合的增添操作
s={1,2,3,4,5,6,7}
s.add(100)#一次添加一个元素
s.update({200,300,400})#一次添加多个元素
print(s)
输出结果:{1, 2, 3, 4, 5, 6, 7, 100,200,300,400}

#集合的删除操作
s={1,2,3,4,5,6,7}
s.remove(7)#discard()函数与remove()函数作用一致，但remove函数若越界则会报错，而discard则不会
#输出结果：{1, 2, 3, 4, 5, 6}
#补充知识点：pop()函数作用：随机删除集合中的一个元素，clear()函数作用：清空该集合


#集合数据操作
#集合的操作
s1 = {1,2,3,4,5,6,7}
s2 = {6,7,8,9,10,11,12}
print(s1|s2)#并集操作
print(s1&s2)#交集操作
print(s1-s2)#差集
print((s1-s2)|(s2-s1))#对称差集
输出结果：
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
{6, 7}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 8, 9, 10, 11, 12}

19.字符串及常用操作
https://blog.csdn.net/swan_tang/article/details/82792657参考这篇博客，字符串的各种常用操作
20.函数
#学过C语言的必然对函数了如执掌，这里不多赘述，在这里把python函数的模板展示

#以下为函数模板
'''def funtion_name(argc,argv):#*agrs和**agrs为可变参，下面放源码
    result = 1

    pass

    return result'''#若无返回值，则return不用写
                    #若返回值为多个值，则返回值为一个元组

#可变参*agrs：示例源码
def funtion_name(*agrs):
    print(agrs)

funtion_name(1,2,3)
funtion_name(1,2)
funtion_name(1)
#输出结果：（结果为元组）
1 2 3
1 2
1
#可变参**agrs：示例源码
def funtion_name(**agrs):
    print(agrs)

funtion_name(a=1,b=2,c=3)

#输出结果：（结果为字典）
{'a': 1, 'b': 2, 'c': 3}

#补充：可变参个数只能为一个

21.try-except-else语句和try-except-else-finally语句
https://blog.csdn.net/m0_37822685/article/details/80259402参考这篇博客
到此Python的基础语法算是过完了，随着我能力的提升，这篇文章应该也会被回炉几遍，如果有不足或者哪里讲错了，希望大佬们可以指出
谢谢

以上是关于Python基础语法总结的主要内容，如果未能解决你的问题，请参考以下文章

Python基础语法总结

Java 基础语法方法的使用

python基础入门（语法基础）