7.其他数据类型详解

7.其他数据类型详解

7.1元组

跟列表类似，区别:可变的列表		=>	不可变列表
元组的数据标识是()
提高表达式
python3.6做了一个print优化， 呈现的结果没有把无序这个特点展示出来, 但是本质上是无序的

代码示例:

7.1.1.元组的声明

t = ()
print(type(t))  # <class 'tuple'>

t = (10)
print(type(t))  # <class 'int'>被认为是普通的赋值    t = 10
# 元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义
t = (10,)
print(type(t))  # <class 'tuple'>

#  将其他序列的元素存放于元组中
t = tuple('abcdefg')
print(t)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

7.1.2元组的的运算符

+  生成是一个新元素 存放多个元组中的元素
*  乘以一个正整数n  将元组中的元素重复n次 放在一个新元组中
in 成员判断
>=
>
<=
<
==
!=
    相同位置的元素进行比较 直到比较出来结果

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

t1 = (12, 34, 56)
t2 = (33, 29, 41)
new_t = t1 + t2
print(new_t)  # (12, 34, 56, 33, 29, 41)

new_t = t1 * 2
print(new_t)  # (12, 34, 56, 12, 34, 56)

print(t1 <= t2)  # True

7.1.3索引和切片

nums = (19, 27, 38, 32, 18, 44, 33, 55, 77)
# 获取下标为-3的位置的元素
ele = nums[-3]
print(ele)

切片相关方法

sub_t = nums[::-1]
print(sub_t)  # (77, 55, 33, 44, 18, 32, 38, 27, 19)

sub_t = nums[-5:]
print(sub_t)  # (18, 44, 33, 55, 77)

sub_t = nums[3::-1]
print(sub_t)  # (32, 38, 27, 19)

# nums[3::-1] = [0]
# print(nums)  # TypeError: 'tuple' object does not support item assignment

values = (12, 34, 56, [77, 85, 23])
values[-1][0] = 88
print(values)  # 只要是元组中的数据的地址没有发生变化  就不会报错

# values[-1] = [88, 82, 51]
# print(values)  #     values[-1] = [88, 82, 51]
# TypeError: 'tuple' object does not support item assignment

统计相关方法

# 统计某个元素出现的次数
nums = (19, 27, 38, 32, 18, 44, 33, 55, 77, 19, 28, 31, 19)
print(nums.count(19))  # 3

# 查看某个元素第一次出现的位置
pos = nums.index(19)
print(pos)  # 0

7.1.4删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup= ('physics','asdasd',1997,asad);
 
print tup	# ('physics','asdasd',1997,asad);
del tup
print tup	# ()

7.2字典

字典由键和对应值成对组成。字典也被称作关联数组或哈希表

数据结构:

给数据添加了标识，这个标识称为键，在字典中存储的是键值成对的数据，键是值的标记。在字典中是根据键来获取值的。
	要求:键是不允许变化的[键的内容是不可变的],且不允许重复

使用场景:
	1.词频统计
	2.用于储存某些对象的信息
	
注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。
键必须独一无二，但值则不必。
值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行

7.2.0重点方法函数:

六、字典内置函数&方法

Python字典包含了以下内置函数：

cmp(dict1, dict2) #比较两个字典元素。
len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：
radiansdict.clear() #删除字典内所有元素
radiansdict.copy() #返回一个字典的浅复制
radiansdict.fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
radiansdict.has_key(key) #如果键在字典dict里返回true，否则返回false
radiansdict.items() #以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() #以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None) #和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2) #把字典dict2的键/值对更新到dict里
radiansdict.values() #以列表返回字典中的所有值

方法代码示例:

7.2.1字典的定义

# 使用字面量 {} 呈现字典中的键值对数据
person = {'name': '乔锋', 'age': 20, 'gender': '男'}
print(person)

# 使用dict创建字典
dict0 = dict()
print(dict0)  # {}

# 将二维序列转化为字典  注意字典中有键有值   [[key,值], [key1, 值]]  内部的一维数据必须有两个元素 第一个元素作为键 第二个作为值
dict0 = dict([['a', 97], ['b', 98]])
print(dict0)  # {'a': 97, 'b': 98}

# 关键字形式传值  key=value
dict1 = dict(a=97, b=98)
print(dict1)  # {'a': 97, 'b': 98, 'c': 99}

# print(dict1 >= dict0)  # TypeError: '>=' not supported between instances of 'dict' and 'dict'

7.2.2运算符

in ---  常用的
	判断的是键存不存在

# 关于字典中的增删改查的操作 下文均默认使用一下字典
person = {'name': '乔锋', 'age': 20, 'gender': '男'}

增加键值对

# 使用set方法
person.setdefault('addr', '山西')
print(person)  # {'name': '乔锋', 'age': 20, 'gender': '男', 'addr': '山西'}

# 键不存在  当做新的键值对添加在字典中 键存在 不做任何操作 只是这个键对应的值返回
value = person.setdefault('name', '乔大侠')
print(value)
print(person)

# 使用中括号形式添加 字典[键] = 值  如果键存在 会新值覆盖旧值
person['score'] = 88
print(person)  # {'name': '乔锋', 'age': 20, 'gender': '男', 'addr': '山西', 'score': 88}

person['name'] = '乔大侠'
print(person)  # {'name': '乔大侠', 'age': 20, 'gender': '男', 'addr': '山西', 'score': 88}

# 合并其他字典中的键值对

person.update([['school', '千锋'], ['class', 'py2103']])
print(person)  # {'name': '乔大侠', 'age': 20, 'gender': '男', 'addr': '山西', 'score': 88, 'school': '千锋', 'class': 'py2103'}

person.update({'classmates': ['江涛', '飞翔', '宏宇']})
print(person)
# {'name': '乔大侠', 'age': 20, 'gender': '男', 'addr': '山西', 'score': 88, 'school': '千锋', 'class': 'py2103', 'classmates': ['江涛', '飞翔', '宏宇']}

删除清空方法

# 删除
item = person.popitem()  # 删除的任意一对键值
print(item)  # ('classmates', ['江涛', '飞翔', '宏宇'])
print(person)

# 根据指定的键删除
value = person.pop('addr')
print(value, person)  # 山西 {'name': '乔大侠', 'age': 20, 'gender': '男', 'score': 88, 'school': '千锋', 'class': 'py2103'}

#清空
# person.clear()
# print(person)  # {}


# 修改  字典[键] = 新值

查询方法

# 可以使用中括号   字典[键]
value = person['name']
print(value)  # 乔大侠
# 弊端： 键不存在会报错
# value = person['adrr']
# print(value)  # KeyError: 'adrr'

# 推荐  使用get方法  键不存在 返回空值None
value = person.get('name')
print(value)

value = person.get('addr')
print(value)  # None

movie = {'start': 100, 'filter': 'top250'}
# get 在字典中获取内容 如果这个键不存在 默认是None  有些情况下 需要给这个字段如果为空的话 设置一个默认值
value = movie.get('start', 0)
print(value)  # 100

movie = {'filter': 'top250'}
# get 在字典中获取内容 如果这个键不存在 默认是None  有些情况下 需要给这个字段如果为空的话 设置一个默认值
value = movie.get('start', 0)
print(value)  # 0

7.2.3获取的操作

# 1. 获取字典下所有的键
all_keys = person.keys()
print(all_keys)  # dict_keys(['name', 'age', 'gender', 'score', 'school', 'class'])

# 2. 获取字典下所有的值
all_values = person.values()
print(all_values)  # dict_values(['乔大侠', 20, '男', 88, '千锋', 'py2103'])

# 3. 获取字典下的键值组合

all_items = person.items()
print(all_items)
# dict_items([('name', '乔大侠'), ('age', 20), ('gender', '男'), ('score', 88), ('school', '千锋'), ('class', 'py2103')])

# 根据列出键创建字典  值会被默认赋予为None
dict0 = dict.fromkeys(['a', 'b', 'c', 'd'])
print(dict0)  # {'a': None, 'b': None, 'c': None, 'd': None}

7.2.4字典的遍历

#  直接遍历字典  --- 获取的是字典中的每一个键
for k in person:
    print(k)

# 遍历字典的所有键
for k in person.keys():
    print(k)

# 遍历字典中所有的值
for v in person.values():
    print(v)

# 获取键值组合
for item in person.items():
    print(item)  # ('class', 'py2103')

# 可以写成
for k, v in person.items():
    print(f'{k} -- {v}')

上次作业改进： 保留及格的科目和成绩

score_dict = {'语文': 78, '数学': 88, '英语': 56, '政治': 87}
pass_list = list(filter(lambda k: score_dict[k] >= 60, score_dict))
print(pass_list)   # ['语文', '数学', '政治']
for k in score_dict:
    if k in pass_list:
        print(score_dict[k])

pass_dict = dict(filter(lambda item: item[-1] >= 60, score_dict.items()))
print(pass_dict)  # {'语文': 78, '数学': 88, '政治': 87}

# 如果使用循环的情况来写
pass_dict = {}
# 遍历
for k, v in score_dict.items():
    if v >= 60:
        pass_dict[k] = v
print(pass_dict)

7.2.5字典推到式简化

{k:v k和v的来源键值筛选}

pass_dict = {k: v for k, v in score_dict.items() if v >= 60}
print(pass_dict)

7.3集合set

无序的可变容器，集合中存放的没有重复的元素

向的理解这个容器中存的字典中的键
来用于排重的原因:
由于集合中的元素不能出现多次，这使得集合在很大程度上能够高效地从列表或元组中删除重复值，并执行取并集、交集等常见的的数学操作。
	集合元素的包含也是使用的{},但是{}并不是集合的数据标记

集合与列表:

列表（list）和元组（tuple）都是标准的 Python 数据类型，它们均将值存储在一个序列中。集合（set）是另一种标准的 Python 数据类型，它也可用于存储值。它们之间主要的区别在于，集合不同于列表或元组，集合中的每一个元素不能出现多次，并且是无序存储的。

代码示例:

7.3.1.声明

nums = {}
print(nums, type(nums))  # {} <class 'dict'>

nums = {12, 34, 5, 6, 78}
print(nums, type(nums))  # {34, 5, 6, 12, 78} <class 'set'>

# 声明一个空集合
set0 = set()  # -- 这个声明空集合的唯一方式
print(set0)

# 空列表  []  list()
# 空字符串 ''  str()
# 空元祖  ()   tuple()
# 空字典 {}   dict()


list0 = [77, 89, 32, 14, 25, 33, 89, 65, 77]
# 去重
print(set(list0))  # {32, 33, 65, 77, 14, 89, 25}  去重之后的顺序 与列表中元素的顺序是不一致的

# 相一致的话
unique_list = []
for ele in list0:
    if ele not in unique_list:
        unique_list.append(ele)
print(unique_list)  # [77, 89, 32, 14, 25, 33, 65]

7.3.2运算符

'''
&   两个集合的交集  存放在新的集合中
|   两个集合的并集  存放在新的集合中
^   两个集合的非交集 存放在新的集合中
-   两个集合的差集   存放在新的集合中
>=  判断后者是否为前者的子集
>   判断后者是否为前者的真子集
<=  判断前者是否为后者的子集
<   判断前者是否为后者的真子集
==  
!=
'''
set1 = {12, 34, 56, 71}
set2 = {34, 28, 19, 56}
new_set = set1 & set2
print(new_set, set1, set2)  # {56, 34} {56, 34, 12, 71} {56, 34, 19, 28}

new_set = set1 | set2
print(new_set)  # {34, 71, 12, 19, 56, 28}

new_set = set1 ^ set2
print(new_set)  # {19, 71, 28, 12}

new_set = set1 - set2  # 在前者中减去与后者 交集的部分
print(new_set)  # {12, 71}

print(new_set <= set1)  # True

print({12, 77} < set1)  # False

7.3.3一些功能操作源码解析

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object

    Build an unordered collection of unique elements.
    """
    # 在集合中中添加元素
    def add(self, *args, **kwargs): # real signature unknown
        """
        Add an element to a set.
        如果元素已经存在 没有任何效果
        This has no effect if the element is already present.
        """
        pass
    # 清空集合
    def clear(self, *args, **kwargs): # real signature unknown
        """ Remove all elements from this set. """
        pass
    # 浅拷贝
    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of a set. """
        pass# 返回集合的浅副本。
    # 等价于 - 
    def difference(self, *args, **kwargs): # real signature unknown
        """
        Return the difference of two or more sets as a new set.
		# 将两个或多个集合的差作为新集合返回。
        (i.e. all elements that are in this set but not the others.)
        """
        pass
    # 等价于 -=
    def difference_update(self, *args, **kwargs): # real signature unknown
        """ Remove all elements of another set from this set. """
        pass # 从此集合中删除另一个集合的所有元素。
    # 移除元素
    def discard(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set if it is a member.
        不是一个成员的话 不做任何事情
        If the element is not a member, do nothing.
        """
        pass

    # 等价于 & 
    def intersection(self, *args, **kwargs): # real signature unknown
        """
        Return the intersection of two sets as a new set.
		# 将两个集合的交集作为新集合返回。
        (i.e. all elements that are in both sets.)
        """
        pass

    #  等价于 &= 
    def intersection_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the intersection of itself and another. """
        pass	# 用一个集合自身和另一个集合的交集更新集合。

    # 是否不存在交集
    def isdisjoint(self, *args, **kwargs): # real signature unknown
        """ Return True if two sets have a null intersection. """
        pass	# 如果两个集合有空交集，则返回True。

    # 是否是指定集合的子集  <=
    def issubset(self, *args, **kwargs): # real signature unknown
        """ Report whether another set contains this set. """
        pass	# 报告另一个集合是否包含此集合。

    # 是否是指定集合父集 【判断指定集合是不是该集合的子集】  >= 
    def issuperset(self, *args, **kwargs): # real signature unknown
        """ Report whether this set contains another set. """
        pass	# 报告此集合是否包含其他集合。

    # 移除任意一个元素
    def pop(self, *args, **kwargs): # real signature unknown
        """
        Remove and return an arbitrary set element.	#移除并返回任意集合元素。
        Raises KeyError if the set is empty. 如果是空集合报错
        """
        pass
    # 删除指定元素
    def remove(self, *args, **kwargs): # real signature unknown
        """
        Remove an element from a set; it must be a member.
		# 从集合中删除元素；它必须是成员。
        If the element is not a member, raise a KeyError.  如果元素不存在会报错
        """
        pass

    # 等价于 ^
    def symmetric_difference(self, *args, **kwargs): # real signature unknown
        """
        Return the symmetric difference of two sets as a new set.
		# 将两个集合的对称差作为新集合返回。
        (i.e. all elements that are in exactly one of the sets.)
        """
        pass

    # 等价于  ^=
    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the symmetric difference of itself and another. 
		用一个集合自身和另一个集合的对称性差异来更新一个集合"""
        pass

    # 等价于 |
    def union(self, *args, **kwargs): # real signature unknown
        """
        Return the union of sets as a new set.
		将集合的并集作为新集合返回。
        (i.e. all elements that are in either set.)
        """
        pass

    # 等价于 |=
    def update(self, *args, **kwargs): # real signature unknown
        """ Update a set with the union of itself and others. 
		用集合自身和其他集合的并集更新集合。"""
        pass

7.3.4代码示例

'''
选数学科目的有
    王建福 田志伟 李子越 李宏文 史雪龙
选语文科目的有
    田志伟 李子越 郭英东 唐晓斌 秦林珍
选英语科目的有
    李子越 田多文 元子腾 姚庆国 任嘉琪 龙章
'''
math = {'王建福', '田志伟', '李子越', '李宏文', '史雪龙'}
chinese = {'田志伟', '李子越', '郭英东', '唐晓斌', '秦林珍'}
english = {'李子越', '田多文', '元子腾', '姚庆国', '任嘉琪', '龙章', '李宏文'}
# 选课的学生共有多少人 分别是谁
students = math | chinese | english
print(students, len(students))
# 只选数学的有多少人 分别是谁
only_math = math - chinese - english
print(only_math, len(only_math))  # {'王建福', '史雪龙'} 2
# 三门课程全部选的有多少人 分别是谁
all_in = math & chinese & english
print(all_in, len(all_in))  # {'李子越'} 1
# 只选了两门课程的有多少人 分别是谁
two = ((math & chinese) | (math & english) | (chinese & english)) - (math & chinese & english)
print(((math & chinese) - english) | ((math ^ chinese) & english))
print(two)  # {'田志伟', '李宏文'}

7.4.高阶函数 sorted()

map		映射
zip ---	相同位置的元素进行组合
filter ---	筛选
reduce ---	累计


sorted ---	排序
	和列表.sort(reverse，key)区别
		列表.sort(reverse，key) 只能对列表排序而且影响的是本身

代码示例:

students = [
    {'name': '静静', 'age': 18},
    {'name': '静静1', 'age': 15},
    {'name': '静静2', 'age': 16},
    {'name': '静静3', 'age': 19},
    {'name': '静静4', 'age': 22},
    {'name': '静静5', 'age': 20},
    {'name': '静静6', 'age': 21}
]

# 对列表中的元素按照年龄降序排序
# students.sort(key=lambda p: p.get('age'), reverse=True)
# print(students)


# 不会影响本身 是生成了新的列表
new_list = sorted(students, key=lambda p: p.get('age'), reverse=True)
print(students)
print(new_list)

'''
字符串
    s = 'vbnmdatyewlfdasdncdew'
排重之后进行降序排序
'''
s = 'vbnmdatyewlfdasdncdew'
unique_s = set(s)
print(unique_s)

desc_s = ''.join(sorted(unique_s, reverse=True))
print(desc_s)  # ywvtsnmlfedcba

# 按照次数进行降序排序
word_count_dict = {'good': 2, 'study': 1, 'day': 3, 'up': 1, 'liu': 5}
print(dict(sorted(word_count_dict.items(), key=lambda a: a[-1], reverse=True)))