day4-python基础-数据类型

今日份小技巧

a =3

b=4,

最快将a和b值替换的方法为

a,b =b,a

今日内容

1. 字典

2. 集合

3.hash

4.基本数据类型总结

5.循环之for循环

6.range的使用

7.深浅copy

 

开始第四天的预习，

 

1.数据类型之字典

　　1.1 字典的定义以及特性

　　定义：字典是一种（key-value）型数据类型，python对key进行哈希运算，决定value的位置，所以字典是无序的，key必须可哈希并且不可变

　　特性：可以存放任意个值，可以修改，可以不唯一，查找速度快。列表是一个有序对象集合，字典是一个无序的对象集合，列表是通过偏移来查找数据，字典是通过键值来查找数据

　　####字典在python3.5以及3.5版本中是无序的，3.6优化了机制，字典会按照字典创建之初排序####

　　1.2 字典的常用方法-增　

方法一：传统方法
dic = {'1':'abc','2':'cde'}
dic['key']= [1,2,3,4,5]
print(dic)
#结果，字典是无序的，只是这个显示是这样
{'1': 'abc', '2': 'cde', 'key': [1, 2, 3, 4, 5]}

方法二：setdefault
#方法就是给字典中添加键值对，如果只有键，则值为none，如果值在以前存在，则不对值做修改
dic = {'1':'abc','2':'cde'}

dic.setdefault('k')
print(dic)
dic.setdefault('k1','v')
print(dic)
dic.setdefault('k1','v1')
print(dic)
print(dic.setdefault('k1','v1'))

#结果。可以看出setdefault返回值为value
{'1': 'abc', '2': 'cde', 'k': None}
{'1': 'abc', '2': 'cde', 'k': None, 'k1': 'v'}
{'1': 'abc', '2': 'cde', 'k': None, 'k1': 'v'}
v

　　1.3 字典的常用方法-删

#第一种，删除返回值,有key返回对应的值，无key返回默认值，默认值需要设定
dic = {'1':'abc','2':'cde'}

print(dic.pop('1'))
print(dic)
#结果
abc
{'2': 'cde'}

#第二种，删除不返回值
dic = {'1':'abc','2':'cde'}
del dic['2']
#结果
{'1': 'abc'}

#第三种，随机删除，在python3.6以及以后的版本中，都是删除的最后一个
dic = {'1':'abc','2':'cde'}
print(dic.popitem())

print(dic)
#结果
('2', 'cde')
{'1': 'abc'}
#第四种，清空字典
dic = {'1':'abc','2':'cde'}
dic.clear()

print(dic)
#结果
{}
#第五种，使用通用办法del，对字典内容进行删除

　　1.4 字典的常用方法-改

#方法一：基本方法
dic = {'1':'abc','2':'cde'}
dic['1']= 'abbbbb'

#方法二：字典更新，俩个列表更新，如果有不同的key，则赋值，如果有相同的key，值覆盖对应的值
dic = {'1':'abc','2':'cde'}
dic2 = {'3':'44444','2':'abbb'}
dic.update(dic2)
print(dic)

#结果
{'1': 'abc', '2': 'abbb', '3': '44444'}

#方法三：字典的更新，不过也是用的updata来做
dic = {'1':'abc','2':'cde'}
dic.updata(weight ='80KG')#谨记，采用这种办法，括号内左边的值相当于变量名，后面为为变量赋值，函数会将俩个值转变为一个键值对给字典赋值，前面变量名不可为数字

　　1.5 字典的常用方法-查

#方法一，直接查找，若有返回对应的键值，如果没有对应的键，则报错
dic = {'1':'abc','2':'cde'}
print(dic['1'])
print(dic['3'])
#结果
Traceback (most recent call last):
abc
  File "D:/pycharm/全栈三期/day3/test.py", line 309, in <module>
    print(dic['3'])
KeyError: '3'

#方法二，查找，若有返回对应的键值，如果没有则返回设定的默认值
dic = {'1':'abc','2':'cde'}
print(dic.get('1','无'))
print(dic.get('3','无'))
print(dic)
#结果
abc
无
{'1': 'abc', '2': 'cde'}

　　1.6 字典的常用方法-循环

dic = {'1':'abc','2':'cde'}
for i in dic:
    print(i)

for i in dic.items():
    print(i)

for k,v in dic.items():
    print(k,v)

#结果
1
2
('1', 'abc')
('2', 'cde')
1 abc
2 cde

　　1.7 字典的常用方法-其他方法

# item = dic.items()
# print(item,type(item))  # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 这个类型就是dict_items类型，可迭代的

# keys = dic.keys()
# print(keys,type(keys))  # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>

# values = dic.values()
# print(values,type(values))  # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上

　　1.8字典的相关函数

#.fromkeys函数，快速生成大量数
dic = dict.fromkeys([1,2,3],['alex'])
print(dic)

dic [1].append('sb')
#坑#这个函数用法是前面一个可迭代对象，后面为一个随意值，不过后面的值为可变对象，就会发现所有生成的字典对象都会变更

print(dic)

#结果
{1: ['alex'], 2: ['alex'], 3: ['alex']}
{1: ['alex', 'sb'], 2: ['alex', 'sb'], 3: ['alex', 'sb']}

2.数据类型之集合

　　2.1 集合的定义以及特性

　　定义：集合是一个无序的，不重复的数据组合，s ={1,2,3,4}则直接创建

　　特性：自动去重，将列表转换为集合则会自动去重，主要作用为关系测试  l = [1,2,3,4]  s =set(l)则直接转换为集合

　　2.2 集合的增删改查

　　s.add() #增加，一次只能增加一个

　　s.pop() #删除，随机删除一个值

　　s.remove() #指定删除一个值

　　s.discard() #丢弃，删除一个值，不存在则不报错，存在则删除！

　　s.update() #把一个集合和另外一个集合合并，update可以一次性添加多个值

　　2.3 集合的关系运算

　　关系运算算是集合经典使用方法了，下面就来看一下集合的关系运算，举个例子，有些人只买iphone7有些人只买iponeX

　　2.3.1 交集

iphone6sp ={'alex','jack','tom','tony','happy','sugimoto','mizutani'}
iphoneX ={'happy','yuki','sugimoto'}

#交集
print(iphone6sp.intersection(iphoneX))
print(iphone6sp&iphoneX)

#结果
{'sugimoto', 'happy'}
{'sugimoto', 'happy'}

　　2.3.2 差集

#差集,有先后顺序，是前一个差后面
print(iphone6sp.difference(iphoneX))
print(iphone6sp-iphoneX)

#结果
{'mizutani', 'jack', 'tom', 'tony', 'alex'}
{'mizutani', 'jack', 'tom', 'tony', 'alex'}

　　2.3.3 并集

#并集
print(iphone6sp.union(iphoneX))
print(iphone6sp|iphoneX)

#结果
{'yuki', 'tony', 'mizutani', 'jack', 'sugimoto', 'tom', 'happy', 'alex'}
{'yuki', 'tony', 'mizutani', 'jack', 'sugimoto', 'tom', 'happy', 'alex'}

　　2.3.4 对称差集

#对称差集
print('只买苹果6sp和苹果X的人')
print(iphone6sp.symmetric_difference(iphoneX))
print(iphone6sp^iphoneX)

#结果
只买苹果6sp和苹果X的人
{'yuki', 'mizutani', 'jack', 'tom', 'tony', 'alex'}
{'yuki', 'mizutani', 'jack', 'tom', 'tony', 'alex'}

　　2.3.5 超集子集

#超集子集
s1 ={1,2,3,4,5,'jack'}
s2 = {1,2,3}
#判断子集
print(s2.issubset(s1))
print(s1 > s2)         #都是判断s2是不是s1的子集

#判断超集
print(s2.issuperset(s1))
print(s1< s2)          #都是判断s2是不是s1的超集



#结果
True
True
False
False

　　2.4 集合的其他用法

　　.isdijoint(s2)#判断俩个集合可交集

　　.difference_update() #把俩个集合的差集赋值给后者

　　.intersection_updata() #把俩个集合的交集赋值给后者

3.数据类型之hash

　　3.1 hash的定义以及特性

　　hash一般称之为“散列”，将任意长度的消息压缩到某一固定长度的消息摘要

　　3.2 hash的用法

　　hash值固定，不可更改,只有不可变类型才能被hash

　　3.3 hash的使用环境

　　一般用途为文件签名，md5加密，密码验证

　　用法就是.hash()

4.数据类型的总结

　　4.1 按照存储空间来分，从小到大　　

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

　　4.2 按照存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

 

 

 

　　4.3 按照可变不可变区分（hash）

可变	列表，字典
不可变	数字，字符串，元组，布尔值

 

 

 

　　4.4 按照访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

  

 

 

 

　　4.5 数据类型之间的转换

　　现有的数据类型有

　　int（整型）

　　str（字符串）

　　bool  布尔值）

　　list（列表）

　　dict（字典）

　　tuple（元祖）

　　set（集合）

　　主要的数据类型转换

　　int <------>str (要转换就在前面加类型)，str(),int() 

　　int <------>bool,非零为真，零为假;布尔值转为数字，真为1，假为0

　　str  ------>bool,非空为真，空为假;,bool值转为字符串无意义

　　str <------>list  str转list用splite,list转str用join  ****

　　空列表，空字典，空元祖，空集合，对应的都是bool值得假

　　list <------>set (要转换就在前面加类型),list转换为set自动去重

　　list <------>tuple(要转换就在前面加类型)

　　dict ------->list 打印字典的key值

　　dict ------->tuple 打印字典的key值

　　4.6 数据类型的补充

# 元组中只有一个元素并且没有逗号，则他不是元组与元素数据类型相同。
# tu1 = (1)
# tu2 = ('alex')
# tu3 = ([1,2,3])
# print(tu1, tu2, tu3)
#结果
1 alex [1, 2, 3]
#不过加了逗号就都变成集合了
(1,) ('alex',) ([1, 2, 3],)

 　　4.7 列表与字典的一些特殊处理方法

　　题目一：# li = [11, 22, 33, 'alex', 55]  将列表中索引为奇数位的元素删除。

　　错误解法：

li = [11, 22, 33, 'alex', 55]
for i in range(len(li)):
    if i %2 ==1:
        li.pop(i)
print(li)

#错误结果
[11, 33, 'alex']
#结果发现并没有我们预期的55

　　正确解法

del li[1::2]
print(li)
#或者是倒序取值，倒着切
#结果
[11, 33, 55]

　　题目二：dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}，将字典中键含有k元素的键值对删除

　　错误解法

dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}
for key in dic:
    if 'k' in key:
        dic.pop(key)
#结果
RuntimeError: dictionary changed size during iteration
翻译过来就是说字典的长度在迭代中修改了

　　正确解法

dic = {'k1':1,'k2':2, 'k3': 3, 'name': '太白'}
l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
for k1 in l1:
    dic.pop(k1)
print(dic)
#结果
{'name': '太白'}

　　总结：在循环一个列表时，最好不要改变列表的大小，这样会影响你的最终结果。在循环一个字典时，不能更改字典的大小，否则会报错！

5.循环之for循环

　　5.1 for循环也是在python中经常用到的内容，用户按照顺序循环迭代可迭代对象

　　      字符串，列表，元祖，字典都可以迭代

　　5.2 与for循环相关的就是enumerate,就是枚举 

　　　   对于于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

list = [1,2,3,4,5,6]
for i in enumerate(list):
    print(i)

for i ,j in enumerate(list):
    print(i,j)

#结果
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
0 1
1 2
2 3
3 4
4 5
5 6

6.range的使用

指定范围生成指定数字以及内容，可迭代对象

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)

7.查漏补缺之深浅copy

深浅copy放在单独的一个去书写