基本数据类型--列表、元组、字典、集合

2.元组

tuple 用括号括起来，相当于对列表的二次加工，一级元素不可被修改、被增加或者删除，二级及其以上可以，一般写元组的时候，推荐在最后加入逗号 , 元组也是一个可迭代对象，元组是有序的

元组类中的实例方法

tu = (11,22,33,44,”dd”,[1,2,3],)    #元组，
tu.count(22)    #获取指定元素在元组中出现的次数
tu.index(22)    #获取指定元素在元组中的索引（最左边）

深灰魔法

tu = (111,"alex",(11,22),[(33,44)],True,33,44,)   #书写格式

v = tu[0]   #索引取值
print(v)

v = tu[0:2]  #切片取值
print(v)

for item in tu:  #可以被for循环，可迭代对象
    print(item)

# 相互转换
s = "asdfasdf0"
li = ["asdf","asdfasdf"]
tu = ("asdf","asdf")

print(tuple(s))    # 字符串转换成元组
print(tuple(li))   # 列表串转换成元组
print(list(tu))    # 元组串转换成列表

print("_".join(tu))
#元组转换为字符串，全部为字符串的时候可以用这个方法，当有数字或者其他的时候用for

li = ["asdf","asdfasdf"]
li.extend((11,22,33,))   # 参数为可迭代对象，可以用元组
print(li)

#元组的一级元素不可修改/删除/增加
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
print(tu[3][0][0])
tu[3][0] = 567    #修改二级元素
print(tu)

3.字典

哈希：一般叫做“散列”，把任意长度的输出，通过散列算法，变换成固定长度的输出，该输出就是散列值。扎种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的出入可能会散列城相同的输出，所以不可能从散列值来唯一确定出入值，简单的说就是将一种任意长度的消息压缩到某一固定长度的消息摘要的函数

特征：Hash值的计算过程是依据这个值的一些特征计算的，这就是要求hash的值必须固定，因此hash的值必须是不可变的
用途：避免哈希冲突
- 文件签名避免发送的问价被篡改
- md5加密避免密码被截获无法反解
- 密码验证

字典特性：

key-value结构
key必须可哈希，切必须为不可变数据类型、必须唯一
可以存放任意多个值、可修改、可以不唯一
无序
查找速度快

上代码：

# 1 dict类 查找非常的块，不用循环
# 基本结构，大括号，内存中按照哈希表保存的
# 键值对, 冒号前面为key,冒号后面为value,构成一对，逗号分隔,如果有相同的key，只随机保留一个

info = {
     "k1": "v1",
     "k2": "v2"
}

# 2 字典的value可以是任何值

info = {
     "k1": 18,
     "k2": True,
     "k3": [
         11,
         [],
         (),
         22,
         33,
         {
             'kk1': 'vv1',
             'kk2': 'vv2',
             'kk3': (11,22),
         }
     ],
     "k4": (11,22,33,44)
}
print(info)
info[key] = value   # 修改对应内容或者增加内容


#  3 列表、字典不能作为字典的key，布尔值（True相当于1,False相当于0），
# 元组，数字，字符串可以作为字典的key
info ={
     1: 'asdf',
     "k1": 'asdf',
     True: "123",
     # [11,22]: 123 错误
     (11,22): 123,
     # {'k1':'v1'}: 123 错误
}
print(info)

# 4 字典无序

print(info)

# 5、索引方式找到指定元素，用法为对象[key]，不能通过切片的方式寻找（无序）

print(info['k1'])
print(info[2])
print(info['k3'][5]['kk3'][0])

# 6 字典支持 del 删除  del info[:] 全清空空

del info['k1']  # del 删除
del info['k3'][5]['kk1']
print(info)

# 7 for循环

for item in info:
     print(item)    # 默认输出key

for item in info.keys(): # dict类提供的实例函数，输出key
     print(item)

for item in info.values(): # dict类提供的实例函数，输出value
     print(item)

for item in info.keys():
     print(item,info[item])  # 获取所有的值

for k,v in info.items():  #dict类提供的静态方法，输出key和value
     print(k,v)

dic = {
     "k1": 'v1',
     "k2": 'v2'
}
v = dict.fromkeys(["k1",123,"999"],123)  # 1 根据序列，创建字典，并指定统一的值
print(v)

v = dic['k11111']  # 1 根据Key获取值，如果key不存在时，报错
print(v)

v = dic.get('k1', 11) # 2 根据Key获取值，如果key不存在时，默认返回None或者返回指定值
print(v)

v = dic.pop('k1',90)  # 3 删除并获取值，如果不存在该key返回指定值90.
print(dic,v)

k,v = dic.popitem() #随机删除一个键值对并获取值
print(dic,k,v)

v = dic.setdefault('k111','123')
# 4 设置值。已存在，不设置，获取当前key对应的值；不存在，设置，获取当前key对应值
print(dic,v)

# 5 更新
dic = {
     "k1": 'v1',
     "k2": 'v2'
}
dic.update({'k1': '111111','k3': 123})  # 5 更新,存在的覆盖掉，不存在的追加一个
print(dic)

dic.update(k1=123,k3=345,k5="asdf")  #这种写法也可以
print(dic)

示例

info = {
    "test1":"first",
    "test2":"second",
    "test3":"thired"
}

dic = {
    "1":"one",
    "2":"two"
}

print("test1" in info)

print(info.get("test1"))   #不会报错,如果不存在，返回none
print(info.get("test1",1))   #如果不存在，返回 1

print(info["test1"])   #可能会报错

info["test4"] = "fourth"  #添加
info["test4"] = "fourth"  #修改

print(info.pop('test1')) #删除该值并返回
info.popitem()  # 随机删除一个
del info["test1"]  # 删除改键值对

info.items()  #将keys和values和转化成一个个小元组，再返回一个对象列表

info.update(dic) #将两个列表合并到本对象,有相同的会被覆盖

info.setdefault("key","value") #有key ,返回key值，没有就创建

print(dict.fromkeys(["a","b"],"alex")) #静态方法，生成字典，批量生成value

# 字典是可迭代的，但查询字典最好如下，这样可以节省很多时间，所以不要将字典内容变成列表再遍历
if "test2" in info:  #字典默认打出keys
    print("haha")

4.布尔值

None "" () [] {} 0 ==>表示 False
bool()转换这些都是False,其他的都是True,包括-1

示例

if not {}:
    print('haha')

bool(...) #转换为bool值

print(bool({}))
print(bool({21,}))

字符串补充

value = '5+9'
v1,v2 = value.split(“+”)
#自动将值赋值给v1和v2

a = 'a'
b = 'b'
a,b = b,a
print(a,b)

5.集合

set 类
可以由不同元素组成（相同类型中相同的值会只保留一个）、无序、元素为不可变类型（数字、字符串、元组），可修改
s = {1,2,3,4,5} # 定义集合，不能通过索引取值
s = set('hello') # 一种定义方式，value为可迭代对象 {'h', 'e', 'o', 'l'}

内置方法

s = {1,2,3,4,5,6}
s.add(6)   # 添加一个元素
s.clear()   # 清空集合元素
s1 = s.copy  # 浅拷贝
s1 = s.pop()  # 随机删除一个元素并取值
s.remove(2)    # 指定删除，如果不存在，会报错
s.discard('1111')  # 指定删除，如果不存在，不会报错

集合的关系测试

# 一、自身不变
p_s={'lcg','szw','zjw','lcg'}
l_s={'lcg','szw','sb'}

p_s.intersection(l_s) # 求交集,返回这个集合
p_s&l_s # 简写方式

p_s.union(l_s)  #求并集,返回这个集合
p_s|l_s)        #简写方式

p_s.difference(l_s)  #差集,返回这个集合 ，位置交换意义不同
p_s-l_s  #差集,返回这个集合

p_s.symmetric_difference(l_s) #交叉补集,返回这个集合
p_s^l_s   #交叉补集,返回这个集合

# 二、自身更新
p_s={'lcg','szw','zjw','lcg'}
l_s={'lcg','szw','sb'}
print(p_s,l_s)
p_s.difference_update(l_s) # Remove all elements of another set from this set将本身集合中和另一个集合共同的元素删除，返回None
p_s.symmetric_difference_update(l_s) # 将本身集合中和另一个集合共同的元素删除并将另一个独有的元素添加到                                       本身集合中，返回None

s1={1,2}
s2={1,2,3}
s1.update(s2)    # 更新多个值
s1.add(1)        # 只能更新一个值
s1.union(s2)     # 这种不更新，只返回值

# 三、返回布尔值
s1={1,2}
s2={2,3,5}
print(s1.isdisjoint(s2)) # 如果两个set没有交集，返回True
print(s1.issubset(s2))   # 判断s1 是s2 的子集 也可以表示为s1 <= s2
print(s2.issuperset(s1)) # 判断s1 是s2 的父集  也可以表示为s2 >= s1

# 四、补充
一般集合是可变的（追加、删除），但是无法修改里面含有的元素
s=frozenset('hello')   #定义不可变集合
names=['alex','alex','wupeiqi']
names=list(set(names))    #可以用这种方式简单去重，不考虑顺序

6.补充

posted @ 2018-06-28 17:34 哈哈大圣阅读(260) 评论(0) 编辑收藏举报

刷新页面返回顶部

哈哈大圣

代码谱写的乐章