2020.7.27 Python basic syntax04-列表、元组及字符串

本小节介绍Python中最基础的三类容器：列表、元组及字符串

列表

列表的创建

• 利用推导式创建列表

【例子】

x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>

x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))

# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

• 创建一个4*3的二维数组

【例子】

x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>

for i in x:
    print(i, type(i))
# [1, 2, 3] <class 'list'>
# [4, 5, 6] <class 'list'>
# [7, 8, 9] <class 'list'>
# [0, 0, 0] <class 'list'>

x = [[0 for col in range(3)] for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x = [[0] * 3 for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[1][1] = 1
print(x, type(x))
# [[0, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

注意：

由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

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

【例子】

x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

获取列表中的元素

• 复制列表中的所有元素（浅拷贝）。

【例子】

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

【例子】浅拷贝与深拷贝

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

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

列表相关基础操作

因为list是可变元素，所以list的bif函数并不会返回新的列表，而是在原有列表上进行修改

list.append()  #添加元素到列表尾部，只能一个元素
list.extend(list)  #使用列表扩展另一个列表，参数应该是列表，追加至列表尾部
len(list)  #返回列表的元素个数
list.insert(a,b)  #a表示列表索引值，b表示插入的元素
list.index(a,x,y)  #返回a在列表中首次出现的位置,x,y圈定寻找的范围
list.remove(a)  #删除元素a
list.pop(index = -1)  #从列表中取出a索引值处的元素并返回，默认最后一个
# remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是制定一个索引
list[:]  #获得列表的拷贝同时又不改变原列表
del list[index]  #删除列表某个值（也可以删除整个列表）
# 如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
list.count(a)  #计算元素在列表中出现的次数
list.reverse()  #反转列表，不返回值
list.sort(key = func, reverse = True)  #默认是排序，加入reverse = True参数实现‘逆袭’（逆向排序），func指用于排序的函数
list.copy()  #同切片拷贝
list.clear()  #清空列表元素，使之变成一个空列表

特别注意一下list.sort
list.sort(key=None, reverse=False) 对原列表进行排序。

• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
• 该方法没有返回值，但是会对列表的对象进行排序。

【例子】

x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]


# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]


x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

课后题作答

class Solution:
    def peakIndexInMountainArray(self, a):
        length = len(a)
        for i in range(1,length - 1):
            n = 0
            sub_list = a[:i + 1]
            sub_list2 = sub_list[:]
            sub_list2.sort(reverse = False)
            if sub_list == sub_list2:
                n += 1
            sub_list = a[i:]
            sub_list2 = sub_list[:]
            sub_list2.sort(reverse = True)
            if sub_list == sub_list2:
                n += 1
            if n == 2:
                return True
        return False

a = Solution()
print(a.peakIndexInMountainArray([1,3,4,5,3]))
print(a.peakIndexInMountainArray([1,3,4,6,4,5]))
print(a.peakIndexInMountainArray([1,7,7,6,5,4,2]))
#True
#False
#True

元组

创建元组

• 逗号即元组，为了可读性，建议还是加上括号

t1 = 1, 10.31, 'python'
print(type(t1))
#<class 'tuple'>

【例子】

x = (1)
print(type(x))  # <class 'int'>
x = 2, 3, 4, 5
print(type(x))  # <class 'tuple'>
x = []
print(type(x))  # <class 'list'>
x = ()
print(type(x))  # <class 'tuple'> 这里特别注意一下
x = (1,)
print(type(x))  # <class 'tuple'>
print(8 * (8))  # 64
print(8 * (8,))  # (8, 8, 8, 8, 8, 8, 8, 8)

更改和删除一个元组

【例子】元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

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])

元组的BIF

元组大小和内容都不可更改，因此只有 count 和 index 两种方法。

【例子】

t = (1, 10.31, 'python')
print(t.count('python'))  # 1
print(t.index(10.31))  # 1

• count('python') 是记录在元组 t 中该元素出现几次，显然是 1 次
• index(10.31) 是找到该元素在元组 t 的索引，显然是 1

元组的解包(unpack)

【例子】解压（unpack）一维元组（有几个元素左边括号定义几个变量）

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

【例子】解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

【例子】如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

【例子】如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线「_」。

t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)  # 1 2

字符串

字符串几个值得注意的BIF

split()与splitlines()

s.split(sep = None, maxsplit = -1)  #按照sep（默认空格）进行切片操作，返回切出元素组成的列表，maxsplit = 1 表示分割一次，0就表示0次
s.splitlines([keepends])  #按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

#示例
print("".split('\n'))
print("".splitlines())
print("Hi\n".split('\n'))
print("Hi\n".splitlines()) #默认是False
print("Hi\n".splitlines(True))

#['']
#[]
#['Hi', '']
#['Hi']
#['Hi\n']

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

maketrans()和translate()函数用于替换字符

• maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
• translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

【例子】

str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

字符串格式化

• 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

课后习题答案

# leetcode05
'''
给定一个字符串 `s`，找到 `s` 中最长的回文子串。你可以假设 `s` 的最大长度为 1000。

示例:

输入: "babad"

输出: "bab"

输入: "cbbd"

输出: "bb"
'''
class Solution:　　　　　　　　　　　　　　　　　　　　　　　　　　#leetcode固定模式：定义一个类
    def longestPalindrome(self, s: str) -> str:　　　　　　 #类中的方法及形参输入
        num1 = len(s)　　　　　　　　　　　　　　　　　　　　　　 #获取给定字符串的长度
        if s == "":　　　　　　　　　　　　　　　　　　　　　　　　#若给定的字符串为空字符串
            return("")　　　　　　　　　　　　　　　　　　　　　　#则返回一个空字符串
        aa = 1　　　　　　　　　　　　　　　　　　　　　　　　　　　#定义一个变量啊啊，并赋值为1，用于获取字符串分片
        for i in range(num1 - 1,-1,-1):　　　　　　　　　　　　#此处for循环从给定字符串的个数的最大值开始，并且步长为-1
            for j in range(aa):　　　　　　　　　　　　　　　　　#此处的aa变量决定循环的次数
                str1 = s[j:j+i+1]　　　　　　　　　　　　　　　　#获取字符串对应的分片
                str2 = str1[::-1]　　　　　　　　　　　　　　　　#字符串反转
                if str1 == str2:　　　　　　　　　　　　　　　　 #判断两字符串是否一样
                    return(str1)　　　　　　　　　　　　　　　　　#若一样，则返回此字符串
            aa = aa + 1　　　　　　　　　　　　　　　　　　　　　　#若不一样则变量aa增加一