博客整理day07

目录

一、元祖内置方法

​ 元祖(tuple)是不可变的列表

用途

​ 存储多个值

定义

​ 在()内可以有多个任意类型的值,用逗号分隔

常用操作和内置方法

  1. 索引取值

    print(tup[0])

  2. 索引切片(顾头不顾尾,步长)

    print(tup[0,2])

  3. 长度len

    print(len(tup))

  4. 成员运算(in 和 not in)
    print(0 in tup)

  5. 计数count
    print(tup.count(2))

  6. 获取元素索引index
    print(tup.index(2))

  7. 循环for

    for i in tup:
    print(i)

有序 or 无序

​ 有序

可变 or 不可变

​ 不可变数据类型

元祖和列表的区别

​ 列表可变的原因是：

​ 索引所对应的值的内存地址是可以改变的

​ 元组不可变得原因是：

​ 索引所对应的值的内存地址是不可以改变的，或者反 过来说，只要索引对应值的内存地址没有改变，那么元 组是始终没有改变的。

二、字典数据类型

用途

​ 存储多个值,但每个值都有一个key与之对应,key对值有描述功能

定义

​ {}内用逗号分隔开多个元素,每个元素都是key:value的形式,value可以是任意数据类型,而key通常是字符串类型,但是key必须为不可变类型

常用操作和内置方法

  1. 按key存取值:可存可取

    print(dic['a'])

  2. 长度len

    print(len(dic))

  3. 成员运算(in 和 not in)

    print('a' in dic)

  4. 删除del

    # dic之删除del
dic = {'a':1,'b':2}
del dic{'a'}
print(dic.get('b', 1))  # 字典中没有返回None,可以给定一个默认值

# dic之删除pop()
dic = {'a':1,'b':2}
dic.pop('a')  # 指定元素删除
print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")

# dic之删除popitem()
dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。

  5. 键key()/值values()/键值对items()

    # dic之键keys()、值values()、键值对items()，
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")
#dic.keys(): dict_keys(['a', 'b'])
#dic.values(): dict_values([1, 2])
#dic.items(): dict_items([('a', 1), ('b', 2)])

  6. 循环

    # dic之循环
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)

  7. get获取值

    # dic之get()
dic = {'a': 1, 'b': 2}

print(f"dic.get('a'): {dic.get('a')}")
print(f"dic.get('c'): {dic.get('c')}")

  8. update()更新值

    # dic之update()
dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2)

print(f"dic1: {dic1}")

  9. fromkeys()创建值为空的字典

    # dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None)

print(f"dic: {dic}")
#dic: {'name': None, 'age': None, 'sex': None}

  10. setdefault()

    # dic之setdefault()，有指定key不会改变值；无指定key则改变值
dic = {'a': 1, 'b': 2}

print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")
#dic.setdefault('a'): 1
#dic: {'a': 1, 'b': 2}
#dic.setdefault('c'): 3
#dic: {'a': 1, 'b': 2, 'c': 3}

有序 or 无序

​ 无序

可变 or 不可变

​ 可变数据类型

三、集合内置方法

用途

​ 用于关系运算的集合体

定义

​ {}内用逗号隔开多个元素,每个元素必须是不可变类型

常用操作和内置方法

  1. 长度len

    print(f"len(s): {len(s)}")

  2. 成员运算(in和not in)

    print(f"1 in s: {1 in s}")

  3. | 并集、union

# str之|并集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")
#pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
#pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
  1. & 交集、intersection
# str之&交集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")
#pythoners&linuxers: {'nick'}
#pythoners.intersection(linuxers): {'nick'}

  1. -差集、difference

    # str之-差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")
#pythoners-linuxers: {'tank', 'jason', 'sean'}
#pythoners.difference(linuxers): {'tank', 'jason', 'sean'}

  2. ^ 对称差集、symmetric_difference

# str之^对称差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
    f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")
#pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
#pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}

  1. ==

    # str之==
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}

print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")
#pythoners==linuxers: False
#javers==linuxers: True

  2. 父集：>、>= 、issuperset

    # str之父集：>、>=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")
#pythoners>linuxers: False
#pythoners>=linuxers: False
#pythoners>=javaers: True
#pythoners.issuperset(javaers): True

  3. 子集：<、<= 、issubset

    # str之子集：<、<=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")
#pythoners<linuxers: False
#pythoners<=linuxers: False
#javaers.issubset(javaers): True

  4. add()

    # set之add()
s = {1, 2, 'a'}
s.add(3)

print(s)
#{1, 2, 3, 'a'}

  5. remove()

    # set之remove()
s = {1, 2, 'a'}
s.remove(1)

print(s)
#{2, 'a'}

  6. difference_update()

    # str之difference_update()
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): {pythoners}")
#pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}

  7. discard()

    # set之discard()
s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)
#{1, 2, 'a'}

  8. isdisjoint()

    # set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
#pythoners.isdisjoint(linuxers): False

有序 or 无序

​ 无序

可变 or 不可变

​ 可变数据类型

四、数据类型总结

# 存一个值：整型/浮点型/字符串
# 存多个值：列表/元组/字典/集合

# 有序or无序
# 有序：字符串/列表/元组（序列类型）
# 无序：字典/集合

# 可变or不可变
# 可变：列表/字典/集合
# 不可变：整型/浮点型/字符串/元组

# 深浅拷贝（只针对可变数据类型） --. 用一定用不到，面试很大概率会问，这不是python独有的，而是一种语言独有的

五、Python深浅拷贝

# 主要内容

# 当lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变(*****)

# 当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化，lt2不变；lt1内部的可变元素变化，lt2变(******)

# 当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变(*****)

# 拷贝/浅拷贝/深拷贝 --> 只针对可变数据类型

s1 = 'nick'
s2 = copy.copy(s1)  # 无论s2是指向s1指向的值nick，还是自己新开辟内存空间

# 内置方法中的copy方法都是浅拷贝的copy，也就是说如果你的列表里面有可变数据类型，那就不要使用.copy方法
lt = [1,2,3,[1,]]
lt2 = copy.deepcopy(lt)

posted @ 2019-09-16 19:57  simple123  阅读(307)  评论(0)  编辑  收藏  举报