基本数据类型的内置函数

字典

定义方式

定义：在{}内用逗号分开多元素，每一个元素都是key：value的形式，其中value可以是任意类型，key必须是不可变类型

info={'name':'star','age':18,'sex'：'male'}


#也可以这样定义字典
info=dict{name='star',age=18,sex=male}

可变与不可变类型：

可变类型：值发生改变时，内存地址地址不变，证明改变的是原值，常见的可变类型有：列表，字典，集合等。

不可变类型：值发生改变时，内存地址也发生改变，即id值发生改变，证明是没有改变原值，而是产生了新的值，常见的不可变类型有：整型，浮点型，字符串

类型转换

#转换1：
info=dict([['name','star'],('age',18)])
print(info) # {'name': 'star', 'age': 18}

#转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
{}.fromkeys(('name','age','sex,),None)
#{'name': 'star', 'age': 18}

内置方法及其使用

取值

#按key取值，可存可取
dic={
    'name':'star',
    'age':18,
    'hobbies': ['play game', 'basketball']
}
print(dic['name'])#'star'


#赋值，如果key原先不存在于字典，则会新增key:value
dic['gender']='male'
print(dic)#{'name': 'star', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}


#对于赋值操作，如果key存在于字典则会修改对应value的值
dic['name']='tony'
print(dic)
#{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'], 'gender': 'male'}

删除

dic={
    'name':'star',
    'age':18,
    'hobbies': ['play game', 'basketball']
}
dic.pop(''name)# 通过指定字典的key来删除字典的键值对
#{'age': 18, 'hobbies': ['play game', 'basketball']}

长度：

dic={
    'name':'star',
    'age':18,
    'hobbies': ['play game', 'basketball']
}
print(len(dic))#3

成员运算 in和not in

键keys()，值values()，键值对items()

dic={
    'name':'star',
    'age':18,
    'hobbies': ['play game', 'basketball']
}
print(dic.keys())#获取字典的所有key值
#dict_keys(['name', 'age', 'hobbies'])

print(dic.values())#获取字典的所有value值
#dict_values(['star', 18, ['play game', 'basketball']])

print(dic.items())# 获取字典所有的键值对
#dict_items([('name', 'star'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

循环

dic={
    'name':'star',
    'age':18,
    'hobbies': ['play game', 'basketball']
}
for key in dic:#默认遍历key值
    print(key)
#name
#age
#hobbies

#只遍历key
for key in dic.keys():
    print(key)

#只遍历value
for key in dic.values():
    print(key)


#遍历key和value
for key in dic.item()
    print(key)

get()

print(dic.get('name'))# key存在，则获取key对应的value值
#'star'

print(dic.get('gender')) # key不存在，不会报错而是默认返回None
#'None'

print(dic.get('xxx',666))# key不存在时，可以设置默认返回的值
# 666

popitem()

dic={'k1':111,'k2':222,'k3':333}
res=dic.popitem()#随机删除一组键值对，并将删除的值放在元组内返回
print(dic)#{'k1': 111, 'k2': 222}
print(res)#('k3', 333)

update()

#用新字典更新旧字典，有则修改，无则添加
dic={'k1':111,'k2':222,'k3':333}
res=dic.update({'k1':123,'k4':444})#
print(dic)
#{'k1': 123, 'k2': 222, 'k3': 333, 'k4': 444}

fromkeys()

dic = dict.fromkeys(['k1','k2','k3'],[])
print(dic)
#{'k1': [], 'k2': [], 'k3': []}

setdefault()

#key不存在则新增键值对，并将新增的value返回
dic={'k1':111,'k2':222,'k3':333}
res=dic.setdefault('k4',444)
print(res)#444
print(dic)#字典中新增了键值对 {'k1': 111, 'k2': 222, 'k3': 333, 'k4': 444}



#key存在时则不做任何修改，并返回已存在key对应的值
dic={'k1':111,'k2':222,'k3':333}
res=dic.setdefault('k1',444)
print(res)#111
print(dic)#字典不变   {'k1': 111, 'k2': 222, 'k3': 333}

元组

作用：元组与列表类似，可以存放任意数据类型的元素，不同之处在于元组里的值不能够修改，即元组相当于不可变的列表元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

定义方式：

在（）内用逗号分隔开多个任意类型的值

ountries = ("中国"，"美国"，"英国")

类型转换

但凡能够被for循环一样遍历数据类型都可以传给tuple（）转换成元组类型

print(tuple('wdad'))  # 结果：('w', 'd', 'a', 'd')
print(tuple([1,2,3]))# 结果：(1, 2, 3)
print(tuple({"name":"jason","age":18}))# 结果：('name', 'age')
print(tuple((1,2,3))) # 结果：(1, 2, 3)
print(tuple({1,2,3,4}))  # 结果：(1, 2, 3, 4)

print(len(tuple1))  # 6

取值

tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！
print(tuple1[0])#1
print(tuple1[-2])#22
print(tuple1[0]='hello' #报错

切片

tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
print(tuple1[0:6:2])# (1, 15000.0, 22)

长度

print(len(tuple1))# 6

成员运算 in 和not in

tuple1= (1, 'hhaha', 15000.00, 11, 22, 33)
print('hahahh' in tuple1)#False
print('hahahs' not in tuple1 )#True

循环

tuple1= (1, 'hhaha', 15000.00, 11, 22, 33)
for line in tuple1:
    print(line)

集合

作用：

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

定义：

在{}内用逗号分隔开多个元素，集合具备以下三个特点;

1.每个元素必须是不可变类型

2.集合内没有重复的元素

3.集合内元素无序

#注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} 		# 默认是空字典 
s = set()   # 这才是定义空集合

类型转换

但凡能够被for循环遍历的数据类型

>>> 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'}

去重

## 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]

关系运算

我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算

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

合集/并集（|）：求两个用户的所有的好友

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

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

print(friends2&friends1)
#{'jason', 'egon'}

差集（-）：

print(friends1 - friends2)# 求用户1独有的好友
#{'zero', 'kevin'}

print(friends2 - friends1)# 求用户2独有的好友
#{'ricky', 'Jy'}

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

print(friends1 ^ friends2)  # {'Jy', 'kevin', 'zero', 'ricky'}

值是否相等(==)

print(friends1 == friends2)  # False

父集：一个集合是否包含另外一个集合

 包含则返回True

print({1, 2, 3} > {1, 2})  # True

子集

print({1, 2, 3} < {1, 2})  # True