python-列表、元组、字符串

列表

练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.append(15)
print(lst)
#[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.insert(len(lst)//2,20)
print(lst)
#[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.extend([2,5,6])
print(lst)
#[2, 5, 6, 7, 8, 9, 2, 9, 9, 2, 5, 6]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.pop(3)
print(lst)
#[2, 5, 6, 8, 9, 2, 9, 9]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.reverse()
print(lst)
#[9, 9, 2, 9, 8, 7, 6, 5, 2]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.sort()
print(lst)
#[2, 2, 5, 6, 7, 8, 9, 9, 9]

lst=[2, 5, 6, 7, 8, 9, 2, 9, 9]
lst.sort(reverse=True)
print(lst)
#[9, 9, 9, 8, 7, 6, 5, 2, 2]

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

元组

元组的定义语法为（元素1, 元素2, …, 元素n）
[1]这与列表的语法不同，元组是 用小括号（）将所有元素放在一起的而列表是用[]把所有元素放在一起的。

创建和访问一个元组

Python 的元组与列表类似，但不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
创建和访问一个元素可以用索引和切片来实现。

t1=("guodong",19,0.7)
print(t1,type(t1))
#('guodong', 19, 0.7) <class 'tuple'>

t1[0]
t1[:-1]
#'guodong'
#('guodong', 19)

注：创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

x=(1)
print(type(x)) 
#<class 'int'>

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

print(6 * (5))  
print(6 * (5,)) 
#30
#(5, 5, 5, 5, 5, 5)

#创建二维元组
x = ("guodong",19,0.7), ('python', 42)
print(x)
print(x[0])
print(x[0][0], x[0][1], x[0][2])
print(x[0][0:2])
#(('guodong', 19, 0.7), ('python', 42))
#('guodong', 19, 0.7)
#guodong 19 0.7
#('guodong', 19)

更新和删除一个元组

元组有不可更改 (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])

x = ("guodong",19,0.7), ('python', 42)
x[0][0]=54
print(x)
#会报错，因为不能直接给元组的元素赋值

与元组相关的操作符

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

内置方法

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

t1=("guodong",19,0.7)
print(t1.index(19))
#1
print(t1.count("guodong"))
#1

解压元组

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

(a, b, c) = t1
print(a, b, c)
#guodong 19 0.7

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

t2 = (19, 0.8, ('I', 'Love','guodong'))
(a, b, (c, d,e)) = t2
print(a, b, c, d,e)
#19 0.8 I Love guodong

如果只想要元组其中几个元素，用通配符「*」

t2 = (19, 0.8, ('I', 'Love','guodong'))
a, *rest2, (c, d,e) = t2
print(a)
print(rest2)
print(c,d,e)
#19
#[0.8]
#I Love guodong

如果不需要输出rest2变量的值，那么就用通配符「」加上下划线「_」。

a,*_,(c, d,e) = t2
print(c,d,e)
#I Love guodong

练习

print((1, 2)*2) #(1, 2, 1, 2)  #
print((1, )*2) #(1, 1) #(1, )还是元组，对元组进行运算
print((1)*2) #2  #(1)是整型，直接进行了数值运算

字符串

定义

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

t1 = 'i love Python!'
print(t1, type(t1))
# i love Python! <class 'str'>

t2 = "I love Python!"
print(t2, type(t2))
# I love Python! <class 'str'>

print(5 + 8)  # 13
print('5' + '8')  # 58

Python 的常用转义字符：

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

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

print('let\'s go')  # let's go
print("let's go")  # let's go
print('C:\\now')  # C:\now
print("C:\\Program Files\\Intel\\Wifi\\Help")
# C:\Program Files\Intel\Wifi\Help

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

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

字符串的切片与拼接

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

str1 = 'I Love LsgoGroup'
print(str1[:6])  # I Love
print(str1[5])  # e
print(str1[:6] + " 插入的字符串 " + str1[6:])  
# I Love 插入的字符串  LsgoGroup

s = 'Python'
print(s)  # Python
print(s[2:4])  # th
print(s[-5:-2])  # yth
print(s[2])  # t
print(s[-1])  # n

字符串的常用内置方法

capitalize() 将字符串的第一个字符转换为大写。
lower() 转换字符串中所有大写字符为小写。
upper() 转换字符串中的小写字母为大写。
swapcase() 将字符串中大写转换为小写，小写转换为大写。

str='guoDong'
print(str.capitalize()) #Guodong
print(str.lower()) #guodong
print(str.upper()) #GUODONG
print(str.swapcase()) #GUOdONG

count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。

str='guoDong'
str.count('g') #2

endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。

str='guoDong'
print(str.startswith('guo'))  #True
print(str.startswith('gguo')) #False
print(str.endswith('dong')) #False
print(str.endswith('Dong')) #True

find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找。

str='guoDong'
print(str.find('o')) #2
print(str.find('no')) #-1
print(str.rfind('o')) #4

isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。

str='guoDong'
str.isnumeric() #False
str1='1104'
str1.isnumeric() #True

ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

str2='1104'
print(str2.ljust(8, '0'))  #11040000
print(str2.rjust(8, '0')) #00001104

lstrip([chars]) 截掉字符串左边的空格或指定字符。
rstrip([chars]) 删除字符串末尾的空格或指定字符。
strip([chars]) 在字符串上执行lstrip()和rstrip()。

partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回(‘原字符串’,’’,’’)。
rpartition(sub)类似于partition()方法，不过是从右边开始查找。

str3='I Love writing paper'
print(str3.strip().partition('o'))#('I L', 'o', 've writing paper')
print(str3.strip().rpartition('i')) #('I Love writ', 'i', 'ng paper')

#replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。
print(str3.strip().replace('I', 'We')) #We Love writing paper

split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。

print(str3.strip().split()) #['I', 'Love', 'writing', 'paper']
print(str3.strip().split('i')) #['I Love wr', 't', 'ng paper']

c = '''say
hello
baby'''

print(c)
# say
# hello
# baby

print(c.split('\n'))

splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

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

Python 字符串格式化符号

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