13、Python基本数据类型及内置方法（列表、元组、字典）

目录

• 一、列表
  • 1.1 列表是什么
  • 1.2 类型转换
  • 1.3 如何使用？
• ＃# 1.3.1 重要的使用方法:
• ＃# 1.3.2 次要的使用方法:
• ＃# 1.3.3 了解知识:
• ＃# 1.3.4 补充
• 二、元组
  • 2.1 元组的是什么
  • 2.2 类型转换
  • ２.3 如何使用？
• ＃# ２.3.1 重要的使用方法:
• ＃# 1.3.2 次要的使用方法:
• 三、字典
  • 3.1 字典及其作用
  • 3.2 类型转换
  • 3.3 如何使用？
• ＃# 3.3.1 重要的使用方法:
• ＃# 1.3.2 次要的使用方法:

一、列表

1.1 列表是什么

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

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

1.2 类型转换

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

>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] ，字符串会被转换成独立的字符的列表
>>>list({'k1':111,'k2':222,'k3':3333}) # 结果：['k1', 'k2', 'k3']　，字典会转换为变量名的列表

1.3 如何使用？

＃# 1.3.1 重要的使用方法:

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取  
# 1.1 正向取(从左往右)
>>> l=[111,'abc','hello']
>>> l[0]  
111
# 1.2 反向取(负号表示从右往左)
>>>  l[-1]  
hello
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> l=[111,'abc','hello']
>>> l[0]=222
>>> print(l)
[222,'abc','hello']

l[3]=333 # IndexError: list assignment index out of range 赋值不存在，报错

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

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

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

# 3.删除
# 3.1 del  通用的删除方法，只是单纯的删除，没有返回值
>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l
[11,22,44]

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

# 3.3 remove()根据元素删除，没有返回值，返回值为None
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None

# 4.切片(顾头不顾尾，步长)
# 4.1 顾头不顾尾：取出索引为0到3的元素
>>> l=[111,'abc','hello',222]
>>>l[0:3] 
[111,'abc','hello']
# 4.2 步长：0:3:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> l=[111,'abc','hello',222] 
>>>l[0:3:2]
[111,'hello']
不指定开始于结尾，默认全部取出，是一种拷贝行为，相当于浅拷贝
>>>l[:]  # 同等操作于l[0:len(l)]
[111,'abc','hello',222]
>>>l[::-1]  # 快速把列表数据全部倒过来
[222,'hello','abc',111]

# 5.长度  统计列表的元素的个数
>>> len(l)
4

# 6.成员运算in和not in
判断元素是否在列表中

# 7.for循环，遍历列表里面的值
for x in [111,'abc','hello']:
    print(x) 
111
'abc'
'hello'

＃# 1.3.2 次要的使用方法:

# 1.  l.count() 统计元素在列表中的出现的次数
>>>l=[111,'abc','hello']
>>>print(l.count('abc'))
1

# 2.   l.index()
>>>print(l.index('abc'))  寻找元素在列表中第一次出现的位置
2
>>>print(l.index('abcdd'))  # 找不到会报错

# 3.  l.clear()  #  清空列表
>>> l=[111,'abc','hello']
>>> l.clear()  #  清空原列表
[]

# 4.  l.reverse()  # 不是排序，颠倒列表内元素顺序
>>> l=[111,'abc','hello']
>>> l.reverse()  # 颠倒
['hello', 'abc', 111]

# 5. sort()给列表内所有元素排序
# 5.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> 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]

＃# 1.3.3 了解知识:

# 常用的数字类型可以直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']

＃# 1.3.4 补充

# 1、队列 ：FIFO，先进先出
>>>l=[]
 入队操作
>>>l.append("first")
>>> l.append("second")
>>>l.append("third")
['first', 'second', 'third']
 出队操作
>>>print(l.pop(0))
first
>>>print(l.pop(0))
second
>>>print(l.pop(0))
third

# 2、堆栈：LIFO，后进先出
l=[]
# 入栈操作
>>>l.append('first')
>>>l.append('second')
>>>l.append('third')
['first', 'second', 'third']
# 出队操作
>>>print(l.pop())
third
>>>print(l.pop())
second
>>>print(l.pop())
first

二、元组

2.1 元组的是什么

　　元组就是在()内用逗号分隔开多个任意类型的值的集合。
　　元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，按照索引/位置记录多个固定不允许修改的值，只读、不能取。
　　如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组.

2.2 类型转换

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

>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
>>> tuple({"name":"jason","age":18}}) # 结果：('name', 'age')，字典会转换为变量名的元组

２.3 如何使用？

＃# ２.3.1 重要的使用方法:

# 1.按索引存取值(正向取+反向取)：不可存只可取  
# 1.1 正向取(从左往右)
>>> t=(111,'abc','hello')
>>> t(0)  
111
# 1.2 反向取(负号表示从右往左)
>>>  t(-1)  
hello

# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
>>> t=(111,'abc','hello',222)
>>>t(0:3) 
(111,'abc','hello')
# 2.2 步长：0:3:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> t=(111,'abc','hello',222) 
>>>t(0:3:2)
(111,'hello')

>>>t(:)  # 同等操作于t(0:len(t))
(111,'abc','hello',222)
>>>t(::-1)  # 快速把元组数据全部倒过来
(222,'hello','abc',111)

# 3.长度  统计元组的元素的个数
>>> len(t)
4

# 4.成员运算in和not in
判断元素是否在元组中

# 5.for循环，遍历列表里面的值
for x in (111,'abc','hello'):
    print(x) 
111
'abc'
'hello'

＃# 1.3.2 次要的使用方法:

# 1.  t.count() 统计元素在列表中的出现的次数
>>>t=(111,'abc','hello')
>>>print(t.count('abc'))
1

# 2.   t.index()
>>>print(t.index('abc'))  寻找元素在元组中第一次出现的位置，起始索引
2
>>>print(l.index('abcdd'))  # 找不到会报错

三、字典

3.1 字典及其作用

　　字典就是{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是key必须是不可变类型,且不能重复。

info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})

3.2 类型转换

　　造字典的几种方法

#  方法1:  d={} # 默认定义出来的是空字典
>>>d={'k1':111,(1,2,3):222} # d=dict(...)
>>>print(d['k1'])
111
>>>print(d[(1,2,3)])
222
>>>print(type(d))
<class 'dict'>

#  方法2:
>>>d=dict(x=1,y=2,z=3)
>>>print(d,type(d))
{'x': 1, 'y': 2, 'z': 3} <class 'dict'>

#  方法3:
>>>info=[['name','Jack'],('age',18),['gender','male']]
>>>d={}
>>>for k,v in info:
>>>print(d)
{'name': 'abc', 'age': 18, 'gender': 'male'}
或dict(info)，一下就搞定

#  方法4：快速初始化一个字典。fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

3.3 如何使用？

＃# 3.3.1 重要的使用方法:

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {'name': 'xxx','age': 18,'hobbies': ['play game', 'basketball']}
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

# 2、长度len，统计字典的元素的个数，若字典中出现重复的key，则只会计算一个
>>> len(dic) 
3

# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True

# 4、删除，通用的删除del
# 4.1 通用删除del
# 4.2 pop删除：根据key删除元素，返回删除key对应的那个value值
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
# 4.3 popitem删除：随机删除，返回元组(删除的key,删除的value)

# 5、键keys()，值values()，键值对items()，在Python3中，取出的不是如下的列表
>>> 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'])])


# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)

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

# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)

＃# 1.3.2 次要的使用方法:

#1、d.clear()    清空字典

#2、d.update()  更新字典，用一个新字典更新老字典，新的元素增加入老字典

#3、d.get() ：根据key取值，容错性好；
 key存在，则获取key对应的value值；key不存在，不会报错，返回None
ps:字典取值建议使用get方法

#4、d.setdefault()    
# info={}
# if 'name' in info:
#     ... # 等同于pass
# else:
#     info['name']='egon'
# print(info)

# 4.1 如果key有则不添加,返回字典中key对应的值
info={'name':'egon'}
res=info.setdefault('name','egon')
# print(info)

print(res)

# 4.2 如果key没有则添加，返回字典中key对应的值
info={}
res=info.setdefault('name','egon')
# print(info)
print(res)