Python入门-基本数据类型进阶（list，dict，tuple，set）

一、列表

1、定义

在[]内,用逗号分隔开多个任意数据类型的值

l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

2、类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

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

3、使用（正取or反取）

按索引存取值(正向存取+反向存取)：即可存也可以取

正向取(从左往右)

my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]  
tony

反向取(负号表示从右往左)

my_friends=['tony','jason','tom',4,5]
>>> my_friends[-1]  
5

对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错

>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]

4、切片(顾头不顾尾，步长)

**顾头不顾尾：**取出索引为0到3的元素

>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]

步长： 0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素

>>> my_friends[0:4:2]  
['tony', 'tom']

5、长度（len）

>>> len(my_friends)
5

6、成员运算（in和not in）

>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

7、添加元素（append，extend，insert）

# append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']

# extend()一次性在列表尾部添加多个元素
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']

# insert()在指定位置插入元素
>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']

8、删除（del，remove，pop）

# del删除没有返回值
>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l
[11,22,44]

# pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22

# remove()括号内指名道姓表示要删除哪个元素，没有返回值
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None

9、其他（reverse，sort，clear，count，index）

# reverse()颠倒列表内元素顺序    # l=l[::-1]也可以实现颠倒
>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]

# sort()给列表内所有元素排序
# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]

# clear（）删除内容列表内容
l = [11,22,3,42,7,55]
l.clear()
print(l) # []

# count()查找元素在列表内重复的次数
l1=[11,22,333,333,333,]
print(l1.count(333)) # 3
# 没有则返回0

# index（）index（）方法返回字符串内子字符串的索引（如果找到）。 如果未找到子字符串，则会引发异常。
l1=[11,22,333,333,333,]
res=l1.index(333，0，3)
# res=l1.index(444) # 报错
print(res) # 2

二、元祖

1、作用

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

2、定义

# 在()内用逗号分隔开多个任意类型的值
>>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")

# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组

>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

3、类型转换

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

4、取用

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

5、切片(顾头不顾尾，步长)

>>> tuple1[0:6:2] 
(1, 15000.0, 22)

6、长度

>>> len(tuple1)  
6

7、成员运算

>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 

三、字典

1、定义

在{}内用逗号分隔开多元素，每一个元素都是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'}

2、类型转换

# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{
     'age': 18, 'name': 'tony'}

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

3、使用

# 按key存取值：可存可取
# 取
>>> dic = {
     
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'

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

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

3、长度

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

4、成员运算

dic = {
     'name': 'xxx','age': 18,'hobbies': ['play game', 'basketball']}
>>> 'name' in dic  # 判断某个值是否是字典的key
True

5、删除（popitem，del，pop）

>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对，有返回值，代表的是取走操作
>>> dic
{
     'age': 18, 'hobbies': ['play game', 'basketball']}

# 万能删除，没有返回值，代表的是单纯的删除
d={
     'k1':111,'k2':222}
del d['k1']
print(d) # {'k2': 222}

# popitem（）随机删,返回一个元组
res=d.popitem()

6、键keys()值values()键值对items()

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

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

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

7、循环

>>> dic = {
     'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
# age
# hobbies
# name

# 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
# age
# hobbies
# name

# 只遍历value
>>> for key in dic.values():
...     print(key)
... 
# 18
# ['play game', 'basketball']
# xxx

# 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
# ('age', 18)
# ('hobbies', ['play game', 'basketball'])
# ('name', 'xxx')

8、其他 get()，update()，fromkeys()，setdefault()

# get()
>>> dic= {
     'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

# update()

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {
     'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({
     'k1':'JN','k4':'xxx'})
>>> dic
{
     'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

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

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

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

四、集合

1、作用

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

2、 定义

在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1： 元素必须是不可变类型；
2： 集合内没有重复的元素；
3： 集合内元素无序，去重之后无法保留原来的顺序。

s = {
     1,2,3,4}  # 本质 s = set({1,2,3,4})

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

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式。
d = {
     } # 默认是空字典 
s = set() # 这才是定义空集合，一定要用set关键字。

3、类型转换

但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

>>> 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、使用

4.1 关系运算

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

# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{
     'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

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

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

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{
     'kevin', 'zero', 'ricky', 'Jy'}

# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {
     1,2,3} > {
     1,2}
True
>>> {
     1,2,3} >= {
     1,2}
True

# 6.2 不存在包含关系，则返回False
>>> {
     1,2,3} > {
     1,3,4,5}
False
>>> {
     1,2,3} >= {
     1,3,4,5}
False


# 7.子集 是否被包含
>>> {
     1,2} < {
     1,2,3}
True
>>> {
     1,2} <= {
     1,2,3}
True

4.2 去重

# 集合去重复有局限性

# 1. 只能针对不可变类型

# 2. 集合本身是无序的，去重之后无法保留原来的顺序示例如下>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{
     'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
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'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {
     'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {
     'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {
     'age': 20, 'sex': 'female', 'name': 'tom'}
]

4.3 其他

# 1.长度
>>> s={
     'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b

5.练习题

集合类型简单练习题