2020-09-26

1. 元组简介

·元组基本介绍

1.元组表现形式tuple

tuple1 = (1, 2, 3, 4)
print(tuple1, type(tuple1))
print(tuple1[0])

输出

(1, 2, 3, 4) <class 'tuple'>
1    

2.元组是⼀个不可变序列(⼀般当我们希望数据不改变时，我们使⽤元组，其他情况下基本都⽤列表)

3.使用()创建元素

4.元组不是空元组至少有⼀个 逗号(,) 当元组不是空元组时括号可以省略

tuple2 = (10,)
tuple2 = 10,
print(type(tuple2))

5.元组解包指将元组当中的每⼀个元素都赋值给⼀个变量

1.元组的拆包

tuple1 = (1, 2, 3, 4, 5)
*a, b, c = tuple1
print(a, b, c)

输出

[1, 2, 3] 4 5

2. 字符串的拆包

s = 'abcdef'
a, b, *c = s
print(a, b, c)

输出

a b ['c', 'd', 'e', 'f']

3.列表的拆包

list1 = [1, 2, 3, 4]
a, b, *c = list1
print(a, b, c)

输出

1 2 [3, 4]

2.字典简介

· 字典的基本介绍

1.字典属于⼀种新的数据结构称为映射(mapping)

2.字典的作⽤和列表类似，都是⽤来存储对象的容器

3.列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反

4.在字典中每⼀个元素都有唯⼀的名字，通过这个唯⼀的名字可以找到指定的元素

5.这个唯⼀的名字我们称之为key 通过key可以快速查询value 也可以称之为值

6.字典我们也称之为键值对(key-value)结构

7.每个字典中都可以有多个键值对，⽽每⼀个键值对我们称其为⼀项(item)

8.创建⼀个有数据的字典 语法 {key:value}

9.字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)

10.字典的键是不能重复的，如果出现重复的后⾯的会替换前面的

#字典：key-value  键-值   （名称：数据）  {}来表示
dict1 = {}
print(type(dict1))    #<class 'dict'>

#数据类型 {key: value}  这么一个key-value我们称它为一项
#当字典中的key有重复的时候，后面的会代替前面的



dict2 = dict(name='郭靖', age=30, gender='男')
print(dict2)   #{'name': '郭靖', 'age': 30, 'gender': '男'}

dict3 = dict([('name', '郭靖'), ('age', 30), ('gender', '男')])
print(dict3)    #{'name': '郭靖', 'age': 30, 'gender': '男'}

import collections

d1=collections.OrderedDict(([('name', '郭靖'), ('age', 30), ('gender', '男')]))
dict1 = {'name': '郭靖',
      'age': 30,
      'gender': '男',
      'name1': '黄蓉'
      }
print(dict1['name1'])   #黄蓉

·字典的使用

1.dict()函数来创建字典

2.get(key[,default]) 根据键来获取字典的值。第⼆个参数可以指定⼀个默认值，当获取不到值的时候会返回默认值

3.update() 将其他字典的key-value添加到当前的字典当中

4.del 删除字典中的key-value

5.popitem() 删除字典最后的⼀个key-value 这个⽅法是有返回值的。删除之后它会将删除的key-value作为返回值返回

6.pop(key[,default]) 根据key删除⾃定中的value。第⼆个参数可以指定⼀个默认值，当获取不到值的时候会返回默认值

#双值子序列   ['ab', 'cd']
#双值序列： 序列中有两个值[1, 2], 'ab', (a, b)
#子序列： 如果序列中的二元素也是序列['ab']
#创建字典：通过双值子序列创建
dict3 = dict([('name', '郭靖'), ('age', 30), ('gender', '男')])

·遍历字典

我们主要可以通过3种⽅式对字典进⾏遍历

1.keys() 该⽅法返回字典所有的key

2.values() 该⽅法返回⼀个序列 序列中保存有字典的值

3.items() 该⽅法会返回字典中所有的项 它返回⼀个序列，序列中包含有双值子序列 双值分别是 字典中的key和value

dict1 = {'name': '郭靖',
     'age': 30,
     'gender': '男',
     'name1': '黄蓉'
     }

#dict.keys()   遍历字典，返回的是一个序列，保存的是字典中所有的键
print(dict1.keys())     #dict_keys(['name', 'age', 'gender', 'name1'])
for k in dict1.keys():
    print(dict1[k])      #郭靖   30    男     黄蓉


#dict.values()  返回的是一个序列，保存的是字典中所有的值
print(dict1.values())   #dict_values(['郭靖', 30, '男', '黄蓉'])

#dict.items()  返回的是字典中所有的项， 返回的是一个序列，这个序列中包含双值子序列，双值就是字典当中的key-value
print(dict1.items())    #dict_items([('name', '郭靖'), ('age', 30), ('gender', '男'), ('name1', '黄蓉')])
for k, v in dict1.items():
    print(k, v)      #name  郭靖     age  30      gender   男       name1   黄蓉

4. 集合

·集合简介

1.集合表现形式set 集合和列表⾮常相似

2.不同点

·集合只能存储不可变对象

·集合中存储的对象是⽆序的

·集合不能出现重复元素

3.使⽤{}来创建集合

4.可以通过set()来将序列和字典转换成集合

5.len() 使⽤len()来获取集合中元素的数量

6.add()像集合中添加元素

7.update()将⼀个集合中的元素添加到另⼀个集合当中

8.pop()随机删除集合中的⼀个元素⼀般是删除最后⼀个元素

9.remove() 删除集合中指定的元素

10.clear() 清空集合

#集合  ： set  {}
#和列表的不同点：
#1. 集合只能存储不可变对象
set1 = {(1, 2), 'ab', True, None, [1, 2, 3]}
print(set1)
#2. 集合中存储的对象是无序的  没有索引
set1 = {10, 6, 8}
print(set1)   #{8, 10, 6}
print(set1)   #{8, 10, 6}
#3. 集合不能出现重复元素   去重set()
set1 = {(1, 2), 'ab', True, None, 1, 0, False}
print(set1)  #{(1, 2), True, 0, 'ab', None}

set1 = {}
set1 = set()
print(set1, type(set1))   #set() <class 'set'>
list1 = [1, 2, 3, 4, 5, 1, 2, 3]
#将字典转换为集合的时候，只会包含字典当中的key
dict1 = {1: '1', 2: '2'}
s = set(dict1)
print(s)    #{1, 2}

·集合的运算

1.& 交集运算

2.| 并集运算

3.- 差集运算

4.^ 亦或集

5.<= 检查⼀个集合是否是另⼀个集合的⼦集

6.< 检查⼀个集合是否是另⼀个集合的真⼦集

7.>=检查⼀个集合是否是另⼀个集合的超集

8.>检查⼀个集合是否是另⼀个集合的真超集

#in
#not in
#len()
#set.add()  向集合中添加元素
#set1 = set()
#set1.add(5)
#set1.add(3)
#set1.add(4)
#print(set1)

#set.update() 将一个集合中的元素添加到另一个集合中
s1 = set('hello')
s2 = set('python')
s1.update(s2)
print(s1)  #{'n', 'l', 'e', 'o', 'h', 'p', 't', 'y'}

#set.pop()
set1 = {'a', 'b', 1, 2}
r = set1.pop()
print(set1)   #{2, 'a', 1}
print(r)   #b

#set.remove()
set1.remove('c')
print(set1)

#set.clear()

作业

1.a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3

a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
print(a['data']['result'][0]['src'])    #python1

2. 有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有⼤于66的值保存⾄字典的第⼀个key的值中，将⼩于66值保存⾄第⼆个key的值中。

list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
list2 = set(list1)
dict1 = {}
list3 = []
list4 = []

for i in list2:
 print(i)  #33   66   99   11   44   77   22  55  88   90
 if i > 66:
     list3.append(i)
elif i < 66:
     list4.append(i)

dict1['key1'] = list3
dict1['key2'] = list4
print(dict1)    #{'key1': [99, 77, 88, 90], 'key2': [33, 11, 44, 22, 55]}