python入门第十节标准数据类型下

标准数据类型下

大家好，我们昨天学习了，python的标准数据类型 数字和字符串，今天我们来把剩下的四种学完

列表（List）

• 列表可变的，它是序列
• 列表用方括号定义，没有元素类型限制

创建列表

lst1 = []  # 创建一个空列表
lst2 = [1, 2, 3, 4] 
lst3 = [1, 2, 3, "hhh", "china"]
lst4 = ["我", "最", "帅"]

• list([iterable])
  • 还可以使用list()函数来创建
  • 将一个iterable对象转化为列表并返回，如果没有实参，则返回空列表
  • iterable 可迭代的对象 字符串，列表，元组，字典，集合等都是可迭代对象

lst1 = list()  # 创建一个空列表
lst2 = list(1, 2, 3, 4) 
lst3 = list([1, 2, 3, "hhh", "china"])
lst4 = list("hello")
# 字典作为一个iterable,只有键参与迭代
lst5 = list({1:2,3:4})
lst6 = list((1,2,3))

lst1 = list()  # 创建一个空列表
lst2 = [1, 2, 3, 4] 
lst3 = [1, 2, 3, "hhh", "china"]
lst4 = ["我", "最", "帅"]

查询列表

lst = [1, 2, 3, "hhh", "china"]
# 使用索引进行查询
print(lst[0])  # 1
print(lst[1])  # 2
print(lst[-1])  # "china"
print(lst[-2])  # "hhh"

# 使用切片进行查询
print(lst[0:5:2])  # [1, 3, 'china']
print(lst[-1:-5:-2])  # ['china', 3]
print(lst[0:4])  # [1, 2, 3, 'hhh']
print(lst[:])  # [1, 2, 3, 'hhh', 'china']
print(lst[::-1])  # ['china', 'hhh', 3, 2, 1]

修改列表

lst = [1, 2, 3, "hhh", "china"]
# 使用索引进行查询
lst[0] = 999
lst[1] = 888
print(lst[0])  # 999
print(lst[1])  # 888

# 使用切片修改一个或多个元素
# 修改一个数据
lst[2:3] = [9.87]
print(lst)  # [1, 2, 9.87, 'hhh', 'china']
# 修改多个数据，如果只在一个位置修改了多个数据，该位置会修改，多余的会在该位置后面添加新的数据
lst[2:3] = [7, 8, 9]
print(lst)  # [1, 2, 7, 8, 9, 'hhh', 'china']
# 修改多个不相邻的数据，数据的个数必须和位置的个数相同，否则就会报错
lst[1:5:2] = ['ccc', 'www']
print(lst)  # [1, 'ccc', 7, 'www', 9, 'hhh', 'china']
# 删除元素
lst[2:3] = []
print(lst)  # [1, 'ccc', 'www', 9, 'hhh', 'china']
# 注意：下面这个代码是将空列表 下标2所对应的数据修改为空列表
lst[2] = []
print(lst)  # [1, 'ccc', [], 9, 'hhh', 'china']
# 删除连续的元素 这个方法无法删除不连续的元素
lst[1:3] = []
print(lst)  # [1, 9, 'hhh', 'china']
# 插入一个元素或多个
lst[0:0] = [1]
print(lst)  # [1, 1, 9, 'hhh', 'china']
lst[2:2] = [666, 777, 888]
print(lst)  # [1, 1, 666, 777, 888, 9, 'hhh', 'china']

List中的方法

list.append(x)

• 在列表的末尾追加一个元素，无返回值，相当于a[len(a):]=[x]

lst = [1, 2, 3, "hhh", "china"]
lst.append(1)
print(lst)  # [1, 2, 3, 'hhh', 'china', 1]
lst.append("abc") 
print(lst)  # [1, 2, 3, 'hhh', 'china', 1, 'abc']
lst.append((999,888))
print(lst)  # [1, 2, 3, 'hhh', 'china', 1, 'abc', (999, 888)]

list.extend(iterable)

• 使用iterable中的所有元素来扩展列表，无返回值，相当于a[len(a):]=iterable

lst = [1, 2, 3, "hhh", "china"]
lst.extend([5, 6])
print(lst)  # [1, 2, 3, 'hhh', 'china', 5, 6]

list.insert(i,x)

• i：要插入的元素的索引
• x：要插入的元素
• 在指定位置插入一个元素，无返回值

lst = [1, 2, 3, "hhh", "china"]
lst.insert(1, ['a', 'b'])
print(lst)  # [1, ['a', 'b'], 2, 3, 'hhh', 'china']

list.sort([key],reverse=False)

• key：指定一个函数,在排序之前,列表每个元素先应用这个函数，再根据返回值对原数据进行排序
• reverse：默认为False，代表升序，指定为True则为降序
• 对原列表进行排序，无返回值

lst = [2, -4, 1, -5, 6, 3]
lst.sort()
print(lst)  # [-5, -4, 1, 2, 3, 6]
lst.sort(reverse=True)
print(lst)  # [6, 3, 2, 1, -4, -5]
lst.sort(key=abs)
print(lst)  # [1, 2, 3, -4, -5, 6]
lst.sort(key=abs, reverse=True)
print(lst)  # [6, -5, -4, 3, 2, 1]

sorted(iterable,[key],reverse=False)

• iterable：可迭代对象（字符串，列表，元组，字典，集合等）
• key：指定一个函数,在排序之前，每个元素都先应这个函数之后再排序
• reverse：默认为False，代表升序，指定为True则为降序
• 对可迭代对象进行排序，以列表形式返回排序之后的结果

lst = [2, -4, 1, -5, 6, 3]
# 升序排序
print(sorted(lst))  # [-5, -4, 1, 2, 3, 6]
# 降序排序
print(sorted(lst, reverse=True))  # [6, 3, 2, 1, -4, -5]
# 对lst中的元素按照绝对值的大小降序排序
print(sorted(lst, key=abs, reverse=True))  # [6, -5, -4, 3, 2, 1]
# 对字符串排序
print(sorted('hello world'))  # [' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

list.reverse()

• 把列表中的元素倒过来，无返回值

lst = [2, -4, 1, -5, 6, 3]
lst.reverse()
print(lst)  # [3, 6, -5, 1, -4, 2]

reversed(seq)

• 返回给定序列的反向迭代器

lst = [1, 3, 5, 2]
obj = reversed(lst)
print(list(obj))  # [2, 5, 3, 1]
string = 'hello'
obj = reversed(string)
print(list(obj))  # ['o', 'l', 'l', 'e', 'h']

list.count(x)

• 返回元素x在列表中出现的次数

lst = [1, 3, 5, 2]
print(lst.count(2))  # 1

list.index(x[,start[,end]])

• x：要找的值
• start：起始索引，默认为0
• end：结束索引（闭区间），默认为len(list)
• 返回从左边开始第一次找到指定值时的正向索引，找不到报错

lst = [1, 2, 3, 2, '23', [2, 4]]
print(lst.index(2))  # 1
print(lst.index(2, 4))  # ValueError

list.pop([i])

• i：要删除元素的索引
• 如果没有这样的元素，则报错

lst = [567, 'hello', True, 456]
print(lst.pop())  # 456
print(lst)  # [567, 'hello', True]

list.remove(x)

• 删除列表中从左往右遇到的第一个x元素，无返回值
• 删除列表中指定索引的元素并返回该元素
• 如果没有指定索引，将会删除并返回列表中的最后一个元素

lst = [567, 'hello', True, 456, 567]
lst.remove(567)
lst.remove(567)
print(lst)  # ['hello', True, 456]

list.copy()

• 返回列表的一个浅拷贝，等价于a[:]

lst = [567, 'hello', True, False, 456]
new_lst = lst.copy()
print(new_lst)  # [567, 'hello', True, False, 456]

list.clear()

• 移除列表中的所有元素，无返回值，等价于del a[:]

lst=[567, 'hello', True, False, 456]
lst.clear()
print(lst)  # []

元组(Tuple)

• 不可变，是序列
• 元组用圆括号定义（圆括号可省略），没有元素类型限制

创建元组

tup = ()  # 创建一个空元组
# 元组中只有一个元素时，逗号不可以省略
tup = (123,)
# 这不是元组，仍然是数字123
tup = (123)
# 封包(等号右边有不带括号的多个数据，python会自动将这些数据封包成一个元组)
tup = 'abc', 123, 456
# 等价于上面的这句
tup = ('abc', 123, 456)

• 使用tuple([iterable])方法创建元组

tup = tuple()  # 创建一个空元组

tup = tuple([1, 2, 3])
# 字典作为一个iterable,只有键参与迭代
print(tuple({1:2, 3:4}))
print(tuple({'a', 'b', 'c', 789, 456}))

查询元组 与 修改元组

# 元组的查询和列表相同
tup = (456, 123, ([678, 8910],))
# 元组是不可变的,但其中的可变成员仍然可以被改变
tup[-1][0][0] = 987
print(tup)  # (456, 123, ([987, 8910],))

元组方法

tuple.count(x)

• 返回元素x在元组中出现的次数

tup = (456, 123, ([678, 8910],))
print(tup.count(456))  # 1

tuple.index(x[,start[,end]])

• x：要找的值start：起始索引，默认为0
• end：结束索引（闭区间），默认为len(list)
• 返回从左边开始第一次找到指定值时的正向索引，找不到报错

tup = (1, 2, 3, 2, '23', [2, 4])
print(tup.index(2))  # 1
print(tup.index(2, 4))  # ValueError

字典（Dictionary）

• 可变，不是序列
• 字典用花括号定义，每个元素都是键值对的形式key:value
• 字典的键不能存在可变的数据；值没有限制。
• 字典的键如果重复，会自动去重，保留第一个重复键，并且其它重复的键对应的值还会对第一个重复键对应的值进行修改；值可以重复。
• 当字典作为一个iterable对象参与操作时，只有键参与迭代。

创建字典

一共有六种创建字典的方式

# 1.直接在空字典里面写键值对
d = {'name': 'tom', 'age': 66}
print(d)  # {'name': 'tom', 'age': 66}

# 2.定义一个空字典，再往里面添加键值对
d = {}
d['name'] = 'Tom'
d['age'] = 66
print(d)  # {'name': 'tom', 'age': 66}

# dict(**kwarg)
# 3.把键作为关键字传入
d = dict(name="tom", age=28)
print(d)  # {'name': 'tom', 'age': 28}

# dict(iterable)
# 4.用可迭代对象来构建字典
d = dict((['name', 'age'], ['Tom', 28]))
print(d)  # {'name': 'age', 'Tom': 28}

# dict(mapping)
# 5.用映射结构构建字典
d = dict(zip(['name', 'age'], ['Tom', 28]))
print(d)  # {'name': 'Tom', 'age': 28}

# 6.利用类方法fromkeys()创建 classmethodfromkeys(iterable[,value])
# 以iterable的每个元素作为键，value作为所有值，创建一个字典，value不指定时，默认为None
d = dict.fromkeys(('name', 'age', 'height'))
print(d)
d = dict.fromkeys(('name', 'age', 'height'), 'abc')
print(d)

zip(*iterables)

• 返回一个迭代器，在进行迭代操作时，其中的第i个元组包含来自每个可迭代对象的第i个元素
• 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代
• 不带参数时，它将返回一个空迭代器

obj = zip('abcd', [4, 5, 7, 1])
print(list(obj))  # [('a', 4), ('b', 5), ('c', 7), ('d', 1)]
obj = zip(['abcd', 4, 5, 7])
print(list(obj))  # [('abcd',), (4,), (5,), (7,)]
obj = zip('abcd')
print(list(obj))  # [('a',), ('b',), ('c',), ('d',)]
obj = zip()  
print(list(obj))  # []

访问和修改字典

# 访问字典里的值
d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
print(d['Name'])  # Tom
print(d['Age'])  # 7
# 如果指定的键不存在,则报错
print(d['Gender'])  # KeyError

# 修改字典里的值
d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
# 修改指定键所对应的值
d['Name'] = 'Tony'
d['Age'] = 8
print(d)  # {'Name': 'Tony', 'Age': 8, 'Class': 'First'}
# 如果指定的键不存在,则新增该键值对
d['Gender'] = 'male'
print(d)  # {'Name': 'Tony', 'Age': 8, 'Class': 'First', 'Gender': 'male'}

字典方法

dict.keys()

• 返回由字典键组成的一个新视图
• 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变

d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
view_keys = d.keys()
print(view_keys)  # dict_keys(['Name', 'Age', 'Class'])
# 修改字典
d['weight'] = 59
print(view_keys)  # dict_keys(['Name', 'Age', 'Class', 'weight'])

dict.values()

• 返回由字典值组成的一个新视图
• 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变

d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
view_values = d.values()
print(view_values)  # dict_values(['Tom', 7, 'First'])
# 修改字典
d['weight'] = 59
print(view_values)  # dict_values(['Tom', 7, 'First', 59])

dict.items()

• 返回由字典键值对组成的一个新视图
• 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变

d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
view_items = d.items()
print(view_items)  # dict_items([('Name', 'Tom'), ('Age', 7), ('Class', 'First')])
# 修改字典
d['weight'] = 59
print(view_items)  # dict_items([('Name', 'Tom'), ('Age', 7), ('Class', 'First'), ('weight', 59)])

dict.get(key,default=None)

• key：键
• default：如果指定的键不存在时，返回该值，默认为None
• 返回指定的键key对应的值,如果key不在字典中，则返回default

d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
print(d.get('Age'))  # 7
print(d.get('weight'))  # None
print(d.get('weight', '该键不存在'))  # 该键不存在

dict.update([other])

• 使用来自other更新字典，没有返回值
• 可以像dict()那样传参

d = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
d.update(Age=18, weight=59)
d.update({'Age': 18, 'weight': 59})
d.update(zip(['Age', 'weight'], [18, 59]))
d.update([('Age', 18), ('weight', 59)])
print(d)  # {'Name': 'Tom', 'Age': 18, 'Class': 'First', 'weight': 59}

dict.pop(key[,default])

• key：键
• default：指定当键不存在时应该返回的值
• 移除指定的键所对应的键值对,并返回该键对应的值,如果该键不在字典中，则返回default指定的值
• 如果default未指定值且指定的键不存在于字典中，则报错

d = {'name': 'Tom', 'age': 15, 'height': 162}
print(d.pop('height'))  # 162
print(d)  # {'name': 'Tom', 'age': 15}
print(d.pop('weight', None))  # None

dict.popitem()

• 从字典中移除最后一个键值对, 并返回它们构成的元组 (键, 值)

d = {'name': 'Tom', 'age': 15, 'height': 162}
print(d.popitem())  # ('height', 162)
print(d)  # {'name': 'Tom', 'age': 15}

dict.setdefault(key, default=None)

• 如果字典存在指定的键，则返回它的值
• 如果不存在，返回 default 指定的值，并且新增该键值对

d = {'name': 'Tom', 'age': 15, 'height': 162}
print(d.setdefault('age'))  # 15
print(d.setdefault('weight'))  # None
print(d)  # {'name': 'Tom', 'age': 15, 'height': 162, 'weight': None}
print(d.setdefault('gender', 'male'))  # male
print(d)  # {'name': 'Tom', 'age': 15, 'height': 162, 'weight': None, 'gender': 'male'}

dict.copy()

• 返回原字典的浅拷贝

d = {'name': 'Tom', 'age': 15, 'height': 162}
new_d = d.copy()
print(new_d)  # {'name': 'Tom', 'age': 15, 'height': 162}

dict.clear()

• 移除字典中的所有元素，无返回值

d = {'name': 'Tom', 'age': 15, 'height': 162}
d.clear()
print(d)

集合(Set)

• 可变，不是序列
• 集合也用花括号定义，但其中的元素不是键值对
• 集合中不能存在可变的数据
• 集合是无序的
• 集合的元素如果重复，会自动去重
• 创建空集合必须用 set()，因为 { } 是用来创建空字典的

# 空集合
s = set()
print(s)
# 空字典
d = {} # d = dict()
print(d)
# 集合中不能存在可变的数据
s = {789, 456, "hello", (135,), 'world'}
print(s)

set([iterable])

• 将一个iterable对象转化为集合并返回，如果没有实参，则返回空集合

print(set())
print(set("hello"))
print(set([1, 2, 3]))
print(set((1, 2, 3)))
# 字典作为一个iterable, 只有键参与迭代
print(set({1: 2, 3: 4}))

• 利用集合特性，可以用来 去重 和 关系测试

# 把iterable变成集合，就会自动去掉重复的元素
lst = [1, 2, 4, 5, 7, 7, 4, 5]
s = set(lst)
print(list(s))
# 集合可以利用操作符做关系测试
a = set('abdefga')
b = set('abc')
c = set('aef')
print(a >= b) # 判断a是否为b的父集
print(c <= a) # 判断c是否是a的子集
print(c < a) # 判断c是否是a的真子集
print(a - b) # 返回a和b的差集
print(b - a) # 返回b和a的差集
print(a | b) # 返回a和b的并集
print(a & b) # 返回a和b的交集
print(a ^ b) # 返回a和b的对称差集
# 优先级: - & ^ |
print(a - b | c ^ b & a)

集合方法

set.update(*others)

• others：Iterable
• 更新集合，添加来自 others 中的所有元素

s = '12'
lst = [1, '2']
d = {1: '1', 2: '2'}
set1 = {'1', '2', 1, 3}
set1.update(s, lst, d)
print(set1)  # {1, 2, 3, '2', '1'}

set.add(elem)

• 将元素elem添加到集合中，如果元素已经存在，则没有影响

s = {1, 2, 3}
s.add("hello world")
print(s)  # {1, 2, 3, 'hello world'}

set.remove(elem)

• 从集合中移除元素 elem。 如果 elem 不存在，则报错

s = {1, 2, 3, 4}
s.remove(3)
print(s)  # {1, 2, 4}

set.discard(elem)

-从集合中移除元素 elem。 如果 elem 不存在，则不做任何操作

s = {1, 2, 3, 4}
s.discard(3)
s.discard(3)
s.discard(3)
print(s)  # {1, 2, 4}

set.pop()

• 从集合中移除并返回任意一个元素。如果集合为空，则报错

s = {'1', '2', 'hello', 789}
print(s.pop())  # 2
print(s)  # {'1', 789, 'hello'}

set.copy()

• 返回原集合的浅拷贝

set1 = {'1', '2', 1, 3}
set2 = set1.copy()
print(set2)  # {1, 3, '1', '2'} 为什么会这样 因为set是无序的

set.clear()

• 从集合中移除所有元素

s = {'1', '2', 'hello', 789}
s.clear()
print(s)  # set()