• 周五. 12月 9th, 2022

5G编程聚合网

5G时代下一个聚合的编程学习网

热门标签

Python–列表-,元组,字典的介绍

admin

11月 28, 2021

补充1

关于字符串切片,就是取出字符串中的单个字符

s='hello world'
print(s[0]) 根据字符的索引值,来取出单个字符,从0 开始,
print(s[1])
print(s[0:5]) 指定范围取值,从0到5的值,取头不取尾,
print(s[0:5:2])在0到5的范围内,按照步长2取值,没个一个字符取一个值,
结果为
h
e
hello
hlo
--------------------------------------------------------------------
补充2

变量的解压
s='hello'
a,b,c,d,e=s 把每个单个字符都绑定一个变量
print(a,b,c,d,e)
print(b) 如果支取某个,就指定那个变量名,
结果
h e l l o
e

-------------------------------------------------------------------------
补充3
关于for和while循环
需要涉及到break和continue的区别了。

break: 只能跳出当前循环,当前这一套循环就结束了。
continue: 跳出当次循环,然后呢还会去继续下一次别的循环。

for循环
for i in range(10):
print(i)
结果
0
1
2
3
4
5
6
7
8
9
从0到9 一次循环打印,直到9结束
for i in range(0,10,3):
print(i)
0
3
6
9
指定步长为3,打印,每隔3个
列表
1.定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素
特性:
1.可存放多个值
2.可修改指定索引位置对应的值,可变
3.
按照从左到右的顺序定义列表元素,下标从0开始顺序访问,有序

关于表格的创建的3种方式:
list_1=[1,2,3]

list_test=list('abc')
print(list_test)

list_test=list(['lhf',12,'ok'])
print(list_test)

2. 列表的常用操作
索引
切片
追加
删除
长度
循环
包含
--------------------------------------------------------------------------------------------------------
列表元素去重
n1=['a','b',1,2,1]
n2=[]
for i in n1 :
if i not in n1 :
n2.append(i)
print(n2)


list_1=list(set(n1))
list_1.sort(key=n1.index) --------------sort是排序,根据n1的列表排序
print(list_1)
-----------------------------------------------------------------------------------------------------------
1.1切片,,根据索引值求值
name=['alex','egon',1 ,[3,4]]
print(name[0]) 索引0的位置的值
print(name[0:2]) 从0到2的值
print(name[0:3:2]) 步长为2的,每隔一个数求值
结果
alex
['alex', 'egon']
['alex', 1]
-----------------------------------------------------------------------------
2.追加
name=['alex','egon',1 ,[3,4]]
name.append('ccc')
print(name) -------------------------从列表的最后开始追加
结果
['alex', 'egon', 1, [3, 4], 'ccc']
-----------------------------------------------------------------------------
3.插入
name=['alex','egon',1 ,[3,4]]
name.insert(1,'ddddd')
print(name)
---------------------插入,指定一个索引,插入到索引值前
结果
['alex', 'ddddd', 'egon', 1, [3, 4]]
------------------------------------------------------------------------------
4.删除
name=['alex','egon',1 ,[3,4]]
name.pop()
print(name) --------如果不加参数,从列表的最后一个值开始删除,
结果
['alex', 'egon', 1]

name=['alex','egon',1 ,[3,4]]
name.pop(1)-------------------指定一个索引,删除索引位置的值
print(name)
结果
['alex', 1, [3, 4]]
----------------------------------------------------------------------------------
5.关于队列和堆栈
队列---先进先出
堆栈---先进后出

队列

先进1
append 的追加方式,默认从最后加
a=[]
a.append('p1')
a.append('p2')
a.append('p3')
print(a)


结果-------['p1', 'p2', 'p3']-----先进来得,排在最前面

先进2
insert 的追加方式,需要指定索引位置

a=[]
a.insert(0,'p1')
a.insert(1,'p2')
a.insert(2,'p3')
print(a)


先出
a=['p1', 'p2', 'p3']
a.pop(0) ---指定0的索引位置弹出 p1弹出
a.pop(1) ---指定1的索引位置弹出 p2弹出
a.pop(2) ---指定2的索引位置弹出 p3弹出
print(a)
--------------------------------------------------
堆栈
先进后出
append 追加
pop 弹出,不加参数,默认从列表的最后弹出,
-------------------------------------------------------------------
5.del 删除 列表元素
a=['p1', 'p2', 'p3']
del a[1]
print(a)
结果----['p1', 'p3']   -------del 的删除列表的格式,del a[1],del后面加上列表名字,跟上索引位置
---------------------------------------------------------------------------------------------
6.列表长度
a=['p1', 'p2', 'p3']
print(len(a))
结果   3  ,
---------------------------------------------------------------------------------------------
7.成员运算
in ,判断元素是否在列表里
a=['p1', 'p2', 'p3']
print('p4' in a )

结果 False -----p4不在a的列表里,

关于字符串里,单个字符的判断
v='dfdfdf'
print('f' in v)
--------判断f 是否在字符串v内,在,返回Ture,
-------------------------------------------------------------------------------
8.求出列表内某个元素的索引值
a=['p1', 'p2', 'p3']
print(a.index('p2'))
----返回 1
-----------------------------------------------------------------------------
9.计算列表里某个元素数量
a=['p1', 'p2', 'p3','p3']
print(a.count('p3'))
-----------返回2 ,2各p3
----------------------------------------------------------------------------------
10.加入新的列表
a=['p1', 'p2', 'p3','p3']
a.extend([1,2,3])
print(a)

结果 ['p1', 'p2', 'p3', 'p3', 1, 2, 3] ----extend是把新表里的每个元素加到原来的列表里
-------------------------------------------------------------------------------------
11.append,追加
a=['p1', 'p2', 'p3','p3']
a.append([1,2,3])
print(a)
结果 ['p1', 'p2', 'p3', 'p3', [1, 2, 3]],,append是把整个列表加到原来的列表里,整体作为列表的一个元素
------------------------------------------------------------------------------------------------------------------
12.指定删除 remove
a=['p1', 'p2', 'p3','p3']
a.remove('p1')
print(a) ------指定删除某个元素
13.排序 sort
a=['p1', 'p6', 'p9','p3']
a.sort()
print(a) -------从小到大排序,,,

a=['p1', 'p6', 'p9','p3']
a.sort(reverse=True) reverse是反转的意思
print(a)
------从大到小排序
---------------------------------------------------------------------
13.按原来的列表倒着排序

a=['p1', 'p6', 'p9','p3']
a.reverse()
print(a)
结果['p3', 'p9', 'p6', 'p1']
------------------------------------------------------------------------------------------
14.清空列表 clear
a=['p1', 'p6', 'p9','p3']
a.clear()
print(a)
结果 [] 清空列表,,
-------------------------------------------------------------------------------------
15.遍历出列表的每个元素
a=['p1', 'p6', 'p9','p3']
for i in range(len(a)) :
print(a[i])


结果--
p1
p6
p9
p3



元组的操作

定义:与列表类似,只不过[]改成()
特性:

1.可存放多个值
2.不可变
3.
按照从左到右的顺序定义元组元素,下标从0开始顺序访问,有序

元组常用操作

索引
切片
循环
长度
包含

1.计算元组里的每个元素个数 count
t=('p1', 'p6', 'p9','p3')
print(t.count('p9'))
---结果 为1 ,代表只有1个p9元素,
--------------------------------------------------------------
2.输出值的索引 index
t=('p1', 'p6', 'p9','p3')
print(t.index('p9'))
---结果 2 代表p9的索引为2,
-----------------------------------------------------------------
3.元组的元素输出,切片  
t=('p1', 'p6', 'p9','p3')
print(t[1])
print(t[3]) ----利用索引,

指定范围取值
t=('p1', 'p6', 'p9','p3')
print(t[1:3]) ---利用索引,也可以指定步长
print(t[3])
结果
('p6',)
p3
---------------------------------------------------------------------
4.求出元组的长度, 确定元素是否在元组内
t=('p1', 'p6', 'p9','p3')
print(len(t)) ---输出元组长度
print('p1' in t) ---身份确认
结果
4
True

----------------------------------------------------------------------------
5.关于元组元素的改动 ,元素里的列表元素可以改动,其他的都不能动
t=('p1', 'p6', 'p9','p3',[1,2])
t[4][0]=('a') -------------指定元组里列表的元素改为‘a’,是可以改的,其他不能改动,否则报错
print(t)
结果('p1', 'p6', 'p9', 'p3', ['a', 2])
--------------------------------------------------------------------------------


字典

dict={'key1':'value','key2':'value2'}
print(dict)
结果
{'key1': 'value', 'key2': 'value2'}
字典的有key,和value 组成,两者一一对应,
key必须是不可变的,是hash类型,数字,元组,字符串是可以作为key的,
value是可变的,

可以用hash()的方法,判断哪些可以作为key
print(hash('a'))
print(hash(2))
t=(1,2,3)
print(hash(t))


结果 ------不报错,都可以用作字典的key,
7486283456454968218
2
2528502973977326415
----------------------------------------------------------------------------------------------
字典没有索引,是无序的,通过key来取值,
1.通过key改值value
dict={'key1':'value','key2':'value2'}
dict['key1']='value3' ----------通过key1的建,赋给新的值value3,
print(dict)
结果
{'key1': 'value3', 'key2': 'value2'}
-------------------------------------------------------------------------------------------------
2.输出字典的key
dict={'key1':'value','key2':'value2'}

print(dict.keys())
结果 dict_keys(['key1', 'key2'])---不是列表
-----------------------------------------------------------------------------------
3.输出字典的value
dict={'key1':'value','key2':'value2'}

print(dict.values())
结果:dict_values(['value', 'value2'])--不是列表
--------------------------------------------------------------------------------------
4.遍历出字典的key 键,value,值,---------不通过索引的方式,输出key 和value
dict={'key1':'value','key2':'value2'}

for i in dict :
print(i,dict[i])
结果
key1 value
key2 value2
----------------------------------------------------------------------
5.get的使用
dict={'key1':'value','key2':'value2'}

print(dict.get('b')) ----即使‘b’不在dict的字典里用get的方法也不会报错
结果 None

如果不用get
dict={'key1':'value','key2':'value2'}

print(dict.('b'))
 
结果 直接报错
print(dict.('b'))
               ^
SyntaxError: invalid syntax
-----------------------------------------------------------------

总结
for,循环,对有索引的,有序的,可以遍历每个元素,适合列表,元组,字符串,

字典的查询速度快,没有索引,通过key,直接找到value,字典里存放的就是hash表,

比较容器类型
10000个用户信息,存在不同的类型容器里,查询速度,占用的内存空间是不一样的,
列表:通过索引取值,索引存放在内存里,没增加一个值,就扩大内存,
元组:不可变的,更省空间,
字典:字典里的hash表,比列表还大,但优化了查询速度,不用找无用的值,直接找 key ,
-----------------------------------------------------------------
字典的嵌套
 
 
-----------------------------------------------------------------------
关于布尔值
True False
每个数据类型都自带布尔值,0,None,空,为 False,其余都是True ,
while 1 :              ---1 为True.
cmd = input('>>: ')
if not cmd : ---cmd 输入为空,就是什么都不输入,直接回车,就是False ,not cmd 就是真,就继续输入,如果输入
continue
print('ok')

------------------------------------------------------------------------------------------------------------
集合

定义:由不同元素组成的集合,集合中是一组无序排列的可hash值,可以作为字典的key
特性:
1.集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值
取连个列表中相同的值

l1=[1,2,3,4]
l2=[1,5,6,3]
l3=[]
for i in l1 :
if i in l2 :
l3.append(i)
print(l3)
结果
[1, 3] ----------这是在做关系运算,

集合的作用就是做关系运算,两个集合之间的关系运算
set 集合,包含的元素没有重复的,,元素必须是不可变的,元组可以,列表不行,
集合也是无序的, 没有可以,没有索引
集合不能取值,
只能做两个集合之间的运算,没有取单个值的需求,可以用for循环遍历每个元素,

------
集合的关系运算
1.交集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 & s2)
结果
{1, 'a', 'b'}

2.求两个集合的所有元素,并集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 | s2) ------用 | 表示
结果
{1, 2, 'alex', 'b', 3, 'a'} ---去掉重复的部分的所有

3.输出s1不包含在s2的值,,反之,s2-s1,
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 - s2) ---减去相同的部分
结果
{2, 'alex'}
4.对称差集,两个集合自己独有的值,
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 ^ s2) -------- ^ 上肩号,在连个集合里都没有重复的值
结果{2, 3, 'alex'}
----------------------------------------------------------------------

用方法调用:
1.s1集合中没有s2 的值,相当于 s1 - s2
s1
={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.difference(s2))
结果
{2, 'alex'}
2. 交集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.intersection(s2))
结果
'b', 1, 'a'}
3.并集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.union(s2))
3.对称差集 ,除去两者集合相同的部分
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.symmetric_difference(s2))
结果
{2, 3, 'alex'}
---------------------------------------------------------------------------
5.把s1的值并给s2, updata
s1={'alex',1,2}
s2={1,'a','b'}
s1.update(s2)
print(s1) -----{1, 2, 'b', 'a', 'alex'} s2还是存在的
------------------------------------------------------------------------
6.添加元素 add
s1={'alex',1,2}
s2={1,'a','b'}
s1.add('aa')
print(s1) ----{1, 2, 'alex', 'aa'}
------------------------------------------------------------------------------
7. 删除集合元素 discard
s1={'alex',1,2}
s2={1,'a','b'}
s1.discard(2) -----------指定删除的元素 ,,如果删除集合里没有的,是不会报错的
print(s1) ---------{1, 'alex'}
---------------------------------------------
8.删除集合元素 remove
s1={'alex',1,2}
s2={1,'a','b'}
s1.discard(3) ------------指定删除,如果删除集合里没有的,会报错
print(s1)
-------------------------------------------------
9.删除集合元素 pop
s1={'alex',1,2}
s2={1,'a','b'}
s1.pop() ---- 不能指定元素,随机删除元素,有返回值
print(s1)
------------------------------------------------------------------
10. issubset,确定是否值子集
issupperset .确定是否是超级父集
isdijoint ,确定是否有交集

---------------------------------------------------------------------
11.关于字符串格式化

res="name%s" %'egon'
name的位置可以添加任意内容,
%s 可以跟数字和字符串
%d 只能跟数字
 
 

---------------------------------------------------------------------------


---------------------------------------------------------------------------------

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注