python基本数据类型的内置方法

目录

• 字典的内置方法
  • 按key取值
  • 修改值
  • 统计字典中键值对的个数
  • 成员运算
  • 键值对的删除
  • 获取所有的键 所有的值 所有的键值对
  • update更新字典
  • fromkeys快速生成字典
  • setdefault方法
• 元组的内置方法
  • 类型转换
  • 元组的特性
  • 索引取值
  • 切片操作
  • 统计元组内元素的个数
  • 成员运算
  • 统计元素出现的次数
  • 元组的特性
• 集合内置方法
  • 类型转换
  • 集合的两大功能
• 垃圾回收机制
• 今日作业
  • 1.登录注册练习
  • 2.去重列表元素并保留原来的顺序
  • 3.去重下列数据字典并保留原来的顺序
  • 4.关系运算

字典的内置方法

按key取值

d1 = {'name':'tom', 'age':18, 'sex':'男'}
#方法一
print(d1['name'])  # tom
print(d1['height'])  #报错
'''
不推荐使用方法一，因为当键不存在时会报错
'''
#方法二
print(d1.get('name'))  # tom
print(d1.get('height'))  # None  不会报错
print(d1.get('height', '键不存在'))  #键不存在，第二个参数是键不存在时返回的值，默认为None
print(d1.get('name', '键不存在'))  # tom   当值存在时，则不需要使用第二个参数

修改值

d1 = {'name':'tom', 'age':18, 'sex':'男'}
#字典是可变类型
d1['name '] = 'jason'
print(d1)
d1['height'] = '180'
print(d1)
>>>{'name': 'tom', 'age': 18, 'sex': '男', 'name ': 'jason'}
>>>{'name': 'tom', 'age': 18, 'sex': '男', 'name ': 'jason', 'height': '180'}
'''
当键存在时，就修改值，当键不存在时，就新增一个键值对
'''

统计字典中键值对的个数

d1 = {'name':'tom', 'age':18, 'sex':'男'}
print(len(d1))  # 3

成员运算

d1 = {'name':'tom', 'age':18, 'sex':'男'}
#只能判断key
print('tom' in d1)  #False
print('name' in d1)  #True

键值对的删除

d1 = {'name':'tom', 'age':18, 'sex':'男'}
#方法一
del d1['name']
print(d2)  #d1 = {'age':18, 'sex':'男'}
#方法二
d1.pop('name')  # 将name键和他对应的值弹出
print(d1)  # {'age':18, 'sex':'男'}
#方法三
d1.popietm()  #随机弹出键值对
print(d1)  # {'name': 'tom', 'age': 18}

获取所有的键 所有的值 所有的键值对

d1 = {'name':'tom', 'age':18, 'sex':'男'}
print(d1.keys())  # dict_keys(['name', 'age', 'sex'])
print(d1.values())  # dict_values(['tom', 18, '男'])
print(d1.items())  # dict_items([('name', 'tom'), ('age', 18), ('sex', '男')])

'''
在python2中上述的三个方法直接返回一个列表
'''

update更新字典

d1 = {'name':'tom', 'age':18, 'sex':'男'}
d1.update({'name':'jason', 'height':180})  #键存在就修改值，不存在，就新增 
print(d1)
>>>{'name': 'jason', 'age': 18, 'sex': '男', 'height': 180}

fromkeys快速生成字典

dic = dict.fromkeys(['name', 'age', 'height'], [])
print(dic)  #{'name': [], 'age': [], 'height': []}
'''
练习
'''
dic['name'].append(11)  # 另外两个键所对应的列表也相应改变 
print(dic)  #{'name': [11], 'age': [11], 'height': [11]}

setdefault方法

d1 = {'name':'tom', 'age':18, 'sex':'男'}
#key不存在就新增键值对，并返回value
print(d1.setdefault('height', 180))  # 180
# 键存在则返回对应的值，不做修改
print(d1.setdefault('name', 'jack'))  # tom

元组的内置方法

类型转换

#支持for循环的基本数据类型都可以转成元组
print(tuple(11))  # 报错
print(tuple(11.123))  # 报错
print(tuple([11,1,2,32]))
print(tuple({'name':'jason', 'age':12}))
print(tuple({1,2,3}))
>>>(11, 1, 2, 32)
>>>('name', 'age')
>>>(1, 2, 3)

元组的特性

#当元组中只有一个元素时，要在元素后面加上逗号,通常情况下，可以存储多个数据的元素类型内部只有一个元素时，都会加逗号。
print(type((111)))  #int
print(type((111.22))) #float
print(type(([1,'m'])))  #list

索引取值

t1 = (1,2,3,5,1,3)
print(t1[0])  # 1
print(t1[-1])  # 3

切片操作

t1 = (1,2,3,5,1,3)
print(t1[1:4])  # (2, 3, 5)
print(t1[-1:-4:-1]) # (3, 1, 5)
#步长
print(t1[1:4:2])  #(2, 5)
print(t1[-1:-4:-2]) # (3, 5)

统计元组内元素的个数

t1 = (1,2,3,5,1,3)
print(len(t1))  # 6

成员运算

t1 = (1,2,3,5,1,3)
print(1 in t1)  #True

统计元素出现的次数

t1 = (1,2,3,5,1,3)
print(t1.count(2))  # 1

元组的特性

#元组内，元素不能“修改”的本质是元组内索引指向的内存地址不能修改
tt = (11, 22, 33, [11, 22])
tt[-1].append('nnnnn')  #  (11, 22, 33, [11, 22， nnnnn]) 
'''修改元组内的列表，本质是修改索引所指向的值的内春地址，列表的地址没有改变'''

集合内置方法

类型转换

print(set(11)) # 报错
print(set(23.2))  #报错
print(set([1,2,3]))
print(set({'name':'jack', 'age', 18}))
print(set((1,2.3,'naem')))
'''可以进行for循环的基本类型，能转换成集合，但是集合内的元素只能是不可变类型'''

集合的两大功能

# 去重
集合内不能出现重复元素，如果出现，会被集合自动去重
s1 = {1,1,1,1,2,2,2,3,3,4,4}  # {1, 2 ,3, 4}
l = ['a', 'a', 1, 1]
print(set(l))  # ['a', 1]
#关系运算
用来进行判断两个群体的差异
s2 = {'jason', 'kevin', 'tony', 'jerry'}
s3 = {'jason', 'tom', 'jerry', 'jack'} 
#求两个集合都有的元素
print(s2 & s3 )  #{'jason', 'jerry'}
#求s3独有元素
print(s3 - s2) #{'tony', 'kevin'}
#求两个集合中的所有元素
print(s3 | s2)  # {'kevin', 'jason', 'tom', 'jack', 'tony', 'jerry'}
#求两个集合中各部拥有的元素
print(s3 ^ s2)  # {'tony', 'jack', 'tom', 'kevin'}

垃圾回收机制

'''python底层对空间的申请和释放都是设计好的，不需程序员操心'''
1.引用计数
	内存中数据身上每绑定一个变量名，计数加一，当计数为零时数据会被清除
2.标记清楚
	当内存空间溢出时，python会启动应急机制，停止程序运行，挨个检查引用计数，并将计数为零的打赏标记，然后一次性全部清理掉
3.分代回收
	根据值的存活时间对值进行等级划分，不同等级值的检查时间不同，存活时间越长，等级越高，检测时间间隔越长

今日作业

1.登录注册练习

展开查看

# 创建列表存储用户信息
data = ['jason|123']
# 创建count用来计数
count = 0
# 循环开始界面
while True:
    # 打印开始界面
    print('********************\n'
          '1.用户登录\n'
          '2.用户注册\n'
          '3.用户信息查询\n'
          '********************')
    # 获取用户选项
    choice = input('请输入选项1/2/3>>>:')
    # 进行登录校验
    if choice == '1':
        username = input('请输入用户名>>>:')
        userpwd = input('请输入密码>>>:')
        # 使用for循环，将data中的数据取出处理后，与用户输入信息进行比对
        for user in data:
            if username == user.split('|')[0] and userpwd == user.split('|')[1]:
                print('登录成功')
                break
        else:
            print('登录失败')
    # 进行用户注册校验
    if choice == '2':
        username2 = input('请输入注册账号>>>:')
        userpwd2 = input('请输入密码>>>:')
        # 使用for循环，将data中的数据取出处理后，与用户输入信息进行比对
        for user2 in data:
            if username2 == user2.split('|')[0]:
                print('用户名已存在')
                break
        # 将用户输入的信息拼接，并添加到列表中
        else:
            data.append(f'{username2}|{userpwd2}')
            print('用户注册成功')
    # 打印列表信息
    if choice == '3':
        print(data)

2.去重列表元素并保留原来的顺序

l = ['a', 'b', 1, 'a', 'a']

展开查看

data = []
l = ['a', 'b', 1, 'a', 'a']
for i in l:
    if i not in data:
        data.append(i)
print(data)

3.去重下列数据字典并保留原来的顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
    l=[
        {'name':'lili','age':18,'sex':'male'},
        {'name':'jack','age':73,'sex':'male'},
        {'name':'tom','age':20,'sex':'female'},
        {'name':'lili','age':18,'sex':'male'},
        {'name':'lili','age':18,'sex':'male'},
    ]

展开查看

data = []
for i in l:
    if i not in data:
        data.append(i)
print(data)

4.关系运算

    有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
　　linuxs={'oscar','tony','gangdan'}

展开查看

#求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
#求出所有报名的学生名字集合
print(pythons | linuxs)
#求出只报名python课程的学员名字
print(pythons - linuxs)
#求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)