7. 基本数据类型的内置方法(列表、元组、布尔、字典、集合)

1. 列表的内置方法

1.1 优先掌握的内置方法

1.1.1 强制类型转换

可以将可迭代类型转换为列表类型

print(list('messi'))  # ['m', 'e', 's', 's', 'i']
print(list((1, 2, 3)))  # [1, 2, 3]
print(list({4, 5, 6}))  # [4, 5, 6]

list方法在强制转换字典的时候默认转换出来的是字典的键

print(list({'name': 'messi', 'goals': 91}))  # ['name', 'goals']

强调:列表转换成字符串之后无法再重新转回列表

 1.1.2 索引取值

正向索引/负向索引

1.1.3  切片

与字符串切片方法一样

列表[起始索引:终止索引:步长]

a = ['messi', 'ronaldo', 'neymar', 'kylian', 'haaland']
print(a[0:3])  # ['messi', 'ronaldo', 'neymar']
print(a[0:3:2])  # ['messi', 'neymar']
# 将列表顺序翻转
print(a[::-1])  # ['haaland', 'kylian', 'neymar', 'ronaldo', 'messi']

1.1.4 计算长度

len

1.1.5 成员运算

in   /  not in

判断某个元素是否在当前列表中

1.1.6 向列表中添加元素

方式一:添加在列表结尾

a = [1, 2, 3]
a.append(4)
print(a)  # [1, 2, 3, 4]

方式二:插入到指定的索引位置

a = [1, 2, 3]
a.insert(0, 'messi')
print(a)  # ['messi', 1, 2, 3]

方式三:将两个列表整合到一起(扩展列表)

# for循环将两个列表整合到一起
a = [1, 2, 3]
b = [4, 5, 6]
for i in b:
    a.append(i)
print(a)  # [1, 2, 3, 4, 5, 6]
# extend方法将两个列表整合到一起
a = ['messi', 'neymar', 'ronaldo']
b = [1, 2, 3]
a.extend(b)
print(a)  # ['messi', 'neymar', 'ronaldo', 1, 2, 3]

1.1.7 删除列表中的元素

方式一:按照指定的值删除指定的元素remove

a = ['messi', 'neymar', 'ronaldo', 'kylian', 'haaland']
print(a.remove('messi'))  # None  没有返回值
print(a)  # ['neymar', 'ronaldo', 'kylian', 'haaland']

方式二:弹出指定元素pop

a = [1, 2, 3, 4, 5, 6]
# 默认弹出最后一个元素
print(a.pop())  # 6  有返回值
print(a)  # [1, 2, 3, 4, 5]
# 弹出指定索引对应的元素
print(a.pop(2))  # 3  有返回值
print(a)  # [1, 2, 4, 5]

方式三:删除指定索引对应的元素del

a = [1, 2, 3, 4, 5, 6]
del a[2]  # 不能返回,使用print会报错
print(a)  # [1, 2, 4, 5, 6]

方式四:将列表清空clear

a = [1, 2, 3]
a.clear()
print(a)  # []

1.1.8 翻转元素,作用在原列表reverse

a = [1, 2, 3, 4, 5, 6]
# 使用通用方法翻转
print(a[::-1])  # [6, 5, 4, 3, 2, 1]
print(a)  # [1, 2, 3, 4, 5, 6]  原列表没有得到改变
# 使用reverse方法翻转
print(a.reverse())  # None 没有返回值
print(a)  # [6, 5, 4, 3, 2, 1] 原列表得到改变

1.1.9 对列表中的元素进行排序,作用在原列表sort

a = [2, 4, 5, 9, 1, 3, 8, 6, 7]
# 默认的排序方式是正序
print(a.sort())  # None  没有返回值
print(a)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 给sort加上参数reverse
b = [2, 4, 5, 9, 1, 3, 8, 6, 7]
b.sort(reverse=True)
print(b)  # [9, 8, 7, 6, 5, 4, 3, 2, 1] 列表先正序,后翻转
c = [2, 4, 5, 9, 1, 3, 8, 6, 7]
c.sort(reverse=False)
print(c)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 补充方法:sorted(列表),把列表当参数而不是调用
d = [2, 4, 5, 9, 1, 3, 8, 6, 7]
print(sorted(d))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]  有返回值
print(d)  # [2, 4, 5, 9, 1, 3, 8, 6, 7]

 总结:

sort        使用方法:列表.sort()      没有返回值    作用在原列表

sorted    使用方法:sorted(列表)   有返回值        不会作用在原列表

1.1.10 列表遍历循环

for循环

while循环

2. 元组的内置方法

回顾:

一个元素的元组要加,逗号   

不加逗号变成了元素原本的类型

在定义字符串或者其它数据类型时加了,逗号就成了元组

2.1 强制类型转换

可以将可迭代类型转换成元组

2.2 索引取值

 2.3 切片

[起始索引:结束索引:步长]

a = (1, 2, 3, 4, 5, 6)
print(a[1:3])  # (2, 3)
print(a[0:5:2])  # (1, 3, 5)
print(a[::-1])  # (6, 5, 4, 3, 2, 1)

sort方法是列表的排序方法,不是元组的 

2.4 计算长度

len

2.5 成员运算

in   /    not in

2.6 遍历

for循环

while循环

2.7 元组拼接

a = (1, 2, 3)
b = (4, 5, 6)
# 方式一:元组.__add__(元组)   返回一个新的元组,不会作用在原来的元组
print(a.__add__((666,)))  # (1, 2, 3, 666)
print(a)  # (1, 2, 3)
# 方式二:使用 + 进行拼接
print(a + b)  # (1, 2, 3, 4, 5, 6)

2.8 元组的重复

元组*数字        将当前元组的所有元素重复指定次数并产生新的元组

a = ('j', 'q', 'k')
print(a * 3)  # ('j', 'q', 'k', 'j', 'q', 'k', 'j', 'q', 'k')

3. 布尔类型的内置方法

强制类型转换   bool()

在python中为假的情况:

1. 布尔值False

2. 数字0

3. 空的其它类型

print(bool(False), type(bool(False)))  # False <class 'bool'>
print(bool(0), type(bool(0)))  # False <class 'bool'>
print(bool(''))  # False
print(bool([]))  # False
print(bool(()))  # False
print(bool({}))  # False

其它情况均为真:

1. 布尔值True

2. 数字1

3. 有值的其它类型,空格也算字符串也算有值

print(bool(True))  # True
print(bool(1))  # True
print(bool(['a']))  # True
print(bool(' '))  # True

4. 字典的内置方法

字典中的键必须是不可变的,通常使用字符串、数字、布尔值作为键

字典中的值可以是任意类型,包括数字、字符串、列表、字典等

4.1 取值

# (1)字典[key]
#  这种方法取字典中没有的键会报错
a = {'name': 'kylian', 'id': 9, 'country': 'France', True: 'psg'}
print(a['id'])  # 9
print(a[True])  # psg
# (2)字典.get(键)
print(a.get('name'))  # kylian
print(a.get('hobby'))  # 如果字典中没有当前的键,返回的就是None
print(a.get('hobby', 'goat'))  # goat 没有键取不到值可以指定默认值

4.2 计算长度

len   计算字典中的键值对个数

4.3 成员运算

判断某个键是否在字典中,而不是某个值

print('name' in a)  # True
print('kylian' in a)  # False

4.4 增加元素

字典的特性:有则添加,无则修改

(1)方式一:字典[key] = value

a = {'name': 'kylian', 'id': 9, 'country': 'France'}
a['club1'] = 'psg'
print(a)  # {'name': 'kylian', 'id': 9, 'country': 'France', 'club1': 'psg'}

(2)方式二:字典.update({key:value})

a = {'one': 1, 'two': 2, 'three': 3}
b = {'four': 4, 'five': 5, 'six': 6}
# 遍历字典b,添加到字典a中
for i in b:
    a[i] = b[i]
print(a)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

(3)方式三:字典.update(key=value)

以上使用=的方式i是一个固定的值,以下使用键值对的形式i可随遍历而改变

(4)方式四:字典.update(字典)

m = {'a': 1, 'b': 2, 'c': 3}
n = {'d': 4, 'e': 5, 'f': 6}
m.update(n)
print(m)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}

相比于方式二for循环遍历增加一个字典所有元素,方式四代码更简洁

(5)方式五:setdefault(key, value)

向字典中设置当前键对应的默认值

setdefault(key,value)方法用于获取指定键的值;如果键不存在,则返回默认值,并在字典中添加新键值对;如果键存在,则返回键原本对应的值

 4.5 删除元素

info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
# 方式一:del字典[key]     按照键删除字典对应的键值对
del info['club']  # 没有返回值,不能用变量接收
print(info)  # {'name': 'kylian', 'id': 9, 'goal': 91}

# 方式二:字典.pop(key)    按照键删除字典对应的键值对弹出
res = info.pop('id')
print(res)  # 9  相比于方式一有返回值,且可以用变量接收
print(info)  # {'name': 'kylian', 'goal': 91}

# 方式三:清空字典
info.clear()
print(info)  # {}
# 方式四:弹出最后一个位置的键值对
info = {'name': 'kylian', 'id': 9, 'club': 'psg', 'goal': 91}
res = info.popitem()
print(res)  # ('goal', 91)
print(info)  # {'name': 'kylian', 'id': 9, 'club': 'psg'}

4.6 取出字典中所有的键、所有的值、所有的键值对

info = {'a': '1', 'b': 2, 'c': 3}
# (1)获取字典中所有的键
print(info.keys())
# dict_keys(['a', 'b', 'c']) 可以看成是列表,可以用for循环取出
print(type(info.keys()))  # <class 'dict_keys'>

# (2)获取字典中所有的值
print(info.values())
# dict_values(['1', 2, 3]) 可以看成是列表

# (3)获取字典中所有的键值对
print(info.items())
# dict_items([('a', '1'), ('b', 2), ('c', 3)]) 可以看成是列表嵌套元组
for k, v in info.items():
    print(k)  # a  b  c  
    print(v)  # 1  2  3

5. 集合的内置方法

集合的特点是无序且去重

5.1 强制类型转换

print(set('messi'))  
# {'e', 'm', 's', 'i'} print(set([1, 2, 3]))
# {1, 2, 3} print(set(('j', 'q', 'k')))
# {'q', 'k', 'j'} print(set({'a': 11, 'b': 22, 'c': 33}))
# {'c', 'a', 'b'}

5.2 添加元素

a = {1, 2, 3, 4, 5}
# 添加单个元素
print(a.add(6))  # None
print(a)  # {1, 2, 3, 4, 5, 6}
# 一次添加多个元素
a.update((11, 22, 33))  # 只能是可迭代类型
print(a)  # {1, 2, 3, 4, 5, 6, 11, 22, 33}

5.3 删除元素

# 方式二:pop
# 集合的pop默认弹出第一个元素,而列表的pop默认弹出最后一个元素
b = {'messi', 'ronaldo', 'neymar', 'kylian'}
print(b.pop())  # messi  索引为0的位置
print(b)  # {'ronaldo', 'neymar', 'kylian'}

5.4 其它方法

计算长度len

遍历循环for 

成员运算 in    /   not in 

 

posted @ 2024-07-19 21:50  hbutmeng  阅读(2)  评论(0编辑  收藏  举报