Python学习笔记1-内置数据结构

本文主要是介绍Python学习笔记1-内置数据结构，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

变量：

存储一个对象的引用；由id()、type()、value组成

1.列表[list]：

python内置数据结构

本身由id()、type()、value组成，指向列表对象；

列表对象相当于数组，存储多个对象的引用；对象可以为多个不同数据类型；

列表的创建

lst = [1,'2',1,'hello','world']
lst = list([1,'2',1])

列表的特点

元素有序、索引映射唯一数据（正序0开始，逆序-1开始）、存储重复数据、存储不同数据类型、根据需要动态分配和回收内存
列表的查询

获取索引

有相同元素，只返回第一个元素的索引；
```
lst.index(1)
```
指定索引区间[0,2)
```
lst.index('2',0,2)
```
获取单个元素

正向0_{N-1，逆向-1}-N;
```
lst[0]=lst[-N]
```
获取多个元素：切片

[0,3)步长为2，步长为-1（逆着取，区间也逆过来，索引左大右小）
```
lst[0:3:2]
lst[::-1]
```
首、尾（省略就能取到，无论正逆）
```
lst[:3:2]
lst[1::2]
```
判断是否在列表中
```
print('2' in lst)
print(10 not in lst)
```
列表的遍历

迭代变量：字符串、列表…
```
for 迭代变量 in lst
```
列表元素添加

append()在末尾添加一个元素，列表对象不变（id不变），可以将列表作为元素添加进去

extend()在末尾添加若干元素，列表对象不变（id不变），可以将列表添加进去（列表里的元素拿出来添加）

insert()在任意位置添加一个元素，在索引1上添加90
```
lst.insert(1,90)
```
切片：在任意位置上添加若干元素

在从lst的索引1开始替换（添加）lst3中的每个元素
```
lst3=[True, False, 1]
lst[1:]=lst3
```
列表元素和列表的删除

remove()根据元素删除，一次只删一个元素，有重复就删第一个

pop()根据索引移除元素，不指定就删除最后一个元素

将list切片赋值给其他列表，也可用空列表赋给自身的切片

clear()清空列表，列表对象还在

del命令，删除列表对象
列表元素的修改

索引：lst[2]=2，将索引更改其指向

切片：lst[1:3]=11,22,33,44；在切片索引的位置，修改为更多个元素
列表元素的排序

lst.sort()，默认从小到大，reverse=True则从大到小，在原列表上改（id不变）

sorted(lst)，内置函数，产生一个新列表，reverse=True则从大到小
列表生成式

产生1~9各自平方的整数序列lst
```
lst = [i*i for i in range(1,10)]
```

2.字典{dict}

python内置数据结构，和列表一样是一个可变序列（可以增删改，对象地址不变）

字典以键值对方式存储数据（元素是键值对），是无序的序列（第一个放未必第一个位置、其位置由hash工序决定（把键放到hash函数计算）所以键要求*不可变序列（字符串）***）

字典的创建

dic = {'a':1, 'b':2, 'c':3}
dic = dict(d=4,e=5)
dic = {}

字典值的获取

利用键获取值。如果不存在[]会报错，get默认返回None（可以改返回值为99）
```
dic['a']
dic.get('a'，99)
```
字典元素增、删、改

判断key是否存在
```
'a' in dic
'b' not int dic
```
删除指定键值对
```
del dic['a']
```
清空字典元素
```
dic.clear()
```
新增或修改
```
dic['h']=5
dic['a']=5
```
获取字典视图

keys()获取所有key，返回dict_keys类型，列表[]

values()获取所有value，返回dict_values类型，[]

items()获取所有key,value对，返回dict_items类型，由元组组成的列表[( , ),( , )]
字典的特点

key不允许重复（会覆盖），value可以重复，无法手动指定元素位置（hash自动计算）

元素无序、key必须是不可变对象

字典根据需要动态伸缩

字典浪费较大内存，是空间换时间的数据结构，查询速度很快

字典生成式

将两个可迭代对象（字典、列表），按序将对应元素打包成一个个元组，返回由元组组成的列表(要进行list转换)

items=['a','b','c']
prices=[1,2,3]
lst=zip(items,prices)#这个返回值显示看不来
list(lst)#需要转换成列表，看到里面全是元组

d = {item:price for item, price in zip(items, prices)}# 这个把元组按序取出来，并且循环按序赋给item:price；

3.元组（tuple）

python内置数据结构，不可变序列（和字符串一样没有增删改，对象地址会变），和列表很像，用的是（）

元组的创建

使用小括号创建可以省略小括号，但对于单元素的元素不可以这样

仅有一个元素的元组必须加小括号和逗号**（如果没有逗号，仍然会被误认为元素本身的数据类型）
```
t = ('a','b',1)# 可以不写（），直接赋值默认为元组
t = tuple(('a','b',1))
t = ()
t = tuple()
```
为什么设计元组为不可变序列

变量内数据不可修改，避免因修改数据导致的错误

在多任务环境下，同时操作对象，不需要加锁（可以看，不可以动）

元组中存储的是对象的引用

引用不允许更改，只能指向原来的那个对象（例如指向列表，可以再这个列表面操作，但是不能指向其他列表或变量等
元组的遍历
```
for item in t:
    print(item)
```

4.集合{set}

python提供的内置数据结构，可变类型序列（和列表、字典一样），是没有value的字典（用hash函数计算位置，无序的，不允许重复）

集合的创建

s={1,2,3,4,5,5}# 集合元素不允许重复，重复的只保存1个
s=set([1,2,3,4,5,5])#set转换列表、元组
s8 = {}# 这无法定义空集合，这是字典dict
s8 = set()# 这是空集合，类型是set

集合相关操作
1. 元素的判断
  
  in,not in
2. 新增集合元素
  
  add()一次添加一个元素
  
  update()一次添加若干元素（可以把列表、元组、集合里的元素拆开放进去）
3. 删除集合元素
  
  remove()一次删除一个指定元素，不存在抛出KeyError异常
  
  discard()一次删除一个指定元素，不存在不抛出异常
  
  pop()一次删除一个任意元素
  
  clear()清空集合元素
集合间的关系
1. 相等
  
  元素相同,==或者!=
2. 子集
```
s1.issubset(s2)# s2是s1的子集与否
```
3. 超集
  
  issuperset()
4. 交集
  
  isdisjoint()

集合的数据操作

交集

intersection()

&
并集

union()

|
差集
```
s1.difference(s2)		#s1集合-交集
```
对称差集
```
symmetric_difference()	# 并集-交集
```
^

集合的生成式
```
{i*i for i in range(1,5)}
```

列表、元组、字典、集合总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表list	可变	可以	有	[]
元组tuple	不可变	可以	有	()
字典dict	可变	key不可，value可	无	{key:value}
集合set	可变	不可	无	{}

字符串

python基本数据类型，不可变的字符序列

字符串驻留机制

仅保存一份相同不可变字符串，不同的值放在字符串的驻留池。因此对相同的字符串只保留一份拷贝，后续创建不会开辟新空间，直接把该字符串地址赋给新变量。

a,b,c都指向’python’这个内存空间。
```
a='python'
b="python"
c='''python'''
```
1. 驻留机制的几种情况
  
  ①符合**标识符（字符、数字、下划线）**的字符串、
  
  ②字符串长度为0或1、
  
  ③只在编译（解释器）时进行驻留（例如基本运算），而非运行时（例如函数）、
  
  ④[-5,256]之间的整数数字（不是字符串）
  
  可以用a=sys.inter(b)强制驻留
  
  Pycharm会对字符串做优化处理，让内容相同的驻留
2. 驻留机制优却点
  
  python中一切皆对象，创建对象和销毁对象消耗时间、内存，从字符串池拿来实用，提升效率节约内存。
  
  字符串的拼接、修改比较影响性能，建议直接用.join()方法，
  
  join方法先计算字符串长度，再拷贝，只new一次对象，效率比+高
字符串的常用操作
1. 字符串的查询
  
  index()查找子串第一次出现位置，不存在抛异常
  
  rindex()查找子串最后一次出现位置，不存在抛异常
  
  find()查找子串第一次出现位置，不存在不抛异常返回-1
  
  rfind()查找子串最后一次出现位置，不存在不抛异常返回-1
2. 字符串的大小写转换
  
  以下，都产生新的字符串对象（不可变序列，用了函数所以不满足驻留条件）
  
  uper()所有变大写
  
  lower()所有变小写
  
  swapcase() 大写变小写，小写变大写
  
  capitalize()开头字母大写，其余小写
  
  title()每个单词的开头大写，其余小写
3. 字符串内容对齐
  
  center()居中对齐，参数一宽度，参数2填充符（默认空格）。宽度小于原字符串的，返回原字符。
  
  ljust()左对齐，
  
  rjust()右对齐，
  
  zfill()右对齐，左边用0填充。只有参数1。对负数字符串，0添加在**-**之后
4. 字符串劈分
  
  split()左边开始劈分，sep指定分隔符（默认空格），maxsplit指定最大劈分次数（其余字串单独作为一部分），返回列表
  
  rsplit()从右边开始劈分
5. 字符串判断
  
  isidentifier()是否合法标识符
  
  isspace()是否空白字符组成（回车、换行、水平制表等等）
  
  isalpha()是否只由字母组成
  
  isdecimal()是否只十进制数字组成（罗马数字不算）
  
  isnumeric()是否只数字组成（罗马、汉字都算）
  
  isalnum()是否只有数字、字母组成（中文算字母）
6. 字符串替换与合并
  
  replace()参数1被替代的子串，参数2替换的子串，参数3最大替换次数。替换后，原字符串不发生变化。
```
s = 'hello,python'
s.replace('python', 'java')# 用java替换s中的python

s1 = 'hello,python,python,python'
s1.replace('python','java',2)# 用java替换s1中python，替换2次
```
  join()将列表或元组中的字符串合并成一个。如果要合并一个字符串，会把它当作字符序列
```
lst = ['hello', 'java']
'|'.join(lst) # 用|连接lst里的字符串
```
字符串的比较

比较规则：从左往右按字符依次比较，如果不满足就不继续比较了

比较原理：字符原始值ord(‘a’)<ord(‘b’)，原始值对应字符chr(98)=‘b’。中文也有对应的ASCII码
字符串的切片

字符串是不可变类型，不能增、删、改。
格式化字符串

比如填写申请表，空格处是我们填写的内容，这里是可以变化的。拼接操作会浪费空间，因此格式化字符串就行。
1. 格式化字符三种方式
  
  %占位符：%s字符串，%d或%i整数，%f浮点数
```
name = 'zjj'
age = 18
'我叫%s，几年%d岁' % (name, age)# 用 %
```
  {}占位符：{0}第0个位置，{1}第一个位置
```
name = 'zjj'
age = 18
'我叫{0}，几年{1}岁'.format(name, age) # 用.format
```
  f-string
```
f'我叫{name}，今年{age}岁'
```
2. 字符宽度、精度
  
  %10d，宽度10字符
  
  %.3f，保留三位小数
  
  %10.3f，宽度10，3位小数
  
  {0:.3}，保留三位有效数（0代表占位符位置，可以省略）# 冒号后加格式要求
  
  {0:.3f}，保留三位小数
  
  {0:10.3f}，宽度10，3位小数
字符串的编码解码转换

不同计算机，str在内存中的表示方式不同（A：Unicode，编码后，byte字节传输，B解码并显示）

编码：字符串转为二进制数据（bytes）

解码：bytes类型数据转换为字符串类型
```
s='天涯共此时'
byte = s.encode(encoding='GBK') # 一个中文俩字符
string = byte.decode(encoding='GBK') # 编码解码的格式要相同

byte = s.encode(encoding='UTF-8')# 一个中文仨字符
string = byte.decode(encoding='UTF-8')
```

这篇关于Python学习笔记1-内置数据结构的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！