python列表元组集合字典_python学习笔记5：列表-元组-集合-字典

list列表

一组有顺序的数据的组合,可进行增删改查

赋值操作

ls = list() ,ls = []

下标从0开始，最后一个数可使用-1访问，依次类推

可使用其切片操作[:],反序排列[::-1]

进行切片和copy()后的新list的ID原id不一致，其他方法：

赋值\append\del\等id和原list一致

赋值操作是传址，copy是传值

常用函数 del ls[2]：删除，

可以将列表乘一个整数，表示多个列表链接在一起

a = ['a',2,3,4,5]

b= 2

c = a *b

print(c)

#输入结果如下

['a', 2, 3, 4, 5, 'a', 2, 3, 4, 5]

双层列表循环和dict 用法一致，要求每个列表只有两个值：for k,v in ls:

列表内涵：快速建立列表

a = [x for x in range(1,35)] #生成从1到34的一个列表

# 把a中所有偶数生成一个新的列表 b

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

print(b)

#..

c = [ m+n for m in a for n in b if m+n < 250]

print(c)

通用函数：len,min,max，其他类型也通用的函数

append:在末尾添加，insert(index,data):在index前面插入

pop()弹出最后一个,返回值的弹出的数据.

remove:在列表中删除指定的值的第一个元素

clear：清空列表，id 不变

reverse():反转

extend 扩展列表 a =[1] b=[2] a.extend(b) a== [1,2]

count():统计某个数据出现的次数

copy属于浅拷贝，即只是拷贝一层

# 深拷贝跟浅拷贝的区别

# 出现下列问题的原因是，copy函数是个浅拷贝函数，即只拷贝一层内容

# 深拷贝需要使用特定工具

a = [1,2,3, [10, 20, 30]]

b = a.copy()

print(id(a))

print(id(b))

print(id(a[3]))

print(id(b[3]))

a[3][2] = 666

print(a)

print(b)

#输出结果如下：

140249408365768

140249409236040

#a[3] 和b[3] id一致，说明还是指向同一地址

140249409236232

140249409236232

[1, 2, 3, [10, 20, 666]]

[1, 2, 3, [10, 20, 666]]

元组-tuple

元组可看成是不可更改的list

特性：

是序列表，有序

元组数据值可以访问，不能修改和删除，指的是内容不可修改，参考下例

元组数据可以是任意类型

list所有特性，除了可修改外，元组都具有

也就是说，list具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等，一模一样

# 元组相加

t1 = (1,2,3)

t2 = (5,6,7)

# 传址操作

print(t1)

print(id(t1))

t1 = t1 + t2

print(t1)

print(id(t1))

# tuple 的不可修改，指的是内容的不可修改

# 修改和删除tuple内容会导致报错

t1[1] = 100

del(t1[2])

#元组相乘

t2 =t2 *2

集合 -set

集合是高中数学中的一个概念

一堆确定的无序的唯一的数据，集合中每一个数据成为一个元素

特性：

集合内数据无序，即无法使用索引和分片

集合内部数据元素具有唯一性，可以用来排除重复数据

集合内的数据，str, int, float, tuple,冰冻集合等，即内部只能放置可哈希数据

集合的内涵

如果定义时有重复数据则自动过滤重复数据

s = {3,1,2,3,4,3,2,3,1,2,4,3}

s == {1,2,3,4}

# 多循环的集合内涵

s1 = {1,2,3,4}

s2 = {"i", "am", "stu"}

s = {m*n for m in s2 for n in s1}

print(s)

s = {m*n for m in s2 for n in s1 if n ==2}

print(s)

集合的函数

add(),添加数据

copy()，拷贝

remove:移除指定的值，直接改变原有值，如果要删除的值不存在，报错 : s.remove(1)

discard:移除集合中指定的值，跟remove一样，但是入股要删除的话，不报错:s.discard(1)

pop 随机弹出一个元素

集合函数

# intersection: 交集

# difference:差集 等于s1 -s2

# union: 并集

# issubset: 检查一个集合是否为另一个子集

# issuperset: 检查一个集合是否为另一个超集

s1 = {1,2,3,4,5,6}

s2 = {5,6,7,8,9}

s_1 = s1.intersection(s2)

print(s_1)

s_2 = s1.difference(s2)

print(s_2)

s_3 = s1.issubset(s2)

print(s_3)

fronzenset:冰冻集合

一种特殊集合：不可以进行任何修改的集合

s = frozenset()

字典-dict

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

创建：

# 创建有值的字典， 每一组数据用冒号隔开， 每一对键值对用逗号隔开

d = {"one":1, "two":2, "three":3}

print(d)

d = dict({"one":1, "two":2, "three":3})

print(d)

# 利用关键字参数

d = dict(one=1, two=2, three=3)

print(d)

#

d = dict( [("one",1), ("two",2), ("three",3)])

print(d['one'])

特性：

字典是序列类型，但是是无序序列，所以没有分片和索引

字典中的数据每个都有键值对组成，即kv对

key: 必须是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行

value: 任何值

字典常用访问

d = {"one":1, "two":2, "three":3}

# 使用for循环，直接按key值访问

for k in d:

print(k, d[k])

# 上述代码可以改写成如下

for k in d.keys():

print(k, d[k])

# 只访问字典的值

for v in d.values():

print(v)

# 注意以下特殊用法

for k,v in d.items():

print(k,'--',v)

字典常用函数

keys():返回字典的键组成的一个结构

values():返回字典的值组成的一个结构

items():返回字典的键值对组成的元组格式

get():根据指定键返回相应的值， 可以设置默认值

d.get('one',100)

fromkeys 使用指定的序列作为键，使用一个值作为字典的所有的键的值

l = ["eins", "zwei", "drei"]

# 注意fromkeys两个参数的类型

# 注意fromkeys的调用主体

d = dict.fromkeys(l, "hahahahahah")

print(d)