Learn_Day5 集合、三元运算、拷贝、函数

 集合

---

list：允许重复的集合，可修改

tuple：允许重复的集合，不可修改

dict：允许重复的集合，可修改

set：无序且不重复的元素集合

---

创建：

s = set（）

s = {11,22,33,44}

---

转换：

l1 = [11, 22, 11, 2]
s2_l1 = set(l1)
print("s2_l1", s2_l1)  # s2 {2, 11, 22}
t1 = (11, 22, 11, 2)
s2_t1 = set(t1)
print("s2_t1", s2_t1)  # s2_t1 {2, 11, 22}

---

功能：se=set()    be=set()

se.add    新增

se = {11, 22, 33}
se.add(44)
print("add==>>", se)
# add==>> {33, 11, 44, 22}

clear    删除，清空

se = {11, 22, 33}
se.clear()
print("clear==>>", se)
# clear==>> set()

se.difference(be)    找se中有，be中没有的集合，并赋值给新的变量

se.difference_update(be)    删除se中和be中相同的元素，并更新se

se = {11, 22, 33, 44}
be = {22, 55}
# se有，be没有
ret = se.difference(be)
print("se==>>", se, "difference==>>", ret)
# se==>> {33, 11, 44, 22} difference==>> {33, 11, 44}
# se有，be没有，更新se（删除相同的）
ret = se.difference_update(be)
print("se==>>", se, "difference_update==>>", ret)
# se==>> {33, 11, 44} difference_update==>> None

se.discard    删除指定元素，没有不报错

se.remove    删除指定元素，没有报错

se = {11, 44, 77, 55} 
be = {33, 77, 22, 55}

# 删除指定元素，不存在不报错
se.discard(55)
print("discard==>>", se)
# discard==>> {33, 11, 44, 77, 22}
# 删除指定元素，不存在报错
se.remove(55)
print("remove", se)
# KeyError: 55(报错）

se.intersection(be)    交集（找se和be中相同的元素）

se.intersection_updat(be)    找se和be的交集，并更新到se中

se = {11, 22, 33, 44}
be = {22, 55}
# 找交集
ret = se.intersection(be)
print("se==>>", se, "intersection==>>", ret)
# se==>> {33, 11, 44, 22} intersection==>> {22}
# 找到交集并更新到se
ret = se.intersection_update(be)
print("se==>>", se, "intersection_update==>>", ret)
# se==>> {33, 11, 44, 22} intersection_update==>> None

se.isdisjoint(be)    判断是否无交集，有交集返回False，无交集返回True

se = {11, 22, 33, 44}
be = {22, 55}

# 判断有无交集，有交集返回False，无交集返回True
ret = se.isdisjoint(be)
print("isdisjoint==>>", ret)
# isdisjoint==>> False

se.issubset(be)    判断se是否为be的子序列，是返回True，不是返回False

se.issuperset(be)        判断se是否为be的父序列，是返回True，不是返回False

se = {11, 22, 33, 44}
be = {22, 55}

# 判断se是否为be的子序列，是返回True，不是返回False
ret = se.issubset(be)
print("issubset==>>", ret)
# issubset==>> False
# 判断se是否为be的父序列，是返回True，不是返回False
ret = se.issuperset(be)
print("issuperst==>>", ret)
# issuperst==>> False

se.pop    移除元素并重新赋值（随机）

se = {11, 22, 33, 44}
# 移除元素并重新赋值(随机)
ret = se.pop()
print("se==>>", se, "pop==>>", ret)
# se==>> {11, 44, 22} pop==>> 33

se.symmetric_difference(be)    找se中有be中没有，be中有se中没有的集合，并赋值给新的变量

se.symmetric_difference_update(be)    找se中有be中没有，be中有se中没有的集合,并更新se

se = {11, 22, 33, 44}
be = {22, 55, 77, 33}
# 找se中有be中没有,找be中有se中没有，并赋值给新的变量
ret = se.symmetric_difference(be)
print("se==>>", se, "symmetric_difference==>>", ret)
# se==>> {33, 11, 44, 22} symmetric_difference==>> {11, 44, 77, 55}
# 找se中有be中没有,找be中有se中没有，并赋更新到se
ret = se.symmetric_difference_update(be)
print("se==>>", se, "symmetric_difference_update==>>", ret)
# se==>> {11, 44, 77, 55} symmetric_difference_update==>> None

se.union(be)    并集

se = {11, 22, 33, 44}
be = {22, 55, 77, 33}
# 并集
ret = se.union(be)
print("se==>>", se, "be==>>", be, "union==>>", ret)
# se==>> {11, 44, 77, 55} be==>> {33, 77, 22, 55} union==>> {33, 11, 44, 77, 22, 55}

se.update(be)    将be更新到se

se = {11, 44, 77, 55} 
be = {33, 77, 22, 55} 
# 把be更新到se，be也可以是列表,元组
ret = se.update(be)
print("se==>>", se, "be==>>", be, "update==>>", ret)
# se==>> {33, 11, 44, 77, 22, 55} be==>> {33, 77, 22, 55} update None

---

三元运算（三目运算）

---

if 条件：

    pass

else：

    pass

等同于：

值1 if 条件 else 值2

# 1
s1 = int(input("输入数字："))
if s1 == 1:
    name = "alex"
else:
    name = "aric"
print("1:", name)
# 1: alex

# 2
name = "alex" if s1 == 1 else "aric"
print("2:", name)
# 2: alex

# 将1简写成2，为三目运算（三元运算）

---

深浅拷贝

---

数字和字符串：赋值，深浅拷贝的地址永远一样

import copy

# 数字、字符串
n1 = 123
# n1 = "i am alex age 10"
print(id(n1))
# 赋值：id不变
n2 = n1
print(id(n2))
# 浅拷贝：id不变
n2 = copy.copy(n1)
print(id(n2))
# 深拷贝：id不变
n3 = copy.deepcopy(n1)
print(id(n3)

其他数据类型：

    赋值：id不变

    浅拷贝：最外层id改变，里层id不变

    深拷贝：外出id改变，最里层id不变

import copy

# 其他数据类型
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
# 赋值：id不变
n2 = n1
# 浅拷贝：最外层id改变，里层id不变
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n3 = copy.copy(n1)
# 深拷贝：外层id改变，最里层id不变
n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
n4 = copy.deepcopy(n1)

---

函数

---

定义函数：

    def 函数名（形式参数）：    

        def    关键字

        函数名    用于调用函数

        形式参数    用于给函数提供数据，定义的时候为形式参数，调用时为实际参数

        返回值    执行完毕后返回的数据，给调用者用作参考

# def 函数名（参数）：  函数名不能是中文
#     函数体
#     return 值  只要执行return，return下面的代码将不再执行

    

执行函数：

    函数名（实际参数）   

    执行时如果不按照顺序传参数，需要指定：

        例：def xxx(a, b, c):

                    …

                xxx(b = xxx, c = xxx, a = xxx)

 

默认参数：（放在参数最后）

    def xxx(a):
        aaa = a + "ooo"
        print(aaa)
        return aaa
    xxx("1")    ==>> 1ooo

    def xxx(a="b"):
        aaa = a + "ooo"
        print(aaa)
        return aaa
    xxx()       ==>> booo

 

动态参数：

　　def xxx(*args)：
        return aaa
    xxx(11，22) ==>>(元组）

    def xxx(**kwargs)：
        return aaa
    xxx(“k1”=11，”k2”=22) ==>>（字典）

    def xxx(*args，**kwargs)： ==>>万能参数
        return aaa
    xxx(11，22，“k1”=11，”k2”=22) ==>> (元组，字典）

 

全局变量、局部变量

全局变量：所有人都能用（书写规范：大写）
局部变量：一个人可以用（书写规范：小写）

p = "alex"  # 全局变量

def fun1():
    a = 123
    global p  # 指定p为全局变量
    p = "eric"  # 局部变量
    print(a)  # ==>> 123

fun1()

def fun2():
    a = 456
    print(p)  # ==>> alex  指定p后==>> eric
    print(a)  # ==>> 456

fun2()