python列表，元组，字典，字符串，集合

最新推荐文章于 2022-02-05 09:00:00 发布

唯尘

最新推荐文章于 2022-02-05 09:00:00 发布

阅读量2.2k

点赞数 8

分类专栏： python 文章标签： python list 列表字符串元组集合

本文链接：https://blog.csdn.net/qq_42839596/article/details/100700244

版权

python 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

作者今天在复习数据类型，想着就把这些内置的方法给集中一下，方便查看。这些都是作者认为比较常用的，不足之处，请见谅。

List列表

list(列表)是python中使用最频繁的数据类型。专门存放数据，存放其中的数据被称作元素。

列表⽤ [ ] 定义，元素之间使⽤ , 分隔。
列表的索引从 0 开始。
索引就是元素在列表中的位置编号。

a = [1, 2, 3]
print(a[0])
print(a[1])
print(a[2])

列表常用的操作

增加元素

列表.append(数据)在列表末尾添加元素。
列表.insert(索引,数据)在列表指定位置插入元素。
列表.extend(可迭代对象)将可迭代对象中的元素追加到列表中。

a = [1, 2, 3]
a.insert(0, 4)  # 在开始加入4
a.append(5)  # 在最后加入5
a.extend('abc')
print(a)

删除元素

列表.remove(数据) 删除第⼀个出现的指定数据
del 列表[索引] 删除指定索引的数据
列表.pop(索引) 删除指定索引数据,返回被删除的元素，默认表尾
列表.clear() 清空列表

a = [1, 3, 1, 3]
a.remove(3)  # 移除第一个3
print(a)
del a[0]  # 移除索引为0的元素
print(a)
print(a.pop(0))  # 返回1
a.clear() # 清空列表

修改元素

列表[索引] = 数据修改指定索引的数据，数据不存在会报错.

查询元素

列表[索引] 根据索引取值，索引不存在会报错
列表.index(数据) 根据值查询索引，返回⾸次出现时的索引，没有查到会报错
列表.count(数据) 数据在列表中出现的次数
len(列表) 列表⻓度
if 数据 in 列表: 检查列表中是否包含某元素

a = [1, 2, 3]
print(a.index(3))  # 2
print(a.count(3))  # 1
print(len(a))  # 3
if 2 in a:
	print('hahaha')

排序

列表.sort()默认升序，将参数reverse设为True降序
列表.reverse() 逆序

a = [1, 8, 9]
a.sort()  # 默认升序
print(a)
a.sort(reverse=True)  # 降序
print(a)
a.reverse()
print(a)  # 逆序

python列表切片截取

>>>L = ['Google', 'Runoob', 'Taobao']
 
>>> L[2] 'Taobao'
 
>>> L[-2] 'Runoob'
 
>>> L[1:] ['Runoob', 'Taobao']
 
>>>

列表总结的大概就这多！！！

元组

元组定义

python元组与列表类似，不同之处在于元组的元素不可更改。元组⽤ () 定义，⽤于存储⼀串数据，元素之间使⽤ , 分隔。元组的索引从 0 开始。

# 定义元组
 
info_tuple = ("Scrat", 18, 1.75)
 
# 取出元素的值
 
print(info_tuple[0]) # 输出：Scrat

元组中只包含⼀个元素时，需要在元素后⾯添加逗号

info_tuple = (50, )

元组常⽤操作

Tuple （元组）与列表类似，不同之处在于元组的元素不能修改

info_tuple = (“Scrat”, 18, 1.75)
info_tuple[0] = “lisi” # 程序报错

查询

元组[索引] 根据索引取值，索引不存在会报错
元组.index(数据) 根据值查询索引，返回⾸次出现时的索引，没有查到会报错
元组.count(数据) 数据在元组中出现的次数
len(列表) 元组⻓度
if 数据 in 元组: 检查元组中是否包含某元素

遍历

for 元素 in 元组: 取出元组中的每个元素

让列表不可以被修改，以保护数据安全

# 元组和列表之间的转换
 
# 使⽤ `tuple` 函数 把列表转换成元组
 
list1 = [10, 11]
 
tuple1 = tuple(list1)
 
# 使⽤ `list` 函数 把元组转换成列表
 
# list1 = list(tuple1)

元组内置函数

1 cmp(tuple1, tuple2)
比较两个元组元素。

2 len(tuple)
计算元组元素个数。

3 max(tuple)
返回元组中元素最大值。

4 min(tuple)
返回元组中元素最小值。

5 tuple(seq)
将列表转换为元组。

字典

dictionary （字典）是除列表以外 Python之中最灵活的数据类型，字典同样可以⽤来存储多个数据，通常⽤于存储描述⼀个物体的相关信息，字典⽤ { } 定义。

字典使⽤键值对存储数据，键值对之间使⽤ , 分隔：

键key是索引
值value是数据
键值之间用：分离
值可以是任何类型，键只能是字符串，数字或者元组。

a={1:2, 'a': 'as', ('as','s'):'x'}
print(a[1])
print(a['a'])
print(a[('as','s')])

键值必须唯一

字典常用操作

1.增

字典[键] = 数据键不存在，会添加键值对；键存在，会修改键值对的值。

2.删

del 字典[键] 删除指定的键值对。
字典.pop(键) 删除指定键值对,返回被删除的值。
字典.popitem()随机返回并删除最后一个元素。
字典.clear 清空字典。

a = {'name': 'LIHUA',
     'age': 18,
     'sex': '男'}
# b = a.pop('name')  # 返回移除的指定键对应的值
# print(b)
# print(a)

# print(a)
# a.clear()  # 清空字典
# print(a)

3.改

字典[键] = 数据键不存在，会添加键值对；键存在，会修改键值对的值。
字典.setdefault(键，数据) 键值对不存在，添加键值对；存在则不做处理。
字典1.update(字典2) 取出字典2的键值对赋值给字典1，若有相同的项则进行覆盖,不同的就添加。

a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
a2 = {'name': 'zzh',
      'age': 16,
      'sex': '男',
      '学号': 123456,
      '能力': '电磁炮'}

# a1.setdefault('能力', '肉')
# a1.setdefault('能力', 'no肉')  # 若键值对存在则不作任何操作，若不存在则添加
# print(a1)

a1.update(a2)  # 以a2覆盖a1
print(a1)

查

字典[键] 根据键取值，键值对不存在会报错。
字典.get(键) 根据键取值，键值对不存在不会报错。
字典.keys() 可进⾏遍历，获取所有键。
字典.values() 可进⾏遍历，获取所有值。
字典.items() 可进⾏遍历，获取所有(键，值)

a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
# a2 = {'name': 'zzh',
#       'age': 16,
#       'sex': '男',
#       '学号': 123456,
#       '能力': '电磁炮'}
print(a1['name'])  # 若键值对不存在报错
print(a1.get('nam'))  # 若键值对不存在不报错，返回None
print(a1.keys())  # 返回所有的键
print(a1.values())  # 返回所有的值
print(a1.items())  # 返回所有的键值对

遍历

for k in 字典.keys()遍历键
for v in 字典.values()遍历值
for k, v in 字典.item()遍历键值对
for item in 字典.items() 遍历字典的元素（以元组的形式遍历出每一项)

a1 = {'name': 'lihua',
      'age': 18,
      'sex': '男',
      '学号': 123456}
for i in a1.items():
    print(i)


for k, v in a1.items():
    print(k)
    print(v)

一些方法

字典.fromkeys(seq, value):
创建一个字典，seq为新字典的键，value为所有键的默认值，value默认为None

seq = ('name', 'age', 'sex')
 
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))
 
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))

字符串

字符串就是⼀串字符，是编程语⾔中表示⽂本的数据类型，在 Python 中可以使⽤⼀对双引号 " 或者⼀对单引号 ’ 定义⼀个字符串,字符串是不可变序列，不能直接进行修改等。

虽然可以使⽤ " 或者 ’ 做字符串的转义，但是在实际开发中：

如果字符串内部需要使⽤ " ，可以使⽤ ’ 定义字符串
如果字符串内部需要使⽤ ’ ，可以使⽤ " 定义字符串
可以使⽤索引获取⼀个字符串中指定位置的字符，索引计数从 0 开始

也可以使⽤ for 循环遍历字符串中每⼀个字符。

string = "Hello Python"
 
for c in string:
 
    print(c)

判断

string.isalpha() 如果 string ⾄少有⼀个字符并且所有字符都是字⺟则返回 True
string.islower() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符，并且所有这些(区分⼤⼩写的)字符都是⼩写，则返回 True
string.isupper() 如果 string 中包含⾄少⼀个区分⼤⼩写的字符，并且所有这些(区分⼤⼩写的)字符都是⼤写，则返回 True
string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True
string.endswith(str) 检查字符串是否是以 str 结束，是则返回 True
string.istitle()检查所有单词都是首字母大写。
string.isspace()检查所有字符都是空的字符。
string.isdigit()检查所有的字符都是数字。

a = '12345667889'
print(a.isdecimal())
print(a.isdigit())
b = 'ahdgkj'
print(b.isalpha())
c = 'adg4156'
print(c.isalnum())  # 判断所有字符都是字母或者数字
d = ';;;;a'
f = ';;;;A'
print(d.islower())
print(f.isupper())

查找，替换

1.string.find(str, start=0,end=len(string))
检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
2.string.rfind(str, start=0,end=len(string)) 类似于 find()，不过是从右边开始查找
3.string.index(str, start=0,end=len(string)) 跟 find() ⽅法类似，不过如果 str 不在 string 会报错
4.string.rindex(str, start=0,end=len(string)) 类似于 index()，不过是从右边开始

a = '123456789078456'
x = a.find('7', 0, len(a))  # 找‘7’找到后返回其索引
y = a.rfind('7', 0, len(a))  # 从右边找
z = a.rfind('a', 0, len(a))
print(x)
print(y)
print(z)  # 不存在则返回-1

a = '123456789078456'
x = a.index('7', 0, len(a))  # 找‘7’找到后返回其索引
y = a.rindex('7', 0, len(a))  # 从右边找
# z = a.index('a', 0, len(a))
print(x)
print(y)
# print(z)  # 不存在则报错

string.replace(old_str, new_str, num)
返回⼀个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次。

a = '123456789123456789123456789'
b = a.replace('1', 'a', 2)  # 返回一个改变过的新字符串
print(a)  # a本身不变
print(b)

拆分与拼接

string.split(str="",num)
返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个⼦字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格。

string.splitlines() 返回列表，按照⾏(’\r’, ‘\n’, ‘\r\n’)分隔

string1 + string2 拼接两个字符串

string.join(seq) 返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为⼀个新的字符串

a = 'Hello auidfh\n nadsjk'
b = ['Hello', 'nihao', 'i love u']
x = a.split()  # 分割
y = ','.join(b)
print(x)
print(y)

大小写转换

a = 'aa bb A'
b = a.title()  # 所有的单词首字母大写
c = a.capitalize()  # 只有第一个单词首字母大写
e = a.upper()  # 字符串字符全部大写
f = a.lower()  # 字符串字符全部小写
print(b)
print(c)
print(e)
print(f)

文本对齐

a = 'adff'
c = a.rjust(10)  # 右对齐，长度填充到10
d = a.ljust(10)  # 左对齐，长度填充到10
e = a.center(10)  # 居中，长度填充到10
print(c)
print(d)
print(e)

在这里插入图片描述

去除空白字符

a = '  adff  '
c = a.rstrip()  # 去除右边的空格
d = a.lstrip()  # 去除左边的空格
e = a.strip()  # 去除两边的空格
print(c)
print(d)
print(e)

提示：列表除了查询⽅法和pop⽅法都没有返回值，字符串所有⽅法都有返回值

注意!


# 字符串的逆序（⾯试题）
 
print(num_str[::-1])

Unicode 字符串

Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：

>>> u'Hello World !'
u'Hello World !'

引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：

>>> u'Hello\u0020World !'
u'Hello World !'

被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。

三引号（所见即所得）

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

内置方法

在这里插入图片描述

字符串格式化：

第一种：%形式
在这里插入图片描述

name = "周安可"
age = 18
sex = "女"
print("我的名字叫做%s,我的年龄是%d,我的性别是%s"%(name,age,sex))

a = 18
print('%-+10.3f'%a)  # %开始 -左对齐 +对正数加+ 10最小宽度 .3小数点精度 f指定的转换类型

第二种format

a = '{}喜欢{}！'
b = '{0}喜欢{1}！'
c = '{name1}喜欢{name2}！'
print(a.format('周安可','李淳风'))
print(b.format('周安可','李淳风'))
print(c.format(name1='周安可',name2='李淳风'))

在这里插入图片描述

字符串常量：

import string

print(string.ascii_lowercase)  # 小写字符
print(string.ascii_uppercase)  # 大写字符
print(string.ascii_letters)  # 大小写字符
print(string.digits)  # 数字
print(string.whitespace)  # 空白字符
print(string.punctuation)  # 标点符号
print(string.printable)  # 可打印字符串的字符，包括大小写字符，标点，空白符
print(string.hexdigits)  # '0123456789abcdefABCDEF'
print(string.octdigits)  # '01234567'

pypinyin库与jieba库

在这里插入图片描述

集合：

集合创建：
a={1,2}
a=set()
集合中的元素只能是可哈希的（即不可变类型）。

集合元素的增加
add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；
update()方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。

集合元素删除
pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；
remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常；
discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
clear()方法清空集合删除所有元素。

集合运算

a_set = set([8, 9, 10, 11, 12, 13])
b_set = {0, 1, 2, 3, 7, 8}
a_set | b_set #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
a_set.union(b_set) #并集
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
a_set & b_set #交集
{8}
a_set.intersection(b_set) #交集
{8}
a_set.difference(b_set) # 差集
{9, 10, 11, 12, 13}
a_set - b_set
{9, 10, 11, 12, 13}
a_set.symmetric_difference(b_set) #对称差集
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
a_set ^ b_set
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}

好累好累！终于集合好了。实际上最后的图片有大多数方法都不常用。作者觉得把作者前面分类的方法熟悉就足够用了。

希望能帮到大家。

唯尘

关注

8
点赞
踩
34

收藏

觉得还不错? 一键收藏
1
评论
python列表，元组，字典，字符串，集合

作者今天在复习数据类型，想着就把这些内置的方法给集中一下，方便查看。这些都是作者认为比较常用的，不足之处，请见谅。List列表list(列表)是python中使用最频繁的数据类型。专门存放数据，存放其中的数据被称作元素。列表⽤ [ ] 定义，元素之间使⽤ , 分隔。列表的索引从 0 开始。索引就是元素在列表中的位置编号。a = [1, 2, 3]print(a[0])...
复制链接

扫一扫

专栏目录