python之旅——task4

列表、元组和字符串

1. 列表

列表由一系列按特定顺序排列的元素组成，其中的元素包括任意类型的对象。在Python中，用方括号[]来表示列表，并用逗号来分隔其中的元素。[元素1，元素2，…]

1.1 列表的创建

1. 直接创建

x = [2, 3, 4, 5, 6, 7]

2. 利用range（）创建

x = list(range(1, 11, 2))
print(x)
# [1, 3, 5, 7, 9] 

3. 利用推导式创建

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

4. 创建4×3的二维数组

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]]
x[1][2] = 1
print(x)
# [[0, 0, 0], [0, 0, 1], [0, 0, 0], [0, 0, 0]]

注列表中所保存的是对象的指针。如x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

a = [0] * 3
x = [a] * 4
print(x)
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 
x[0][0] = 1
print(x)
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]

列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。

1.2 列表的操作

1. 添加
   list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
   此元素如果是一个 list，那么这个 list 将作为一个整体进行追加。list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

x = ['a','b','c']
x.append('d')
print(x)
x.append(['d','e'])
print(x)
x.extend(['d','e'])
print(x)
#['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', ['d', 'e']]
['a', 'b', 'c', 'd', ['d', 'e'], 'd', 'e']

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。
list.insert(index, obj) 在编号 index 位置插入 obj。

x = ['a','b','c']
x.insert(3,'d')
print(x)
#['a', 'b', 'c', 'd']

x = ['a','b','c']
x.insert(3,['d','e'])
print(x)
#['a', 'b', 'c', ['d', 'e']]

2. 删除
   list.remove(obj) 移除列表中某个值的第一个匹配项。

x = ['a','b','c']
x.remove('b')
#['a', 'c']

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

x=['a','b','c']
y=x.pop()
print(y)
#c

x=['a','b','c']
y=x.pop(0)
print(y)
#a

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
del [var1, var2 ……] 删除单个或多个对象。

x=['a','b','c']
del x[0:2]
print(x)
#['c']

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

3. 获取
   通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
   通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

切片的通用写法是 start : stop : step
情况 1 - “start :”
以 step 为 1 (默认) 从编号 start 往列表尾部切片
情况 2 - “: stop”
以 step 为 1 (默认) 从列表头部往编号 stop 切片。
情况 3 - “start : stop”
以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
情况 4 - “start : stop : step”
以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。
情况 5 - " : "
复制列表中的所有元素（浅拷贝）。

x = ['a','b','c','e','f']
print(x[1:])
print(x[:2])
print(x[1:3])
print(x[1:2:3])
print(x[:])
#['b', 'c', 'e', 'f']
#['a', 'b']
#['b', 'c']
#['b']
#['a', 'b', 'c', 'e', 'f']

1.3 列表常用操作符

1. 等号操作符：==
2. 连接操作符 +
3. 重复操作符 *
4. 成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。 列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

x = ['a','b','c']
y=['d','e']
z=x+y
print(z)
#['a', 'b', 'c', 'd', 'e']
x = ['a','b','c']
z=x*2
print(z)
#['a', 'b', 'c', 'a', 'b', 'c']
x = ['a','b','c']
y=['d','e']
print('a'in x)
print('a'in y)
#True
False

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。 而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

1.4 列表的其他操作

list.count(obj) 统计某个元素在列表中出现的次数

x = ['a','a','b','c']
print(x.count('a'))
print(x.count('b'))
#2
1

list.index(x, start, end) 从列表中找出某个值第一个匹配项的索引位置

x = ['a','b','c']*3
print(x.index('b'))
print(x.index('b',4,8))
#1
4

list.reverse() 反向列表中元素

x = ['a','b','c']
x.reverse()
print(x)
#['c', 'b', 'a']

list.sort(key=None, reverse=False) 对原列表进行排序。

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

练习题

1. 列表操作练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15)
print(lst)
lst.insert(len(lst)//2,20)
print(lst)
lst.extend([2, 5, 6])
print(lst)
del lst[3]
print(lst)
lst.reverse()
print(lst)
lst.sort(reverse=True)
print(lst)
lst.sort(reverse=False)
print(lst)
'''
结果：
2. [2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
3. [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
4. [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
5. [2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
6. [6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
7. [20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
8. [2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
'''

9. 修改列表

def list_g(list_0):
    for i in range(len(list_0)):
        if str(list_0[i]).isdigit():
            list_0[i]*=2
        if isinstance(list_0[i],list): #判断是不是列表类型
            list_g(list_0[i])
lst = [1, [4, 6], True]
list_g(lst)
print(lst)
'''
结果：
[2, [8, 12], True]
'''

3. 山脉数组的峰顶索引

def data_up(k,i):
    y=0
    for j in range(i):
        if k[j] < k[j+1]:
            continue
        else:
            y=1
    return y
def data_down(l,m):
    y=0
    for a in range(m,len(l)-1):
        if l[a] > l[a+1]:
            continue
        else:
            y=1
    return y

user_in = input('请一个输入长度大于3的数组').split()
if len(user_in) > 3:
    n = user_in.index(max(user_in))
    x1 = data_up(user_in,n)
    x2 = data_down(user_in,n)
    if x1 or x2:
        print('False')
    else:
        print('True')
else:
    print('数组长度不够，请重新输入')

结果：

2. 元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网 站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素， 元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
定义语法:

(元素1，元素2，......)

2.1 元组的创建和访问

1.Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
2.元组使用小括号，列表使用方括号。
3.元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
4.创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
5.元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

示例：

x = (1, 2, 'a')
y = 1, 2, 'a'
print(x, type(x))
# (1, 2, 'a') <class 'tuple'>

print(y, type(y))
# (1, 2, 'a') <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'>

2.2 更新和删除一个元组

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

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

2.3 与元组相关的操作符

元组的操作符与列表相同，详见本文1.3节。

2.4 内置方法

元组大小和内容都不可更改，因此只有 count 和 index 两种方法。其中count是查看某元素出现的次数，index是该元素在元组的索引。

2.5 解压元祖

1. 解压（unpack）一维元组（有几个元素左边括号定义几个变量）

x = (1, 2, 'a')
(a, b, c) = x
print(a, b, c)
# 1 2 a

2. 解压二维元组（按照元组里的元组结构来定义变量）。
3. 如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。下例就是把多个元素丢给了 rest 变量。

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

4. 如果你根本不在乎 rest 变量，那么就用通配符「*」加上下划线‘_’。

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

2.6 练习题

1. 元祖概念

x1 = (1,2)
x2 = (1,)
x3 = (1)
print(x1*2)
print(x2*2)
print(x3*2)
'''
(1, 2, 1, 2)
(1, 1)
2
'''

分析：

结果1和结果2的对象均为元组，（1，）加了逗号作为元组使用，而*为复制操作符，所以1和2结果均为元组；结果3中（1）没加‘，’作为运算符使用，而不是元组，所以进行的是乘法运算。

2. 拆包的过程是什么

a,b = 1,2
拆包的过程是什么
上述过程属于拆包吗？
可迭代对象拆包时，怎么赋值给占位符？

答：
一、对于可迭代对象，如元组、列表、字符串、集合、字典这些可迭代对象都可以被拆包，拆包是指将一个结构中的数据拆分为多个单独变量中。拆包的方式大致有两种，一种是以变量的方式来接收，另一种是用‘*’号。
二、上述过程属于变量的直接赋值，不属于拆包。
三、保证变量的数量和可迭代对象元素的数量一致。有的时候，拆包后的元素我们不一定全部需要，对于不需要的元素可以用任意符号占位。

3. 字符串

3.1 字符串的定义

Python 中字符串被定义为引号之间的字符集合。 Python 支持使用成对的单引号或双引号。

字符串常用转义字符：

1. 如果字符串中需要出现单引号或双引号，可以使用转义符号\对字符串中的符号进行转义。

print('l\'m jack')  # I'm jack
print('C:\\now')  # C:\now

2. 原始字符串只需要在字符串前边加一个英文字母 r 即可。

print(r'C:\Program Files\Intel\Wifi\Help')  
# C:\Program Files\Intel\Wifi\Help

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

para_str = '''这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
'''
print(para_str)
# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB ( 	 )。
# 也可以使用换行符 [ 
#  ]。

3.2 字符串的切片与拼接

1.类似于元组具有不可修改性
2.从 0 开始 (和 Java 一样)
3.切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。
4.索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

3.3 字符串的常用内置方法

capitalize() 将字符串的第一个字符转换为大写。
count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。

str2 = "DAXIExiaoxie"
print(str2.find('xi'))  # 5
print(str2.find('ix'))  # -1
print(str2.rfind('xi'))  # 9

isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。
ljust(width[, fillchar]) 返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
rjust(width[, fillchar]) 返回一个原字符串右对齐，并使用fillchar（默认空格） 填充至长度width的新字符串。
lstrip([chars]) 截掉字符串左边的空格或指定字符。
rstrip([chars]) 删除字符串末尾的空格或指定字符。
strip([chars]) 在字符串上执行lstrip()和rstrip()。

str5 = ' I Love LsgoGroup '
print(str5.lstrip())  # 'I Love LsgoGroup '
print(str5.lstrip().strip('I'))  # ' Love LsgoGroup '
print(str5.rstrip())  # ' I Love LsgoGroup'
print(str5.strip())  # 'I Love LsgoGroup'
print(str5.strip().strip('p'))  # 'I Love LsgoGrou'

partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回(‘原字符串’,’’,’’)。

rpartition(sub) 类似于partition()方法，不过是从右边开始查找。

str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。
split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。
splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

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

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!!!

3.4 字符串格式化

1. 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

2. Python 字符串格式化符号
   
3. 格式化操作符辅助指令
   

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

3.5 练习题

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

答：

1. 使用replace(old, new )函数。
2. 使用str.split(str="", num) 不带参数默认是以空格为分隔符切片字符串。
3. 使用str.lstrip(]) 截掉字符串左边的空格。

实现isdigit函数
题目要求：
实现函数isdigit， 判断字符串里是否只包含数字0~9

def isdigit(str_in):
    for i in range(len(str_in)):
        if (str_in[i] >= '0') and (str_in[i] <= '9'):
            continue
        else:
            return '该字符串不只包含数字'
    return '该字符串只包含数字'
use_str = input("请输入字符串")
n=isdigit(use_str)
print(n)

结果：


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

def find_str(s):
    n = len(s)
    max_length = 0
    start = 0
    for i in range(len(s)):
        if i - max_length >= 1 and s[i - max_length - 1: i + 1] == s[i - max_length - 1: i + 1][::-1]:
            start = i - max_length - 1
            max_length += 2
            continue
        if i - max_length >= 0 and s[i - max_length: i + 1] == s[i - max_length: i + 1][::-1]:
            start = i - max_length
            max_length += 1
    return s[start: start + max_length]
user_in = input("请输入长度小于1000的字符串")
if len(user_in) <= 1000:
    out = find_str(user_in)
    print(out)
else:
    print('字符串长度过长，请重新输入')
'''
结果：
输入: "babad"
输出: "bab"
输入: "cbbd"
输出: "bb"
'''