Task04列表、元组和字符串

列表、元组和字符串

• 可变（mutable）对象： 列表、字典、集合
  所谓可变是指可变对象的值可变，身份是不变的。
• 不可变（immutable）对象：数字、字符串、元组、键
• 映射类型：字典
• 序列类型：字符串，元组，列表
  不可变对象就是对象的身份和值都不可变。新创建的对象被关联到原来的变量名，旧对象被丢弃，垃圾回收器会在适当的时机回收这些对象。
• 容器数据类型
  列表
  元组
  字典
  集合
  字符串
• 简单数据类型
  整型
  浮点型
  布尔型
• 涉及到通过索引值获取元素的，都是x[]是中括号，x可是列表、元组、字符串
• 列表、元组和字符串的共同点：
  都可以通过索引得到每一个元素
  默认的第一个元素的索引值是0
  可以通过切片得到一个范围内的元素的集合
  有很多共同的操作符

06列表

笔记

• 列表定义语法为：[元素1, 元素2, …, 元素n]

• 二维列表：[[元素1, 元素2, ..., 元素n],[元素1, 元素2, ..., 元素n],....]

• 列表的元素可以是任何对象，列表中所保存的是对象的指针

• 可以通过列表构建数组，x=[a]*4操作中，若a发生改变，则4个a都会发生改变

• 列表的元素可以更改(mutable)，对应操作：
  附加(append,extend)
  插入(insert)
  删除(remove,pop)

• append和extend的区别：append只能添加一个参数，并保持该参数原有数据类型（任何类型的都可），把一个东西整体放在原列表后。extend是用新序列扩展原序列，要补充的参数必须放在中括号[]里，可以补充多个参数

• del x[m:n]删除索引值m到n-1的元素

• 如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del；如果在删除元素后还能继续使用它，就使用pop()。

• 浅拷贝与深拷贝：
  浅拷贝（shallow copy）只复制指向某个对象的指针，而不复制对象本身，新旧对象共享同一块内存，改变就对象
  深拷贝（deep copy）会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象
  浅拷贝与深拷贝的对比

• reverse：排序规则reverse = True 降序， reverse = False 升序（默认）

• lambda匿名函数

• 列表相关参考

练习

1、 列表操作练习
列表lst 内容如下
lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

1. 请写程序完成下列操作：
2. 在列表的末尾增加元素15
3. 在列表的中间位置插入元素20
4. 将列表[2, 5, 6]合并到lst中
5. 移除列表中索引为3的元素
6. 翻转列表里的所有元素
7. 对列表里的元素进行排序，从小到大一次，从大到小一次

#列表操作练习
lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
#1.在列表的末尾增加元素15
lst.append(15)
#2.在列表的中间位置插入元素20
lst.insert(5,20)
#3.将列表[2, 5, 6]合并到lst中
lst=lst+[2,5,6]
#4.移除列表中索引为3的元素
lst.remove(lst[3])
#5.翻转列表里的所有元素
lst.reverse()
#6.对列表里的元素进行排序，从小到大一次，从大到小一次
lst.sort(reverse=False)#从小到大
lst.sort(reverse=True)#从大到小

2、修改列表

问题描述：

lst = [1, [4, 6], True]

请将列表里所有数字修改成原来的两倍

#修改列表
lst = [1, [4, 6], True]
lst[0]=lst[0]*2
lst[1][0] *= 2
lst[1][1] *= 2

3、leetcode 852题 山脉数组的峰顶索引

如果一个数组k符合下面两个属性，则称之为山脉数组

数组的长度大于等于3

存在$i$，$i$ >0 且$i<\mathrm{len}(k)-1$， 使得$$\mathrm{k}[0]<\mathrm{k}[1]<\dots <\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1]\dots >\mathrm{k}[\mathrm{len}(\mathrm{k})-1]$$

这个$i$就是顶峰索引。

现在，给定一个山脉数组，求顶峰索引。

#山脉数组的峰顶索引
def mountain(nums):
    l = len(nums)
    if l < 3 :
        a=False
    else:
        zuida=max(nums)
        zuida_weizhi=nums.index(zuida)
        if zuida_weizhi > 0 and zuida_weizhi < l-1 :
            nums1 = nums[0:zuida_weizhi:1]
            nums2 = nums[zuida_weizhi + 1:]
            nums3 = nums1[:]  # 这个地方要用浅拷贝，否则原序列发生变化时，该序列也会发生变化
            nums4 = nums2[:]
            nums1.sort(reverse=False)
            nums2.sort(reverse=True)
            if nums1 == nums3 and nums2 == nums4:
                a = True
            else:
                a = False
        else:
            a = False
    for i in range(0,len(nums)-1) :
        if nums[i] == nums[i+1] :
            a=False
    index = nums.index(zuida)
    return a,zuida,index
nums=[1,1,4,6,5,4]
print(mountain(nums))

---

07元组

笔记

• 元组定义语法为：(元素1, 元素2, ..., 元素n)
  （也可不用小括号，但为可读性还是用（））
• 元组与列表类似，但tuple被创建后不可修改，类似于字符串，但是可以直接更改元素，例如：

t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

• 利用整数对元组进行索引 (indexing) 和切片 (slicing)，如tuple[5:]
• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
• 二维元组(元素1, 元素2, ..., 元素n),(元素1, 元素2, ..., 元素n)....,最外层不需小括号括住
• 元组中的元素不可直接赋值，但是若元组中包含可变的元素（如列表），则可以直接更改其元素
• 解压元组：通配符*
  把多个元素丢给rest变量：*rest，可以通过变量rest再用这些元素
  不在乎剩余变量：*_
• 元组相关参考

练习

1、元组概念
写出下面代码的执行结果和最终结果的类型

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

分析为什么会出现这样的结果.

#元组概念
(1, 2)*2 # (1, 2, 1, 2),通过重复操作符复制拼接
(1, )*2 # (1, 1),（）括号内有逗号，说明这还是元组类型，进行复制拼接
(1)*2 # 2 括号内无逗号，括号被认作为运算符，进行整型乘法运算

2、拆包过程是什么？

a, b = 1, 2

上述过程属于拆包吗？
可迭代对象拆包时，怎么赋值给占位符？
答：拆包过程：对于函数中的多个返回数据, 去掉元组, 列表 或者字典 直接获取里面数据的过程。
上述过程属于拆包，右边是元组类型，省略了（）没写，但为了可读性一般还是写（）
例如：print("我叫 %s 今年 %d 岁!" % ('小明', 10))字符串中的占位符赋值可迭代对象中的元素按序对应，同时注意迭代对象中的元素类型要和占位符含义对应。最后占位符和迭代对象之间添加%即可

---

08字符串

笔记

• 定义为引号之间的字符集合，支持成对的单引号或双引号

字符串的定义：

• 转义字符：

转义字符	描述
\\	反斜杠符号
\'	单引号
\"	双引号
\n	换行
\t	横向制表符(TAB)
\r	回车

• 想输出原始字符串，不借用转义字符，就在字符串前加一个英文字母r即可
• 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

字符串中常用内置方法：

• capitalize() 将字符串的第一个字符转换为大写
• lower() 转换字符串中所有大写字符为小写
• upper() 转换字符串中的小写字母为大写
• swapcase() 将字符串中大写转换为小写，小写转换为大写
• center(width)将字符串居中，并使用空格填充至长度width的新字符串
• count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数
• encode(encoding='utf-8',errors='strict')以encoding指定的编码格式对字符串进行编码
• endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix结束，如果是，返回 True，否则返回 False。
• startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr开头，如果是，返回 True，否则返回 False
• find(str, beg=0, end=len(string)) 从左往右检测 str是否包含在字符串中，如果包含，返回开始的索引值，否则返回 -1。
• rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右往左开始查找
• isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
• ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串
• rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串
• lstrip([chars]) 截掉字符串左边的空格或指定字符
• rstrip([chars]) 删除字符串末尾的空格或指定字符
• strip([chars]) 在字符串上一并执行lstrip()和rstrip()
• partition(sub) 从左往右找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')
• rpartition(sub)类似于partition()方法，不过是从右往左开始查找
• replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次
• split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则从左往右仅分隔num个子字符串，返回切片后的子字符串拼接的列表（可以通过split去掉字符串中不想要的代码，然后把剩余的代码拼接成列表）
• splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符
• maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
• translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。（可以由str.maketrans('a','b')定制）
  【例子】

s = 'sssssssssaaaaaaaa'
s = s.translate(str.maketrans('a','c'))
print(s) #ssssssssscccccccc

• s 为字符串
  s.isalnum() 所有字符都是数字或者字母，为真返回 True，否则返回 False。
  s.isalpha() 所有字符都是字母，为真返回 True，否则返回 False。
  s.isdigit() 所有字符都是数字，为真返回 True，否则返回 False。
  s.islower() 所有字符都是小写，为真返回 True，否则返回 False。
  s.isupper() 所有字符都是大写，为真返回 True，否则返回 False。
  s.istitle() 所有单词都是首字母大写，为真返回 True，否则返回 False。
  s.isspace() 所有字符都是空白字符，为真返回 True，否则返回 False。

字符串格式化

即按统一的规格输出成一个字符串

• format格式化函数

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

• Python字符串格式化符号：

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

【例子】

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c注意是用元组括住的三个数据
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

• 格式化操作符辅助指令：

符号	功能
m.n	m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
-	用作左对齐
+	在正数前面显示加号( + )
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格

【例子】

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

• 字符串相关参考

练习

1、字符串函数回顾

• 怎么批量替换字符串中的元素？
• 怎么把字符串按照空格进⾏拆分？
• 怎么去除字符串⾸位的空格？

replace(old, new [, max]) #用元素new替换元素old，max控制替换的次数,替换次数不超过max次
split(' ', num) #引号之间打空格，num控制分隔分隔多少个字符串
lstrip() #删除字符串首尾空格

2、实现isdigit函数
题目要求
实现函数isdigit， 判断字符串里是否只包含数字0~9
法一：就利用字符串的常用内置方式

def isdigit(string):
    """
    判断字符串只包含数字
    :param string:
    :return:
    """
    flag = string.isnumeric()
    return flag

法二：自己写看字符串内元素对应asc码值是否在区间内ord()获取asc码值

def isdigit(string):
    """
    判断字符串只包含数字
    :param string:
    :return:
    """
    for i in string :
        a=ord(i)
        if a >= 48 and a <= 57 :
            flag = True
        else:
            flag = False
    return flag

3、leetcode 5题 最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

class Solution :
    def longestPalindrome(s) :
        i = 0
        l_s = len(s)
        huiwen_max = ''
        while i < l_s:
            a = s[i:]
            while True:
                end = a.rfind(a[0])
                str1 = a[0:end + 1]
                str2 = str1[1:end]
                while len(str2) > 1:
                    if str2.endswith(str2[0]) == True:
                        str2 = str2[1:len(str2) - 1]
                    else:
                        a = str1[:len(str1) - 1]
                        break
                if len(str2) < 3:
                    huiwen = str1
                    break
                else:
                    continue
            i += 1
            if len(huiwen) > len(huiwen_max):
                huiwen_max = huiwen
        return huiwen_max
    s = "eabcbacfcdcfcabcdafe"
    print(longestPalindrome(s))