python将元祖元素连接成字符串

一、元祖

　　1.用途:记录多个值，当多个值没有改变的需求，元祖不能修改，但元祖里的数据的数据可以修改。

　　2.定义方式:在()内用逗号分隔开多个任意值。

　　　　思考:如果定义一个只有一个一个值的元祖。 # t = (1, )

　常用操作:

　　优先掌握: 

1 # 索引取值
 2 t = (1, 2, 3, 2, 3, 2)
 3 print(t[1])
 4 print(t[-2])
 5 
 6 # 切片
 7 print(id(t))
 8 nt = t[:-1:]
 9 print(nt, id(nt))
10 
11 # 长度（item元素个数）
12 print(len(t))
13 
14 # 元组内置方法
15 print(t.count(2))  # 该数据集合可以存放相同数据
16 print(t.index(2, 2, 3))

 元祖案例:

1 # 提前拥有一个老师列表，打算开除，如果是校长亲友团，免开
 2 
 3 # 原始列表为list类型
 4 # 手动输入是否是亲友团，决定是否能开除（）
 5 
 6 teas = ['Bob', 'Alex']
 7 
 8 friends = input("亲友团[0, 1]：")
 9 
10 if friends == '1':
11     teas = tuple(teas)
12 
13 # => 异常处理
14 # 判断teas对象是否是tuple类型
15 if not isinstance(teas, tuple):  # 老师是否是亲友团，不是就开除
16     teas.clear()
17 
18 for t in teas:
19     print("在职老师：%s" % t)
20 
21 # 案例二
22 # 元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变
23 t1 = (1, 2, "abc", True, (1, 2))  # t1永远无法改变
24 
25 t2 = (1, 2, [])
26 print(t2, type(t2), id(t2), id(t2[2]))
27 t2[2].extend((10, 20))
28 print(t2, type(t2), id(t2), id(t2[2]))

二、字典类型

特别了解：dict是python中仅存的mapping类型

1 1.声明
 2 dict的key：可以为所不可以变类型：int float tuple str bool None
 3 dict的value：可以为所有数据类型
 4 注:key具有唯一性(重复会覆盖旧值)，value可以重复
 5 例:
 6 dic = {1: None, None: None, 3.14: None,
 7        True: None, 'abc': None, (1,): None,
 8        None: 12345
 9        }
10 print(dic)

2.1用途:记录多个值，每一个值都是对应的key用来描述value的作用

2.2定义方法：在{}内用逗号分隔开多个：key-value其中value可以定

义可以使任意类型，而可以必须是不可变的类型，通常情况下应该是

str类型。

2.3字典无序存储数据，无索引与切片，用key来取值

2.4优先掌握的操作

①.按key存取值：可存、可取

②.长度len()

③.成员运算 in not in

4④删除：del()   pop() 删除对应的值并返回value  popitem()随机删除，有返回值

⑤.循环：

1 #示例
 2 d={'name':'zhaokang','age':18}
 3 #取key
 4 #方法一
 5 for i in d:
 6     print(i)
 7 #方法二
 8 for i in d.keys():
 9     print(i)
10 
11 #取Value
12 for i in d.values:
13     print(i)
14 
15 #取key-value
16 for k,v in d.item():
17     print(k,v)

2.5字典的内置方法

#增删改查
 dic={}
 #增：key不存在
 #方法一
 dic['name']='Mac'
 print(dic)
 结果是：{'name':'Mac'}
 #方法二
 #update添加的参数字典，与dic 可以重复，就是更新值，新key就是新增
 dic.update({'a':100,'c':300})
 print(dic)
结果是：{'a':100,'b':30,'c':300}
#方法三 setdefault 有两个参数 ①key ②default
#字典中已经存在key则不做任何操作，返回的结果是已存在的Value
#如果字典不存在key则添加，返回新的value
#一
dic = {'name':'zhaokang'}
dic.setdefault('name','ZhaoKang')
print(dic)
输出结果是:{'name':'zhaokang'}  返回值是 zhaokang
#二
dic = {'name':'zhaokang'}
dic.setdefault('name1','ZhaoKang')
print(dic)
输出结果是:{'name1':'ZhaoKang'}  返回值是 ZhaoKang
 #改：key已经存在
 dic['name']='Big Mac'
 print(dic)
 输出结果是:{'name':'Big Mac'}

#查
print(dic['name'])
输出结果是:{'name':'zhaokang'}

#删
#方法一
del dic['name']
print(dic)
输出结果是：{}
#二  据key删除指定对象，并返回删除的对象的value
print(dic.pop(['name']))
输出结果是:{}
#三 随机删除
print('dic.popitems()')
输出结果是:{}

2.6需要掌握的操作:

1   #get 当需要取得值得key不在字典中则不会报错返回默认值None
 2   #如果需要取得值得key存在字典中则取到value
 3 dic={'a':20,'b':30}
 4 res=dic.get('c')  # 拥有默认值.None，可以避免报错
 5 print(res)
 6 输出结果是:None
 7 dic = {'a': 20, 'b': 30}
 8 res = dic.get('b')  # 拥有默认值.None，可以避免报错
 9 print(res)
10 输出结果是:30
11 
12 {}.fromkeys('n',20)
13 输出结果是:{'n': 20}
14 
15 #copy:
16 #浅copy：只做第一层copy，内部的成员地址还是原来的地址
17 dic = {'a': 20, 'b': 30}
18 print(dic.ccopy())
19 输出结果是:{'a': 20, 'b': 30}

1 # 字典的定义：{} | dict()
 2 # 字典的常用操作：增删改查
 3 # 字典的内置方法：
 4 # 字典的循环(迭代)
 5 
 6 dic = {'a': 10, 'b': 20, 'c': 30}
 7 # 直接for循环(遍历)字典得到的是key
 8 for k in dic:
 9     print(k, dic[k])
10 
11 # 能不能只循环值
12 values = dic.values()
13 print(values, type(values))
14 # 存放key的集合
15 keys = dic.keys()
16 print(keys, type(keys))
17 # 存放key-value的键值对关系
18 k_vs = dic.items()
19 print(k_vs, type(k_vs))
20 
21 # dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循环取值
22 # vs = list(values)
23 # print(vs[1])
24 # for v in vs:
25 #     print(v)
26 
27 for v in values:
28     print(v)
29 print()
30 for k in keys:  # 跟直接遍历字典是一样的
31     print(k)
32 
33 print()
34 # ***** 同时遍历k-v
35 for k, v in dic.items():
36     print(k, v)
37 
38 
39 
40 ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
41 name_dic = {}
42 for name in ls:
43     name = name.lower()
44     # name已存在，不管，不存在，初始化指定key：name值为1
45     name_dic.setdefault(name, 0)
46     name_dic[name] += 1
47 print(name_dic)

字典循环与案例

三、集合

#定义与声明:
#什么事set:
#①单列数据集合：str，list，tuple，set 
#双列:dict
②无序存储：无key无index，无法取值
③可变数据类型，内部可以存放任意数据类型，但数据具有唯一性
#{}代表空字典，set()用来表示空集合
s1=set()
print(s1,type(s1))
s2=set('abc')
print(s2,type(s2))

2.内置方法与使用  集合运算 （$  |  ^  -  >  <  ==）
p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}
# 交集 &   intersection
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res)  # {'egon'}

# 并集 |   union
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res)  # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}

#差集  - difference
res = p_set - l_set
print(res)  # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res)  # {'x', 'z', 'y'}

# 对称差集  ^   symmetric_difference
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res)  # {'y', 'a', 'b', 'x', 'z', 'c'}


# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop()  # 随机删除一个ele元素
print(res)
if 'xyz' in s:
    s.remove('xyz')  # 有ele删除，无ele抛异常


#循环 利用set 去重
classes = set()
for _, cless in class_map:
    classes.add(cless)
classes = list(classes)
print(classes)


# 了解：父子set
sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}

print(sup_set > sub_set)
print(sup_set < sub_set)
print(temp_set == sub_set)

# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set)
print(res)
res = temp_set.isdisjoint(sup_set)
print(res)

1 # 需求：
 2 # 1.多少人参加了选课: ['owen', 'egon', 'liuxx']
 3 # 2.都选了哪些课程: ['python', 'linux', 'java']
 4 # 利用逻辑代码去重
 5 names = []
 6 for name, _ in class_map:
 7     # 判断列表中是否已存在，不存在才添加
 8     if name not in names:
 9         names.append(name)
10 print(names)

案例