python的数据结构
类 | 描述 | 不可变 |
---|---|---|
bool | 布尔值 | Y |
int | 整数 | Y |
float | 浮点 | Y |
list | 列表 | N |
tuple | 元组 | Y |
str | 字符串 | Y |
set | 集合 | N |
forzenset | 冰冻集合 | Y |
doct | 字典 | N |
一、列表list
list的显著特征:
- 列表中的每个元素都可变的,意味着可以对每个元素进行修改和删除;
- 列表是有序的,每个元素的位置是确定的,可以用索引去访问每个元素;
- 列表中的元素可以是Python中的任何对象;
- 可以为任意对象就意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。
- 直接创建列表
mylist = ['Google', 'Yahoo', 'Baidu']
- 对列表中的指定位置变更数据
mylist = ['Google', 'Yahoo', 'Baidu']
#变更索引位置1Yahoo的内容为Microsoft
mylist[1] = 'Microsoft'
- 在列表后面追加元素
mylist.append('Alibaba') #运行结果: ['Google', 'Microsoft', 'Baidu', 'Alibaba']
- 在指定位置插入元素
mylist.insert(1, 'Tencent') # ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba']
- 删除元素
mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba']
# 删除尾部元素
mylist.pop() # 会返回被删除元素
# 删除指定位置的元素
mylist.pop(1) # 删除索引为1的元素,并返回删除的元素
mylist.remove('Microsoft') #删除列表中的Microsoft
del mylist[1:3] #删除列表中索引位置1到位置 3 的数据
- 替换元素
mylist[0] = 'Baidu'
mylist[1] = ['python', 'java', 'php'] # 集合的数据类型可以不同,也可以是集合
- 列表排序
mylist = [1, 2, 5, 4]
mylist.sort() # [1, 2 ,4, 5]
#如果列表里面是字母,则根据Ascii码来排序
- 获取列表长度
mylist = [1, 2, 5, 4]
len(mylist)
- 获取列表指定位置的数据
mylist = ['Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba','Sina']
#获取索引位置1的数据
mylist[1] #'Tencent'
#获取索引位置1到5的数据,注意这里只会取到索引位置4,这里叫做取头不取尾
mylist[1:5] # 'Tencent', 'Microsoft', 'Baidu', 'Alibaba'
#获取从最头到索引位置5的数据
mylist[ :5] #'Google', 'Tencent', 'Microsoft', 'Baidu', 'Alibaba'
#获取从索引位置2开到最后的数据
mylist[2:] #'Microsoft', 'Baidu', 'Alibaba','Sina'
- 用循环来创建列表
a = [1,2,3,4,5,6]
#在a的数据基础上每个数据乘以10,再生成一个列表b,
b = [i*10 for i in a]
print(a)
print(b)
#运行结果如下:
#[1, 2, 3, 4, 5, 6]
#[10, 20, 30, 40, 50, 60]
- 过滤列表中的内容放入新的列表中
#生成一个从1到20的列表
a = [x for x in range(1,20)]
#把a中所有偶数生成一个新的列表b
b = [m for m in a if m % 2 == 0]
print(b)
#运行结果如下:
# [2, 4, 6, 8, 10, 12, 14, 16, 18]
- 嵌套式生成列表
#生成一个列表a
a = [i for i in range(1,4)]
print(a)
#生成一个列表b
b = [i for i in range(100,400) if i % 100 == 0]
print(b)
# 嵌套式
c = [m+n for m in a for n in b]
print(c)
#运行结果:
# [1, 2, 3]
# [100, 200, 300]
# [101, 201, 301, 102, 202, 302, 103, 203, 303]
可以通过list将序列创建为列表
列表中常用的方法
方法 | 意义 |
---|---|
L.index(v [, begin[, end]]) | 返回对应元素的索引下标, begin为开始索引,end为结束索引,当 value 不存在时触发ValueError错误 |
L.insert(index, obj) | 将某个元素插放到列表中指定的位置 |
L.count(x) | 返回列表中元素的个数 |
L.remove(x) | 从列表中删除第一次出现在列表中的值 |
L.copy() | 复制此列表(只复制一层,不会复制深层对象) |
L.append(x) | 向列表中追加单个元素 |
L.extend(lst) | 向列表追加另一个列表 |
L.clear() | 清空列表,等同于 L[:] = [] |
L.sort(reverse=False) | 将列表中的元素进行排序,默认顺序按值的小到大的顺序排列 |
L.reverse() | 列表的反转,用来改变原列表的先后顺序 |
L.pop([index]) | 删除索引对应的元素,如果不加索引,默认删除最后元素,同时返回删除元素的引用关系 |
深拷贝 deep copy 和 浅拷贝 shallow copy
浅拷贝
是在复制过程中,只复制一层变量,不会复制深层变量绑定的对象
的复制过程
如:
- L1 = [1, 2, [3.1, 3.2]]
- L2 = L1.copy() # 浅拷贝
- print(L1) # [1, 2, [3.1, 3.2]]
- print(L2) # [1, 2, [3.1, 3.2]]
- L2[2][0] = 3.14
- print(L2) # [1, 2, [3.14, 3.2]]
- print(L1) # [1, 2, [3.14, 3.2]]
深拷贝
复制整个依懒的变量
如 :
- import copy # 导入复制模块
- L1 = [1, 2, [3.1, 3.2]]
- L2 = copy.deepcopy(L1) # 调用deepcopy函数实现深拷贝
- print(L1) # [1, 2, [3.1, 3.2]]
- print(L2) # [1, 2, [3.1, 3.2]]
- L2[2][0] = 3.14
- print(L2) # [1, 2, [3.14, 3.2]]
- print(L1) # [1, 2, [3.1, 3.2]] # L1不变
列表推导式
作用:
- 用简易方法生成列表
语法:
- [ 表达式 for 变量 in 可迭代对象 ]
- 或
- [ 表达式 for 变量 in 可迭代对象 if 真值表达式]
说明:
if 子句部分可以省略,省略后将对所有生成的对象进行处理
如果if真值表达式的布尔值为False,则可迭代对象生成的
数据将被丢弃
示例:
#以下生成1个数值在 1~9之间的奇数的平方的列表
L = [x**2 for x in range(1, 9) if x % 2 == 1]
#等同于:
for x in range(1, 9):
if x % 2 == 1:
L.append(x ** 2)
```
### 列表推导式嵌套
语法:
- [ 表达式 for 变量1 in 可迭代对象 if 真值表达式1
- for 变量2 in 可迭代对象2 if 真值表达式2
- ...
- ]
示例:
- 将列表[10, 20, 30] 中的元素与 列表[1, 2, 3]分别
相加,将得到的数据放于一个列表中
- L = [x + y for x in [10, 20, 30]
- for y in [1,2,3]]
- 等同于:
- L = []
- for x in [10, 20, 30]:
- for y in [1, 2, 3]:
- L.append(x + y)
## 二、元组tuple
**重点:元组Tuple,用法与List类似,但Tuple一经初始化,就不能修改,没有List中的append(), insert(), pop()等修改的方法,只能对元素进行查询**
<br>下面看个例子来证实一下我们说的:
a = (1,2,3,4)
a
(1, 2, 3, 4)print(type(a))
<class ‘tuple’>a[1]=5
Traceback (most recent call last):
File “<pyshell#3>”, line 1, in
a[1]=5
TypeError: ‘tuple’ object does not support item assignmenta[1:1] = 5
Traceback (most recent call last):
File “<pyshell#4>”, line 1, in
a[1:1] = 5
TypeError: ‘tuple’ object does not support item assignmenta[1]
2
**从上面的例子,证实了tuple不支持对元素的修改(包括删除),tuple一初始化便固定下来了。**
<br>再来看一个例子:
a = (‘a’,‘b’,[‘A’,‘B’])
print(type(a)) #检测a的数据类型是什么
<class ‘tuple’> #检测出a的类型是元组tupleprint(a)
(‘a’, ‘b’, [‘A’, ‘B’])a[2][0] = ‘X’ #尝试变更数据,成功了,为什么?
a[2][1] = ‘y’
print(a) #打印出变更后的内容
(‘a’, ‘b’, [‘X’, ‘y’])print(type(a[2])) #检测a的数据类型是什么
<class ‘list’> #检测出a[2]的类型是list
这里看似元素中的元素改变了,可是仔细分析下,元组中的第三个元素是一个列表。<br>
代码4,5行改变的是列表中的值,元组所指的这个元素列表并没有改变,需要注意这点!<br>
这就涉及到Python中的可变对象和不可变对象,像list这样的就是可变对象,tuple便是不可变对象。<br>
元组是固定的列表,那么元组的意义何在呢?<br>
因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple并且需要注意元组中元素的可变性!!<br>
空的tuple可以记为(),若只有一个元素的tuple记为(1,)<br>
## 三、字典dict(dictionary)
字典dictionary全称这个概念就是基于现实生活中的字典原型,生活中的使用名称-内容对数据进行构建,Python中使用键(key)-值(value)存储,也就是java、C++中的map。
### 字典的方法
方法| 说明
---|---
D.clear() |清空字典
D.pop(key) |移除键,同时返回此键所对应的值
D.copy() |返回字典D的副本,只复制一层(浅拷贝)
D.update(D2)| 将字典 D2 合并到D中,如果键相同,则此键的值取D2的值作为新值
D.get(key, default=None)| 返回键key所对应的值,如果没有此键,则返回default
D.keys() |返回可迭代的 dict_keys 集合对象
D.values() |返回可迭代的 dict_values 值对象
D.items() |返回可迭代的 dict_items 对象
### dict的显著特征:
* 字典中的数据必须以键值对的形式出现,即k,v:
* key:必须是可哈希的值,比如intmstring,float,tuple,但是,list,set,dict不行
* value:任何值
* 键不可重复,值可重复
* 键若重复字典中只会记该键对应的最后一个值
* 字典中键(key)是不可变的,何为不可变对象,不能进行修改;而值(value)是可以修改的,可以是任何对象。
* 在dict中是根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。
### 字典生成创建方式
```python
#创建空字典1
d = {}
print(d)
#创建空字典2
d = dict()
#直接赋值方式
d = {"one":1,"two":2,"three":3,"four":4}
#常规字典生成式
dd = {k:v for k,v in d.items()}
print(dd)
#加限制条件的字典生成方式
ddd = {k:v for k,v in d.items() if v % 2 ==0}
print(ddd)
字典的常见操作:访问、删除、变更字典里面的内容
#访问字典中的数据
d = {"one":1,"two":2,"three":3,"four":4}
print(d["one"])
#变更字典里面的数据
d["one"] = "eins"
print(d)
#删除一个数据,使用del
del d["one"]
print(d)
#运行结果如下:
1
{'one': 'eins', 'two': 2, 'three': 3, 'four': 4}
{'two': 2, 'three': 3, 'four': 4}
字典中成员检测
d = {"one":1,"two":2,"three":3,"four":4}
if 2 in d:
print("value")
if "two" in d:
print("key")
if ("two",2) in d:
print("kv")
使用for循环访问字典
d = {"one":1,"two":2,"three":3,"four":4}
#使用for循环,直接按key值访问
for k in d:
print(k,d[k])
#上述代码也可以写成如下
for k in d.keys():
print(k,d[k])
#只访问字典的值
for v in d.values():
print(v)
#以下是特殊用法
for k,v in d.items():
print(k,'--->',v)
字典相关函数
通用函数:len,max,min,dict
d = {"one":1,"two":2,"three":3,"four":4}
print(max(d))
print(min(d))
print(len(d))
dict() 函数的使用方法:
dict0 = dict() # 传一个空字典
print('dict0:', dict0)
dict1 = dict({'three': 3, 'four': 4}) # 传一个字典
print('dict1:', dict1)
dict2 = dict(five=5, six=6) # 传关键字
print('dict2:', dict2)
dict3 = dict([('seven', 7), ('eight', 8)]) # 传一个包含一个或多个元祖的列表
print('dict3:', dict3)
dict5 = dict(zip(['eleven', 'twelve'], [11, 12])) # 传一个zip()函数
print('dict5:', dict5)
str(字典):返回字典的字符串格式
d = {"one":1,"two":2,"three":3,"four":4}
print(str(d))
clear:清空字典
items:返回字典的键值对组成的元组格式
d = {"one":1,"two":2,"three":3,"four":4}
i = d.items()
print(type(i))
print(i)
d.clear()
print(d)
keys:返回字典的键组成的一个结构
d = {"one":1,"two":2,"three":3,"four":4}
k = d.keys()
print(type(k))
print(k)
values:返回字典的值组成的一个结构
d = {"one":1,"two":2,"three":3,"four":4}
v = d.values()
print(type(v))
print(v)
get:根据制定键返回相应的值,好处是可以设置默认值
d = {"one":1,"two":2,"three":3,"four":4}
print(d.get("one333"))
#get默认值是None,可以设置
print(d.get("one",100))
print(d.get("one222",100))
fromkeys:使用指定的序列作为键,使用一个值作为字典的所有的键的值
p = ["one","two","three","four",]
#注意fromkeys两个参数的类型
#注意fromkeys的调用主体
d = dict.fromkeys(p,"222")
print(d)
字典的推导式
字典推导式
-
字典推导式是用可迭代对象生成字典的表达式
-
语法:
- {键表达式: 值表达式 for 变量 in 可迭代对象
-
[if 真值表达式] }
- 注: [] 的内容代表可省略
-
示例:
- #生成一个字典,键为数字 1~9, 值为键的平方
- #{1:1, 2:4, 3:9, … 9:81}
- d = {x : x**2 for x in range(1, 10)}
四、集合set
- 集合更接近数学上集合的概念。集合中每个元素都是无序的、不重复的任意对象。
- 可以通过集合去判断数据的从属关系,也可以通过集合把数据结构中重复的元素减掉。集合可做集合运算,可添加和删除元素。
- 集合内数据无序,即无法使用索引和分片
- 集合内部数据元素具有唯一性,可以用来排除重复数据
- 集合内的数据:str,int,float,tuple,冰冻集合等,即内部只能放置可哈希数据
集合的常用方法
方法 | 意义 |
---|---|
S.add(e) | 在集合中添加一个新的元素e;如果元素已经存在,则不添加 |
S.remove(e) | 从集合中删除一个元素,如果元素不存在于集合中,则会产生一个KeyError错误 |
S.discard(e) | 从集合S中移除一个元素e,在元素e不存在时什么都不做; |
S.clear() | 清空集合内的所有元素 |
S.copy() | 将集合进行一次浅拷贝 |
S.pop() | 从集合S中删除一个随机元素;如果此集合为空,则引发KeyError异常 |
S.update(s2) | 等同于 S l= s2, 用 S与s2得到的全集更新变量S |
S.difference(s2) | S - s2 补集运算,返回存在于在S中,但不在s2中的所有元素的集合 |
S.difference_update(s2) | 等同于 S -= s2 |
S.intersection(s2) | 等同于 S & s2 |
S.intersection_update(s2) | 等同于S &= s2 |
S.isdisjoint(s2) | 如果S与s2交集为空返回True,非空则返回False |
S.issubset(s2) | 如果S与s2交集为非空返回True,空则返回False |
S.issuperset(…) | 如果S为s2的超集返回True,否则返回False |
S.symmetric_difference(s2) | 返回对称补集, 等同于 S ^ s2 |
S.symmetric_difference_update(s2) | 等同于 S ^= s2, 用 S 与 s2 的对称补集更新 S |
S.union(s2) | 生成 S 与 s2的全集, 等同于 S \ |
集合的定义
#集合的定义,set()
s = set()
print(type(s))
print(s)
#也可以像下面这样做,大括号内一定要有值,否则定义出的将是一个dict
s = {1,2,3,4,5,6,7}
print(s)
创建集合时需要用list作为输入集合,可通过add()方法增加元素,remove()方法删除元素
s = set([1,2,3])
s.add(6)
s.remove(2)
集合的内涵
普通集合内涵
以下集合会在初始化后自动过滤掉重复元素
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
print(s)
普通循环集合内涵
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
ss = {i for i in s}
print(ss)
带条件的集合内涵
s = {33,1,33,6,9,126,8,6,3,77,88,99,126}
sss = {i for i in s if i % 2 ==0}
print(sss)
多循环集合的内涵
s1 = {1,2,3,4}
s2 = {"nice","to","meet","you"}
s = {m*n for m in s2 for n in s1}
print(s)
集合函数
- intersection:交集
- difference:差集
- union:并集
- issubset:检查一个集合是否为另一个子集
- issuperset:检查一个集合是否为另一个超集
通过代码来看区别:
s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,8,9}
#交集
s_1 = s1.intersection(s2)
print("交集:",s_1)
#差集
s_2 = s1.difference(s2)
print("差集:",s_2)
#并集
s_3 = s1.union(s2)
print("并集:",s_3)
#检查一个集合是否为另一个子集
s_4 = s1.issubset(s2)
print("检查子集结果:",s_4)
#检查一个集合是否为另一个超集
s_5 = s1.issuperset(s2)
print("检查超集结果:",s_5)
# 这里是运行结果:
# 交集: {5, 6, 7}
# 差集: {1, 2, 3, 4}
# 并集: {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 检查子集结果: False
# 检查超集结果: False
frozen set:冰冻集合
创建冰冻集合的方式:
s = frozenset()
字符串
字符串的常见方法
方法 | 说明 |
---|---|
S.isdigit() | 判断字符串中的字符是否全为数字 |
S.isalpha() | 判断字符串是否全为英文字母 |
S.islower() | 判断字符串所有字符是否全为小写英文字母 |
S.isupper() | 判断字符串所有字符是否全为大写英文字母 |
S.isspace() | |
S.center(width[,fill]) | 将原字符串居中,左右默认填充空格 |
S.count(sub[, start[,end]]) | 获取一个字符串中子串的个数 |
S.find(sub[, start[,end]]) | 获取字符串中子串sub的索引,失败返回-1 |
S.strip([chars]) | 返回去掉左右char字符的字符串(默认char为空白字符) |
S.lstrip([chars]) | 返回去掉左侧char字符的字符串(默认char为空白字符) |
S.rstrip([chars]) | 返回去掉右侧char字符的字符串(默认char为空白字符) |
S.upper() | 生成将英文转换为大写的字符串 |
S.lower() | 生成将英文转换为小写的字符串 |
S.replace(old, new[, count]) | 将原字符串的old用new代替,生成一个新的字符串 |
S.startswith(prefix[, start[, end]]) | 返回S是否是以prefix开头,如果以prefix开头返回True,否则返回False, |
S.endswith(suffix[, start[, end]]) | 返回S是否是以suffix结尾,如果以suffix结尾返回True,否则返回False |
S.title() | 生成每个英文单词的首字母大写字符串 |
S.isnumeric() | 判断字符串是否全为数字字符 |
常用的转义字符
- ’ 一个单引号
- " 一个双引号
- \ 一个斜杠
- \n 换行符
- \r 返回光标至行首
- \f 换页
- \t 水平制表符
- \v 垂直制表符
- \b 倒退
- \a 响铃(已无效)
- \0 字符串(编码值为0的字符)
- \0oo oo为两位八进制表示的字符
- \xXX xx为两位十六进制表示的字符
- \uXXXX Unicode 16的十六进制表示的字符
- \UXXXXXXXX Unicode 32 的十六进制表示的字符
raw 字符串(原始字符串)
让转义字符 \ 无效
r'str'
字符串格式化表达式
格式化字符串中的占位符和类型码:
- %s 转为字符串,使用str(x) 函数转换
- %r 转为字符串,使用repr(x) 函数转换
- %c 整数转为单个字符
- %d 数字转为十进制整数
- %o 整数转为八进制整数
- %x 整数转为十六进制整数(字符a-f小写)
- %X 整数转为十六进制整数(字符A-F大写)
- %e 指数浮点数(e小写), 如:2.9e+10
- %E 指数浮点数(E大写), 如:2.9E+10
- %f, %F 转为十进制浮点数
- %g, %G 十进制形式浮点数或指数浮占数自动转换
- %% 等同于一个%字符
fmt = "姓名: %s, 年龄: %d"
print(fmt % ('Tarena', 15)) # 姓名: Tarena, 年龄: 15
print(fmt % ('小张', 20))
print("这个学生的成绩是: %d" % 99)
姓名: Tarena, 年龄: 15
姓名: 小张, 年龄: 20
这个学生的成绩是: 99
字符串的str方法
format
这是另一种格式化输出字符串的方法
s1="today is {} , the temperature is {} degrees."
print(s1.format("Saturday",24))
today is Saturday , the temperature is 24 degrees.
join方法
拼接字符串
list = ['1','2','3','4','5']
s = '*'
print(s.join(list))
1*2*3*4*5
split方法
切割字符串
list = '/user/local/nginx'.split('/')
print(list)
['', 'user', 'local', 'nginx']
capwords
格式化英文字符
import string
words = "i am a boy, can you help me ?"
print(string.capwords(words))
I Am A Boy, Can You Help Me ?
replace
替换字符串
words = "i am a boy, can you help me ?"
print(words.replace("boy","girl"))
i am a girl, can you help me ?
strip方法
截取字符串的前后空格
print(" geekori.com ".strip())
geekori.com