python day08 字典元组集合内置方法

Posted 2023-05-22 zfq132

字典的内置方法

定义方式

d = \'usernamne\':"kevin"

定义空字典：d =

1.key取值

dic = \'name\': \'kevin\', \'age\': 18, \'hobbies\': [\'play game\', \'basketball\']
print(dic[\'name\'])  # kevin
print(dic[\'hobbies\']) # [\'play game\', \'basketball\']
print(dic[\'hobbies\'][1]) # basketball

2.赋值操作

\'name\': \'jack\', \'age\': 18, \'hobbies\': [\'play game\', \'basketball\']
dic[\'name\'] = \'kevin\'  # \'name\': \'kevin\', \'age\': 18, \'hobbies\': [\'play game\', \'basketball\']
dic[\'gender\'] = \'male\' # 字典：当K存在的时候，就是修改操作，当k不存在的时候，就是增加一个key值 (重要)
# print(dic)
# dic1 = \'name\': \'yyy\'
# dic1[\'name\'] = \'xxx\'
# dic1[\'age\'] = \'aaaa\'
# dic1[\'gender\'] = \'xxx\'
# print(dic1)
# print(len(dic1))   # 3

3. 成员运算符 in 和 not in

d = \'username\':\'kevin\', \'age\':18
print(\'kevin\' in d) # False
print(\'username\' in d) # True
print(\'username\' not in d)  #False

4. 删除

d = \'username\':\'kevin\', \'age\':18
d.pop(\'username\')  # \'age\': 18 字典删除k值必须写上要删除的key值，不能通过索引删除值
del d[\'username\']  # \'age\': 18
print(d)

5. 键keys（），值values（），键值对items（）三剑客

d = \'username\': \'kevin\', \'age\': 18
print(d.keys())  # dict_keys([\'username\', \'age\'])  # 把它当成列表来记忆，把字典的所有key拿出来，组装成列表返回

print(d.values())  # dict_values([\'kevin\', 18]) #  把它当成列表来记忆，把字典的所有value值拿出来，组装成列表返回

# 返回的是列表套元组的形式，列表里面是一个个的小元组，元组里面是字典的k和v
print(d.items()) # dict_items([(\'username\', \'kevin\'), (\'age\', 18)])

6.循环

d = \'username\': \'kevin\', \'age\': 18
 for i in d.keys():
     print(i)
#
 for j in d.values():
     print(j)
d.items()----->dict_items([(\'username\', \'kevin\'), (\'age\', 18)])
for items in d.items():
     # items是元组啊
     print(items)  # (\'username\', \'kevin\')
     print(items)  # (\'age\', 18)
     print(items[0], items[1])

for dic in d:
     print(dic)  # 暴露的是k值

字典的其他方法

1. get

d = \'username\': \'jack\', \'age\': 18
print(d[\'username\'])
print(d[\'username1\'])  # 字典取值，如果key不存在，直接报错
print(d.get(\'username\'))  # jack
print(d.get(\'username1\'))  # None 如果使用get取值，key存在，则直接取出对应的值，如果key不存在，返回None
if d.get(\'username1\'):
    print(\'有值\')
else:
    print(\'无值\')

\'\'\'以后字典取值最好使用get取值，不会直接报错\'\'\'
print(d.get(\'username\', \'xxx\'))  # jack
print(d.get(\'username1\', \'xxx\'))  # xxx, get可以传递第二个参数，意思是默认值，当取出的key不存在的时候，直接返回第二个参数的值


d = \'username\': \'jack\', \'age\': 18, \'gender\':\'male\'
# popitem
print(d.popitem())  # (\'age\', 18)  (\'gender\', \'male\')
print(d)  # \'username\': \'jack\'    \'username\': \'jack\', \'age\': 18
\'\'\'代表的是删除字典的元素。但是，删除的值末尾的k：v，并且把最后一个k：v弹出来了\'\'\'

2. update

d = \'username\': \'jack\', \'age\': 18, \'gender\': \'male\'

\'\'\'update的功能是：如果字典的k存在，则修改原来的k，如果不存在，则添加一个新值\'\'\'
d1 = \'username\': \'tank\', \'hobbys\': [\'read\', \'music\']
d.update(d1)
print(d) # \'username\': \'tank\', \'age\': 18, \'gender\': \'male\', \'hobbys\': [\'read\', \'music\']

3. fromkeys(了解)

dic = dict.fromkeys([\'k1\',\'k2\',\'k3\', \'k4\'],[]) # 相当于是给字典批量赋值
print(dic)  # \'k1\': [], \'k2\': [], \'k3\': []
\'\'\'使用fromkeys初始化出来的值，占用的是一样的内存地址，有一个值改变了，其他值跟着改变\'\'\'

dic[\'k1\'].append(666)  # \'k1\': [666], \'k2\': [666], \'k3\': [666], \'k4\': [666]
dic[\'k2\'].append(999)  # \'k1\': [666, 999], \'k2\': [666, 999], \'k3\': [666, 999], \'k4\': [666, 999]
dic[\'k3\'].append(888)  # \'k1\': [666, 999, 888], \'k2\': [666, 999, 888], \'k3\': [666, 999, 888], \'k4\': [666, 999, 888]
print(dic)

4. setdefault

dic = \'k1\': 111, \'k2\': 222
res = dic.setdefault(\'k3\', 333)  # \'k1\': 111, \'k2\': 222, \'k3\': 333
res = dic.setdefault(\'k3\', 333)  # \'k1\': 111, \'k2\': 222, \'k3\': 333
print(dic)
print(res)  # 333
# key不存在则新增键值对，并将新增的value返回
# key存在则不做任何修改，并返回已存在key对应的value值

元组的内置方法

定义

使用小括号括起来，内部存放多个元素，元素之间逗号个隔开，元素值不支持修改(索引对应的那个元素不能修),不可变的列表。

1. 类型转换

print(tuple(\'hello\'))  # (\'h\', \'e\', \'l\', \'l\', \'o\')
print(tuple((1, 2, 3, 4)))  # (1, 2, 3, 4)
print(tuple([1, 2, 3, 4, 5]))  # (1, 2, 3, 4, 5)
print(tuple(\'a\': 1, \'b\': 2))  # (\'a\', \'b\')
print(tuple(1, 2, 3, 4))  # (1, 2, 3, 4)

2. 索引取值

t = (1, 2, 3, 4)
print(t[0])
print(t[1])
print(t[2]) # 索引取值，索引从0开始
print(t[-1])
print(t[-2]) # 负数代表的就是方向

3. 切片

t = (1, 2, 3, 4)
print(t[0:2])  # (1, 2)
print(t[0:])  # (1, 2)
print(t[:2])  # (1, 2)
print(t[0:3:2])  # (1, 2)

4. 求长度

t = (1, 2, 3, 4)
print(len(t))

5. 成员运算 in 和 not in

tup = (1, 2, 3, 4, 5, 6, )
print(1 in tup)
# True

 

6. 循环

tup = (1, 2, 3, 4, 5, 6, )
for i in tup:
    print(i)

7. 单一元素元组

\'\'\'当元组内只有一个元素的时候，也要加上逗号结尾，否则不是元组类型！\'\'\'t = (123, )
\'\'\'建议：
        只要是容器类型，当元素只有一个的时候，建议都加上逗号
容器类型：
    只要是能够存放多个元素的数据类型都可以称之为是容器类型
\'\'\'

集合的内置方法

定义：

使用大括号括起来，内部存放多个元素，元素之间逗号隔开，不是k:v键值对的形式

s = 1, 2, 3, 4

集合功能：

去重、集合运算、无序

1. 类型转换

# 空集合
set（）
print(set(123))   不行
print(set(123.1)) 不行
print(set(\'hello\'))  # \'e\', \'o\', \'l\', \'h\'
print(set([1, 2, 3, 4, 4, 3, 2, 1]))  # 1, 2, 3, 4
print(set((1, 2, 3, 4, 5)))  # 1, 2, 3, 4, 5
print(set(\'username\': \'kevin\', \'age\': 28))  # \'age\', \'username\'
\'\'\'集合能够把支持for循环的数据类型都转为集合类型!\'\'\'

练习：

name_list = [\'kevin\', \'tank\', \'tony\', \'tony\', \'jack\', \'jack\', \'jack\', \'tony\', \'ly\',]
# 基本要求：去重
print(set(name_list))  # \'tank\', \'jack\', \'kevin\'

# 再次转为列表
print(list(set(name_list)))  # [\'kevin\', \'tank\', \'jack\']

#### 拔高要求
# 去重，并且保留原来的顺序

new_list = [] # 用来存放取出之后的元素
for name in name_list:
    # name----->列表的一个个元素
    if name not in new_list:
        new_list.append(name)

print(new_list)  # [\'kevin\', \'tank\', \'tony\', \'jack\', \'ly\']

2. 集合的关系运算

friends1 = "zero","kevin","jason","egon" # 用户1的好友们
friends2 = "Jy","ricky","jason","egon" # 用户2的好友们

1.合集/并集（|）：求两个用户所有的好友（重复好友只留一个）

print(friends1 | friends2) # \'zero\', \'kevin\', \'ricky\', \'Jy\', \'jason\', \'egon\'

2. 交集（&）：求两个用户的共同好友

print(friends1 & friends2)  # \'jason\', \'egon\'

3. 差集（-）

print(friends1 - friends2)  # \'kevin\', \'zero\'
print(friends2 - friends1)  # \'Jy\', \'ricky\'

4. 对称差集（^）：求两个用户独有的好友们（即去掉共有的好友）

print(friends1 ^ friends2)

5. 值是否相等（==）

print(friends1 == friends2) # False

6. 父集（>=）:一个集合是否包含另外一个集合

print(1, 2, 3 >= 1, 2, 3) # True

7. 子集（<）:一个集合是否被另外一个集合包含

print(1, 2, 3 < 1, 2) # False

8.集合练习题

一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons=\'ly\',\'qq\',\'kevin\',\'ricky\',\'gangdan\',\'biubiu\'
　　linuxs=\'kermit\',\'tony\',\'gangdan\'
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
>>> pythons & linuxs
# 求出所有报名的学生名字集合
>>> pythons | linuxs
# 求出只报名python课程的学员名字
>>> pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
>>> pythons ^ linuxs

 

3. 内置方法

1. 长度（len）

s=\'a\',\'b\',\'c\'
len(s)

2. 成员运算（in  not in）

s = 1, 2, 3, 4, 
print(1 in s)
# True

3. 循环

for item in s:
    print(item)

 

Python Day2 数据类型： 列表元组和字典

列表(List)

列表是指一组有序的数据集合,可以将各种各样的数据有序的存放在列表 中,并且可以对其进行增删改查,以及遍历。列表的存在是为了通过一个变量存 储更多的信息 

通过 len()内置函数可查看列表中元素的个数

>>> len(list)

你可以通过索引来找到列表中每个元素的位置,记住索引是从 0 开始的 

>>> shopping_list[2] #找Bike

>>> shopping_list[0] #第一个元素取出来
>>> shopping_list[-1] #-1代表取列表中最后一个元素‘Gift‘
>>> shopping_list[-3] #取倒数第3位元素‘Clothes‘
>>> shopping_list[-4] #取倒数第4个元素

切片(Slice)

你还可以从列表中取出指定多个元素,这种操作叫做切片

>>> shopping_list[0:3] #取0到第3个元素,不包括第4个
>>> shopping_list[:3] #同上,取0到第3个元素,不包括第4个,0可以不写
>>> shopping_list[2:5] #取第3至第5个元素
>>> shopping_list[:-3] #取从0至倒数第3个元素
>>> shopping_list[-3:] #取最后3个元素
>>> shopping_list[1:8:2] #从1至8隔一个取一个,后面的2是步长,即每隔几个元素取一个
>>> shopping_list[::2] #从头到位每隔一个取一个

增删改查 

>>> shopping_list.append(‘MovieTicket‘) #向列表后面追加一个元素
>>> shopping_list.pop() #删除最后一个元素
>>> shopping_list.remove(‘Mac‘) #删除叫’Mac’的元素,如果有多个’Mac’,那会删除从左边数找到的第一 个
>>> shopping_list[2] = ‘COFFEE‘ #将索引为2的元素改为”COFFEE”,原来是小写
>>> shopping_list.insert(3,"Toy") #插入一个新元素,索引为3

>>> shopping_list.index(‘Toy‘) #返回’Toy’元素的索引值,如果有多个相同元素,则返回匹配的第一个
>>> shopping_list.append(‘Food‘)
>>> shopping_list.count(‘Food‘) #统计’Food’的元素的个数,刚添加了一个,所以现在是2个
>>> list2= [‘Banana‘,‘Apple‘] #创建一个新列表
>>> shopping_list.extend(list2) #把上面的新列表合并到shopping_list中
>>> shopping_list.sort() #将列表排序
>>> shopping_list.reverse() #将列表反转
>>> del shopping_list[3:8] #删除索引3至8的元素,不包括8
>>> for i in shopping_list: #遍历列表
... print i 

本文出自 “风继续吹” 博客，谢绝转载！