【系统开发基础储备】python语言语法（第一篇）

系列文章目录

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
TODO:写完再整理

文章目录

• 系列文章目录
• 前言
• 一、python 和CC++语言语法的区别
• • python 和CC++语言语法的区别
  • python和c、c++语言使用场景
• 二、python的数据结构
• • 1.列表list[] 【数据结构的大杂缸】
  • • （1）功能
    • （2）创建一个普通的列表方法一(类似于数组)
    • （3）创建一个普通的列表方法二
    • （4）创建一个普通的列表方法三
    • （5）向列表里面添加元素
    • • （1）背景：
      • （2）方法一：【append函数】：
      • 方法二：【extend()函数】
      • 方法三：【insert函数】
    • （6）从列表里面删除元素
    • • 方法一：【remove()函数】
      • 方法二：【del方法】
      • 方法三：【pop()函数】
    • （7）同时获取操作多个元素
    • （8）列表的一些常用操作符
    • • （1）比较操作符 "<"、">"、"="、"!"的组合
      • （2）逻辑操作符"and"、"or"、"not"
      • （3）连接操作符“+”
      • （4）重复操作符“*”
      • （5）成员关系操作符“in”、“not in”
    • （9）访问列表中的元素（下标方式）
    • （10）列表的其他常用内置函数
    • • （1）计算元素在列表中出现的次数count()函数
      • （2）返回要判断的元素在列表中的位置 index()函数
      • （3）把列表中的元素先后顺序翻转reverse()
      • （4）把列表中的元素按大小顺序排序sort()
  • 2.元祖tuple（戴上了枷锁的列表）
  • • 功能：
    • （1）创建一个元祖
    • （2）访问一个元祖
    • （3）修改一个元祖的元素
    • （4）更新一个元祖的元素
    • （5）删除一个元祖
    • （6）元祖常用的操作符
  • 3.字符串string
  • • （1）创建一个字符串
    • （2）访问操作一个字符串
    • （3）内置函数
    • （4）字符串格式化
  • 4.字典dictionary{}
  • • 功能：
    • （1）创建一个字典
    • （2）访问一个字典
    • （3）修改或添加字典中键对应的值
    • （4）字典的内建函数
    • （5）常用访问字典的函数
    • （6）删除一个字典的元素
  • 5.集合set
  • • 功能
    • （1）定义一个集合
    • （2）在集合里面索引访问一个元素
    • （3）集合里面不能有相同的元素
    • （4）去除列表中的重复元素方法对比
    • （5）集合的内置函数
    • （6）不可变集合frozenset（）

---

前言 认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！

本文先对python语言语法做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章

---

提示：以下是本篇文章正文内容

一、python 和CC++语言语法的区别

(1)python是由C语言写成的，C语言是python的底层

(2)python是一个灵活的语言，你想的到的他几乎都有，使用的时候要有猜想

(3)python在严格意义上说是，只有函数没有过程的
【防盗标记--盒子君hzj】

(4)python是没有变量只有名字的，因为python会动态分配变量的数据类型

(5)py文件在win中有工具用终端直接运行代码【linux中记得给权限】

python 和CC++语言语法的区别

1、python没有变量的声明
2、python没有花括号等作用域提示，用缩进的方法使编程界面更简洁
3、python用缩进符代替分号符“：”语法 ，python是一个注重审美的语言
4、python冒号“：”后下一行直接缩进，if/else、for/while、函数、类后面都有冒号 
5、python编写代码不能用汉语输入，用英文输入法
6、python的每种数据结构都有其内置的底层函数，这是C/C++没有的
7、python中没有switch语句 ，只有if/else语句
8、C语言定义函数都要单独定义，但是允许在一个函数里调用另外一个函数。python允许在一个函数里面定义并调用另外一个函数

python和c、c++语言使用场景

python一般用来写感知的代码，较底层的都是用c和c++写，但是c++的数据太多的数据需要查看可以用python写一个脚本可视化，c和c++数据量小可以直接看log

二、python的数据结构 1.列表list[] 【数据结构的大杂缸】 （1）功能

和C语言的数组功能类似 ，但是数组要求数据类型是一致的，列表没有这个要求，列表可以把整型，浮点型、元祖，列表等等的数据类型打包放在一起，统一管理

（2）创建一个普通的列表方法一(类似于数组)

num=[1,2,3,4,5,6]
num=[range(5)]
num=['a','b','c','d']

（3）创建一个普通的列表方法二

里面的元素包括整型，浮点型，字符型，字符串型，对象，列表，布尔类型等等
min=['小狗'，1，3.14，[1,2,3]]

（4）创建一个普通的列表方法三

当想不到要填充什么内容，但是有知道一定要用的的时候
   empty=[]

（5）向列表里面添加元素 （1）背景：

除了在创建列表的时候向列表里面添加元素的方法外，还可以在已有的列表里面添加元素

（2）方法一：【append函数】：

empty.append(1)	【这时候空列表就有1】
min.append(1)		 【这时候混合列表在做后面会加入1】
注意
1、append（）是一个方法（函数）
2、append（）只能添加一个元素
【防盗标记--盒子君hzj】

方法二：【extend()函数】

empty.extend([1,2,3,4,5])【这时候空列表就有1,2,3,4,5】
注意
1、只能输入一个参数，这个参数就是列表（本质上就是用一个列表去扩展另外一个列表）

方法三：【insert函数】

min. insert(0,'aaa')		【在min这个列表的第一元素插入‘aa’字符串】
注意：
1、insert（）有两个输入参数，第一个参数是添加的元素放在列表的位置，第二参数是插入的元素

（6）从列表里面删除元素 方法一：【remove()函数】

举例：
num=[1,2,3,4,5,6]
num.remove(1)		【从num这个列表中删除1这个元素】
【防盗标记--盒子君hzj】
注意：
（1）使用remove这个函数不要知道这个元素在列表的位置，仅仅知道这个元素存在列表中就可以的
（2）如果该元素不存在与这个列表中，使用remove操作会报错

方法二：【del方法】

举例：
del num				【把num这个列表删除】
del num[1]			【把num这个列表删除的第二个元素删除】
注意：
（1）del既可以删除整个列表，也可以删除列表中的某个元素，但是要知道该元素在列表中的位置

方法三：【pop()函数】

举例：
num=[1,2,3,4,5,6]
num.pop()		【删除num这个列表】
num.pop(1)	【删除num这个列表中的第二个元素】
注意：
（1）使用pop这种方法不仅可以删除列表中的元素，还可以同时返回删除掉的元素（用于赋值）

（7）同时获取操作多个元素

	方法：列表分片（slice）	【关键符是冒号：】
	举例：
	（1）num=[1,2,3,4,5,6]		
	（2）num[：]					【把num这个列表所有的元素都获取】
	（3）num[：3]				【把num这个列表开始到第三号的元素都获取】
	（4）num[3：]				【把num这个列表第三号到结尾的元素都获取】
	（5）num[1：3]				【把num这个列表第二号到第四号的元素都获取】
	【防盗标记--盒子君hzj】
	注意：
	（1）切片的方法本质上市对列表进行复制，并不影响原来的列表

（8）列表的一些常用操作符 （1）比较操作符 “<”、">"、"="、"!"的组合

举例：
num1=[123]
num2=[456]
num3=[123,456]
num4=[456,123]
num1==123		【返回的是true】
num1>num2		【返回的是false】
num3>num4		【返回的是false】
注意：
（1）对于列表的比较操作符，仅仅比较列表的第0 号元素
（2）数值型的能直接比较，字符型的转换成Acase码比较

（2）逻辑操作符"and"、“or”、“not”

举例：
	(num1 
（3）连接操作符“+” 
举例：
	（1）num6=num1+num2		【返回的是[123,456]】
	（2）num6=num1+"aaa"		【返回的false】
注意：
（1）功能类似字符串的连接
（2）连接操作符“+”是一个双目操作符，左右两边的元素类型必须一样
 
（4）重复操作符“*” 
举例：
（1）num7=num1*3		【返回的是[123,123,123]】
（2）num1*=3				【返回的是[123,123,123]】
注意：
（1）对于列表和元祖，“*”号是重复操作符 	
（2）对于数字数值，“*”号是乘法
（3）对于指针，“*”号是引用操作符
（4）重复操作符“*”可以和赋值操作符结合“=”在一起，成为“*=”
 
（5）成员关系操作符“in”、“not in” 
举例：
（1）123 in num3			【判断123这个元素是否在num3这个列表里，若在返回true,不在返回false】
（2）123 not in num3		【判断123这个元素是否在num3这个列表里，若在返回true,不在返回false】
（3）num8=[123,456,[789,147]]
	789 in num3			【返回的是false，因为789不是该列表的元素，是该列表元素的元素】
	789 in num3[2]		【判断123这个元素是否在num3这个列表第三个元素里里，若在返回true,不在															返回false】
注意：
（1）成员关系操作符可以判断列表所有元素和元素树的包含关系
 
（9）访问列表中的元素（下标方式） 
举例：
num=[123,[123,456],456]
num2=num[0]		【返回的是123】
num3=num[1]		【返回的是[123,456]】
num4=num[1][1]	【返回的是123】
注意：
【防盗标记--盒子君hzj】
（1）访问下标有点像二维数组，可以用二维数组来理解
 
（10）列表的其他常用内置函数 
注意：list全部的函数可以通过指令dir(list)获取
 
（1）计算元素在列表中出现的次数count()函数 
举例	：
num=[123,123,456]
num.count(123)				【返回的是2，说明元素123在列表num中出现了两次】
注意：
（1）count()的输入的参数是查询的元素
 
（2）返回要判断的元素在列表中的位置 index()函数 
举例：
（1）num=[123,123,456]
（2）num.index(123)			【返回的是0，说明元素123在列表num中的第0个位																			置，默认是最左边的】
（3）num.index(123,1,2)		【返回的是1，说明元素123在列表num中的第1个位																		置，查询范围是2~3号位置】
（4）num.index(456)			【返回的是2，说明元素123在列表num中的第三个位																		置】				
注意：
【防盗标记--盒子君hzj】
（1）index()的一号输入的参数是查询的元素，二号输入的参数是查询的起始位置，							三号输入的参数是查询的终止位置
（2）若列表中含有多个相同的元素，默认返回的是查询范围最左边的
 
（3）把列表中的元素先后顺序翻转reverse() 
举例：				
num=[1,2,3,4,5,6,7,8,9]
num.reverse()				【返回的是[9，8，7，6，5，4，3，2，1]】 
注意：
（1）reverse是list列表的内置函数，相当于是类内函数，用“.”操作符
 
（4）把列表中的元素按大小顺序排序sort() 
举例：
num=[1,3,5,7,9,2,4,6,8]
  (1)  num.sort()					【返回的是[9，8，7，6，5，4，3，2，1]】
（2）num.sort(reverse=true)			【返回的是[1，2，3，4，5，6，7，8，9]】
注意：
（1）默认是从小到大进行排序的
【防盗标记--盒子君hzj】
（2）sort()中的参数如果是reverse，则从大到小排序
 
.
 .
 
2.元祖tuple（戴上了枷锁的列表） 
功能： 
元祖和列表的使用方法是很相似的，都是所有数据类型的仓库，但是不同之处在于，
 列表可以更改（添加删除）自身的元素，而元祖从创建开始就不嫩更改自身的元素
 
（1）创建一个元祖 
举例：
（1）tulpe1=(1,2,3,4,5,6)
（2）tulpe1=1,2,3,4,5,6		【和上面的作用是一样】
（3）tulpe1=（）				    【创建一个空元祖】
（4）tulpe1=1，					【创建一个元素为1 的元祖】
注意：
（1）创建一个元素一般是用小括号“（）”，但是本身上是逗号“，”
（2）推荐使用第一种方法，比较规范整洁
【防盗标记--盒子君hzj】
 
（2）访问一个元祖 
举例：
（1）tulpe1=(1,2,3,4,5,6)
tulpe2=tulpe1[1]		【下标的方法，输出的是2，使用tulpe1的第二个tulpe2】
（2）tulpe2=tulpe1[1:]		【切片的方法，输出的是2,3,4,5,6，使用tulpe1的第二个																	元素到最后一个元素创建tulpe2】
注意：
（1）访问列表里面的元素和列表于数组一样，都是用下标的方法，包括二维下标
（2）可以使用切片的方法对元祖的元素进行访问
 
（3）修改一个元祖的元素 
举例：
（1）tulpe1=(1,2,3,4,5,6)
tulpe1[0]=2				【这样会报错】
注意：
（2）元祖的元素从创建起就不能被修改
 
（4）更新一个元祖的元素 
举例：
（1）tulpe=(1,2,3,4,5,6)
tulpe=tulpe[:3]+"aa"+tulpe[3:] 		【输出的是（1，2，3，aa，4，5，6）】
注意：
（1）元祖的元素不能被更改，但是可以被更新，更新后的元祖会覆盖原来的元祖
 
（5）删除一个元祖 
举例：
del tuple		【删除整个元祖】
注意：
（1）当个元祖不存在的时候，会报错 
 
（6）元祖常用的操作符 
（1）比较操作符		"<"、">"、"="、"!"的组合
（2）逻辑操作符"and"、"or"、"not"
（3）连接操作符“+”
（4）把列表中的元素按大小顺序排序sort()
（5）成员关系操作符“in”、“not in”
【防盗标记--盒子君hzj】
注意：
（1）用法和列表操作符一致
 
.
 .
 
3.字符串string 
（1）创建一个字符串 
举例：
str1="abcdefg"
注意：
（1）创建一个字符串是用双引号“”
 
（2）访问操作一个字符串 
举例：
str2=str1[1]		【输出的是b，使用下标的方法】
str2=str1[:3]		【输出的是abc，使用的是切片的方法】
注意：
（1）python这个类型是没有字符这个类型的，python认为字符是字符串串里面的某个元素
（2）当我们要使用单个字符的时候可以直接用下标、切片的方式直接索引字符穿的某个元素
（3）字符串一旦被创建就不能被更改了，只能使用类似元祖的方法进行更新
 
（3）内置函数 
注意：		
（1）无论是列表，元祖还是字符串，都有自己的内置函数，其中功能上，字符串>列表>元祖
（2）由于字符串的内置函数非常多，我们不可能全部都记得住，要用什么功能的时候就百度上查，记住以下常用的内置函数就好
【防盗标记--盒子君hzj】
（3）每次python版本更新都会加入更多的内置函数
 
（4）字符串格式化 
举例：
（1）“{0}”love“{1}”“{2}”.format("I","HZJ","HAHA")	【输出的是I love HZJ 																															HAHA】
（2）“{a}”love“{b}”“{c}”.format(a="I",b="HZJ",c="HAHA")	【输出的是I 																															love HZJ HAHA】
（3）“{0}”love“{b}”“{c}”.format("I",b="HZJ",c="HAHA")		【输出的是I 																															love HZJ HAHA】
（4）‘%c’%97									【输出的是a,因为97的ASCII码是a】	
（5）‘%c%c%c’%（97，98，99）		【输出的是abc，因为97，98，99的ASCII																							码是abc】
注意
（1）不同程序员写出的字符串格式不一样，不能兼容的同一管理，字符串格式化可以解决这个问题
（2）"{}"里面如果输入的是123等的位置信息会自动根据format()里面的信息进行匹配
（3）"{}"里面如果输入的是关键字信息，format()里面要有对应关键字信息进行匹配
（4）"{}"里面可以结合123等位置信息和关键字信息，在用format对应进行匹配，但是要注意123等位置信息						一定要在关键字信息前面，不然会报错
（5）格式化符“%”，“%”本来是去余数操作符，但是遇到了字符串后被重载为格式化操作符
具体的格式化符号为%c ，%s ，%d ，%o ，%x ，%X ，%f ，%e ，%E ，%g ，%G
具体功能和使用方法可以查百度
 
.
 .
 
4.字典dictionary{} 
功能： 
相当于数学里面的映射关系，当索引不好用的时候可以使用字典,字典是python中唯一的映射类型，
字典中的单词类似于键（key）,字典中单词的含义类似于值（value），
允许通过某个键值（key）索引查找对应的值（value）
【防盗标记--盒子君hzj】
 
（1）创建一个字典 
模板：
dict1={'键1（key1）'：'值1（value1）','键2（key2）'：'值2（value2）','键3（key3）'：'值3（value3）'}
举例：
【1,创建一个字符对象的字典】  
dict1={'李宁':'一切皆有可能','耐克':'哈哈','阿迪达斯':'hoho'}

【2，创建一个数值对象的字典】
dict2={1:'one',2:'two',3:'three'}

【3，创建一个空字典】				
dict3={}
 
（2）访问一个字典 
【1】print('李宁的口号是：'，dict1[李宁])		【输出的是一切皆有可能】
【2】dict2[2]															【输出的是two】
 
（3）修改或添加字典中键对应的值 
dict1['李宁']=‘我超厉害’
dict1['何子俊']=‘我超牛逼’
 
（4）字典的内建函数 
（1）fromkeys(...)
用法：dict.fromkeys(s,[,v]),其中s是键值（key），v是值(value)可选的，如果不提供值默认为none
功能：在字典里添加元素，仅仅可以添加一个
举例：
dict1={}
dict1.fromkeys(1)				【返回的是{1：None}】
dict1.fromkeys(1，哈哈)		【返回的是{1：哈哈}】
【防盗标记--盒子君hzj】
 
（5）常用访问字典的函数 
【1】keys()
功能：仅仅返回字典中键值，不返回键对应的值
举例：
dict2={1:'one',2:'two',3:'three'}
dict2.key()								【返回的是1,2,3】

【2】values()	
功能：仅仅返回字典中键对应的值，不返回键值
举例：
dict2={1:'one',2:'two',3:'three'}
dict2.value()							【返回的是one,two,three】

【3】items()
功能：既返回字典中键值，有返回键对应的值
举例：
dict2={1:'one',2:'two',3:'three'}
dict2.items()								【返回的是（1，one）,（2，two）,（3，three）】
 
（6）删除一个字典的元素 
（1）dict1.clear()		【建议，不会泄露数据，删除一个字典dict1里面的元素，但是dict1依然存在，是一个空字典】
（2）dict1={}				【不建议，会泄露数据，把dict1赋值为空字典也可以清空字典里面的内容】

注意：
（1）注意区分映射类型和序列类型的存储方式，序列类型典型的是列表、元祖、字符串等等，序列类型可以通过下标和切片索引到每个元素，但是映射类型是建立两个元素之间的关系
【防盗标记--盒子君hzj】
（2）大花括号是字典的标志，但不是字典特有的，当大花括号里面有键和键对应的值才是字典
（3）访问一个字典键的属性的时候，仅仅用大括号输入键的值就可以了，python可以自动映射进去找到键对应的值
（4）键和值得数据类型可以是数值数据类型、列表、元祖、字符串、关键字参数等等
（5）修改字典中键对应的值，直接用键名索引键的值，并用赋值的方式修改，若输入的键本来就在字典里的，直接修改键对应的值，若输入的键不在字典里的，直接创建新的键对应的值。
（6）索引字典中的元素，如果该元素不存在，就会报错
（7）判断元素在不在字典里，可以使用成员操作符“in”,"not in"
（8）字典还有很多内置函数，自行百度 可以用命令行dir(dict)查找全部的内置函数
 
.
 .
 
5.集合set 
功能 
集合里面的元素都是唯一，就是集合里面的元素都没有重复，
若创建集合的时候有重复的元素会自动清除重复的元素
 
（1）定义一个集合 
num={1,2,3,4,5,6}		【方法一：直接把一堆元素用花括号括起来】
num=set([1,2,3,4,5,6])	【方法二：使用set()内置函数,直接输入参数】

num=[1,2,3,4,5,6]		【方法三：使用set()内置函数，用列表创建集合】
num1=set(num)			
 
（2）在集合里面索引访问一个元素 
（1）num1=num[2]			【报错，不同通过索引获得集合里面的元素】
（2）【方法一：使用for 把集合里面的数据一个个读取出来，通过成员操作符判断元素是否在集合里】
 
（3）集合里面不能有相同的元素 
num={1,2,3,4,5,6,6}		【调用这个集合的时候会自动把相同的元素清除，但不会报错】
 
（4）去除列表中的重复元素方法对比 
【函数的方法：成员操作符】
num=[1,2,3,4,5,1,3,5]
temp=[]
for each in num:
	if each not in num
		temp.append(each)
temp

【集合的方法】
num=[1,2,3,4,5,1,3,5]
temp=list(set(num))
temp
 
（5）集合的内置函数 
（1）向集合里面添加元素add()
num={1,2,3,4,5,6}
num.add(7)			【向num这个集合里面添加元素7】
（2）在集合里面删除元素remove()
num={1,2,3,4,5,6}
num.remove(6)			【向num这个集合里面添加元素6】
 
（6）不可变集合frozenset（） 
功能：不能改变集合里面的元素，包括更改，添加和删除
num=frozenset（[1,2,3,4,5]）	【定义不可变集合】
num.add(1)							【报错，不能改变集合里面的元素，包括更改，添加和删除】
【防盗标记--盒子君hzj】
注意：
（1）在python中如果只有大花括号没有键和键对应的值，就是集合类型set，所以集合和字典是近亲关系
（2）集合set是无序的，无法通过索引获取集合里面的元素，集合不支持索引index
（3）集合里面的元素数据类型不限，包括数值类型，列表，元祖、字典、字符串等等
（4）调用这个集合的时候会自动把相同的元素清除，但不会报错
（5）用set()创建的集合是无序的，若想创建有虚的集合最好用大花括号直接给参数创建
（6）集合有很多内置函数可以调用，可以用百度结合命令行dir(set)继续学习相应功能
 
.
 .