Python中的常见6中数据结构

python中常见的数据结构有六种：Number（数值），String（字符串），List（列表），Tuple（元组），Dictionary（字典），Set（集合）

1.number数值

Python3 支持 int、float、bool、complex（复数）。 在Python3里，只有一种整数类型 int，表示为长整型。 在Python3中bool类型继承了int类型，所以也是数值。默认0为False，其他的都为True：True+1=2。 数值是不可变数据类型。

i=100  #int类型，没有大小限制的
f=3.1415  #float浮点类型
b=True   #布尔类型，True False 0（空容器）表示为假，非0（非空容器）表示为真
c1=10+1j
c2=10-1j
print(c1*c2)
a=104
b=7
​
print("a/b",a/b)#/相除
print("a//b",a//b)#//整除，整除不是四舍五入，而是直接把小数点后面的内容舍去
print("2**64=",2**64)
print('3*3.1415926',3*3.1415926)#由于精度问题所以会出现最后的0000001的现象
#所以一般浮点类型之间比较大小我们不用=进行比较，我们一般是9.4247778-3*3.1415926<0.000001进行判断是否相等
​
#字符串分行书写
#\ 换行符号
str="hello world " \
    "hello linux " \
    "hello China"
print(str)
​
#或者使用"""
str2="""hello world
hello linux
hello China"""
print(str2)

数值类型的基本操作

+，-，*，/，取余/取整（%，//），乘方（**）

如果不同的类型的数字（int，float）进行运算，则结果类型为精度较高的那个类型

取值的话不是四舍五入，而是把小数点部分直接舍去

2.字符串

字符串是不可变的，即被定义后不可以修改

Python中的字符串是一个由多个字符组成的有序序列，字符的个数即为字符串的长度。所以，在Python中是没有字符的，单个字符被认作长度为1的字符串。 声明一个字符串只需要使用单引号（'…'）或者双引号（"…"）将内容包住即可，也可以使用三引号('''…. '''，"""…""") 。 在字符串中可以使用转义字符()和原始字符串。 字符串是不可变的，即被定义后不可以修改。

我可以指向另外一个字符串的位置，但是一旦我定义了一个hello world我就不可以再进行修改了

这里面我们就可以把第0个位置的元素变为lala，因为字符串是不可变的

但是我们可以这样子修改

str2='abcde'
str2='123456'
print(str2)

获取字符串中的字符元素： 1.因为字符串是个有序序列，所以我们在访问字符串中的某些元素时可以根据元素对应的下标（索 引）来访问：str[n]。正向访问时下标从零开始，到字符串长度减一。逆向访问时从负一开始，每次递减一。 2.批量获取（切片）：str[a🅱️c]，a是起始元素的位置，b是终止元素的位置，c是步长（默认为1）。[a,b)左闭右开的

在对字符串切片的时候，位置和步长都可以是负值的，负向是-1开始的

str='0123456789'
#默认为起始位置为0，结束位置为默认字符串长度，步长默认为为1
print(str[::-1])#将字符串倒序输出
输出结果为9876543210

拼接： +：字符串相加会得到一个由两个字符串组成的新字符串，"a"+"b"=>"ab" ：字符串乘以一个数字可以得到重复次数的新的字符串，"a"2=>"aa" str.join(iter)：将所给参数中的每个元素以指定的字符连接生成一个新的字符串。

lst=['10','20','30']
print(":".join(lst))#使用指定的符号，把容器中的成员连接起来
输出结果为：
10：20：30

替换： str.replace(str1,str2)：将字符串中的str1替换为str2生成新的字符串：'python'.replace('py','PY') 输出 'PYthon'。

eg:print("hello world hello linux".replace("hello","thank you "))

输出结果：thank you world thank you linux

切割： str.split(str1)：以为str1为分隔符对字符串切割：'python' .split('h') 输出 ['pyt', 'on']。

小写： str.lower()：将字符串中的大写字符转化为小写：'PYTHON'. lower() 输出 'python'。 大写： str.upper()：将字符串中小写字符转化为大写：'python' .upper() 输出 'PYTHON'。

Python中的字符串支持格式化输出，即将字符串中的数据按照我们所需要的形式进行输出。 Python中的字符串格式化是通过字符串格式化操作符（百分号%）来实现的，其字符串转换类型表及其格式化操作符辅助指令如后续表格所示。

3.列表

• 列表是一个有序的序列。

• 列表中可以随时进行元素的添加和删除。

• 列表是可变的，它的元素可以是任何数据类型。

• 列表由一个中括号包裹住元素，元素用逗号隔开。创建列表的方式有：

  • List = list(obj1, obj2,…)

  • List = [obj1, obj2, ….]

  • 列表推导式

• 列表为有序序列，获取元素的方式和字符串一样。

• 添加：

  • list.append(obj)：将参数内的对象添加至列表的尾部。

  • list.insert(index, obj)：将对象插入到列表的index位置。

  • list.extend(iter)：将可迭代对象的每个元素逐个插入列表的尾部。

  • 删除

  • list.pop([index])：删除下标为index的元素，并将其返回（不传参数，默认删除最后一位元素）。

  • list.remove(obj)：删除列表中第一个出现的给定元素。

  • +，*的运算符操作和字符串是相同的。

  • 位置查找：

    • list.index(obj)：返回给定元素第一次出现位置的下标。

  • 排序：

    • list.sort()：对列表进行排序，默认是升序：reverse=False。

  • 逆序：

    • list.reverse()：将列表中的元素进行逆置（直接修改列表本身）。

  • 数量统计：

    • list.count(obj)：返回给定元素出现的次数。

内置函数也可以做排序和逆序，内置函数不会改变原来的列表数据会生成一个新的容器

空列表lst=[];lst=list()

4.元组

• 元组是一个有序序列。

• 元组是不可变的，所以在定义时便要确定元组内的元素。

• 元组因为其不可变性，所以相比于列表而言数据更加安全。

• 我们在考试的时候会去问你在封装数据的时候是列表好还是元组好，而不是直接问你其是不是可变的，那我们应该选择元组的方式，因为大数据是集群传递信息的，通过网络传递，放在元组里面就可以防止在传递过程中防止被修改，就是因为其不可变性

• 元组由一个小括号包裹，元素用逗号隔开。声明一个元组有三种方式： Tuple = tuple(obj1, obj2, …) Tuple = (obj1, obj2, …) Tuple = obj1,obj2,obj3 如果在声明元组时元组只有一个元素，需要在元素后面加上逗号，告诉解释器这不是运算符号中的括号。

  tup1=（1）#单个不是一个元组，单个是一个int类型

  tup2=（1，2）这样才是一个元组

  print(type(tup1))--------tup1:int

  print(type(tup2))--------tup2:tuple

  如果一定要单个元素作为一个元组的话，就只能写tup1=（1，）

  tuple直接修改其中的元素是不可以的，但是列表是可以的

  但是有一种情况就是元组当中如果有一个列表，其中的列表是可以修改的

tup=(1,[2,3],4)
​
tup[1][0]=100
print(tup)
tup=(1,[100,3],4)

5.字典（键值对）

• 字典是一个无序可变的序列。

• 字典的每个元素由两部分组成 – 键和值，所以字典的元素也被称为键值对。其中键是不可变且唯一的，如果字典有相同的键，则后面的键对应的值会将前面的值覆盖。

• 字典由一对花括号包裹，元素由逗号隔开。常见的字典创建方式：

  • Dict = {key:value,}

  • Dict = dict(key=value,)

  • Dict = dict([(key,value),])

  • 字典推导式

dic={"key1":"value1",100:"value2",(2,3):"value3"}
#获取键对应的值
print(dic.get("key1"))
得出value1

获取元素： dict.get(key,default=None)/dict[key]：获取key对应的value，前者在访问不存在的key时不会报错，会返回设置的默认值（default）。

dict.items()：返回一个包含所有（键，值）元组的列表。 dict.keys()：返回一个包含字典所有key的列表。 dict.values()：返回一个包含字典所有value的列表。 添加： dict[key] = value。若key已存在，则修改现有key的值。

更新： dict.update(dict1)：使用dict1来对字典进行更新。 删除： dict.pop(key)：删除并返回key对应的值。 dict.popitem()：随机删除并返回一个键值对。 dict.clear()：清空字典。

6.集合（可以看成一个是只有键没有值的字典）

• 集合是一个无序的可变序列。

• 集合中的元素是唯一的，重复的元素会被删除。

• 集合是由一个花括号包裹，内部元素以逗号隔开。声明一个集合的方式有：

  • Set = set()

  • Set = {obj1,obj2,…}

空集合：set1=set()

但是不可以是set1={}，这样子表示的是空字典

• 添加： set.add(obj)：如果元素以已存在，则不会进行任何操作。 set.update(obj)：添加对象可以是列表，字典等，且可以是多个，用逗号隔开。

• 删除： set.remove(obj)/set.discard(obj)：如果删除元素不存在，前者会报错。 set.clear()：清空集合。 set.pop()：随机删除一个元素。

• 逻辑运算：

  • 交集 set1 & set2：两个集合中相同的元素。

  • 对称差集 set1 ^ set2：两个集合中不同的元素。

  • 并集 set1 | set 2：两个集合内总共的元素（重复的删除）。

  • 差集 set1 - set 2：集合二相比集合一中不存在的元素。

  • 不可变集合：

    • frozenset()：不可被改变的集合。

内置函数：

1. len(obj)：返回数据的长度。

2. type(obj)：返回数据的类型。

3. enumerate(iter)：返回一个可迭代对象，对象中元素为下标和数据组成的元组。

   迭代器：不会直接去保存到内存中，不是去记录数据本身，而是去记录这个数据的一个存在，当真正用到的时候才会加载到内存中，这样子可以节省内存

4. id(obj)：返回数据所在内存中的存储地址，类似于一个编号是唯一的（主要是去测试看一下里面的两个变量是不是指向同一个内存）

5. in(obj)：判断数据是否在给定的数据之中。

6. max(obj)/min(obj)：返回数据中的最大/小值。

7. del(obj)：删除对象。 类型转化：str()，list()，tuple()，set()，dict()，int()，float()。