Python复杂数据类型

一、列表(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

   扫描二维码关注公众号，回复： 7995900 查看本文章

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']]