Task04 列表、元组和字符串

最新推荐文章于 2021-11-29 12:42:35 发布

明明明明明_

最新推荐文章于 2021-11-29 12:42:35 发布

阅读量192

点赞数

分类专栏： Datawhale

本文链接：https://blog.csdn.net/weixin_45069175/article/details/107646283

版权

Datawhale 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1. 列表

定义： 用[]表示整体，每个元素用,隔开。有序集合，没有固定大小，能够保存任意数量任意剋性的Python对象。
创建：
（1）普通列表
（2）range
（3）推导式
（4）数组
（5）混合
（6）空列表

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
x = list(range(10))
x = list(range(1, 11, 2))
x = [0] * 5
x = [0 for i in range(5)]
x = [i for i in range(10)]
x = [i for i in range(100) if (i % 2 != 0) and (i % 3 == 0)]
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
x = [[0] * 3 for row in range(4)]

# x = [a] * 4操作中，只是创建4个指向list的引用，a一旦改变，x中的4个a也随之改变。
x = [[0] * 3] * 4
x[0][0] = 1

mix = [1, 'lsgo', 3.14, [1, 2, 3]] 
empty = []

向列表中添加元素：
（1）list.append(obj)：列表末尾添加新的对象，可以是任意类型，被追加的元素在list中保持原结构类型。
（2）list.extend(seq)：列表末尾一次性追加另一个序列中的多个值。
（3）list.insert(index, obj)：指定位置添加某元素。
删除列表中的元素：
（1）list.remove(obj)：移除某个值的第一个匹配项。
（2）list.pop([index=-1])：移除某个位置的元素，默认是最后一个元素，并返回该元素值。
（3）del var1[, var2, …]：删除单个或多个对象。
获取列表中的元素：
（1）单个元素：

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
print(x[0])

（2）多个元素：切片

x = [123, 456, 789, 213]
x1 = x
x2 = x[:]

x.sort() # x1随之改变，x2不变
x[2] = 546 # x1随之改变，x2不变

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]

list1[0][0] = 111 # list2、list3都随之改变

常用操作符：
==：列表中元素、位置都一致时才返回True。
+：首尾拼接；*：复制拼接。需要消耗额外的没存，尽量不用，多用 append, extend, insert。
其他方法：
list.count(obj)：统计某元素出现的次数。
list.reverse()：反向列表中的元素。
list.sort(key=None, reverse=False)：key – 用来比较的元素，指定可迭代对象中的一个元素进行排序。reverse – True(降序)，False(升序，默认)
练习题：
（1）列表操作练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15)
lst.insert(len(lst) // 2, 20)
lst.extend([2, 5, 6])
lst.pop(3)
lst.reverse()
lst.sort()
lst.sort(reverse=True)

（2）修改列表：把列表中所有数字修改为原来的两倍。

lst = [1, [4, 6], True]
for i in range(len(lst)):
    if type(lst[i]) == list:
        l = len(lst[i])
        for j in range(l):
            if type(lst[i][j]) == int:
                lst[i][j] *= 2
    elif type(lst[i]) == int:
        lst[i] *= 2

print(lst)

（3）给定一个山脉数组，求顶峰索引。

class Solution:
    def peakIndexInMountainArray(self, A):
        if len(A) < 3:
            print("False")
        else:
            max = A[0]
            for nums in A:
                if nums > max:
                    max = nums
                    j = A.index(nums)
            # print(max, j)
            k = 0
            for i in range(len(A) - 1):
                if (i < j and A[i] >= A[i + 1]) or (i > j and A[i] <= A[i + 1]):
                    k += 1

            if k == 0:
                print('True')
            else:
                print('False')

if __name__ == '__main__':
    result = Solution()
    A = [1, 3, 4, 5, 3]
    result.peakIndexInMountainArray(A)

2. 元组

**定义：**用()把元素绑在一起，用,隔开不同元素。
创建和访问：
与列表类似，不同的是列表使用方括号，元组使用圆括号，且元组内的元素不能修改，除非是元组中的元素为列表这种可修改的形式。

a = (1, 3, [2, 5])
a[2][1] = 0           #(1, 3, [2, 0])
a[1] = 0              #TypeError: 'tuple' object does not support item assignment.

创建元组可以使用小括号，也可以不使用。建议使用提高可读性。
元组中只包含一个元素时，要在元素后加逗号，否则不会认为是元组。
访问时也可以有索引和切片两种形式。
更新和删除：
用+的形式把不同元组或元组的不同部分连接起来。

week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday', ) + week[2:]
print(week)

内置方法：
元组的大小和内容都不能修改，因此只有count和index两种方法。
tuple.count(obj)：记录该元素在元组中出现的次数。
tuple.index(obj)：找到该元素的索引。
解压元组
（1）解压一维元组
（2）解压二维元组
（3）解压多维元组

t = (1, 10.31, 'python')
(a, b, c) = t           # 一维
t = (1, 10.31, ('ok', 'python'))
(a, b, (c, d)) = t      # 二维
t = (1, 2, 3, 4, 5)
a, b, *rest, c = t      # 把多个元素丢给了*rest变量

练习题：
（1）元组概念

(1, 2) * 2            #(1, 2, 1, 2)
(1, ) * 2             #(1, 1)
(1) * 2               # 2

(1, 2) (1, ) 是一个完整的元组，* 表示复制。
(1) 括号内无逗号，括号看作运算符，* 表示相乘。
（2）拆包
拆包是把元组里的元素单拉出来分别赋给不同的变量。不仅元组可以，所有的可迭代对象都可以。

a, b = 1, 2               # 属于拆包过程
a, b, _, _ = 1, 2, 3, 4   
a, b, *_ = 1, 2, 3, 4     # 赋值给占位符

3. 字符串

**定义：**引号（单、双）之间的字符集合。不同字符串之间可用+连接。若想在字符串中间加引号，需用转义字符。
常见的转义字符：

转义字符	描述
\\	反斜杠
\’	单引号
\"	双引号
\n	换行
\t	Tab
\r	回车

print('Let\'s go!')
print("Let's go!")
print('C:\\now')
print("C:\\Program files\\Intel")
print(r"C:\Program files\Intel")

切片与拼接：
和列表与元组类似。
常用内置方法：

内置函数	功能
capitalize()	首字母大写
lower()	大写转小写
upper()	小写转大写
swapcase()	大写转小写，小写转大写
count(str, beg=0,end=len(string))	统计 str 出现的次数
endswith(suffix,beg=0,end=len(string))	是否以suffix结束
startswith(substr,beg=0,end=len(string))	是否以substr开始
find(str,beg=0,end=len(string))	从左边开始找str,返回索引值；不包含返回-1
rfing(str,beg=0,end=len(string))	从右边开始找str
isnumeric()	判断字符串中是否全为数字字符
ljust(width[, fillchar])	从左边补全字符串至width长度，默认用0补
rjust(width[, fillchar])	从右边补全字符串
lstrip([chars])	删除左边的空格或指定字符
rstrip([chars])	删除右边的空格或指定字符
strip([chars])	同时执行lstrip和rstrip
partition(sub)	分割成三部分，pre-sub,sub,fol-sub，或’原字符串’,’ ‘,’ ’
rpartition(sub)	从右边开始分割
replace(old,new[,max])	用new替换old，max为最大替换次数
split(str="",num)	默认以空格分割字符串，也可以指定字符，num表示仅分割num个字符串
splitlines([keepends])	按行(’\t’ ‘\n’ ‘\t\n’)分割字符串，keepends=False(默认)不保留’\n’，keepends=True保留’\n’。
maketrans(intab,outtab)	创建字符映射的转换表
translate(table,deletechars="")	用转换表转换字符串中的字符，过滤掉的字符放在deletechars中。

字符串格式化：
两种方法：format 和格式化操作符。
（1）format
两种参数：位置参数和关键字参数。

str = "{0} love {1}".format('I', 'Lsgogroup')   #位置参数
str = "{a} love {b}".format(a='I',b='Lsgogroup')   #关键字参数

（2）格式化操作符

符号	描述
%c	格式化字符及其ASCⅡ码
%s	格式化字符串，用str()的方法处理对象
%r	格式化字符串，用rper()方法处理对象
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数，可指定小数精度
%e	用科学计数法的形式格式化浮点数
%E	同上
%g	根据值的大小选择用%f 或%e
%G	同上

练习：

字符串函数回顾
（1）怎么批量替换字符串中的元素？replace 函数。
（2）怎么把字符串按照空格进行划分？split 函数。
（3）怎么去除字符串首位的空格？lstrip 函数。
实现isdigit 函数：判断字符串中是否只包含数字0~9。

def isdigit(string):
    """    判断字符串只包含数字
    :param string:
    :return:
    """
    # your code here
    #return  string.isnumeric()
    for i in string:
        if not(48 <= ord(i) <= 57):
            return False
    return True
print(isdigit('231p'))

明明明明明_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Task04 列表、元组和字符串

练习题：（1）列表操作练习lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]lst.append(15)lst.insert(len(lst) // 2, 20)lst.extend([2, 5, 6])lst.pop(3)lst.reverse()lst.sort()lst.sort(reverse=True)（2）修改列表待续…
复制链接

扫一扫

专栏目录