列表、元组、字典、集合

列表(List)

一. 列表

1.列表介绍

　　列表是一种数据类型,由[ ]括起来,里面的元素由","隔开列表可以右增删修改查询的操作.列表里可以有数字,字符串,列表,元组,字典等不同类型的数据.

　　例如:lst = [12,"hello",["good","morning",26],("way","Jack"),{"element":"元素","roof":"房屋"},"computer","CPU"]

2.索引和切片

　　1) 索引

　　语法:lst[下标],和字符串一样.

lst = [12,"hello","way","Jack","element","roof","computer","CPU"]
print(lst[0]) #12
print(lst[1]) #hello
print(lst[2]) #way
print(lst[5]) #roof
print(lst[15]) #list index out of range 超出列表的范围,报错.

　　2) 切片

　　语法:lst[start:end:步数(int型)],从左往右切范围[:],从右往左切范围[-1:]. start是列表开始的下标,为空时表示从头开始切, end是列表中结束的下标,为空时表示切到尾(包括尾). 步数是每隔几个取一个,有方向,正的表示从左往右,负值表示从右往左.没有步数值时,默认从左往右获取.切片顾头不顾尾,取不到结束位置的元素,只能取到结束位置元素的前一个.

lst = [12, "hello", "way", "Jack", "element", "roof", "computer", "CPU"]
print(lst[0:1])       # [12]
print(lst[:])         # [12, 'hello', 'way', 'Jack', 'element', 'roof', 'computer', 'CPU']
print(lst[2::2])      # ['way', 'element', 'computer']
print(lst[2:-2:2])    # ['way', 'element']
print(lst[-2:-7:-3])  # ['computer', 'Jack']

二 .列表的增删改查

1. 增加

　　列表的增加操作有append(),insert(),extend()这三个方法,其中append()是用的最多.

　　append(): 在列表的后面直接增加元素

　　insert(): 在列表的指定位置插入元素

　　extend(): 迭代添加

 

lst = [12, "hello", "way", "CPU"]
lst.append("finish")
print(lst)  #lst变成 [12, 'hello', 'way', 'CPU', 'finish']
lst.insert(1,"world")
print(lst)  #"world"被插入下标为1的"hello"后面. [12, 'world', 'hello', 'way', 'CPU', 'finish']

lst1 = ["way", "Jack", "element", "roof", "computer"]
lst1.extend("你真棒")
print(lst1)  #['way', 'Jack', 'element', 'roof', 'computer', '你', '真', '棒']
lst1.extend(["你真棒"])
print(lst1)  #['way', 'Jack', 'element', 'roof', 'computer', '你', '真', '棒','你真棒']

2. 删除

pop(索引下标):删除指定位置的元素,没有给值时,默认删除最后一个元素.

remove(): 删除指定元素.

clear(): 清空列表

del lst[start:end:步数 ]:切片删除

lst1 = ["way", "Jack", "element", "roof", "computer"]
lst1.pop(2)
print(lst1)  #删除所以下标为2的"element"

lst2 = [12, "hello", "way", "CPU"]
lst2.remove("way")
print(lst2)  #[12, 'hello', 'CPU']
# lst2.remove("way")
print(lst2)  #找不到"way",所以报错

lst3 = ["well","good","better","best"]
del lst3[0:2]
print(lst3)  #['better', 'best']

lst1.clear()
lst2.clear()
lst3.clear()
print(lst1)  #[]
print(lst2)  #[]
print(lst3)  #[]

3. 修改

 　　索引切片修改

lst1 = ["way", "Jack", "element", "roof", "computer"]
lst1[1] = "Tom"
print(lst1)  #['way', 'Tom', 'element', 'roof', 'computer']

lst2 = [12, "hello", "way", "CPU"]
lst2[1:4:2] = ["iPhone","Android"] 
#步数为2指每隔两个取一个,[1:4]里可取"Jack","roof"两个元素,修改的元素也要为两个.
print(lst2)  #[12, 'iPhone', 'way', 'Android']

4. 查询

 列表是一个可迭代对象, 所以可以进行for循环

lst1 = ["way", "Jack", "element", "roof", "computer"]
for c in lst1: #把lst1的元素赋给c
    print(c)
# way
# Jack
# element
# roof
# computer

 5. 其他操作

lst1 = ["way", "Jack", "element", "roof", "computer","roof"]
print(lst1.count("roof"))  #2
print(lst1.count("way"))   #1
lst1.reverse()  #表示翻转,元素从后往前排列
print(lst1)  #['roof', 'computer', 'roof', 'element', 'Jack', 'way']

lst4 = [5,9,2,18,11,15,6]
lst4.sort()  #升序
print(lst4)  #[2, 5, 6, 9, 11, 15, 18]
lst4.sort(reverse = True)  #降序
print(lst4)  #[18, 15, 11, 9, 6, 5, 2]
print(len(lst4))  #7 求列表长度

三 .列表的嵌套

 降维操作,先当做一层来看

lst = ["roof", "computer", ["way", "Jack",["computer","roof"] ,"element"]]
print(lst[2][2][0])  #computer

lst[2][1] = lst[2][1].lower()  
#把Jack全小写,注意改变了字符串"Jack"的值,因为字符串本身不可变,所以要赋值给lst[2][1]
print(lst)  #['roof', 'computer', ['way', 'jack', ['computer', 'roof'], 'element']]

lst[1] = "CPU"
print(lst)  #['roof', 'CPU', ['way', 'jack', ['computer', 'roof'], 'element']]

元组(Tuple)

一 .元组和元组嵌套

　　元组: 俗称不可变的列表.⼜又被成为只读列表, 元组也是python的基本数据类型之一, ⽤用⼩小括 号括起来, 里面可以放任何数据类型的数据,  查询可以. 循环也可以. 切片也可以. 但就是不能改.用()括起来,元素用逗号,隔开.元组中只有一个元素时要添加逗号,否则不是元组.例如: (1,)

1. 索引和切片

tu = ("way", "Jack", "element", "roof", "computer")
print(tu [2])  #element
print(tu[1:4])  #('Jack', 'element', 'roof') 切片过后还是元组.

2 .遍历元组

tu = ("way", "Jack", "element", "roof", "computer")
for c in tu:
    print(c)
# way
# Jack
# element
# roof
# computer

3.修改元组

tu = ("way", "Jack", "element",[], "roof", "computer")
tu[1] = "Tom"
print(tu)  #无法修改,结果报错.

tu[1] = tu[1].replace("Jack","Tom")
print(tu)  #无法修改,报错.

tu[3].append("because")
print(tu)  #('way', 'Jack', 'element', ['because'], 'roof', 'computer')

五.range

　　 range可以帮我们获取到一组数据. 通过for循环能够获取到这些数据.

for c in range(5):  #从0数到4
    print(c)  #从0打印到4
# 0
# 1
# 2
# 3
# 4

for c in range(15,3,-2):  #从15数到2,每隔两个取一个
    print(c)  #从15到2,每隔两个打印一个
# 15
# 13
# 11
# 9
# 7
# 5

字典(Dict)

一. 字典的简单介绍

　　字典是{}括起来的键值对组成dict = {key1:value1,key2:value2,...}. 在dict中key是唯一的. 在dict中的key必须是不可变的. dict保存的数据不是按照我们添加进去的顺序保存的.

dic = {"one":1, "two":2, "three":3}
dic["four"] = 4  #把"four":4添加进字典
print(dic)  #{'one': 1, 'two': 2, 'three': 3, 'four': 4}.  

dic = {["work","job"]:"long"}
print(dic)  #TypeError: unhashable type: 'list'  list是可变的不能作为key

二. 字典的增删改查和其他操作

1. 增加

dic = {"one":1, "two":2, "three":3}
dic["four"] = 4  #把"four":4添加进字典
print(dic)  #{'one': 1, 'two': 2, 'three': 3, 'four': 4}.

dic = {"one":1, "two":2, "three":3}
dic["two"] = "二"  #当key重复时,会更新value的值
print(dic)  #{'one': 1, 'two': '二', 'three': 3}

dic = {"one":1, "two":2, "three":3}
dic.setdefault("five",5) #把key值为"five",value值为5.添加到dic字典里
print(dic)  #{'one': 1, 'two': 2, 'three': 3, 'five': 5}
dic.setdefault("six",6)
print(dic)  #{'one': 1, 'two': 2, 'three': 3, 'five': 5,'six': 6}
dic.setdefault("six",7)  #已经有key值为"six",所以此次不存储
print(dic)  #{'one': 1, 'two': 2, 'three': 3, 'five': 5, 'six': 6}

2.删除

　　pop(key)       通过key值删除,删除一个元素. 返回这个元素的value值

　　del dic[key]   通过key值删除

　　popitem()      随机删除,删除一个元素. 返回一个元组

　　clear()           清空字典

dic = {"one":1, "two":2, "three":3}
ret = dic.pop("two")  #删除key值为"two"的元素
print(dic)  #{'one': 1, 'three': 3}
print(ret)  #2 key值为"two"的value为2 

dic = {"one":1, "two":2, "three":3}
del dic["one"]
print(dic)  3{'two': 2, 'three': 3}

dic = {"one":1, "two":2, "three":3}
a = dic.popitem()
print(a)  #('three', 3)  返回的是一个元组
print(dic)  #{'one': 1, 'two': 2}

dic = {"one":1, "two":2, "three":3}
dic.clear()
print(dic)  #{}

3. 修改

 　　update()是更新的意思,可以在两个字典里,把一个字典的元素更新到另一个字典里.不同的key值,直接把元素添加到另一个字典中,若有相同的key值,则把value值覆盖.达到了修改的作用.

dic1 = {"one": 1, "two": 2, "three": 3, "four": "四"}
dic2 = {"one": "一", "four": 4, "five": 5, "two": "二"}
dic3 = {"five": "五", "six": "六", "seven": 7}
dic1.update(dic2)
dic2.update(dic3)
dic3.update(dic2)
print(dic1)  #{'one': '一', 'two': '二', 'three': 3, 'four': 4, 'five': 5}
print(dic2)  #{'one': '一', 'four': 4, 'five': '五', 'two': '二', 'six': '六', 'seven': 7}
print(dic3)  #{'five': '五', 'six': '六', 'seven': 7, 'one': '一', 'four': 4, 'two': '二'}

4.查询

　　可以直接查询dic[key],也可以用get(key)和setdefault(key,value).

dic1 = {"one": 1, "two": 2, "three": 3, "four": "四"}
print(dic1["four"])  #四
print(dic1.get("on"))  #None  找不到key值,返回None,也可以自己设置返回值dic1.get(key,返回值).
ret = dic1.setdefault("five",5)
print(dic1)  #{'one': 1, 'two': 2, 'three': 3, 'four': '四', 'five': 5}
print(ret)  #5

 5. 其它相关操作

　　keys()    打印出所有的key值

　　values() 打印出所有的value值

　　items()   打印出所有键值对.

dic = {"name":"tom","sex":"male","age":25,"job":"actor"}
print(dic.keys())  #dict_keys(['name', 'sex', 'age', 'job'])  高仿列表,不是列表
for c in dic.keys():
    print(c)
# name
# sex
# age
# job

dic = {"name":"tom","sex":"male","age":25,"job":"actor"}
print(dic.values())  #dict_values(['tom', 'male', 25, 'actor'])
for c in dic.values():
    print(c)
# tom
# male
# 25
# actor

dic = {"name":"tom","sex":"male","age":25,"job":"actor"}
print(dic.items())  #dict_items([('name', 'tom'), ('sex', 'male'), ('age', 25), ('job', 'actor')])
for c in dic.items():
    print(c)
    # ('name', 'tom')
    # ('sex', 'male')
    # ('age', 25)
    # ('job', 'actor')
    print(c[0])  #打印元组c的第一个元素
    print(c[1])  #打印元组c中的第二个元素

key,value = ("name", "tom")
print(key)  #name
print(value)  #tom
#key,value对应name,tom,我们key把上面for循环的c直接换成key,value
for key,value in dic.items():
    print(key,value)
# name tom
# sex male
# age 25
# job actor

三. 字典的嵌套

　　字典的嵌套是通过找key值来打印出value值,先从最外层找起.

dic = {"time":8,"place":"park","people":{"name":"tom","sex":"male","age":20}
    ,"food":{"China":"rice","America":"steak","Britain":"tea"}}

print(dic["people"]["sex"])  #male
print(dic["food"]["Britain"])  #tea 

集合(Set)

　　set集合是python的一个基本数据类型. 一般不是很常⽤用. set中的元素是不重复的.无序的.里面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但是不保存value, 只保存key. set也用{}表示.

　　 注意: set集合中的元素必须是可hash的, 但是set本身是不可hash得. set是可变的

s = {123, {1,2,3}}    
print(s)  # 不合法 TypeError: unhashable type: 'set'

1. set集合的增删改查

　　(1) 增加

s = {'an','empty','street'}
s.add('sky')
print(s)  #{'sky', 'an', 'empty', 'street'}

s = {'an','empty','street'}
s.update('sea')  #迭代添加
print(s)  #{'s', 'a', 'e', 'street', 'an', 'empty'}

s = {'an','empty','street'}
s.update(['sea'])
print(s)  #{'an', 'street', 'sea', 'empty'}

　　(2) 删除

s = {'an','empty','street'}
ret = s.pop()  #随机删除
print(ret)  #返回删除的元素:empty
print(s)  #{'street', 'an'}

s = {'an','empty','street'}
s.remove('an')  #删除指定元素
print(s)  #{'empty', 'street'}
s.remove('one')  #没有one这个元素,会报错

s = {'an','empty','street'}
s.clear()
print(s)  #set()

　　(3) 修改 

　　set集合中的数据没有索引,也没有办法去定位一个元素.所以没有办法进行直接修改,我们可以采用先删除后添加的方式来完成修改操作.

s = {'an','empty','street'}
s.remove('an')  #先删除'an'
s.add('one')  #再添加'one'
print(s)  #{'one', 'empty', 'street'}

　　(4) 查询 

　　 set是一个可迭代对象. 所以可以进行for循环

s = {'an','empty','street'}
for c in s:
    print(c)
# an
# empty
# street

2. 常用操作

s1 = {'an','empty','street'}
s2 = {'the','empty','house'}
#交集
print(s1 & s2)  #{'empty'}
#并集
print(s1 | s2)  #{'an', 'the', 'house', 'empty', 'street'}
#差集
print(s1 - s2)  #{'an', 'street'}
# 反交集
print(s1 ^ s2)  #{'an', 'street', 'house', 'the'}

set集合本身是可以发生改变的.是不可hash的. 我们可以使用frozenset来保存数据. frozenset是不可变的. 也就是一个可哈希的数据类型.

s = frozenset({'an','empty','street'})
dic = {'hello':s}
print(dic)  #{'hello': frozenset({'empty', 'street', 'an'})}