7-内置数据结构

双层列表循环变异

#a 为嵌套列表，或者叫双层列表
a=[['one',1],['two',2],['three',3]]
for k,v in a:
	print(k,'--',v)

列表内涵：list content

• 通过简单方法创作列表

#for 创建
a=['a','b','c']
#用list a 创建一个list b
#下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i for i in a]
print(b)

#过滤
a = [x for x in range(1,35)]

b=[m for m in a if m % 2 == 0]
print(b)

#列表生成式可以嵌套
a = [i for i in range(1,4)]
print(a)

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)
	
#相当于
for m in a:
	for n in b:
		print(m+n, end="   ")
print()

#嵌套的列表生成式也可以用条件表达式
c = [ m+n for m in a for n in b if m+n < 250]
print(c)

关于列表的常用函数

# len：求列表长度
# max：求列表中最大值
# list：将其他格式的数据转换成list
# 把range产生的内容转换成list
print(list(range(10,30)))

'''
# append 插入一个内容，在末尾追加
'''
a = [ i for i in range(1,5)]
print(a)
a.append(100)
print(a)

'''
# insert：指定位置插入
# insert(index,data),插入位置是index前面
'''
print(a)
a.insert(3,666)
print(a)

'''
# del 删除
# pop，从对位拿出一个元素，即把最后一个元素取出来
'''
print(a)
last_ele =a.pop()
print(last_ele)
print(a)

'''
# remove：在列表中删除指定的值得元素
# 如果被删除的值没在list中，则报错
'''
print(a)
print(id(a))
a.remove(666)
print(a)
print(id(a))
# 输出两个id值一样，说明，remove操作是在原list直接操作

# clear：清空
print(a)
print(id(a))
a.clear()
print(a)
print(id(a))
'''
# 如果不需要列表地址保持不变，这清空列表可以使用以下方式
# a = list()
# a = []
'''

# reverse：翻转列表内容，原地翻转（地址不变）
a = [ 1,2,3,4,5]
print(a)
print(id(a))

a.reverse()

print(a)
print(id(a))

# extend：扩展列表，两个列表，把一个直接拼接到后一个上
a = [1,2,3,4,5]
b = [6,7,8,9,10]
print(a)
print(id(a))

a = extend(b)

print(a)
print(id(a))
'''
#地址不变
'''

# count：查找列表中指定值或元素的个数
a = [i for i in range(1,11)]
print(a)
a.append(8)
print(a)
a.insert(4,8)
print(a)
a_len=a.count(8)
print(a_len)
#8的个数

# copy：拷贝，浅拷贝
'''
list的简单赋值操作，都是传地址
'''
# 解决以上问题，list赋值需要采用copy函数
b = a.copy()
b[3]=888
'''
copy函数是一个浅拷贝函数，即只拷贝一层内容
深拷贝需要使用特定工具
'''

元组

元组的特性

• 有序列表
• 元组数据可以访问，不能修改
• 元组数据可以是任意类型
• 总之，list所有特性，除了不可修改外，元组都具有
• list具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等

#索引操作
t = (1,2,3,4,5)
print(t[3])

#超标操作
print(t[12])

'''
tuple不可修改，指的是内容不可修改
修改tuple内容会导致报错
'''

#元组的遍历
#单层元组遍历
t = (1,2,3,4,5,6)
for i in t:
    print(i,end=" ")
#双层元组遍历
t=((1,2,3),(4,5,6),(7,8,9))
for k,m,v in t:
    print(k,"--",m,"--",v)

元组变量交换法

两个变量交换值
a = 1
b = 2
a,b=b,a

集合-set

• 集合是高中数学中的一个概念
• 一堆确定的无序的唯一的数据，集合中每一个数据成为一个元素

# 集合的定义 
s = set()

集合的特征

• 集合内数据无序，即无法使用索引和分片
• 集合内部数据元素具有唯一性，可以用来排除重复数据
• 集合内的数据，str,int,float,tuple,冰冻集合等，即内部只能放置可哈希数据

集合的内涵

#普通集合内涵
s = {22,323,412,554,3,76,23,213,32,32}
print(s)

ss = {i for i in s}
print(ss)

#带条件的集合内涵
sss = {i for i in s if i % 2 == 0}
print(sss)

# set：生成一个集合
l = [1,2,3,4,5,6]
s = set(l)
print(s)

# add：向集合内添加元素
s = {1}
s.add(334)
print(s)

# copy：拷贝
# remove：移除指定的值，直接改变原有值，如果要删除的值不存在，报错
# discard：移除集合中指定的值，跟remove一样，值不存在，不报错

• 集合函数
  • intersection：交集
  • difference：差集
  • union：并集
  • issubset：检查一个集合是否为另一个子集
  • issuperset：检查一个集合是否为另一个超集

s_1 = s1.difference(s2)
相当于
s_1 = s1 - s2

frozen set：冰冻集合

• 冰冻集合就是不可以修改的集合
• frozeset是一种特殊集合

#创建
s = frozenset()
print(s)

字典

• 字典是一种组合数据，没有顺序的组合数，数据以键值对形式出现

# 创建
d = {}
d = dict()
d = {"one":1,"two":2,"three":3}
d = dict({"one":1,"two":2,"three":3})
d = dict(one=1,two=2,three=3)
d = dict([("one",1),("two",2),("three",3)])

字典的特征

• 字典是序列类型，但是是无序序列，所以没有分片和索引
• 字典中的数据每个都有键值对组成，即kv对
  • key：必须是可哈希的值，比如int，string但是，list，set，dict不行
  • value：任何值

字典常见操作

# 访问数据
d = {"one":1,"two":2,"three":3}
#中括号内是键值
print(d["one"])

d["one"] = "eins"
print(d)

# 删除
del d["one"]

# 成员检测，in,not in
# 成员检测的是key内容

字典生成式

d = {"one":1,"two":2,"three":3}
dd = {k:v for k,v in d.items()}
print(dd)

# 加限制条件的字典生成式
dd = {k:v for k,v in d.items() if v % 2 ==0}

字典相关函数

# 通用函数：len ，max,min,dict
# str(字典)：返回字典的字符串格式

# clear：清空字典
# items：返回字典的键值对组成的元组格式
i = d.items()

# keys：返回字典的键组成的一个结构
k = d.keys()

# values：一个可迭代对的结构
v = d.values()

# get：根据指定键返回相应的值，可以设置默认值
print(d.get("one"))
存在返回1，不存在返回none
 print(d.get("one",100))
存在返回1，不存在返回100

# fromkeys：使用指定的序列作为键，使用一个值作为字典的所有键的值
l = ['eins','zwei','drei']
d = dict.fromkeys(l,'jjc')
print(d)
给每个键赋予同一个值