1.基础数据类型补充

1）字符串函数join

①把字符串1插入到字符串那2中

s1 = "abc"
s2 = "可口可乐"
s3 = s1.join(s2)
print(s3)
输出：
可abc口abc可abc乐
View Code

例二：

s = "tx".join("sb")
print(s)
输出：
stxb
View Code

 ②把某个列表，通过某个字符连接，转化为字符串 ，即把列表转化为字符串

s = "_".join(["lol","dnf","cf","zz"])
print(s)
lol_dnf_cf_zz
View Code

 补充：字符串转化为列表（split）

s = "lpl_dnf_cf_lol"
s_new = s.split("_")
print(s_new)
输出：
['lpl', 'dnf', 'cf', 'lol']
View Code

 2)通过remove循环删除列表中元素的时候，会删不干净，如下

lst = ["九尾妖狐","影流之主","惩戒之箭","德玛西亚"]
for el in lst:
    lst.remove(el)
print(lst)
输出：
['影流之主', '德玛西亚']
说明：在列表内部，有一个索引下标，当删除第0号元素，即九尾妖狐后，其后的元素会补充到前面，即影流之主成为了第0号元素，接着循环删除第1号元素，即删除了惩戒之箭

总结：列表在循环的时候不能删除列表中元素，因为会改变索引；可先把要删除的东西记录到一个新得列表中，再去删除

lst = ["九尾妖狐","影流之主","惩戒之箭","德玛西亚"]
lst_new = []
for el in lst:
    lst_new.append(el)      #记录下要删除得内容
for i in lst_new:         #循环记录得内容
    lst.remove(i)       #删除原来得内容
print(lst)
输出：
[]
View Code

 3）字典fromkeys方法：返回一个新得字典，和原字典没有任何关系（不会对原来的字典产生影响）

dic = {"a":"123"}
s = dic.fromkeys("九尾妖狐","阿狸")
print(s)
输出：
{'尾': '阿狸', '狐': '阿狸', '妖': '阿狸', '九': '阿狸'}
View Code

4）类型转换：想要转换为什么类型，就要用什么类型括起来

①元组--->列表：list(tuple)

②列表--->元组：tuple(list)

③列表---->字符串：str.join(list)

④字符串--->列表：str.split()

5)可转换为False的数据：

0,None,[] () {} set() ====>False

2.set集合：

         1）基本数据类型，不是很常用，set集合中的元素是不重复且无序的，且其中的元素必须是可hash的（int,str,tuple,bool），可理解为set就是dict类型的数据但是不保存value,只保存key,---------可用于去重复         set也用{}表示

         注：set集合中的元素必须是可hash的，但是set本身是不可hash的，set是可变的

#实例化一个空集合

s = set()
print(s)
输出：
set()
View Code

 #set集合的的定义

s = {"九尾妖狐","影流之主","九尾妖狐",'123',"Ture",'123'}
print(s)
输出：
{'Ture', '123', '影流之主', '九尾妖狐'}
View Code

 #列表的去重

lst = ["张三","李四","张三","王麻子","李四","张三"]
s = set(lst)
print(s)
lst_new = list(s)
print(lst_new)
输出：
{'张三', '李四', '王麻子'}
['张三', '李四', '王麻子']
View Code

 2）set集合的增加

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.add("德玛西亚")
print(s)
输出：
{'九尾妖狐', '皮城女警', '德玛西亚', '惩戒之箭', '远古巫灵'}
View Code

 #迭代添加（即按照字符添加）

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.update("德玛西亚")
print(s)
输出：
{'远古巫灵', '西', '亚', '九尾妖狐', '惩戒之箭', '德', '玛', '皮城女警'}
View Code

3）set集合的删除

#随机删除一个元素

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.pop()
print(s)
输出：
{'惩戒之箭', '九尾妖狐', '皮城女警'}
View Code

#直接删除元素

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.remove("远古巫灵")
print(s)
输出：
{'皮城女警', '惩戒之箭', '九尾妖狐'}
View Code

 #情况set集合，如果set集合是空的，为了区分字典，打印出来的为set()

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.clear()
print(s)
输出：
set()
View Code

4）set集合的修改：set集合中元素没有索引，也没有办法定位一个元素，所以没有办法直接进行修改，可以采取先删除后添加的方式完成修改操作

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
s.remove("惩戒之箭")
s.add("麦林炮手")
print(s)
输出：
{'九尾妖狐', '麦林炮手', '皮城女警', '远古巫灵'}
View Code

 5）set集合的查询：set集合是一个可迭代对象，所以可以进行for循环

s = {"九尾妖狐","远古巫灵","惩戒之箭","皮城女警"}
for i in s:
    print(i)
输出：
九尾妖狐
惩戒之箭
皮城女警
远古巫灵
View Code

6）set集合的其他操作

①求交集

s1 = {"寒冰射手","蛮族之王","惩戒之箭"}
s2 = {"九尾妖狐","影流之主","惩戒之箭"}
print(s1 & s2)
print(s1.intersection(s2))
输出：
{'惩戒之箭'}
{'惩戒之箭'}
View Code

②求并集

s1 = {"寒冰射手","蛮族之王","惩戒之箭"}
s2 = {"九尾妖狐","影流之主","惩戒之箭"}
print(s1 | s2)
print(s1.union(s2))
输出：
{'影流之主', '九尾妖狐', '蛮族之王', '惩戒之箭', '寒冰射手'}
{'影流之主', '九尾妖狐', '蛮族之王', '惩戒之箭', '寒冰射手'}
View Code

③求差集

s1 = {"寒冰射手","蛮族之王","惩戒之箭"}
s2 = {"九尾妖狐","影流之主","惩戒之箭"}
print(s1 - s2)
print(s1.difference(s2))
输出：
{'蛮族之王', '寒冰射手'}
{'蛮族之王', '寒冰射手'}
View Code

④求反交集

s1 = {"寒冰射手","蛮族之王","惩戒之箭"}
s2 = {"九尾妖狐","影流之主","惩戒之箭"}
print(s1 < s2)
print(s1.issubset(s2))
输出：
{'蛮族之王', '寒冰射手', '影流之主', '九尾妖狐'}
{'蛮族之王', '寒冰射手', '影流之主', '九尾妖狐'}
View Code

 ⑤判断是否为子集

s1 = {"寒冰射手","蛮族之王","惩戒之箭"}
s2 = {"九尾妖狐","影流之主","惩戒之箭"}
print(s1 < s2)       #s1是s2的子集吗
print(s1.issubset(s2))
输出：
False
False
View Code

3.浅拷贝

1）补充：变量在内存中的表现形式

         先在内存中产生对象，再把对象（字符串、字典、列表等都是对象）赋值给变量；将对象赋值给变量，就是将对象的内存地址赋值给变量

2）引用赋值：

#进行列表赋值操作，实际上是引用内存地址的赋值，内存中此时只有一个列表，两个变量指向一个列表

#两个对象指向了同样的内存对象
lst1 = ["阿狸","寒冰","女枪","光辉"]
lst2 = lst1
lst2.append("德玛")           #同样赋值给了列表1，因为指向了同样的内存地址
print(lst1)
print(lst2)
print(id(lst1),id(lst2))
输出：
['阿狸', '寒冰', '女枪', '光辉', '德玛']
['阿狸', '寒冰', '女枪', '光辉', '德玛']
2379648430344 2379648430344
View Code

 3）浅拷贝（copy）：创建新对象，把原来的拷贝一份；即不是一个对象了

lst_1 = ["寒冰射手","蛮族之王","惩戒之箭"]
lst_2 = lst_1.copy()
lst_1.append("远古巫灵")
print(lst_1,lst_2)
print(id(lst_1),id(lst_2))
输出：
['寒冰射手', '蛮族之王', '惩戒之箭', '远古巫灵'] ['寒冰射手', '蛮族之王', '惩戒之箭']
2371399025160 2371398497160
View Code
#列表浅拷贝其他方式：
lst_2 = lst_1[:]         #切片会产生新的对象

4.深拷贝

1)如果存在列表的嵌套，浅拷贝复制列表后，改变第二层列表的值，复制后的别表也会改变：因为第一层列表中存放着第二层列表的内存地址（所以浅拷贝只拷贝列表的第一层，第二层的内容不会拷贝如果第二层改变了，复制后的列表同样改变）

lst_1 = ["寒冰射手","蛮族之王","惩戒之箭",["治疗","闪现","传送"]]
lst_2 = lst_1.copy()
lst_1[3].append("屏障")
print(lst_1)
print(lst_2)
print(id(lst_1),id(lst_2))
输出：
['寒冰射手', '蛮族之王', '惩戒之箭', ['治疗', '闪现', '传送', '屏障']]
['寒冰射手', '蛮族之王', '惩戒之箭', ['治疗', '闪现', '传送', '屏障']]
View Code

2)深拷贝：深度拷贝，包括内部的所有内容进行拷贝，不会再出现两个变量指向同一个对象的情况；需要导入模块copy

import copy
lst_1 = ["寒冰射手","蛮族之王","惩戒之箭",["治疗","闪现","传送"]]
lst_2 = copy.deepcopy(lst_1)
lst_1[3].append("屏障")
print(lst_1)
print(lst_2)
print(id(lst_1),id(lst_2))
输出：
['寒冰射手', '蛮族之王', '惩戒之箭', ['治疗', '闪现', '传送', '屏障']]
['寒冰射手', '蛮族之王', '惩戒之箭', ['治疗', '闪现', '传送']]
2418075329608 2420068964616
View Code

3)为什么要深浅拷贝:创建对象，实际上是一个类的实例化的过程，要过要创建对象，需要按照类中的写法去开辟内存，赋值等；但是通过拷贝的方式很快，因为拷贝直接是在内存中把这块区域，以二进制流的形式直接复制一份；因为拷贝比创建对象的方式要快

5.练习

1）判断一个数是否为水仙花数，水仙花树是一个三位数，三位数的每一位的三次方和还等于这个数，拿这个数就是一个水仙花数。例如153=1**3+5**3+3**3

num = input("请输入一个三位数：")
s = int(num[0])**3 + int(num[1])**3 + int(num[2])**3
if int(num) == s:
    print("是一个水仙花数")
else:
    print("不是水仙花数")
输入输出：
请输入一个三位数：153
是一个水仙花数
View Code

2）给出一个纯数字集合，对列表元素进行排序（冒泡排序）

①完成a和b的数据交换，例如a=10,b=24，交换之后，a=24,b=10

②循环列表：判断a[i]和a[i+1]之箭的大小关系，如果a[i]比a[i+1]大，则进行互换，循环结束的时候，当前列表中最大的数据就会被移动到最右端

③如果再次执行一遍上面的操作，最终第二大的数据就一定到了右端，以此类推，如果反复的进行执行相应的操作，那这个列表就变成了一个有序列表

lst = [10,22,3,20,33,1]
for j in range(len(lst)):       #记录内部排序的次数
    i = 0
    while i<len(lst)-1:    #把最大值移动到最右边
        if lst[i]>lst[i+1]:
            lst[i],lst[i+1]=lst[i+1],lst[i]
        i = i +1
print(lst)
输出：
[1, 3, 10, 20, 22, 33]
View Code

3.完成彩票36选7的功能，从36个数中随机产生7个数，最终获取到7个不重复的数据。作为最终的开奖结果：随机数：

from random import randint

randint(0,20) #产生0-20的随机数

from random import randint
s = set()
while len(s)<7:
    s.add(randint(1,36))
print(s)
输出：
{35, 8, 12, 13, 24, 25, 27}
View Code