双层列表循环变异
#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)
给每个键赋予同一个值