初学python之路-day06

时间:2021-10-28 19:07:10

每天一篇总结,今天学习了大概有深浅拷贝,元组类型,字典类型与集合类型。第一次感觉有点难度,需要花费多点时间来掌握。

深浅拷贝,分为值拷贝、浅拷贝、深拷贝。

ls = [1, 'abc', [10]]

值拷贝:ls1 = ls  ==> ls1直接将ls中存放的地址拿过来

值拷贝的具体表现: ls1直接将ls中存放的地址拿过来。当ls内部的值发生任何变化时,ls1与ls中存放的地址时一致的,因此ls1必定随之变化。

浅拷贝:ls2 = ls.copy()

浅拷贝后,ls2是新开辟空间来存放ls中存放的地址,但列表中的地址都是直接从ls列表中拿来。因此ls内部的可变类型值发生改变,ls2会随之变化;ls2内部的不可变类型值地址还是与原来地址相连,因此不会变化。

深拷贝:ls3 = deepcopy(ls)

深拷贝后,ls3是新开辟空间来存放ls中存放的地址,但由于pycharm的优化机制,不改变类型数据地址不变,但是列表中的地址是需要新开辟空间来存放地址的。最后的结果:ls内部的所有类型的值发生改变,ls3都不会随之变化。

元组类型:

元组:可以理解为不可变的列表
   1.值可以为任意类型
   2.可以存放多个值 - 可以进行成员运算
   3.可以存放重复的值 - 可以计算成员出现的次数
   4.有序存储 - 可以通过索引取值,可以切片

元组的常用操作:

1.索引取值
  print(t1[1], type(t1[1]))
  print(t1[-3])

2.运算(拼接)
  print((1, 2) + (2, 3))

3.长度
  print(len(t1))

4.切片
  print((2, 1, 3)[::-1])

5.成员运算
  print(True in t1)
  print(False in t1) False == 0, t1中如果有0或False,该结果都是True

6.for循环
  for obj in t1:
  print(obj, end=" ")
  print()

元组的使用方法:count  |  index

print(t1.count(0)) 对象0在元组中出现的次数

print(t1.index(123, 4, len(t1))) 对象0在区间4~末尾第一次出现的索引

字典类型:

字典概念:

1.容器(集合):存放多个值的变量
  2.单列容器(系统中的单列容器很多):list | tuple
  3.双列容器(map):只有dict,存放数据 成对出现,dict存放数据采用 key-value键值对方式

字典的须知:

  1. 字典中的key可以为什么类型:key必须为不可变类型
  2. key是取value的唯一依据,key一旦被确定,就需要唯一确定(不能被改变)
  3. 字典中的value可以为什么类型:value可以为任意类型
  4. value是用来存放世间所有存在的数据

key要确保唯一性,不能重复,值可以重复,并且可以被改变 => 字典为可变类型

dic = {'a': 10, 1: 20, True: 30, (): 40} 1和True都是1,key具有唯一性,所以只保留最后一次值
print(dic) {'a': 10, 1: 30, (): 40}

字典的定义:

1.空字典
  d1 = {}
  d2 = dict()
2.用map映射创建字典
  d3 = dict({'a': 1, 'b': 1})
  print(d3)
3.用关键字赋值方式
  d4 = dict(name='Bob', age=18) 参数=左侧的名字就是合法的变量名,都会被转化为字符串形式的key
  print(d4)
4. 创建有多个key值采用默认值的方式: 默认值不写默认None,也可以自定义
  d5 = {}.fromkeys('abc', 0)
  print(d5)

字典的常用操作:

dic = {'a': 1, 'b': 2}
print(dic)

1.增: 字典名[key] = 值 => key已存在就是修改值,不存在就是新增值
  dic['c'] = 3
  print(dic)
2.改
  dic['c'] = 30
  print(dic)
3.查:字典名[key]
  print(dic['c']) 只能查找已有的key,没有崩溃
有默认值的查询:有key取出对应value,没有返还默认值,默认值可以自定义
  print(dic.get('d', 'http://www.baidu.com'))

4.删
  print(dic)

5.清空
  dic.clear()
  pop(k)删除指定key的value并返还删除的value
  res = dic.pop('a')
  从dic末尾删除,返还(key, value)形成的元组
res = dic.popitem()
print(dic, res)

其他的方法:

1.更新: a有值覆盖,c没被新操作,带下来,b为新增,增加并赋值

dic = {'a': 1, 'c': 2}
d = {'a': 10, 'b': 20}
dic.update(d)
print(dic) {'a': 10, 'c': 2, 'b': 20}

2.带默认值的新增: 新增key,key已有,啥事不干,没有添加key,值就是第二个参数

dic.setdefault('z', 100)
print(dic)

字典的循环:

1.直接循环,就是循环得到key
   for k in dic:
   print(k)

2.循环keys
  print(dic.keys())
   for k in dic.keys():
   print(k)

3.循环values
   print(dic.values())
   for v in dic.values():
  print(v)

同时循环key和value (key, value)
  print(dic.items())
  a, b = (1, 2)
  print(a, b)
  for res in dic.items():
  print(res)
  重点:
  for k, v in dic.items():
  print(k, v)

解压赋值
  a, _, _, b = (1, 2, 3, 4)

集合类型:

s=set()

此为空集合,虽然集合都是用{}表示,但是{}代表的是空字典。

集合概念:

  1. 1.set为可变类型 - 可增可删
  2. 2.set为去重存储 - set中不能存放重复数据
  3. 3.set为无序存储 - 不能索引取值
  4. 4.set为单列容器 - 没有取值的key
  5. 总结:set不能取值

集合的使用方法:

1.增

s.add('1')
s.add('2')
s.add('1')
print(s)
s.update({'2', '3'})
print(s)

2.删

res = s.pop()
print(res)
s.remove('1')
print(s)
s.clear()
print(s)

集合set运算:

1.交集:两个都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx)
print(py.intersection(lx))

2.合集:两个的合体 |
print(py | lx)
print(py.union(lx))

3. 对称交集:抛出共有的办法的合体 ^
print(py ^ lx)
print(py.symmetric_difference(lx))

4. 差集:独有的
print(py - lx)
print(py.difference(lx))

5. 比较:前提一定是包含关系
s1 = {'1', '2'}
s2 = {'2'}
print(s1 < s2)