逻辑教育.png
元组
元组简介
- 元组是序列结构的一种，但是是不可变序列，可以简单的理解为内容不可变更的列表，除了在内部元素不可修改的区域外，元组和列表用法差不多。
- 元组表现形式tuple
- 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
- 元组和列表相比，用法相近，但是元组所消耗的内存更少。
元组的创建
- 使用()创建元素
- 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
tu = (1,2,3)
print(tu,type(tu))
tu2 = 1,2,3
print(tu2,type(tu2))
tu3 =5,
print(tu3,type(tu3))
#运行结果：
(1, 2, 3) <class 'tuple'>
(1, 2, 3) <class 'tuple'>
(5,) <class 'tuple'>
- 用tuple()函数创建元组
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.
"""
tu = tuple(range(5))
print(tu)
#运行结果：
(0, 1, 2, 3, 4)
元组的访问
元组可以引用索引，可以切片，也有count()、index()、len()、max()和min()方法，但是没有sort()和reverse()方法，如果想要对元组进行排序或者逆序打印，可以通过sorted()和reversed()函数完成。
tu = (1,2,3)
print(sorted(tu))
print((reversed(sorted(tu))))
#运行结果：
[1, 2, 3]
<list_reverseiterator object at 0x0000000001E7C5F8>
1.reversed()会将元组逆序后的结果返回到一个list object，如果需要打印输出，可以用list()转换后打印，如果只是遍历或者迭代，直接引用即可。
2.sorted()对元组排序后返回的是列表，按列表操作即可。
元组不充许的操作
- 不可以修改，但是可以拼接，如果元组的元素中含有列表，也可以在列表内部进行值的增删改。
tu = (1,2,3)
tu = tu + (["4",5],)
print(tu)
tu[3][0] = 4
print(tu)
#运行结果：
(1, 2, 3, ['4', 5])
(1, 2, 3, [4, 5])
- 不可以删除某个元素，（但是可以删除整个元组）
tu = (1,2,3)
print(tu)
del tu
print(tu)
#运行结果
(1, 2, 3)
Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/Excercise_100/元组练习.py", line 24, in <module>
print(tu)
NameError: name 'tu' is not defined
- 元组没有remove()、pop()、append()方法
元组的解包
- 元组解包指将元组当中的每一个元素都赋值给一个变量
a,b = 1,2
print(a,b)
a,b,c = (1,2,3)
print(a,b,c)
a,*b = tuple(range(4))
print(a,b)
#运行结果：
1 2
1 2 3
0 [1, 2, 3]
字典
概念
- 字典属于一种新的数据结构称为映射(mapping)
- 字典的作用和列表类似，都是用来存储对象的容器
- 列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
- 在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
- 这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
- 字典我们也称之为键值对(key-value)结构
- 每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
- 创建一个有数据的字典 语法 {key:value}
- 字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple....)
- 字典的键是不能重复的，如果出现重复的后面的会替换前面的
字典的创建方法：
Pycharm中dict()函数的提示语
根据提示语句，我们可以找到创建字典的如下方法：
1.创建空字典
d1 = {}
2.按键值对创建：
d2 = {"name":"shen","age":18,"address":"baotou","job":"teacher"}
3.按照mapping映射创建字典
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
4.通过dict(iterable)创建字典
a = ["name","age","address","job"]
b = ["shen",18,"baotou","teacher"]
def fmap(a,b):
return (a,b)
d4 = {}
for k,v in map(fmap,a,b):
d4[k] = v
5.通过dict(**kwargs)创建字典
d5 = dict(name="shen",age=18,address="baotou",job="teacher")
6.通过map()函数创建字典
a = ["name","age","address","job"]
b = ["shen",18,"baotou","teacher"]
def fmap(a,b):
return (a,b)
d6 = dict(map(fmap,a,b))
7.通过zip()函数创建字典
d7 = dict(zip(a,b))
无论是map()还是zip()都是将可迭代对象打包成元组，然后按照mapping方式进行字典的创建，重点在于mapping方法，打包元组也可以用自定义函数的方法完成。
访问字典的方法
1.按键访问——dict.keys()返回所有键的列表
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
print(d3.keys())
print(d3["name"])
#运行结果：
dict_keys(['name', 'age', 'address', 'job'])
shen
2.按值访问——dict.values()返回所有值的列表
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
print(d3.values())
#运行结果：
dict_values(['shen', 18, 'baotou', 'teacher'])
3.按项目item()访问——返回所有键值对的列表
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
print(d3.items())
#运行结果：
dict_items([('name', 'shen'), ('age', 18), ('address', 'baotou'), ('job', 'teacher')])
返回结果恰好是mapping方法，返回的结果是一个列表，经常结合for循环使用
4.get(key)返回指定键的值，如果值不在字典中，则返回default值。get(key)方法比较友好，不会报错，key不存在返回None；如果直接用dict[key]，key存在时返回值，key不存在就会报错。
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
d3["sex"] = "male"
print(d3.get("name"))
print(d3.get("home"))
#运行结果：
shen
None
添加与修改项目
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
d3["sex"] = "male"
print(d3)
#运行结果：
{'name': 'shen', 'age': 18, 'address': 'baotou', 'job': 'teacher', 'sex': 'male'}
删除方法
1.del dict[key]——del是关键字，后面要加上字典名[键]
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
del d3["job"]
print(d3.get("job"))
print(d3)
#运行结果：
None
{'name': 'shen', 'age': 18, 'address': 'baotou'}
2.字典没有remove方法——强行使用会报错
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
d3.remove()
#运行结果：
Traceback (most recent call last):
File "C:/Users/Administrator/PycharmProjects/字典.py", line 41, in <module>
d3.remove()
AttributeError: 'dict' object has no attribute 'remove'
3.pop(key)——删除键和对应的值
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
d3.pop("job")
print(d3.get("job"))
print(d3)
#运行结果：
None
{'name': 'shen', 'age': 18, 'address': 'baotou'}
4.clear()方法——清空字典，清除键值对
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
d3.clear()
print(d3)
5.关键字del dict 删除整个字典
d3 = dict([("name","shen"),("age",18),("address","baotou"),("job","teacher")])
del d3
print(d3)
#运行结果：
NameError: name 'd3' is not defined
字典的排序
1.sorted(dict)，默认按key排序。
dic = {"zhao":90,"qian":85,"sun":80}
print(sorted(dic)
#运行结果：
['qian', 'sun', 'zhao']
2.利用zip()函数对值进行排序
dic = {"zhao":90,"qian":85,"sun":80}
print(sorted(list(zip(dic.values(),dic.keys()))))
#运行结果：
[(80, 'sun'), (85, 'qian'), (90, 'zhao')]
集合
集合的概念：
与数学概念中的集合是同一个意义，他是一个无序，不重复的集，基本功能包括关系测试，消除重复元素，集合使用{}框定元素，并以逗号进行分隔。
但是注意，如果要创建一个空集合，必须用set{}，而不是{}，因为后者创建的是一个空字典。
集合的创建、转化
- 创建一个空字典
a = set()
2.将序列拆分为集合
tup = (1,1,2,2,3,3)
a1 = set(tup)
lst = [1,1,2,2,3,3]
a2 = set(lst)
strs = 'abcabc'
a3 = set(strs)
print(a1,a2,a3)
#运行结果：
{1, 2, 3} {1, 2, 3} {'b', 'a', 'c'}
3.将字典转化为集合——set()函数会将字典的键作为元素，转化为集合
dic =dict([("one",1),("two",2)])
print(dic)
a4 = set(dic)
print(a4)
#运行结果：
{'one': 1, 'two': 2}
{'one', 'two'}
4.向集合中添加元素——不可变类型可以作为元素添加到集合中去，可变类型不可添加，例如列表。
a1 = set(range(4))
a1.add(4)
a1.add("hello")
print(a1)
#运行结果：
{0, 1, 2, 3, 4, 'hello'}
5.更新集合——upgrade()方法是将不可变对象转化为集合，然后将新集合更新到目标集合中去
a1 = set(range(4))
print(a1)
a1.update("hello")
print(a1)
#运行结果：
{0, 1, 2, 3}
{0, 1, 2, 3, 'e', 'o', 'h', 'l'}
6.删除元素：
（1）remove()可以删除指定的元素；
a = {0, 1, 2, 3, 'e', 'o', 'h', 'l'}
a.remove('e')
print(a)
#运行结果：
{0, 1, 2, 3, 'o', 'h', 'l'}
（2）pop()方法是随机删除集合中的一个元素，并以字符串的形式返回被删除的元素；
a = {0, 1, 2, 3, 'e', 'o', 'h', 'l'}
print(a)
n = len(a)
for i in range(n):
print(a.pop())
print(a)
#运行结果：
{0, 1, 2, 3, 'e', 'o', 'h', 'l'}
0
{1, 2, 3, 'o', 'e', 'l', 'h'}
1
{2, 3, 'o', 'e', 'l', 'h'}
2
{3, 'o', 'e', 'l', 'h'}
3
{'o', 'e', 'l', 'h'}
o
{'e', 'l', 'h'}
e
{'l', 'h'}
l
{'h'}
h
set()
（3）当对空集合使用pop()方法时，程序会报错。
a = set()
print(a.pop())
#运行结果：
KeyError: 'pop from an empty set'
- 集合没有索引，不可以切片。
集合的运算
- 交集&，并集|，差集-，异或^ 四种常见运算
a = set(range(4))
b = set([i for i in range(1,10,2)])
print("a={},b={}".format(a,b))
#交
print("a&b=",a&b)
#并
print("a|b=",a|b)
#异或——两个集合的并集，减去两个集合的交集
print("a^b=",a^b)
#差集——“a-b”是指a集合减去a，b的交集
print("a-b=",a-b)
- 运行结果：
a={0, 1, 2, 3},b={1, 3, 5, 7, 9}
a&b= {1, 3}
a|b= {0, 1, 2, 3, 5, 7, 9}
a^b= {0, 2, 5, 7, 9}
a-b= {0, 2}
可变类型——list,dict,set
- 可变类型，指程序在运行中对象的id,type,value中有一些可以发生变化。
lst1 = [1,2,3]
print(id(lst1),lst1)
lst1.insert(0,4)
print(id(lst1),lst1)
lst1[0] = "4"
print(id(lst1),lst1)
- 运行结果：
44062280 [1, 2, 3]
44062280 [4, 1, 2, 3]
44062280 ['4', 1, 2, 3]
不可变类型——int,float,str,tuple
- 不可变类型，指对象的id,type,value中任何一个都不发生变化。
s1 = "aaa"
print(id(s1))
s2 = s1.capitalize()
print(id(s1),id(s2))
- 运行结果：
43469264
43469264 43469320
第7课作业
- 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"}]}
}
k1 = a["data"]
k2 = k1["result"]
for i in k2:
print(i["src"])
#运行结果：
python1
python2
python3
- 有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。
lst = [11,22,33,44,55,66,77,88,99,90]
dic = {}
list1 = []
list2 = []
for i in lst:
if i > 66:
list1.append(i)
elif i < 66:
list2.append(i)
dic = dict(one = list1,two = list2)
print(dic)
#运行结果：
{'one': [77, 88, 99, 90], 'two': [11, 22, 33, 44, 55]}
