码迷，mamicode.com
首页 > 编程语言 > 详细

Python复杂数据类型

时间：2019-11-27 19:23:03      阅读：76      评论：0      收藏：0      [点我收藏+]

标签：lse   字符串   lin   ima   read   序号   pytho   strong   建立   

一、列表(list):[]

序列：序列是基类类型，扩展类型包括：字符串、元组和列表

序列是一个基类类型

技术图片

列表：列表是序列类型的一种扩展，十分常用

  • 列表是一种序列类型，创建后可以随意被修改
  • 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
  • 列表中各元素类型可以不同，无长度限制
hobby_list = [hobby, ‘run‘, ‘girl‘]
print(id(hobby_list))#4558605960
print(type(hobby_list))#<class ‘list‘>
print(hobby_list)#[‘read‘, ‘run‘, ‘girl‘]

列表索引取值的方法，牢记索引序号从0开始。

hobby_list = [‘read‘, ‘run‘, ‘girl‘]
# 索引序号      0       1      2
# 取出第二个爱好
print(hobby_list[1])#run
hobby_list[0] = ‘write‘

复合列表

hobby_list = [‘read‘, ‘run‘, [‘girl_name‘, 18, ‘shanghai‘]]
# 取出girl的年龄
print(hobby_list[2][1])# 18

s + t： 连接两个列表和t，s*n：将列表s复制n次。

ls1 = [‘python‘, 123]
ls2 = [‘java‘, 456]
print(ls1 * 2);  # [‘python‘, 123, ‘python‘, 123]
print(ls1 + ls2);  # [‘python‘, 123, ‘java‘, 456]

1、常用函数：

  1. 切片 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list[0:3:2])  # [‘nick‘, ‘tank‘]
  2. 长度len；
    min(s)：返回序列s的最小元素，s中元素需要可比较；
    max(s)：返回序列s的最大元素，s中元素需要可比较 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(len(name_list))  # 4
  3. 成员运算in和not in 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(‘tank sb‘ in name_list)  # False
print(‘nick handsome‘ not in name_list)  # True
  4. append:在列表ls最后增加一个元素x 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list.append(‘tank sb‘)
print(name_list)  # [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘, ‘tank sb‘]
  5. del ls(i:j):删除第i-j位置的元素 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
del name_list[2]
print(name_list)  # [‘nick‘, ‘jason‘, ‘sean‘]
  6. for循环 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
for name in name_list:
    print(name)
  7. insert(i,x):在列表ls的第i位置增加元素x 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list.insert(1, ‘handsome‘)
print(name_list)  # [‘nick‘, ‘handsome‘, ‘jason‘, ‘tank‘, ‘sean‘]
  8. pop(i):将列表ls中第i位置元素取出并删除该元素 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list.pop(1))  # jason
print(name_list)  # [‘nick‘, ‘tank‘, ‘sean‘]
  9. remove(x):将列表ls中出现的第一个元素x删除 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list.remove(‘nick‘))  # None
print(name_list)  # [‘jason‘, ‘tank‘, ‘sean‘]
  10. count 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list.count(‘nick‘))  # 1
  11. index(x):返回元素所在lt中的索引 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list.index(‘nick‘))  # 0
  12. clear:删除列表ls中所有元素 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list.clear()
print(name_list)  # []
  13. copy：生成一个新列表，赋值ls中所有元素 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
print(name_list.copy())  # [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
  14. extend 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list2 = [‘nick handsome‘]
name_list.extend(name_list2)
print(name_list)  # [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘, ‘nick handsome‘]
  15. reverse:将列表ls中的元素反转 
    name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list.reverse()
print(name_list)  # [‘sean‘, ‘tank‘, ‘jason‘, ‘nick‘]
  16. sort 
    # list之sort()，使用sort列表的元素必须是同类型的
name_list = [‘nick‘, ‘jason‘, ‘tank‘, ‘sean‘]
name_list.sort()
print(name_list)  # [‘jason‘, ‘nick‘, ‘sean‘, ‘tank‘]

name_list.sort(reverse=True)
print(name_list)  # [‘tank‘, ‘sean‘, ‘nick‘, ‘jason‘]

2、实例：

有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

stu_info_list = [
    {‘name‘: ‘nick‘, ‘age‘: 19, ‘sex‘: ‘male‘},
    {‘name‘: ‘egon‘, ‘age‘: 18, ‘sex‘: ‘male‘},
    {‘name‘: ‘tank‘, ‘age‘: 20, ‘sex‘: ‘female‘},
    {‘name‘: ‘tank‘, ‘age‘: 20, ‘sex‘: ‘female‘},
    {‘name‘: ‘egon‘, ‘age‘: 18, ‘sex‘: ‘male‘},
]

new_stu_info_list = []
for stu_info in stu_info_list:
    if stu_info not in new_stu_info_list:
        new_stu_info_list.append(stu_info)

for new_stu_info in new_stu_info_list:
    print(new_stu_info)

二、元组(tuple):（）

元组是一种列表类型，一旦创建就不能被修改。

  • 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
  • 可以使用或不使用小括号
creature = "cat", "dog", "tiger", "human"
color = (0x001100, "blue", creature)
print(type(creature))  # <class ‘tuple‘>
print(type(color))  # <class ‘tuple‘>

注意与字符串区别：

name_str = (‘egon‘)  # ()只是普通包含的意思
name_tuple = (‘egon‘,)

print(type(name_str))  # <class ‘str‘>
print(type(name_tuple))  # <class ‘tuple‘>

1、常用函数：同列表，只是不更改值。

  1. 索引取值

  2. 切片（顾头不顾尾，步长）

  3. 长度len

  4. 成员运算in和not in

  5. 循环

  6. count

  7. index

三、集合(set):{}

集合是多个元素的无序组合

  • 集合类型与数学中的集合概念一致
  • 集合元素之间无序，每个元素唯一，不存在相同元素

  • 集合元素不可更改，不能是可变数据类型

  • 集合用大括号 {} 表示，元素间用逗号分隔
  • 建立集合类型用 {} 或 set()

  • 建立空集合类型，必须使用set()

s = {1, 2, 1, ‘a‘}  # s = set({1,2,‘a‘})
print(s)  # {‘a‘, 1, 2}
s = set(‘hello‘) # 使用set()建立集合
print(s)  # {‘h‘, ‘l‘, ‘o‘, ‘e‘}

集合类型主要应用于：包含关系比较、数据去重

ls = ["p", "p", "y", "y", 123]
s = set(ls)   # 利用了集合无重复元素的特

1、常用函数：

1.长度len

s = {1, 2, ‘a‘} 
print(len(s)) #len(s): 3




2.成员运算in和not in

s = {1, 2, ‘a‘}
print(1 in s) # True

技术图片

3.|：并集

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}

print(pythoners|linuxers) # {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘}
print(pythoners.union(linuxers)) #{‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘}


4.&：交集

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}

print(pythoners&linuxers) #{‘nick‘}
print(pythoners.intersection(linuxers)}) {‘nick‘}


5.-：差集

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
 
print(pythoners-linuxers) #{‘tank‘, ‘jason‘, ‘sean‘}
print(pythoners.difference(linuxers)) #{‘tank‘, ‘jason‘, ‘sean‘}



6.^：补集

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}

print(pythoners^linuxers) # {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘sean‘}
print(pythoners.symmetric_difference(linuxers))# {‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘sean‘}


7.==

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
javers = {‘nick‘, ‘egon‘, ‘kevin‘}

print(pythoners==linuxers) #False
print(javers==linuxers) # True


8.父集：>、>=

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
javaers = {‘jason‘, ‘nick‘}

print(pythoners>linuxers) # False
print(pythoners>=linuxers) # False
print(pythoners>=javaers) # True
print(pythoners.issuperset(javaers)) #True


9.子集：<、<=

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
javaers = {‘jason‘, ‘nick‘}

print(pythoners<linuxers) # False
print(pythoners<=linuxers) #False
print(javaers.issubset(javaers)) #True

10.add(x):如果x不在集合S中，将x增加到S

s = {1, 2, ‘a‘}
s.add(3)

print(s) #{1, 2, 3, ‘a‘}


11.remove(x):移除S中元素x，如果x不在集合S中，产生KeyError异常

s = {1, 2, ‘a‘}
s.remove(1)

print(s) #{2, ‘a‘}


12.difference_update()

pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
pythoners.difference_update(linuxers)

print(pythoners) #{‘tank‘, ‘jason‘, ‘sean‘}


13.discard(x):移除S中元素x，如果x不在集合S中，不报错

s = {1, 2, ‘a‘}
# s.remove(3)  # 报错
s.discard(3)

print(s) #{1, 2, ‘a‘}


14.isdisjoint()

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {‘jason‘, ‘nick‘, ‘tank‘, ‘sean‘}
linuxers = {‘nick‘, ‘egon‘, ‘kevin‘}
pythoners.isdisjoint(linuxers)

print(pythoners.isdisjoint(linuxers)) # False

15、set(x)：将其他类型变量x转变为集合类型

四、字典(dict):{}

用来存取多个值，按照key：value的方式存值，取的时候可以通过key而非索引去取值，key对value具有描述性的作用。存放数据的种类各种各样并且数据较多的时候可以使用字典。

在{}内用逗号分隔开多个元素，每一个元素都是key: value的格式，其中value是任意格式的数据类型，key由于具有描述性的作用，所以key通常是字符串类型。

创建空字典必须使用 { }。

user_info = {‘name‘: ‘nick‘, ‘gender‘: ‘male‘, ‘age‘: 19,
             ‘company_info‘: [‘oldboy‘, ‘shanghai‘, 50]}

print(id(user_info))#4396183344
print(type(user_info))#<class ‘dict‘>
print(user_info)#{‘name‘: ‘nick‘, ‘gender‘: ‘male‘, ‘age‘: 19, ‘company_info‘: [‘oldboy‘, ‘shanghai‘, 50]}

字典取值方式不再依赖于索引，而是依赖于key，通过[key]即可获取key对应的value值。可存可取

字典套列表

user_info = {‘name‘: ‘nick‘, ‘gender‘: ‘male‘, ‘age‘: 19,
             ‘company_info‘: [‘oldboy‘, ‘shanghai‘, 50]}
print(user_info[‘name‘])#nick

user_info[‘name‘])=’a’
print(user_info[‘company_info‘][0])#oldboy

字典套字典

user_info = {‘name‘: ‘nick‘, ‘gender‘: ‘male‘, ‘age‘: 19, ‘company_info‘: {
    ‘c_name‘: ‘oldboy‘, ‘c_addr‘: ‘shanghai‘, ‘c_num_of_employee‘: 50}}

print(user_info[‘name‘])#nick
print(user_info[‘company_info‘][‘c_name‘])#oldboy

1、转成字典类型

dic = dict(a=1, b=2, c=3)
print(dic)  # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

2、常用函数：

  1. 长度len

    dic = {‘a‘: 1, ‘b‘: 2}
print(len(dic)) #2


  2. 成员运算in和not in

    dic = {‘a‘: 1, ‘b‘: 2}
print(‘a‘ in dic)  # True
print(1 in dic)  # False


  3. 删除del,pop,popitem

    dic = {‘a‘: 1, ‘b‘: 2}
del dic[‘a‘]
print(dic.get(‘a‘))  # None
dic = {‘a‘: 1, ‘b‘: 2}
dic.pop(‘a‘)  # 指定元素删除

print(dic.pop(‘b‘))  # 2
print(dic.get(‘a‘))  # None
dic = {‘a‘: 1, ‘b‘: 2}
print(dic.popitem())  #(‘b‘, 2), popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。


  4. 键keys()、值values()、键值对items()

    #  python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
dic = {‘a‘: 1, ‘b‘: 2}

print(dic.keys())  # dict_keys([‘a‘, ‘b‘])
print(dic.values())  # dict_values([1, 2])
print(dic.items())  # dict_items([(‘a‘, 1), (‘b‘, 2)])


  5. for循环

    # dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)

  6. get(k)：键k存在，则返回相应值，不在则返回值

    dic = {‘a‘: 1, ‘b‘: 2}

print(dic.get(‘a‘))  # 1
print(dic.get(‘c‘))  # None


  7. update

    dic1 = {‘a‘: 1, ‘b‘: 2}
dic2 = {‘c‘: 3}
dic1.update(dic2)
print(dic1)  # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}


  8. fromkeys

    dic = dict.fromkeys([‘name‘, ‘age‘, ‘sex‘], None)
print(dic)  # {‘name‘: None, ‘age‘: None, ‘sex‘: None}


  9. setdefault

    # dic之setdefault()，有指定key不会改变值；无指定key则改变值
dic = {‘a‘: 1, ‘b‘: 2}

print(dic.setdefault(‘a‘, 3))  # 1
print(dic)  # {‘a‘: 1, ‘b‘: 2}
print(dic.setdefault(‘c‘, 3))  # 3
print(dic)  # {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

3、实例

统计s=‘hello tank tank say hello sb sb‘中每个单词的个数

结果如：{‘hello‘: 2, ‘tank‘: 2, ‘say‘: 1, ‘sb‘: 2}

s=‘hello tank tank say hello sb sb‘

l=s.split()

dic={}
for item in l:
    if item in dic:
        dic[item]+=1
    else:
        dic[item]=1
print(dic)

五、可变与不可变类型

1、不可变的数据类型：数字，字符串，元组、bool，None

不可变类型 没有提供修改对象自身的方法，对数据进行操作时，id会发生改变（重新分配地址）。

a = "hello"   #定义一个字符串的变量
print(id(a))  #第一次的地址
print(a)      #a = hello
a = a.upper() # 单纯的a.upper() 执行过后，无法存储到a本身，必须得重新赋值给a  换句话说，a在被upper之后，重新指向了一个新的地址
print(id(a))  #第二次的地址
print(a)

第一段代码执行结果：

技术图片

2、可变数据类型：列表，字典，集合

可变类型提供了修改自身这些方法，对数据进行操作 ，id不会发生改变（使用原来的地址）。

b = [11,22,33,44,55]  #定义一个列表的变量
print(id(b))          #第一次的地址
print(b)              #b = [11,22,33,44,55]
b.append(99)          #单纯的b.append()执行过后，不需要存储到b，因为b已经被更改
print(id(b))          #检查第一次的地址
print(b)              #发现在第一次地址当中，b已经改变

第二段代码执行结果：

技术图片

六、对象深浅拷贝

1、拷贝（赋值）

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。

l1 = [‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]
l2 = l1

l1.append(‘g‘)

print(l1) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘], ‘g‘]
print(l2) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘], ‘g‘]

2、浅拷贝

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。

import copy

l1 = [‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]
l2 = copy.copy(l1)

l1.append(‘g‘)

print(l1) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘], ‘g‘]
print(l2) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]
l1[3].append(‘g‘)

print(l1) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘, ‘g‘], ‘g‘]
print(l2) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘, ‘g‘]]

3、深拷贝

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。

import copy

l1 = [‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]
l2 = copy.deepcopy(l1)

l1.append(‘g‘)

print(l1) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘], ‘g‘]
print(l2) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]

l1[3].append(‘g‘)

print(l1) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘, ‘g‘], ‘g‘]
print(l2) #[‘a‘, ‘b‘, ‘c‘, [‘d‘, ‘e‘, ‘f‘]]

Python复杂数据类型

标签：lse   字符串   lin   ima   read   序号   pytho   strong   建立   

原文地址：https://www.cnblogs.com/springsnow/p/11944380.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！