本文主要是介绍列表内置方法 元组内置方法 字典内置方法 集合内置方法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 列表内置方法
  • 特点
  • 一.统计列表中数据值的个数
  • 二.增加数据值
    • 1..append()
    • 2..insert()
    • 3.扩展列表
      • 方式一：
      • 方式二：
      • 方式三
  • 三.查询数据与修改数据
  • 四.删除数据
    • 1.通用删除
    • 2.指名道姓删除
    • 3. .pop()
  • 五.查看数据值对应的索引值
  • 六.统计数据值出现的次数
  • 七.排序
  • 八.翻转
  • 九.比较运算
• 元组内置方法
  • 1.类型转换
  • 2.相关操作
• 字典内置方法
  • 1.类型转换(了解即可)
  • 2.相关操作
    • 1.字典内K:V键值对是无序的
    • 2.取值操作
    • 3.统计键值对个数
    • 4.修改数据
    • 5.新增数据
    • 6.删除数据
    • 7.快速获取键、值、键值对数据
    • 8.修改字典数据（键存在是修改，不存在是新增）
    • 9.快速构建字典（给的值默认情况下所有键都用同一个）
    • 10.键存在则获取键对应的值，键不存在则设置，并返回设置的新值
• 集合内置方法
  • 一.标志：
  • 二.类型转换
  • 三.注意事项
    • 1.定义集合需要使用关键字才可以
    • 2.集合内数据必须是不可变类型（整型 浮点型 字符串 元组 布尔值）
  • 四.功能
    • 1.去重
    • 2.关系运算
• 可变与不可变类型
  • 一、可变类型 list
  • 二、不可变类型 str、int、float
• 作业
  • 作业一
  • 作业二
  • 作业三

列表内置方法

特点

​ 列表在调用内置方法后不会产生新的值，而是修改自身

一.统计列表中数据值的个数

l1 = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
l2 = [77, 33, 22, 44, 55, 99, 88]
print(len(l2))		# 输出 7

二.增加数据值

1..append()

​ 括号内无论写什么数据类型，都当成一个数据值追加

l1.append('owen')
print(li) 		
#输出 ['jason', 'kevin', 'oscar', 'tony', 'jerry','owen']

2..insert()

​ 括号内无论写什么数据类型，都当成是一个数据值插入

l1.insert(0,'插队')
print(l1)
# ['插队', 'jason', 'kevin', 'oscar', 'tony', 'jerry']
l1.inster(0,[1,2,3])
print(l1)
# 报错 AttributeError: 'list' object has no attribute 'inster'

3.扩展列表

l1 = [11, 22, 33, 44, 55]
l2 = [1, 2, 3]

方式一：

for i in l1:
    l2.append(i)
print(l2)
# 输出[1, 2, 3, 11, 22, 33, 44, 55]

方式二：

print(l1 + l2)

方式三

li.extend(l2)
# 括号里必须是支持for循环的数据类型

三.查询数据与修改数据

l1 = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
print(l1)		# ['jason', 'kevin', 'oscar', 'tony', 'jerry']
print(l1[0])	# jason
print(l1[1,4])	# 报错
l1[0] = 'zhang'
print(l1)		#['zhang', 'kevin', 'oscar', 'tony', 'jerry']

四.删除数据

1.通用删除

​ 通过索引

del l1[0] 	

2.指名道姓删除

​ 括号内必须填写明确的数据值

res = l1.remove('jason')

3. .pop()

​ 先取值再删除

res = l1.pop() 		# 默认取出列表尾部的数据值，然后再删
res = l1.pop(0)		# 索引取值

五.查看数据值对应的索引值

print(l1.index('jason'))

六.统计数据值出现的次数

print(l1.count('jason'))

七.排序

l2.sort() 	#升序
l2.sort(reverse = True) 	# 降序

八.翻转

l1.reverse() 	#前后颠倒

九.比较运算

new_1 = [99,11]
new_2 = [11,22,33,44]
print(new_1 > new_2)		# True  按位置顺序一一比较
new_1 = ['a',11]
new_2 = [11,22,33,44]		# 不同数据类型之间默认无法直接操作
print(new_1 > new_2)
new_1 = ['a',11]
new_2 = ['A',22,33,44]		# a 97 A 65 
print(new_1 > new_2)		
new_1 = ['你'，11] 		
new_2 = ['我'，22，23,44]
print(new_1 > new_2)

元组内置方法

1.类型转换

​ 支持for循环的数据类型才可以转元组

print(tuple(123))		 # 不行
print(tuple(123.11))	 # 不行
print(tuple（'hello')	# 可以
t = ()  	# tuple
t = (1) 	# int
t = ('abc')  # str
'''
当元组内只有一个数据值的时候，都好不能省略
如果省略了 括号里是什么数据类型就是什么数据类型
ps:以后遇到可以存储多个数据值的数据类型，如果只有一个数据，逗号也要加上
'''

2.相关操作

t1 = (11,22,33,[11,22])
t1[-1].append(33)
print(t1)		# (11,22,33,[11,22,33])

字典内置方法

1.类型转换(了解即可)

print(dict([('name','jason'),('pwd',123)]))
print(dict(name='jason',pwd=123))
'''字典额很少涉及类型转换 一般直接定义使用'''

2.相关操作

1.字典内K:V键值对是无序的

2.取值操作

3.统计键值对个数

print(len(info))

4.修改数据

info['username'] = 'zhang'  # 键存在是修改
print(info)

5.新增数据

info['salary'] = 6   		# 键不存在则是新增

6.删除数据

7.快速获取键、值、键值对数据

8.修改字典数据（键存在是修改，不存在是新增）

info.update({'username':'jason'})

9.快速构建字典（给的值默认情况下所有键都用同一个）

res = dict.fromkeys([1,2,3],None)
print(res)
# {1: None, 2: None, 3: None}
new_dict = dict.fromkeys(['name','pwd','hobby'],[])
# {'name':[],'pwd':[],'hobby':[]}
new_dict['name'] = []
new_dict['name'].append(123)
new_dict['pwd'].append(123)
new_dict['hobby'].append(123)

res = dict.fromkeys([1,2,3],154656161616)
print(id(res[1]))
print(id(res[2]))
print(id(res[3]))
'''
3039221108496
3039221108496
3039221108496
'''

10.键存在则获取键对应的值，键不存在则设置，并返回设置的新值

res = info.setdefault('username','zhang')
print(res,info)
# zhang {'username': 'zhang'}
res1 = info.setdefault('xxx','ababa')
print(res1,info)
# ababa {'username': 'zhang', 'xxx': 'ababa'}

集合内置方法

一.标志：

​ set()

二.类型转换

​ 支持for循环的，并且数据必须是不可变类型

三.注意事项

1.定义集合需要使用关键字才可以

2.集合内数据必须是不可变类型（整型 浮点型 字符串 元组 布尔值）

四.功能

1.去重

s1 = {1,2,3,4,5,2,2,6,6,5,6}
print(s1) 		# {1,2,3,4,5,6}
l1 = ['zhang','li','zhao','zhang','zhang','zhang']
s2 = set(l1)
li = list(s2)
print(s2)		# {'li', 'zhao', 'zhang'}

2.关系运算

print({1,2,[1,2,3]})
print({1,2,{'name':'jason'}})
s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  # {1, 2, 3, 4, 5, 12}
l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
s2 = set(l1)
l1 = list(s2)
print(l1)

可变与不可变类型

一、可变类型 list

​ 值改变(内置方法) 内存地址可以不变

l1 = [11,22,33]
print(id(l1))		# 1785983809160
l1.append(44)
print(id(l1))		# 1785983809160

二、不可变类型 str、int、float

​ 值改变（通过内置方法）内存地址肯定变

s1 = '$zhang$'
print(id(s1))		# 1317312885232
s1 = s1.strip('$')
print(id(s1))		# 1317312885680

作业

作业一

date_list = [{'name': 'zhang'}, {'name': 'wang'}, {'name': 'li'}]
while True:
    print('1.查看所有用户名\n2.删除指定用户\n3.完善用户信息\n4.退出程序')
    choice = int(input('请输入指令代码：').strip())
    if choice == 1:
        print(date_list)
    elif choice == 2:
        de_name = input('输入删除的对象：').strip()
        date = {}
        date['name'] = de_name
        for i in date_list:
            if date == i:
                date_list.remove(i)
                print('删除成功！')
                break
        else:
            print('用户不存在')
    elif choice == 3:
        print('用户信息')
        name = input('输入要修改的员工姓名：')
        new_age = input('请输入年龄：').strip()
        new_gender = input('请输入性别：').strip()
        new_addr = input('请输入地址：').strip()
        name1 = {}
        name1['name'] = name
        new = {}
        new['age'] = new_age
        new['gender'] = new_gender
        new['adderess'] = new_addr
        for i in date_list:
            if name1 == i:
                i.update(new)
                print('添加成功')
                break
            else:
                print('用户不存在')
    elif choice == 4:
        break

作业二

l1 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
li_1 = list(set(l1))
li_1.sort(key=l1.index)
print(li_1)

作业三

pythons = {'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs = {'kermit','tony','gangdan'}
same = pythons & linuxs
print('两门课都报了的有：%s' % same)
sum_name = set(pythons ^ linuxs)
print('报名了的名单：%s' % sum_name)
only_pythons = pythons - linuxs
print('只报了python的名单：%s' % only_pythons)
noboth = (pythons-linuxs)^(linuxs-pythons)
print('没有两门都报的名单：%s' % noboth)

这篇关于列表内置方法 元组内置方法 字典内置方法 集合内置方法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！