Python的数据类型的内置方法

Python的数据类型的内置方法

  • 可变与不可变数据类型
  • 字典的内置方法
  • 元组的内置方法
  • 集合的内置方法

可变与不可变数据类型

常见的数据类型

常见的数据结构类型:链表、单链表、双链表、循环列表、(C实现的 指针)、栈、树、二叉树、平衡二叉树、完全二叉树、b树、b+树、b-树等、队列、图等
在Python中,没有值传递还是引用传递一说,都说可变类型与不可变类型

不可变数据类型

不可变类型:str、int、float
    特点:值改变了,内存地址也改变、其实改变的不是原值、而是改变之后又生成一块空间来保存新值

可变数据类型


可变类型: list、dict、
    特点:值改变了,内存地址没有改变,其实改变的是原值,只要你改变了值,原来的值就会发生变化

字典的内置方法

定义

# 定义:在{}内用逗号分隔开多元素,每一个元素都是key:value的形式,其中value可以是任意类型,而key则必须是不可变类型,通常key应该是str类型,因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})

# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}
ic = {
    'name': 'xxx',
    'age': 18,
    'hobby': ['play game', 'basketball']
}

取值

# 1. 取值
# print(ic['name'])
# print(ic['age'])
# print(ic['hobby'][1])

转换

转换1:
info=dict([['name','tony'],('age',18)])
print(info)
# 转换2:fromkeys会从元组中取出每个值当做key,然后与None组成key:value放到字典中
print({}.fromkeys(('name','age','sex'),None)  )

重点

# 赋值操作
'''如果key已经在字典中存在,那么,就是对原来的值进行修改,如果不存在key值,就是新增一个键值对'''
dic = {

    'name': 'xxx',
    'age': 18,
    'hobby': ['play game', 'basketball']
}
dic['gender'] = 'male' # {'name': 'xxx', 'age': 18, 'hobby': ['play game', 'basketball'], 'gender': 'male'}
# dic['name'] = 'jerry' # {'name': 'jerry', 'age': 18, 'hobby': ['play game', 'basketball'], 'gender': 'male'}
# print(dic)
#3.长度len
print(len(dic))
#4.成员运算
in和not in#判断某个值是否在字典key
print('name' in dic)
True
#5删除pop#通过字典的key来删除字典对应的键
print(dic.pop('name'))

字典三剑客:keys() values() items()
# print(dic.keys()) # dict_keys(['name', 'age', 'hobby'])
#
# for i in dic.keys():
#     print(i)
'''values方法把字典中得所有的value值组织成一个列表'''
# print(dic.values()) # dict_values(['xxx', 18, ['play game', 'basketball']])
#
# for i in dic.values():
#     print(i)


print(dic.items()) # dict_items([('name', 'xxx'), ('age', 18), ('hobby', ['play game', 'basketball'])])
# for i in dic.items():  #
#     print(i[0], i[1]) # ('name', 'xxx')
for i, j in dic.items():  #
    print(i , j) # ('name', 'xxx')

需要掌握

需要掌握的操作:
#1.get取值

# print(dic.get('name')) # xxx
# print(dic.get('age')) # xxx
# print(dic.get('hobby')) # xxx
# print(dic.get('name1')) # None
'''get方法获取key不存在的时候,不会报错,会返回None,另外,还可以设置默认值'''
# print(dic.get('name1', 666)) # 666

"""以后字典取值推荐使用get方法,中括号取值是可以用的"""

#2. 随机删除一组键值对,并将删除的键值放到元组内返回

# print(dic.popitem()) # ('hobby', ['play game', 'basketball'])

# print(dic.popitem()) # ('hobby', ['play game', 'basketball'])

# print(dic) # {'name': 'xxx', 'age': 18}




# 3.update()
'''如果key值存在,则为修改,如果不存在,则为添加'''
# dic.update({'name': "jerry", 'gender': 'male'}) # 要记忆
# print(dic) # {'name': 'jerry', 'age': 18, 'hobby': ['play game', 'basketball'], 'gender': 'male'}
# 4初始化变量
dic = dict.fromkeys(['k1','k2','k3'],[])
dic = dict.fromkeys(['k1','k2','k3'],[666]) # {'k1': [666], 'k2': [666], 'k3': [666]}
dic = dict.fromkeys(['k1','k2','k3'],[666, 888]) # {'k1': [666, 888], 'k2': [666, 888], 'k3': [666, 888]}
print(dic) # {'k1': [], 'k2': [], 'k3': []} # 初始化变量

print(dic['k1'])
print(dic['k2'])
print(dic['k3'])
dic = {
    'name': 'xxx',
    'age': 18,
    'hobby': ['play game', 'basketball']
}
'''setdefault:如果key值存在,则直接获取key对应的value值,如果不存在,就返回第二个参数的值'''
print(dic.setdefault('name', 666)) # xxx
print(dic.setdefault('name1', 666)) # 666

元组的内置方法

定义

定义方式
countries = ("中国","美国","英国")  # 常见的
本质:countries = tuple("中国","美国","英国")    

作用

作用:元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元组的元素不能修改,即元组相当于不可变的列表,'用于记录多个固定不允许修改的值,单纯用于取'

类型转换

类型转换
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
pint(tuple('wdad'))  					 # 结果:('w', 'd', 'a', 'd') 
pinth(tuple([1,2,3]))					 # 结果:(1, 2, 3)
pyton(tuple({"name":"jason","age":18})) # 结果:('name', 'age')
python(tuple((1,2,3)) )					 # 结果:(1, 2, 3)
python(tuple({1,2,3,4}))				 # 结果:(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

扩展

扩展:
	'''面试题:'''

res = (111 )  # <class 'int'>
res1 = (123.1) # <class 'float'>
res2 = ('hello') # <class 'str'>
'''元组内部如果只有一个元组也要加逗号,否则就不是元组,只有加了逗号才是元组'''

'''以后只要是容器类型的数据类型,内部只要只有一个元素,末尾都推荐加一个逗号'''

"""
容器类型:只要是内部能够存放多个元素的都可以称为是容器类型
    eg:list dict tuple set 
不是容器类型的:int float str bool
"""

集合

定义,类型转换,作用

1. 如何定义集合
	s = set() # 空集合
2. 集合、list、tuple、dict一样都可以存放多个值,但是集合主要用于:去重、关系运算
3. 类型转换
	 pinth(s = set([1,2,3,4]))
    >>> s1 = set((1,2,3,4))
    >>> s2 = set({'name':'jason',})
    >>> s3 = set('egon')
    >>> s,s1,s2,s3
    {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}
    
4. 去重

## 1. 去重
# name_list = ['kevin', 'jerry', 'tony', 'oscar', 'tony', 'oscar', 'jerry', ]
#
# ## 要求:去除重复元素
# # 思路:列表------------>集合
# s = set(name_list) # {'kevin', 'tony', 'jerry', 'oscar'}
# print(s)
#
# # 在把集合转为列表
# print(list(s)) # ['tony', 'oscar', 'jerry', 'kevin']


'''集合的另外一个特点:无序'''
###
ll = [11, 22, 4, 55, 3, 66, 77, 99, 88, 10, 20, 30, 66, 77, 99, 88,]
# 1. 去重
# 转为集合

# 2. 去重之后,保留原来的位置
# 思路:循环   遍历

# 1. 先定义一个空列表来存储去重之后的结果
new_list = []

# 2. 循环遍历
for i in ll:
    # 判断new_list这个列表中是否已经存在这个值,如果存在了,就不在添加,如果不存在,则追加进去
    if i not in new_list:
        new_list.append(i)

    # 如果在的话,就不用管了
print(new_list) # [11, 22, 4, 55, 3, 66, 77, 99, 88, 10, 20, 30]

friends1 = {"zero", "kevin", "jason", "egon"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "egon"}  # 用户2的好友们
print(friends1)
# # 1.合集/并集(|):求两个用户所有的好友(重复好友只留一个)
# 集合嫩不嫩单个取值?
print(friends1 | friends2)  # {'Jy', 'ricky', 'egon', 'kevin', 'jason', 'zero'}-------[]

# 2.交集(&):求两个用户的共同好友
print(friends1 & friends2)  # {'jason', 'egon'}

# # 3.差集(-):
# >>> friends1 - friends2 # 求用户1独有的好友
print(friends1 - friends2)  # {'zero', 'kevin'}
print(friends2 - friends1)  # {'Jy', 'ricky'}

# 4.对称差集(^) # 求两个用户独有的好友们(即去掉共有的好友)
print(friends1 ^ friends2)  # {'Jy', 'kevin', 'zero', 'ricky'}
# 5.值是否相等(==)
# >>> friends1 == friends2

print(friends1 == friends2)  # False

# 6.父集:一个集合是否包含另外一个集合
# 6.1 包含则返回True
# >>> {1,2,3} > {1,2}
print({1, 2, 3} > {1, 2})  # True
# 7.子集
print({1, 2, 3} < {1, 2})  # True

热门相关:神秘总裁小小妻   今天也没变成玩偶呢   拒嫁豪门,前妻太抢手   不科学御兽   被帅哥打动的打工妹