python基本数据类型

一、列表

1.添加

append()

将一个对象 item 添加到列表的末尾。

list = []
list.append("小宝贝")       # [1,'小宝贝']
list.append(1)              # [1, '小宝贝', 1]
list.append((1,2,3))        # [1, '小宝贝', 1, (1, 2, 3)]
list.append([1,2,3])        # [1, '小宝贝', 1, (1, 2, 3), [1, 2, 3]]
list.append({'like':'hkk'}) # [1, '小宝贝', 1, (1, 2, 3), [1, 2, 3], {'like': 'hkk'}]
print(list)                 # 打印结果
print(len(list))            # 5  获取列表长度

extend()

将一个可迭代对象的所有元素，添加到列表末尾。

list2 = [1,2,3]
list3 = [4,5,6]
list4 = {'name':'hkk','like':'ltt'}
list5 = (7,8,9)
list6 = "hkkltt"
list2.extend(list3)     # [1, 2, 3, 4, 5, 6]
list2.append(list3)     # [1, 2, 3, [4, 5, 6]]  对比append()和extend()
list2.extend(list4)     # [1, 2, 3, 'name', 'like']  接收字典的所有key值
list2.extend(list5)     # [1, 2, 3, 7, 8, 9]   接受字典的所有值
list2.append(list5)     # [1, 2, 3, (7, 8, 9)]   对比append()和extend()
list2.extend(list6)     # [1, 2, 3, 'h', 'k', 'k', 'l', 't', 't']  添加的是字符串的所有字母
print(list2)

insert(index,item)

将一个对象插入到指定的索引位置
index：想要插入值所在的索引位置
item：想要插入的值
原索引位置及后面的元素后移一位

list7 = [1,2,4]
list7.insert(2,3)  # [1, 2, 3, 4]
print(list7)

pop(index) / pop()

删除所指定索引的元素，没有指定索引则默认删除列表最后一个元素

list8 = [1,2,3,4,5]
list8.pop(2)   # [1, 2, 4, 5]
list8.pop()      # [1, 2, 3, 4]  没有穿index值时默认删除列表末尾的一个元素
print(list8)
list9 = []
list9.pop()
print(list9)    # IndexError: pop from empty list  如果索引值不正确，或者列表已经为空，则引发 IndexError 错误 

remove(item)

移除列表中第一个等于 item 的元素

list10 = [1,2,3,4,5]
list10.remove(1)    # [2, 3, 4, 5]
list10.remove(6)      # ValueError: list.remove(x): x not in list  目标元素必须已存在，否则会报 ValueError
print(list10)

sort(key=None, reverse=False)

对列表进行原地排序，排序默认为升序（从小到大）reverse默认为False，降序排序需要将reverse改为True

list11 = [2,6,1,4,7,6,78,52]
list11.sort()  # [1, 2, 4, 6, 6, 7, 52, 78]
list11.sort(reverse=True)  # [78, 52, 7, 6, 6, 4, 2, 1]  将reverse=True
print(list11)

reverse()

将列表中的元素顺序反转。

list11 = [2,6,1,4,7,6,78,52]
list11.reverse()   # [52, 78, 6, 7, 4, 1, 6, 2]
print(list11)

二、元组

• 元组是有序的不可变对象集合
• 元组使用小括号包围，各个对象之间使用逗号分隔
• 元组是异构的，可以包含多种数据类型

创建

使用逗号分隔

tuple = 1,2,3      # (1, 2, 3)
print(tuple)
print(type(tuple))   # <class 'tuple'>

通过小括号填充元素

tuple2 = ('a','b','c')
print(type(tuple2))     # <class 'tuple'>

通过构造方法 tuple(iterable)

t1 = tuple()
print(type(t1))       # <class 'tuple'>
t2 = tuple([1, 2, 3])
print(t2)             # (1, 2, 3)
print(type(t2))       # <class 'tuple'>

索引

• 可以通过索引值来访问对应的元素。
• 正向索引，默认编号从 0 开始
• 反向索引，默认编号从-1 开始

t = tuple(range(1, 6))
print(t[2])   # 3
print(t[-2])  # 4

切片 [start: stop: step]

三个值都是可选的，非必填
start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
stop 值：指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取元组允许的最大索引值；
step 值：步长值指示每一步大小，如果没有指定，则默认步长值为 1。

t = (1,2,3,4,5,6)
print(t[:])      # (1, 2, 3, 4, 5, 6)
print(t[:-2])    # (1, 2, 3, 4)
print(t[2:4])    # (3, 4)
print(t[2:5:2])  # (3, 5)
# 特殊的切片写法：逆序
print(t[::-1])   # (6, 5, 4, 3, 2, 1)

index(item)

返回与目标元素相匹配的首个元素的索引。
目标必须在元组中存在的，否则会报错。

t = (1, 3, 2, 3, 2)
print(t.index(3))
t = ('a','b','c','d','e')   # 1
print(t.index('d'))         # 3
print(t.index('f'))         # ValueError: tuple.index(x): x not in tuple

count(item)：

返回某个元素出现的次数。

t = (1, 2, 2, 3, 3, 3, 3)
print(t.count(3))             # 4
t = ('a','b','c','d','e','a')
print(t.count('a'))           # 2

元组解包

把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

t = (1,2,3)
a,b,c = t
print(a)
print(b)
print(c)

元组与列表的异同点

• 相同点
  都是有序的
  都是异构的，能够包含不同类型的对象
  都支持索引和切片
• 区别
  声明方式不同，元组使用()，列表使用 []
  列表是可变的，元组是不可变的

三、集合

• 无序的唯一对象集合
• 用大括号{}包围，对象相互之间使用逗号分隔
• 集合是动态的，可以随时添加或删除元素
• 集合是异构的，可以包含不同类型的数据