Python复习(四)-内置数据结构

内置数据结构(变量类型)

  • list
  • set
  • dict
  • tuple

list(列表)

  • 一组由顺序的数据的组合
  • 创建列表

    • 空列表
# 空的列表
list1 = []
print(type(list1))
print(list1)
print("- " * 15)

list2 = [1, 2, 3]
print(type(list2))
print(list2)
print("- " * 15)

list3 = list()
print(type(list3))
print(list3)
<class 'list'>
[]
- - - - - - - - - - - - - - - 
<class 'list'>
[1, 2, 3]
- - - - - - - - - - - - - - - 
<class 'list'>
[]

列表常用操作

  • 访问

    • 使用下标操作(索引)
    • 列表的位置是从0开始
  • 分片操作

    • 对列表进行任意一段的截取
    • l[:]
l = [1, 2, 3, 4]
print(l[0])
print(l[2])
print(l[-1])

# 分片操作 包含左边的下标值,不包含右边的下标值
print(l[1:2])
# 下标值可以为空,如果不写,左边下标值默认为0, 
# 右边下标值为最大数加一,即表示截取到最后一个数据
print(l[:])
print(l[:2])
print(l[2:])
1
3
4
[2]
[1, 2, 3, 4]
[1, 2]
[3, 4]
l = [1, 2, 3, 4, 5, 6, 7]
print(l)
# 分片可以控制增长幅度,默认增长幅度为1
print(l[1:6:1])

print(l[1:6:2])
# 下标可以超出范围,超出后不在考虑多余下标内容
print(l[3:10])

# 下标值,增长幅度可以为负数
# 为负数,表明顺序是从右往左
# 规定: 数组最后一个数字的下标是-1

# 下面显示的是为空,因为默认分片总是从左向右截取
# 即正常情况,分片左边的值一定小于右边的值
print(l[-2:-4]) # 空

print(l[-4:-2])

# 列表反转
print("- " * 20)
print(l)
print(l[::-1])
# 字符串也可以分皮
Name = "Taoy"
print(Name[0:3])
[1, 2, 3, 4, 5, 6, 7]
[2, 3, 4, 5, 6]
[2, 4, 6]
[4, 5, 6, 7]
[]
[4, 5]
- - - - - - - - - - - - - - - - - - - - 
[1, 2, 3, 4, 5, 6, 7]
[7, 6, 5, 4, 3, 2, 1]
Tao

分片操作是生成一个新的list

  • 内置函数id,负责显示一个变量或者数据的唯一确定编号
l = [1, 2, 3, 4]
ll = l[:]
lll = ll
print(id(l))
print(id(ll))
print(id(lll))
2888176581512
2888175471944
2888175471944

List(列表)

  • del: 删除命令
# del 删除
l = [1, 2, 3, 4, 5]
del l[1]
print(l)
[1, 3, 4, 5]
# del 删除 
# 如果使用del之后,id的值和删除前不一样,则说明删除生成了一个新的list
# 下列例子说明,del删除不是生成一个新的列表
l = [1, 2, 3]
print(id(l))
del l[1]
print(id(l))
print(l)
2888176581704
2888176581704
[1, 3]
# del一个变量后不能在继续使用此变量
a = 'Taoy'
del a
print(a)
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-32-9d2c5289f387> in <module>
      2 a = 'Taoy'
      3 del a
----> 4 print(a)
NameError: name 'a' is not defined
# 使用加号连接两个列表
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)
[1, 2, 3, 4, 5, 6]
# 使用 乘号操作列表
a = [8, 9]
b = a * 3
print(b)
[8, 9, 8, 9, 8, 9]
# 成员资格运算
# 判断一个元素是否在列表中
a = [1, 2, 3]
b = 3
c = 5
print(b in a)
print(c in a)
# not in
print(c not in a)
True
False
True

列表的遍历

  • for
  • while
a = [1, 2, 3]
for i in a:
    print(i)
1
2
3
for i in range(0,len(a)):
    print(a[i])
    i += 1
1
2
3
# while 访问list
a = [4, 5, 6]
length = len(a)
i = 0
while i < length:
    print(a[i])
    i += 1
4
5
6
# 双层列表循环
a = [["one", 1], ["Two", 2], ["Three", 3]]
for k,v in a:
    print(k,"---", v)
one --- 1
Two --- 2
Three --- 3
# 双层列表中,内层的每一个数量要相等
a = [["one", 1], ["Two", 2], ["Three", 3, 4]]
for k,v in a:
    print(k,"---", v)
one --- 1
Two --- 2
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-45-54ba0d21f1d4> in <module>
      1 # 双层列表中,内层的每一个数量要相等
      2 a = [["one", 1], ["Two", 2], ["Three", 3, 4]]
----> 3 for k,v in a:
      4     print(k,"---", v)
ValueError: too many values to unpack (expected 2)
# 双层列表循环变异
a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
#这个例子说明,k,v,w的个数应该跟解包出来的变量个数一致
for k,v,w in a:
    print(k, "--", v, "--",w)
one -- 1 -- eins
two -- 2 -- zwei
three -- 3 -- drei

列表内涵: list content

  • 通过简单方法创作列表
a = [i for i in range(5)]
print(a)
# 元素都乘 10
b = [i * 10 for i in range(5)]
print(b)
[0, 1, 2, 3, 4]
[0, 10, 20, 30, 40]
# 1- 31 偶数列表
a = [i for i in range(1,32) if i % 2 == 0]
print(a)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
# 列表生成式可以嵌套
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 = [ i + j for i in a for j in b]
print(c)
# 上面代码等价
for i in a:
    for j in b:
        print(i + j, end=" ")
print()

d = [i +j for i in a for j in b if i+j < 300]
print(d)
[1, 2, 3]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
101 201 301 102 202 302 103 203 303 
[101, 201, 102, 202, 103, 203]

关于列表常用的函数

# len():求列表长度
l = [1, 2, 3, 5]
print(len(l))
# max(): 求列表中最大值
# min(): 求列表中最小值
print(max(l))
print(min(l))
4
5
1
a = 1,2,3
print(a)
print(list(a))
(1, 2, 3)
[1, 2, 3]
Url = "https://www.betao.cn"
print(Url)
print(list(Url))
https://www.betao.cn
['h', 't', 't', 'p', 's', ':', '/', '/', 'w', 'w', 'w', '.', 'b', 'e', 't', 'a', 'o', '.', 'c', 'n']
# 使用 range 产生一个新的列表
print(list(range(1,10)))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
# append 插入一个内容
a = [i for i in range(4)]
print(a)
a.append(100)
print(a)
[0, 1, 2, 3]
[0, 1, 2, 3, 100]
# insert(index, data): 制定位置插入,插入的位置是 index 前面
print(a)
a.insert(2,200)
print(a)
[0, 1, 2, 3, 100]
[0, 1, 200, 2, 3, 100]
# 删除
# del 删除, pop 把最后一个元素取出来
a = [i for i in range(4)]
print(a)
b = a.pop()
print(b)
print(a)
[0, 1, 2, 3]
3
[0, 1, 2]
# remove:在列表中删除指定的值的元素 , 如果被删除的值不再list, 则报错
a = [i for i in range(4)]
print(a)
print(id(a))
a.remove(1)
print(a)
print(id(a))
# id值一样,说明,remove 实在原list上直接操作
[0, 1, 2, 3]
2888177085128
[0, 2, 3]
2888177085128
# clear 清空
a = [i for i in range(4)]
print(a)
print(id(a))
a.clear()
print(a)
print(id(a))
# 上例清空地址保持不变

# 如果地址需要改变,可用以下方式清空
# a = list()
# a = []
# 二选一
[0, 1, 2, 3]
2888177085448
[]
2888177085448
# reverse: 翻转列表内容
a = [i for i in range(4)]
print(a)
print(id(a))
a.reverse()
print(a)
print(id(a))
# 也可以使用分片反转 a[::-1]
[0, 1, 2, 3]
2888177103816
[3, 2, 1, 0]
2888177103816
# extend:扩展列表,两个列表,把一个直接拼接到后一个上
a = [i for i in range(4)]
print(a)
print(id(a))
b = [4, 5, 6]
a.extend(b)
print(a)
print(id(a))
# 也可以直接加起来  a = a + b
a = [i for i in range(4)]
b = [4, 5, 6]
a += b
print(a)
[0, 1, 2, 3]
2888177166472
[0, 1, 2, 3, 4, 5, 6]
2888177166472
[0, 1, 2, 3, 4, 5, 6]
# count:查找列表中指定值或元素的个数
a = [i for i in range(4)]
print(a)
a.append(2)
print(a)
print(a.count(2))
[0, 1, 2, 3]
[0, 1, 2, 3, 2]
2
# copy: 拷贝,此函数是浅拷贝,
a = [i for i in range(4)]
print(a)
b = a
print(id(a))
print(id(b))
# list类型,简单赋值操作,是传地址
print("- " * 20)
# 解决以上问题, 我们需要使用copy 函数
b = a.copy()
print(id(a))
print(id(b))
a.append(4)
print(a)
print(b)
[0, 1, 2, 3]
2888176953928
2888176953928
- - - - - - - - - - - - - - - - - - - - 
2888176953928
2888174553480
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
# 深拷贝跟浅拷贝
a = [1, 2, 3, [10, 20, 30]]
b = a.copy()
print(id(a))
print(id(b))
print("- " * 15)
print(id(a[3]))
print(id(b[3]))
# 地址相同???
print("- " * 15)
# 结局以上问题, 使用copy模块即可
import copy
a = [1, 2, 3, [10, 20, 30]]
b = copy.deepcopy(a)  #这里不一样哦
print(id(a))
print(id(b))
print('- ' * 15)
print(id(a[3]))
print(id(b[3]))
a[3][2]=666
print(a)
print(b)
2888174549320
2888177070472
- - - - - - - - - - - - - - - 
2888174551304
2888174551304
- - - - - - - - - - - - - - - 
2888175471432
2888177042952
- - - - - - - - - - - - - - - 
2888177166408
2888176581576
[1, 2, 3, [10, 20, 666]]
[1, 2, 3, [10, 20, 30]]

元组 tuple

  • 元组可以看成是一个不可更改的list

元组创建

# 创建元祖
t = ()
print(type(t))

# 创建一个只有一个值的元祖
t = (1,)
print(type(t))
print(t)

t = 1,
print(type(t))
print(t)

t = 1, 2, 3
print(type(t))
print(t)

l = [1, 2, 3, 4]
t = tuple(l)
print(type(l))
print(t)
<class 'tuple'>
<class 'tuple'>
(1,)
<class 'tuple'>
(1,)
<class 'tuple'>
(1, 2, 3)
<class 'list'>
(1, 2, 3, 4)

元组的特性

  • 是序列表,有序
  • 元组数据值可以访问,不能修改,不能修改,不能修改
  • 元组数据可以是任意类型
  • 总之,list所有特性,除了可修改外,元组都具有
  • 也就意味着,list具有的一些操作,比如索引,分片,序列相加,相乘,成员资格操作等,一模一样
# 操作 和 函数 都差不错,这里都不一一举例了!

元组变量交换法

  • 两个变量交换值
# 两个遍历值交换
a = 1
b = 2

# 别的语言应该会怎么写:
c = a
a = b
b = c
print(a)
print(b)

print("- " * 10)
# python的写法
a,b = b,a
print(a)
print(b)
2
1
- - - - - - - - - - 
1
2

集合-set

  • 集合是数学中的一个概念
  • 一堆确定的无序的唯一的数据,集合中每一个数据成为一个元素
# 集合的定义
s = set()
print(type(s))
print(s)

# 此时,大括号内一定要有值,否则定义出的是一个dict
s = {1, 2, 3, 4 ,5}
print(s)
print(type(s))
<class 'set'>
set()
{1, 2, 3, 4, 5}
<class 'set'>
# 如果只是用一个大括号,则定义的是一个dict类
d = {}
print(type(d))
print(d)
<class 'dict'>
{}

集合的特征

  • 集合内数据无序,即无法使用索引和分片
  • 集合内部数据元素具有唯一性,可以用来排除重复数据
  • 集合内的数据,str, int, float, tuple,冰冻集合等,即内部只能放置可哈希数据
# 成员检测
# in, not in
s = { 'Taoy', 19, 'cool'}
if 'Taoy' in s:
    print('Taoy')
Taoy
# 集合遍历操作
for i in s:
    print(i, end=" ")
19 Taoy cool 
# 带有元组的集合遍历
s = {(1, 2, 3), ('Taoy', 'is', 'Cool'), (4, 5, 6)}
for k,m,n in s:
    print("{0}---{1}---{2}".format(k, m, n))
for k in s:
    print(k)
Taoy---is---Cool
4---5---6
1---2---3
('Taoy', 'is', 'Cool')
(4, 5, 6)
(1, 2, 3)
# 集合的内涵
# 普通集合内涵,集合在初始化后过滤重复元素,因为集合具有唯一性
s = {1, 2, 3, 4, 5, 6, 1, 5, 4}
print(s)
ss = {i for i in s}
print(ss)
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
# 待条件的集合内涵
sss = {i for i in s if i % 2 == 0}
print(sss)
{2, 4, 6}
# 关于集合的函数
# len()
# max()
# min()
# 跟上面实例差不多,就不演示了
# add: 向集合里添加元素
s = {1}
s.add(2)
print(s)
{1, 2}
#clear
s = {1, 2, 3}
print(id(s))
s.clear()
print(id(s))
# 结果表明clear函数是原地清空数据
2888176813224
2888176813224
# copy:拷贝
# remove:移除制定的值,直接改变原有值,如果要删除的值不存在,报错
# discard:移除集合中指定的值,跟remove一样,但是删除的值不在的话,不报错

s = {1, 2, 3, 4, 5, 6}
s.remove(3)
print(s)
s.discard(2)
print(s)

print('- ' * 10)
s.discard(666)
print(s) # 不报错

print('- ' * 10)
s.remove(666) # 报错
print(s)
{1, 2, 4, 5, 6}
{1, 4, 5, 6}
- - - - - - - - - - 
{1, 4, 5, 6}
- - - - - - - - - - 
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-131-15bba25217e9> in <module>
     14 
     15 print('- ' * 10)
---> 16 s.remove(666)
     17 print(s)
KeyError: 666
# pop 随机移除一个元素
s = {1, 2, 3, 4, 5}
d = s.pop()
print(d)
print(s)
1
{2, 3, 4, 5}
# 集合函数
# intersection: 交集
# difference:差集
# 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)
{5, 6}
{1, 2, 3, 4}
False

frozen set:冰冻集合

  • 并冻和就是不可以进行任何修改的集合
  • frozenset是一种特殊集合
# 创建
s = frozenset()
print(type(s))
print(s)
<class 'frozenset'>
frozenset()

dict字典

  • 字典是一种组合数据,没有顺序的组合数据,数据以键值对形式出现
# 创建字典1
d = {}
print(type(d))
print(d)
# 创建字典2
d = dict()
print(type(d))
print(d)

# 创建有值的字典1
d = {"one":1, "Two":2, "Three":3}
print(d)

# 创建有值字典2
d = dict(one = 1, two = 2, three = 3)
print(d)

# 创建有值字典3
d = dict( [("one",1), ("two",2), ("three",3)])
print(d)
<class 'dict'>
{}
<class 'dict'>
{}
{'one': 1, 'Two': 2, 'Three': 3}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}

字典的特征

  • 字典是序列类型,但是是无序序列,所以没有分片和索引
  • 字典中的数据每个都有键值对组成,即kv对

    • key: 必须是可哈希的值,比如int,string,float,tuple, 但是,list,set,dict 不行
    • value: 任何值
# 访问数据
d = {"one":1, "Two":2, "Three":3}
print(d["one"])

# 修改数据
d["one"] = "Taoy"
print(d)

# 删除某个数据
del d["Three"]
print(d)
1
{'one': 'Taoy', 'Two': 2, 'Three': 3}
{'one': 'Taoy', 'Two': 2}
# 成员检测,in ,not in
# 成员检测 检测的是key的内容
d = {"one":1, "Two":2, "Three":3}
if 1 in d:
    print("value")
if 'one' in d:
    print("key")
if ("Three", 3) in d:
    print("hhh")
key
# 字典的遍历
d = {"one":1, "Two":2, "Three":3}
for k in d:
    print(k, d[k])

print("- " * 15)

# 上述的代码可以写成:
for k in d.keys():
    print(k, d[k])
print("- " * 15)
# 只访问字典的值
for v in d.values():
    print(v)
print("- " * 15)

# 常用的方法
for k,v in d.items():
    print(k, '----', v)
one 1
Two 2
Three 3
- - - - - - - - - - - - - - - 
one 1
Two 2
Three 3
- - - - - - - - - - - - - - - 
1
2
3
- - - - - - - - - - - - - - - 
one ---- 1
Two ---- 2
Three ---- 3
# 字典生成式
d = {"one":1, "Two":2, "Three":3}
dd = {k:v for k,v in d.items()}
print(dd)

# 加限制条件
ddd = {k:v for k,v in d.items() if v % 2 == 1}
print(ddd)
{'one': 1, 'Two': 2, 'Three': 3}
{'one': 1, 'Three': 3}
# 通用函数: len, max, min, dict
# str(字典): 返回字典的字符串格式
d = {"one":1, "Two":2, "Three":3}
print(str(d))
{'one': 1, 'Two': 2, 'Three': 3}
# clear: 清空字典
# items: 返回字典的键值对组成的元组格式

d = {"one":1, "Two":2, "Three":3}
i = d.items()
print(type(i))
print(i)

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

# values: 同理,一个可迭代的结构
v = d.values()
print(type(v))
print(v)
<class 'dict_items'>
dict_items([('one', 1), ('Two', 2), ('Three', 3)])
dict_keys(['one', 'Two', 'Three'])
<class 'dict_values'>
dict_values([1, 2, 3])
# get: 根据制定键返回相应的值, 好处是,可以设置默认值
d = {"one":1, "Two":2, "Three":3}
print(d.get("Taoy")) # 输出 None

# 设置 get 默认值,(get默认值是None)
print(d.get("one", 100))
print(d.get("Taoy", 100))
None
1
100
# fromkeys: 使用指定的序列作为键,使用一个值作为字典的所有的键的值
l = ["pig", "bear", "Dog"]
# 注意fromkeys两个参数的类型
# 注意fromkeys的调用主体
d = dict.fromkeys(l, "eat")
print(d)
{'pig': 'eat', 'bear': 'eat', 'Dog': 'eat'}

本文链接:

https://www.betao.cn/archives/python-review04.html
1 + 4 =
快来做第一个评论的人吧~