编程语言
首页 > 编程语言> > 2.Python 数据容器

2.Python 数据容器

作者：互联网

知识要点：

2.1 字符串 ( str)

2.2 列表 ( list )

2.3 元组 ( tuple )

2.4 字典 ( dict )

2.5 集合 ( set )

2.1 字符串 ( str )

字符串: 单引号，双引号，三引号 包围的字符组。

str = ' hello '
str = " world "
str = ''' hello 
          world'''

字符串：下标和切片

下标索引：即编号，根据下标找到对应元素。

切片：对操作的对象截取其中一部分的操作.

切片语法: [ 起始 : 结束 : 步长 ]  ( 支持负数 )

描述 实例 实例输出 
'''
　　正向下标：0 ~ (len(str)-1 )
　　负向下标：(-len(str)) ~ (-1)
'''
my_str = 'welcome hyl' # len(name)=11
 
下标索引
取下标 0 的元素 
my_str[0]
 
w
取下标 -11 的元素 
my_str[-11]
取下标 10 的元素 
my_str[-1]
 
l
取下标 -1 的元素 
my_str[10]
取下标 -3 的 
my_str[-3]
 
h
取下标 3 的元素 
my_str[3]
 
c
切片
取下标 3 之前的元素 (不包含下标 3 ) 
my_str[0:3]
 
wel
 
my_str[:3]
取下标 3 之后的元素 (包含下标 3 ) 
my_str[3:11]
 
come hyl
 
my_str[3:]
取下标 3 之后 每间隔 2 的元素 (包含下标 3 ) 
my_str[3:11:2]
 
cm y
字符串反向输出 
my_str[::-1]
 
lyh emoclew
取下标 1 开始到最后第 2 个之间的字符 
my_str[1:-1]
 
elcome hy

字符串的常见操作：

方法 方法说明 实例 实例输出
查  
my_str = 'welcome hyl' # len(name)=11
find( str ) 检测 str 是否被包含，若是返回索引值，否则返回 -1 
my_str.find('o')
 
 4
 
my_str.find('s')
 
-1
rfind( str )

类似于 find() ,从右边开始查找

 
my_str.rfind('o')
 
 4
index( str )

与 find() 方法一样，若str 不在会报异常

 
my_str.index('h')
 
8
rindex( str )

类似于 index() ,从右边开始查找

 
my_str.rindex('h')
 
8
count( str )

str 出现的次数

 
my_str.count('l')
 
 2
startswith( str )  是否以 str 开头，返回 True or False  
my_str.startswith('w')
 
True
 
my_str.startswith('e')
 
False
endswith( str )  是否以 str 结束，返回 True or False  
my_str.endswith('l')
 
True
 
my_str.endswith('y')
 
False
增 
my_str = 'welcome hyl' # len(name)=11
joinStr.join( mystr ) mystr 中每个元素后面插入 str 
joinStr.join(mystr)
 
w-e-l-c-o-m-e- -h-y-l

删

my_name = ' h y l '
lstrip() 删除左边的空白字符 
my_str.lstrip()
 
h y l
rstrip() 删除末尾的空白字符 
my_str.rstrip()
 
 h y l
strip() 删除两端的空白字符 
my_str.strip()
 
h y l

改

my_str = 'welcome hyl'
my_name = ' h y l '
replace(str1,ste2,x) 将 str1 替换成 str2 
my_str.replace('l','09')
my_name.replace(' ','')
 
we09come hy09
hyl
replace(str1,ste2,x) 将 str1 替换成 str2,替换 x 次 
my_str.replace('l','09'，1)
my_name.replace(' ',''，2)
 
we09come hyl
hy l
split(str,x) 以 str 为分隔符切片，仅分隔 x 个子字符串 
my_name.split(' ')
my_name.split(' ',1)
my_name.split(' ',2)
 
['', 'h', 'y', 'l', '']
['', 'h y l ']
['', 'h', 'y l ']
capitalize() 把字符串的每一个字符大写 
---
 
---
title() 每一个字符串首字母大写 
---
 
---
lower() 所有大写字符为小写 
---
 
---
upper() 所有小写字符为大写 
---
 
---
ljust( x ) 原字符串左对齐，用空格填充至长度为 x 
---
 
---
rjust( x ) 原字符串右对齐，用空格填充至长度为 x 
---
 
---
center( x ) 原字符串居中，用空格填充至长度为 x 
---
 
---
partition( str ) 把字符串分为 str前，str，str后三部分   
my_name.partition('y')
   
(' h ', 'y', ' l ')
rpartition( str ) 类似于 partition()，从右边开始 
---
 
---
splitlines() 按照行分隔，返回一个包含各行作为元素的列表 
---
 
---

 2.2  列表 ( list )

列表：Python 内置的一种数据类型，是一种有序的集合。

列表的格式：写在方括号之间、用逗号隔开。

list = ['mike','里斯',25000,99.99,True]
# 列表可以是不同类型的

列表遍历：为了更有效率的输出列表的每个数据，可以使用循环来完成。

namesList = ['zhangsan','lisi ','wangwu ','zhaoliu'] # for 循环 for name in namesList: 　　print(name) # while 循环 length = len(namesList) i=0 while i <length: 　　print(namesList[i]) 　　i+=1

列表的常用操作

方法 方法说明 实例 实例输出
namesList = ['ZhangSan', 'LiSi ', 25000, 99.99, True]
len( list ) 列表长度 len(namesList) 
5
list[索引] 列表访问 
namesList[3]
 
99.99
list[start:stop:step] 列表切片 
namesList[:3]
 
['ZhangSan', 'LiSi ', 25000]
 
namesList[0:-2]
 
namesList[:4:2]
 
['ZhangSan', 25000]

append 整体添加

extend  整体展开 元素依次添加

insert  （下标，值）

 列表添加元素 
list_1=['元素1','元素2']
namesList.append(list_1)
namesList.extend(list_1)
namesList.insert(0,'100')
 ['ZhangSan', 'LiSi ', 25000, 99.99, True, ['元素1', '元素2']] ['ZhangSan', 'LiSi ', 25000, 99.99, True, '元素1', '元素2'] ['100','ZhangSan', 'LiSi ', 25000, 99.99, True]
list[索引] = 新元素 列表修改元素 
namesList[0]='123'
 
['123', 'LiSi ', 25000, 99.99, True]
in/not in/index/count 列表查找元素 
namesList.index('LiSi ')
namesList.count('ZhangSan')
 
2
1

del 参数使用 下标

remove 参数化使用 数据

pop 进栈

 列表删除元素 
del namesList[2]
names.remove('')
namesList.pop()
 
['ZhangSan', 'LiSi ', 99.99, True]
['ZhangSan', 25000, 99.99, True]
['ZhangSan', 'LiSi ', 25000, 99.99]

clear 清空列表

 清空列表 
namesList.clear()
 
[]

reverse 倒叙输出

sort 排序

 列表排序 
namesList.reverse()
 
[True, 99.99, 25000, 'LiSi ', 'ZhangSan']

2.3 元组

元组：另一种有序列表，元组不饿能修改。

元组的格式：写在圆括号之间、用逗号隔开。

classMates = (1,) # 如果元组只有一个元素时，后面需要加一个 逗号。
classMates = ('Michael','Bob','Tracy')
# tuple 不可变，没有append(),inseret()方法；其他和 list 是一样的。

2.4 字典

字典：可变容器模型，且可存储任意类型对象。

字典格式：每个键值对用冒号分割，每个对之间用逗号分割，整个字典包括在 花括号 内。

dict = {'Mike':90, 'Bob':95,'Jack':100}

字典的常见操作

方法 方法说明 实例 实例输出 
dict = {'name':'hyl','id':200,'sex':'f','addr':'中国广州'}
 dict[key]=value

修改元素，通过 key 修改

若无该 key，则增加一个 key

 
dict['id']=100
dict['newid'] = 200
 
{'name':'hyl','id':100,'sex':'f','addr':'中国广州'}
{'name':'hyl','id':200,'sex':'f','addr':'中国广州','newid':200}
del

删除元素

 
del dict['id']
del
 
{'name':'hyl','sex':'f','addr':'中国广州'}
clear

清空元素

 
dict.clear()
 
{}
len()

键值对的长度

 
len(dict)
 
4
 dict.keys()

返回一个包含字典所有 keys 的列表

 
dict.keys()
list(dict.keys())
 dict_keys(['name', 'id', 'sex', 'addr']) ['name', 'id', 'sex', 'addr']
 dict.values()  返回一个包含字典所有 values 的列表 dict.values() list(dict.values()) dict_values(['hyl', 200, 'f', '中国广州']) ['hyl', 200, 'f', '中国广州']
dict.items() 返回包含所有（键值对）元组的列表 dict.values() list(dict.values()) dict_values(['hyl', 200, 'f', '中国广州']) ['hyl', 200, 'f', '中国广州'] 

 2.5 集合 (set )

集合：一个无序的不重复元素序列。

集合的创建：使用大括号{} 或者 set() 函数。

my_set = {1, 4, 'abc', 'hello'}
my_set = set([1, 1, 3, 5, 3])  # 把列表转成集合，会去重。
# 集合不支持下标赋值和取值；定义空的集合时，需要使用 set() 函数
 含义  实例 实例输出  
my_set = {1, 4, 'abc', 'hello'}
通过遍历获取数据 
for value in my_set:
　　print(value)
for index,value in enumerate(my_set):
　　print(index,value)
 
1
4
hello
abc
0 1
1 4
2 hello
3 abc
定义空的集合的时候不能直接使用{} 
my_set = set()
my_set.add(1)
my_set.add(1)
print(my_set, type(my_set))
 
{1} <class 'set'>
集合可以对容器类型数据去重，把列表转成集合，会把数据去重 
my_list = [1, 1, 3, 5, 3] 
my_set = set(my_list)
 
{1, 3, 5}

标签：容器,下标,name,Python,数据,namesList,dict,str,my
来源： https://www.cnblogs.com/hello-lan/p/15141377.html