python 第五章 组合数据类型

除了字符串还有以下几种

5.1列表List

一段连续的空间储存

最灵活的序列类型。

没有长度限制，可以包含任意元素。

5.1.1创建列表

1.直接用[]创建

格式:

list_one=[]   #空列表

[]里的是列表元素，可以是整型，浮点，字符串等基本元素。也可以是列表，元组，字典等组合。

列表元素的类型可以相同也可以不同。元素间用，分割。

2.使用list()函数接收一个可迭代类型的数据，返回一个列表。

li_one=list(1)
li_tow=list('python')
li_three=list([1,'python'])
print(li_one,li_tow,li_three)

整数不是可迭代类型。

可迭代对象：

支持for……in……语句的对象就是可迭代对象。字符串和列表都是可迭代对象。

使用isinstance()函数可以判断目标是否为可迭代对象。

from collections.abc import Iterable
ls =[3,4,5]
print(isinstance(ls,Iterable))

3.列表中有算数、变量、函数

结果会打印出结果、变量内容、函数调用。

5.1.2访问列表元素

两种方式：切片和索引

1.以索引方式访问列表元素

格式：列表名[下标]

list[n]

双向索引，0-长度减一，或倒着-1-n

2.以切片方式访问列表元素

格式：列表名[始:终:步长]

不包括终

1. 在循环中访问列表元素

列表是可迭代对象

li_one =['p','y','t','h','o','n']
for li in li_one:
    print(li)

结果

这样就是只有一个元素

li_one =['p,y,t,h,o,n']
for li in li_one:
    print(li)

可以用in ，not in 查询列表元素

格式：

li=[1,2,3,4]
print (5 not in li)
print(5 in li)

3.访问列表中的列表

如果列表中的元素是一个列表可以对那个列表进行切片。

a=[1,2,3,4,5,6,7,8,['y','u','n',6,6,6]]
print(a[8][:3])

5.1.3添加列表元素

1. • append()

在列表末尾添加元素

格式：列表名.append（内容）

list_one =[1,2,3,4]
list_one.append(6)
print(list_one)

2. • extend()

在列表l1末尾添加另一个列表l2的所有元素

格式：l1.extend(l2)

3. • inster()

向l1的6号索引添加'6'

l1.inster(6,'6')

如果添加的索引大于数组的最大下标，就会自动添加到最后正数添加到最后

负数小于最小下标会添加到最前边

l1=['9','1']
l1.insert(6,'6')
print(l1)

l1=['9','1']
l1.insert(-9,'6')
print(l1)

5.1.4 元素排序

1. • sort()方法

特定顺序对列表元素排序。

sort(key=None,reverse=False)

key是排序规则，reverse是排序方式，升序降序

false升序（默认），true降序

sort排序后直接将原来的列表覆盖，不会产生新的列表

li.sort(key=len)

可以根据列表元素长度排序，默认升

2.sorted()

升序排序列表，产生一个新的列表

li_one=[4,3,2,1]
li_two=sorted(li_one)
print(li_one)
print(li_two)

3.reverse()

逆序：把原列表逆序排下

格式：

li_one=[4,3,2,1]
li_one.reverse()
print(li_one)

5.1.5删除列表元素

1. • del（）

删除列表中指定位置的元素

del li[n]

2. • remove（）

这里给出的是内容

删除某个元素，若有多个，仅仅删除第一个

3. • pop（）

这里给出的是索引号

删除某个元素如果没有指定，删除最后一个元素

会返回所删除的内容

4. • clear()

清空列表

格式：

li.clear()

删除后会变成空[]

5.1.6列表推导式

符和py语法规则的符合表达式，他能以简洁的方式根据已有的列表构建满足特定需求的列表。由于列表使用[]创建，列表推导式用于生成列表，所以推导式用[]括起来

格式：

[exp for x in list]

例子

li=[1,2,3,4,5]
ls=[data*data for data in li]
print (li)
print (ls)

1. • 带有if的列表推导式

格式

[exp for x in list if cond]

例子：输出大于1的

li=[1,2,3,4,5]
ls2 =[data for data in li if data>1]
print (li)
print(ls2)

结果

2嵌套for循环语句的列表推导式

在基本推导式的for后添加一个for语句

格式：

[exp for x in list_1 for y  in list_2]

从左到右分别是外层循环和内层循环

例子：

ls_one=[1,2,3]
ls_two=[3,4,5]
ls_three=[x+y for x in ls_one for y in ls_two]
print(ls_one)
print(ls_two)
print(ls_three)

他的执行顺序好像是第一个列表的第一个元素分别和第二个列表的每一个元素相加，然后再第一个列表的第二个元素和第二个列表的每一个元素相加，以此类推

3.带有if语句和嵌套for循环语句的列表推导式

列表推导式中嵌套的for循环可以有多个，每个循环也都可以与if语句连用，其语法格式如下：

[exp 
for x in list_1 [if cond]
for y in list_2[if cond]
for n in list_3 [if cond]
]

list_1='6'
list_2='6'
list_3='6'

l= [x+y+n for x in list_1 if x=='6'
       for y in list_2 if y=='6'
       for n in list_3 if n=='6']
print(l)

好像是起到了拼接作用

5.2元组Tuple

1.定义()

（可以存储任意类型的元素）

逗号隔开，个数类型不限制。

t1=()
t2=(1,)  #如果只有一个元素则不能省略后边的,
t3=(6,6,6)
t4=(6,(6,6,6))

使用函数tuple()也可以创建元组

函数参数为空时，表示创建空元组，含有可迭代对象时为创建非空元组。

与列表相同，元组支持索引和切片访问元组的元素，也可以在循环中遍历元组。

t3=(1,2,3,4,5,6,7,8)
print(t3[1])
print(t3[2:5])
for data in t3:
    print(data,end=' ')

注意：元组是不可变类型（元组的内容不可以改变），它不支持元素的增删查改和排序

其实圆括号可以省略不写

字符串的内容也不支持改变

列表和元组支持多个变量同时赋值,前提是必须满足个数

x,y=((1,2,3,4,5,6),2)
b,c=[[1,2,3,4,5,6],2]
print(x)
print(y)
print(b)
print(c)

5.3集合

集合本身是可变类型，但是py要求集合中的元素必需是不可变类型。

集合类型和列表元组的区别是:集合中的元素无序但是必须唯一。

1. • 创建集合

{}创建，元素间用逗号分隔开。（"{}"不能创建空集合，空集合只能用set()创建）

使用内置函数set()也可以创建集合

set()创建集合必须是可迭代对象

s1=set([1,2,3])
s2=set((4,5,6))
s3=set('python')
s4=set(range(5))
print(s1)
print(s2)
print(s3)
print(s4)

range(n):产生整数0~n-1

步长可以设置默认为1

2. • 集合常见操作

集合可以变，集合中的元素可以动态增加删除。

python中有内置方法可以更改。

add(x)     #向集合中添加元素x，x已经存在的话不做处理
remove(x)   #删除集合中的元素x，若不存在抛出KeyError异常
discard(x)   #删除集合中的元素x，若x不存在不做处理
pop()    #随即返回集合中的一个元素，同时删除该元素，若集合为空，抛出KeyError异常
clear()     #清空集合
copy()     #复制集合，返回值为集合
isdisjoint(T)     #判断集与集合T是否没有相同的元素，没有返回True，有则返回False

格式：集合名字.函数名

3.集合推导式

集合也可以利用推导式创建，集合推导式与列表推导式相似，区别在于集合推导式外侧为大括号"{}"

格式：

{exp for x in set if cond}

以上格式遍历可以是集合，或者其他可迭代对象。

利用集合推导式在列表ls的基础上生成只包含偶数元素的集合，示例代码如下。

ls=[1,2,3,4,5,6,7,8]
s={data for data in ls if data%2==0}
print(s)

5.4字典

以键值对组成，通过键快速查找值，（映射）

1. • 创建字典

字典和集合一样都是由"{}"括起来的，只是字典中是键值对，集合中是值。

字典中，每一个键值对为一个元素，元素间用”，“隔开。

没对键值通过”：“隔开

{键1:值1,键2:值2,键3:值3,键4:值4,键5:值5}

字典的值可以是任意的，但是键不能是列表或者字典类型。字典具有集合的特点：无序，键/值必须唯一。

(1)用{}可以直接创建字典

d1={}
d2={'a':123,'b':456}
d3={'a':'python'}

(2)用dict（）函数创建字典

d4=dict()
d5=dict({'a':123,'b':456})

2. • 字典的访问

1.字典的值用键来访问

格式如下：

字典变量[键]

d5=dict({'a':123,'b':456})
print(d5['a'])

如果是字符串也是全部输出，没有‘’

d5=dict({'a':123,'b':'python'})
print(d5['a'])
print(d5['b'])

2.通过函数get()访问

d.get(key[,default])

d5=dict({'a':123,'b':'python'})
print(d5.get('b'))

3.通过内置方法访问数据类型

keys()、values()、items()

格式：

字典名.函数名
不会自己输出，要print

返回类型是可迭代对象

dic={'name':'yun','age':20,'height':170}
print(dic.keys())
print(dic.values())
print(dic.items())

可以用for遍历

dic={'name':'yun','age':20,'height':170}
for key in dic.keys():
    print(key,end=' ')

3. • 字典元素的添加和修改

1.字典元素的添加

格式：

字典变量[键]=值

前提是不能存在某个键

dic={'name':'yun','age':20,'height':170}
dic['l']='666'
print(dic['l'])
print(dic)

2替换增加update()

dic={'name':'yun','age':20,'height':170}
dic['l']='666'
print(dic)
dic.update(l=6)
print(dic)

如果updata里的参数已经有就改变对应的值，如果没有，就添加

dic={'name':'yun','age':20,'height':170}
dic['l']='666'
print(dic)
dic.update(l2=6)
print(dic)

3.字典元素的删除

函数：pop()、popitem()、clear()

1. • pop()

dic={'name':'yun','age':20,'height':170}
print(dic.pop('name'))
print(dic)

注意里边的参数只能是键不能是值

2.popitem()

随机删除一个元素，之所以能随机删除是因为字典是无序的。若删除成功就返回被删除的元素。

格式

字典名字.popitem()

3.clear()

清空字典中的元素

格式

字典名字.clear()

4.字典推导式

用法和列表推导式类似

格式：

{new_key :new_value for key,value in dict.items()}

交换键值位置

dic={'name':'yun','age':20,'height':170}
new_dic={value:key  for key,value in dic.items()}
print(new_dic)

items()用来返回键和值（以可迭对象的形式）

5.5组合数据类型的运算符

1.”+“运算符

相当于拼接

格式：可以是字符串，列表，元组

print(s1+s2)

2.”*“运算符

将原来的元素以几倍的形式扩大

格式：可以是字符串，列表，元组

print(s1*6)

3.”in“、”not in“运算符

判断某个元素是否属于某个变量。字符串，列表，集合，元组，字典都支持

格式：

print(元素 in list)

存在返回真（true）否则为假（false）

not in 和in相反