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

 集合

list：允许重复的集合，可修改
tuple：允许重复的集合，不可修改
dict：允许重复的集合，可修改
set：无序且不重复的元素集合
创建：
s = set（）
s = {11,22,33,44}
转换：
1 l1 = [11, 22, 11, 2]
2 s2_l1 = set(l1)
3 print("s2_l1", s2_l1)  # s2 {2, 11, 22}
4 t1 = (11, 22, 11, 2)
5 s2_t1 = set(t1)
6 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
difference，difference_update
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(报错）
discard，remove
se.intersection(be)    交集（找se和be中相同的元素）
se.intersection_updat(be)    找se和be的交集，并更新到se中 
 1 se = {11, 22, 33, 44}
 2 be = {22, 55}
 3 # 找交集
 4 ret = se.intersection(be)
 5 print("se==>>", se, "intersection==>>", ret)
 6 # se==>> {33, 11, 44, 22} intersection==>> {22}
 7 # 找到交集并更新到se
 8 ret = se.intersection_update(be)
 9 print("se==>>", se, "intersection_update==>>", ret)
10 # se==>> {33, 11, 44, 22} intersection_update==>> None
intersection，intersection_update
se.isdisjoint(be)    判断是否无交集，有交集返回False，无交集返回True 
se = {11, 22, 33, 44}
be = {22, 55}

# 判断有无交集，有交集返回False，无交集返回True
ret = se.isdisjoint(be)
print("isdisjoint==>>", ret)
# isdisjoint==>> False
isdisjoint
se.issubset(be)    判断se是否为be的子序列，是返回True，不是返回False
se.issuperset(be)        判断se是否为be的父序列，是返回True，不是返回False 
 1 se = {11, 22, 33, 44}
 2 be = {22, 55}
 3 
 4 # 判断se是否为be的子序列，是返回True，不是返回False
 5 ret = se.issubset(be)
 6 print("issubset==>>", ret)
 7 # issubset==>> False
 8 # 判断se是否为be的父序列，是返回True，不是返回False
 9 ret = se.issuperset(be)
10 print("issuperst==>>", ret)
11 # issuperst==>> False
issubset，issuperset
se.pop    移除元素并重新赋值（随机） 
se = {11, 22, 33, 44}
# 移除元素并重新赋值(随机)
ret = se.pop()
print("se==>>", se, "pop==>>", ret)
# se==>> {11, 44, 22} pop==>> 33
pop
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
symmetric_difference,symmetric_difference_update
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
update
三元运算（三目运算）
if 条件：
    pass
else：
    pass
等同于：
值1 if 条件 else 值2 
 1 # 1
 2 s1 = int(input("输入数字："))
 3 if s1 == 1:
 4     name = "alex"
 5 else:
 6     name = "aric"
 7 print("1:", name)
 8 # 1: alex
 9 
10 # 2
11 name = "alex" if s1 == 1 else "aric"
12 print("2:", name)
13 # 2: alex
14 
15 # 将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不变 
 1 import copy
 2 
 3 # 其他数据类型
 4 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
 5 # 赋值：id不变
 6 n2 = n1
 7 # 浅拷贝：最外层id改变，里层id不变
 8 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
 9 n3 = copy.copy(n1)
10 # 深拷贝：外层id改变，最里层id不变
11 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
12 n4 = copy.deepcopy(n1)
# 其他数据类型

 

函数
定义函数：
    def 函数名（形式参数）：    
        def    关键字
        函数名    用于调用函数
        形式参数    用于给函数提供数据，定义的时候为形式参数，调用时为实际参数
        返回值    执行完毕后返回的数据，给调用者用作参考 
# def 函数名（参数）：  函数名不能是中文
#     函数体
#     return 值  只要执行return，return下面的代码将不再执行
View Code
    
执行函数：
    函数名（实际参数）   
    执行时如果不按照顺序传参数，需要指定：
        例：def xxx(a, b, c):
                    …
                xxx(b = xxx, c = xxx, a = xxx)
 
默认参数：（放在参数最后） 
 1     def xxx(a):
 2         aaa = a + "ooo"
 3         print(aaa)
 4         return aaa
 5     xxx("1")    ==>> 1ooo
 6 
 7     def xxx(a="b"):
 8         aaa = a + "ooo"
 9         print(aaa)
10         return aaa
11     xxx()       ==>> booo
 
动态参数： 
 1 　　def xxx(*args)：
 2         return aaa
 3     xxx(11，22) ==>>(元组）
 4 
 5     def xxx(**kwargs)：
 6         return aaa
 7     xxx(“k1”=11，”k2”=22) ==>>（字典）
 8 
 9     def xxx(*args，**kwargs)： ==>>万能参数
10         return aaa
11     xxx(11，22，“k1”=11，”k2”=22) ==>> (元组，字典）
 
全局变量、局部变量
全局变量：所有人都能用（书写规范：大写）
局部变量：一个人可以用（书写规范：小写）
 1 p = "alex"  # 全局变量
 2 
 3 def fun1():
 4     a = 123
 5     global p  # 指定p为全局变量
 6     p = "eric"  # 局部变量
 7     print(a)  # ==>> 123
 8 
 9 fun1()
10 
11 def fun2():
12     a = 456
13     print(p)  # ==>> alex  指定p后==>> eric
14     print(a)  # ==>> 456
15 
16 fun2()

 

 

posted @ 2017-02-06 11:11  Grisom  阅读(150)  评论(0)  编辑  收藏  举报