序列-CSDN博客

本文链接：https://blog.csdn.net/fengsen321/article/details/79015096

可变（指：支持原位改变）分为：list列表和可变序列通用操作

# 列表存在“引用”

Python 有几个复合数据类型，用于表示其它的值。最通用的是 list (列表) ，它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型:

（1） List列表

1.可包含任意对象的有序集合

>>> score = 90

>>> scores = [99,32,65,90.7,”abc”] #可以包含整数和浮点数以及字符串

>>> type(scores)

>>> scores

[99, 32, 65, 90.7.”abc”]

2.通过下标索引（位置偏移）访问元素

>>> x = [90,99,34.5,"tom"]

>>> x[0] #访问单一元素

>>> x[3]

'tom'

>>> x[-1]

'tom'

就像字符串(以及其它所有内建的序列类型)一样，列表可以被索引和切片:

>>>x[0:2] # 也可以访问一定范围的元素,也叫切片

[90, 99]

x = ([90,99,34.5,"tom"])
print(x[0],x[2]) # 打印列表元素

90 34.5

x = ([90,99,34.5,"tom"])
print(x[-3:-1])    #  重左到右取值，故左不故右
print(x[-3:])      #  需要取最后的值直接冒号

[99, 34.5]

[99, 34.5, 'tom']

# 跳着切片

name = ["tom","jerry","mike","peter","john"]
print(name[::2])

['tom', 'mike', 'john']

3.可变长度，异质，可任意嵌套（嵌套指：列表本身可以包含列表）

不像 不可变的 字符串，列表是 可变的，它允许修改元素:

>>> x =[90,99,34.5,"tom"]

>>> x.enu(79) # append是方法不是函数

>>> x

[90, 99, 34.5, 'tom', 79]

>>> y = [90, 99, [34.5, 'tom'],79] #可任意嵌套

>>> y

[90, 99, [34.5,'tom'], 79]

4.支持原位改变 # 列表本身是可以改变的

>>> x = [90, 99, [34.5,'tom'], 79]

>>> x[1] = 66

>>> x

[90, 66, [34.5, 'tom'], 79]

x.insert(1,277)    # 或者用insert,通用操作方法
print(x)

[90, 277, 99, 34.5, 'tom']

也可以对切片赋值，此操作可以改变列表的尺寸，或清空它:

>>> letters = ['a','b','c','d','e','f','g']

>>> letters

['a', 'b', 'c', 'd', 'e', 'f', 'g']

>>> # replace some values

>>> letters[2:5] = ['C','D','E']

>>> letters

['a', 'b', 'C', 'D', 'E', 'f', 'g']

>>> # now remove them

>>> letters[2:5] = []

>>> letters

['a', 'b', 'f', 'g']

>>> # clear the list by replacing all the elements with an empty list

>>> letters[:] = []

>>> letters

[]

内置函数 len() 同样适用于列表:

>>> letters = ['a','b','c','d']

>>> len(letters)

允许嵌套列表(创建一个包含其它列表的列表)，例如:

>>> a= ['a','b','c']

>>> n= [1,2,3]

>>> x= [a,n]

>>> x

[['a', 'b', 'c'], [1, 2, 3]]

>>> x[0]

['a', 'b', 'c']

>>> x[0][1]

'b'

5．对象”引用”数组

X = [1,2,3] # 存储原理图： 0指向1

>>> x[0] = "tom"

>>> x

['tom', 2, 3] #存储原理图：0 重新指向“tom”

>>> z = 2

>>> x[1] == z

True

>>> x[1] is z

True # 256以下的数都会缓存一个地方原理如下图;

6.常用操作排序

l.sort # 从小到大排序

>>>scores = [100,43,89,98,67,76.9]

>>> scores

[100, 43, 89, 98, 67, 76.9]

>>> scores.sort() # 不直接返回参数

>>> scores # 需要再次调用

[43, 67, 76.9, 89,98, 100]

>>> a =["tom","jerry","mike","peter","john"]

>>> a.sort() # 按字母顺序排序

>>> a

['jerry', 'john', 'mike', 'peter', 'tom']

l.reverse() # 从大到小排序

>>>scores.reverse()

>>> scores

[100, 98, 89, 76.9, 67, 43]

>>> a = ['jerry', 'john', 'mike','peter', 'tom']

>>> a.sort(key=lambda x:x[-1])

>>> a # lambda是一个函数，[-1]指按照名字最后一个字母排序

['mike', 'tom', 'john', 'peter', 'jerry']

sorted(t) # 是一个全局函数，不需要调用模块或包

不依附某个对象，需要把参数传给t

>>> scores = [23,34,56.6,100,99]

>>> sorted(scores) # 直接返回参数

[23, 34, 56.6, 99, 100]

dict= {6:4,2:3,-2:9}
print(sorted(dict)) # 键值大小排序
print(sorted(dict.items())) # 按键值大小排序字典

print(sorted(dict.items(),key = lambda x:x[1])) # 按值大小排序字典

# x是元素，x[1]是元素里面的[1]的位置

[-2, 2, 6]

[(-2, 9), (2, 3),(6, 4)]

[(2, 3), (6, 4),(-2, 9)]

num = [2,3,45,6]
w = ["a","b","c","d"]
for i in zip(w,num):
print(i)

('a', 2)

('b', 3)

('c', 45)

('d', 6)

>>> a = ['mike', 'tom', 'john','peter', 'jerry']

>>> sorted(a,key=lambda n:n[1]) # 按照名字第二个字母排序

['peter', 'jerry', 'mike', 'tom', 'john']

（2）可变序列通用操作

1. 改变某个元素值 s[i] = x

>>> s = list(range(1,11))

>>> s

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> s[0] = 99

>>> s

[99, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2.改变特定范围内元素值

s[i:j] = t

>>> s[:3] = [66,77,88]

>>> s

[66, 77, 88, 4, 5, 6, 7, 8, 9, 10]

>>> s[:3] = [66,77,88,99,00] # 赋值大于设定，将会挤压后面元素

>>> s

[66, 77, 88, 99, 0, 4, 5, 6, 7, 8, 9, 10]

>>> s[:5] = [666]

>>> s

[666, 4, 5, 6, 7, 8, 9, 10]

s[i:j:k]= t

>>> b =list(range(1,11))

>>>b

[1,2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> b[::2] = [99,99,99,99,99] #需要给定赋值的数量，以及相匹配元素的值

>>> b

[99, 2, 99, 4, 99, 6, 99, 8, 99, 10]

3.删除元素

dels[i] # 通过索引来删除，不需要知道具体的值

>>> b = [99, 2, 99, 4, 99, 6, 99,8, 99, 10]

>>> del b[0] # 此方法还可以删除变量

>>> b

[2, 99, 4, 99, 6, 99, 8, 99, 10]

del s[i:j]

>>> del b[0:3]

>>> b

[99, 6, 99, 8, 99,10]

#或者删除元素的方法

>>> b[0:3] = [ ] # 相当于给一个空的序列

>>> b

[99, 6, 99, 8, 99, 10]

dels[i:j:k]

>>> del b[::3]

>>> b

[6, 99, 99, 10]

s.remove(x) s 指序列 x要删除的元素内容

>>> c = list(range(1,11))

>>> c

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> c.remove(2) # 指定删除元素

>>> c

[1, 3, 4, 5, 6, 7, 8, 9, 10]

>>> z = [2,3,4,5,6,7,2,3,2]

>>> z.remove(3) # 序列出现多个元素，但删除第一个

>>> z

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

s.clear()清空序列

>>> z = [2,3,4,5,6,7,2,3,2]

>>> z.clear()

>>> z

[ ]

4.追加元素在列表后面追加

s.append(x)

>>> z = [ ]

>>> z.append(5)

>>> z

[5]

>>> z.append(7)

>>> z

[5, 7]

>>> z.append([8,9]) # s.append(x) 只能把括号里面的内容当成一个值

>>> z

[5, 7, [8, 9]] # s.append(x) 只能把括号里面的内容当成一个值，哪怕是一个序列，如果想要并列加进去，得用扩展元素

5.扩展序列

s.extend(x) # 追加的不是一个整体，而是独立的元素

>>> z = [5, 7, [8, 9]]

>>> z.extend([10,11,12])

>>> z

[5, 7, [8, 9], 10, 11, 12]

6.插入元素 s.insert(i,x) s指列表 i指所追加位置 x指元素

>>> z = [5, 7, [8, 9], 10, 11, 12]

>>> z.insert(0,99)

>>> z

[99, 5, 7, [8, 9], 10, 11, 12]

>>> z.insert(3,10)

>>> z

[99, 5, 7, 10, [8, 9], 10, 11, 12]

7.检索并删除特定元素 s.pop([i]) # i不指定下标，默认删除最后一个

>>> a = [1, 2, 100, 3, 4, 5, 6, 7,8, 9, 10]

>>> a.pop() #，输入下标等于del s[i]用法

>>> a

[1, 2, 100, 3, 4, 5, 6, 7, 8, 9]

>>> a.pop()

>>> a

[1, 2, 100, 3, 4, 5, 6, 7, 8]

>>> b = list(range(1,11))

>>> a

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> b.extend([23,[100,10],101])

>>>b

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, [100,10], 101]

>>> result = b.pop()

>>> b

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, [100,10]]

>>> result # 检索被删除的元素

101

>>> a.pop(1) # 删除所在的元素

>>> a

[1, 3, 4, 5, 6, 7, 8, 9, 10, 23, [100, 10]]

8.反转序列s.reverse()

>>> a.reverse()

>>> a

[[100,10], 23, 10, 9, 8, 7, 6, 5, 4, 3, 1]

>>> y = a.reverse()

>>> y # y是空的，证明a.reverse()只会影响a原来的变量本身

>>> a

[1, 3, 4, 5, 6, 7, 8, 9, 10, 23, [100, 10]]

9.复制序列 s[:] 或者 s.copy()

s[:]

>>> s = list(range(11))

>>> s

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> z = s

>>> z

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> z[1] = 99

>>> z

[0, 99, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> s # z和s 关联了一个对象，其实是共享引用了

[0, 99, 2, 3, 4, 5, 6, 7, 8, 9, 10]

或者调用copy进行深度copy

import copy
name = ["tom","jerry","mike","peter","john"]
names = copy.deepcopy(name)
names[0] = "copy"
print(name,names)

['tom', 'jerry', 'mike', 'peter', 'john']

['copy', 'jerry', 'mike', 'peter', 'john']

的

s.copy() # 浅copy，不调用copy,只复制一层

>>> a = list(range(11))

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> x = a.copy()

>>> x

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> x[0] =99

>>> x

[99, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# s.copy()的使用是复制了一个引用存储的值是一样的，除非超过256

# 当>>> x[0] = 99 的时候，原理如下图

类似# 只复制值一次值，工资举例

a = ["fengsen",["salary",50.00]]

b = a[:]

['fengsen', ['salary', 50.0]]

['fengsen', ['salary', 50.0]]

b[0] = "王"    # 第一次一个列表值改变，不影响另一个列表

['王', ['salary', 50.0]]

['fengsen', ['salary', 50.0]]

a[1][1] = 100.00 # 第二次一个列表值改变，影响另一个列表，这就是浅copy

['fengsen', ['salary', 100.0]]

['王', ['salary', 100.0]]

不可变

（1） tuple 元组(只读列表)

a = [ ] # 方括号代表list

b = ( ) # 元括号代表元组

1. 可包含任意对象的有序集合

>>> c = ("tom")

>>> c

'tom'

>>> type(c)

<class 'str'> # 应该是tuple元组，为什么成了字串str了

>>> c = ("tom",) #应该做结尾加，逗号结束，告知这是元组

>>> c

('tom',)

>>> type(c)

# 如果想生成tuple序列，可以以下操作

>>> scores = tuple(range(1,9)) # 用tuple生成，不用list

>>> scores

(1, 2, 3, 4, 5, 6, 7, 8)

>>> type(scores)

2. 通过下标索引（位置偏移）访问元素

>>> t = (1,2,3,4,5,[33,33.11],100)

>>> t[5]

[33, 33.11]

>>> t[5][1] # 嵌套可以用这种方式访问

33.11

>>> t[0:3] # 访问元素和list列表方式一样

(1, 2, 3)

3. 固定长度，异质，可任意嵌套 # 异质表示可以包含任意对象，如：数字，浮点，嵌套，字母等

>>> t = (1, 2, 3, 4, 5,[33, 33.11], 100)

>>> t.append(5) # 体现了tuple 不支持原位改变

Traceback (most recent call last):

File "<pyshell#9>", line 1, in <module>

t.append(5)

AttributeError: 'tuple' object hasno attribute 'append'

4. 对象引用数组

>>>a = (12,34,45,"tom",32.99)

>>>a1 = (100,)

>>> a3 = a + a1 # 只是引用相加后过的值，想要相加的值，可以用 a4 = a3 的方式给a4 赋值

>>>a3

(12, 34,45, 'tom', 32.99, 100)

>>>a1 # a1 和 a2 的值不变，体现了tuple不支持原位改变

(100,)

>>>a

(12, 34,45, 'tom', 32.99)

>>>a = 3

>>>b = 4

>>>a,b = 3,4 # 本质上是tuple元组

>>>a

>>>b

>>>b,a = 3,4 # 交换数值

>>>a

>>>b

>>>

（3）文本序列str字符串

1. ‘字符串 “字符串” “””三字符串”””

“””三字符串”””

s = """

您好wangxueya

冯森爱你哟

都很爱你哟

"""

>>>s

'\n您好wangxueya\n冯森爱你哟\n都很爱你哟\n'

>>> print(s)

您好wangxueya

冯森爱你哟

都很爱你哟

2.转义符

\n 换行

>>> z = "优教通\nwww.yjt361.com" # \n表示换行

>>> print(z)

优教通

www.yjt361.com

\t tab

>>> a = "有交通\twww.yjt361.com"

>>> print(a)

有交通 www.yjt361.com # 空4格，一个tab键

\\ \ # 解决 \ 不能在文件路径中使用

>>>path = "c:\\abc\\vbn\\tag.txt"

>>> print(path)

c:\abc\vbn\tag.txt

# 或者用r表示一个声明，声明后面的字符串忽略掉转义符

>>>path = r"c:\abc\vbn\tag.txt"

>>>print(path)

c:\abc\vbn\tag.txt

>>> print('C:\some\name')  # here \n means newline!

C:\some

ame

>>> print(r'C:\some\name')  # note the r before the quote

C:\some\name

\a 响铃 \b退格 \ r回车 \’ \’’ \？？ \0空字符 \ooo八进制

\xhh十六进制

>>>world = "what\'s your name" #\声明后一位是字符串

>>>print(world)

what'syour name

>>>type(world)

<class'str'>

字符串可以由 + 操作符连接(粘到一起)，可以由 * 表示重复:

>>> # 3 times 'un', followed by 'ium'

>>> 3 * 'un' + 'ium'

'unununium'

相邻的两个字符串文本自动连接在一起。:

>>> 'Py''thon'

'Python'

它只用于两个字符串文本，不能用于字符串表达式:

>>> prefix = 'Py'

>>> prefix'thon'  # can't concatenate a variable and a string literal

...

SyntaxError: invalid syntax

>>> ('un' * 3)'ium'

...

SyntaxError: invalid syntax

如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 +:

>>> prefix + 'thon'

'Python'

这个功能在你想切分很长的字符串的时候特别有用:

>>> text = ('Put several strings within parentheses '

            'to have them joined together.')

>>> text

'Put several strings within parentheses to have them joined together.'

字符串也可以被截取(检索)。类似于 C ，字符串的第一个字符索引为 0 。Python没有单独的字符类型；一个字符就是一个简单的长度为1的字符串。:

>>> word = 'Python'

>>> word[0]  # character in position 0

'P'

>>> word[5]  # character in position 5

'n'

索引也可以是负数，这将导致从右边开始计算。例如:

>>> word[-1]  # last character

'n'

>>> word[-2]  # second-last character

'o'

>>> word[-6]

'P'

请注意 -0 实际上就是 0，所以它不会导致从右边开始计算。

除了索引，还支持切片。索引用于获得单个字符，切片让你获得一个子字符串:

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)

'Py'

>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)

'tho'

注意，包含起始的字符，不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s:

>>> word[:2] + word[2:]

'Python'

>>> word[:4] + word[4:]

'Python'

切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。:

>>> word[:2]  # character from the beginning to position 2 (excluded)

'Py'

>>> word[4:]  # characters from position 4 (included) to the end

'on'

>>> word[-2:]# characters from the second-last (included) to the end

'on'

有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个字符之间。左边第一个字符的索引为 0，而长度为 n 的字符串其最后一个字符的右界索引为 n。例如:

 +---+---+---+---+---+---+

 | P | y | t | h | o | n |

 +---+---+---+---+---+---+

0   1   2   3   4   5   6

-6  -5  -4  -3  -2  -1

文本中的第一行数字给出字符串中的索引点 0…6。第二行给出相应的负索引。切片是从 i 到 j 两个数值标示的边界之间的所有字符。

对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如，word[1:3] 是 2 。

试图使用太大的索引会导致错误:

>>> word[42]  # the word only has 6 characters

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

IndexError: string index out of range

Python 能够优雅地处理那些没有意义的切片索引：一个过大的索引值(即下标值大于字符串实际长度)将被字符串实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空字符串:

>>> word[4:42]

'on'

>>> word[42:]

''

Python字符串不可以被更改 — 它们是不可变的。因此，赋值给字符串索引的位置会导致错误:

>>> word[0] = 'J'

...

TypeError: 'str' object does not support item assignment

>>> word[2:] = 'py'

...

TypeError: 'str' object does not support item assignment

如果你需要一个不同的字符串，你应该创建一个新的:

>>> 'J' + word[1:]

'Jython'

>>> word[:2] + 'py'

'Pypy'

内置函数 len() 返回字符串长度:

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

文本序列str常用操作

1.str（obj） # str是全局函数，不是方法

>>>int("33") +5 # 强制转换

>>>"33" + str(55)

'3355'

>>>

2. str.replace(old,new[,cound])

>>>s = "a"*5

>>>s

'aaaaa'

>>>s.replace("a","b")

'bbbbb'

>>>s

'aaaaa' # 所以只是替换输出数值

>>>s = s.replace("a","b") # 可以变通重新赋值

>>>s

'bbbbb'

>>>s.replace("b","c",2) # 替换两个字符

'ccbbb'

>>>s # s本身还是不可变

'bbbbb'

>>>url = www.yjt361.com

>>>url.replace("com","cn")

'www.yjt361.cn'

3. str.capitalize() # 字符第一个字母大写

>>> url = "www.yjt361.com"

>>>url.capitalize()

'Www.yjt361.com'

4. str.upper() # 字符字母全部大写

>>>url.upper()

'WWW.YJT361.COM'

5. str.lower() # 字符字母全部小写

>>>url.lower()

'www.yjt361.com'

6. str.startswith(“str”) # 判断字符开头字符

>>>url.startswith("w")

True

>>>url.startswith("www.")

True

>>>url.startswith("wabc")

False

7.str.endswith(“str”) # 判断字符结束字符

>>>url.endswith("com")

True

>>>url.endswith("cn")

False

8. str.isnumeric() # 判断当前字符是不是数字

>>>"321".isnumeric()

True

9. str.isalpha() # 判断当前字符是不是字母

>>>"321".isalpha()

False

10. str.split() # 按谋元素进行字符拆分

>>>url = "www.yjt361.com"

>>> url.split(".")

['www', 'yjt361', 'com']

11. str.join() # 按谋元素进行字符连接起来

>>> url = 'www', 'yjt361', 'com'

>>> ":".join(url)

'www:yjt361:com'

12. str.format() # 用来格式化字符串

>>>name = "tom"

>>>age = 20

>>>job = "dev"

>>>print("姓名" +name + "年龄" + str(age) + "工作" +job)

姓名tom年龄20工作dev # 这样拼接比较麻烦

>>>"姓名：{0}，年龄：{1}，工作：{2}".format(name,age,job)

'姓名：tom，年龄：20，工作：dev' # 用format拼接简单

>>>"姓名：{0}，年龄：{1}，工作：{2},虚岁：{1}".format(name,age,job)

'姓名：tom，年龄：20，工作：dev,虚岁：20' # 可以多次使用元素

>>>"{0} = {1}".format("王学亚","23岁")

'王学亚 = 23岁'

>>>"{0:10} = {1:10}".format("王学亚","23岁")

'王学亚 = 23岁 # 10代表空10个字符给元素

>>>"{0:>10} = {1:<10}".format("王学亚","23岁")

' 王学亚 = 23岁 '# 指定对齐方式来呈现

>>>"{}，{}，{}".format(3.14159,3.14159,3.14159)

'3.14159，3.14159，3.14159'

>>>"{:f}，{:.2f}，{}".format(3.14159,3.14159,3.14159)

'3.141590，3.14，3.14159' # 可以指定呈现浮点以及保留的小数点

>>>"{}，{}，{:06.2f}".format(3.14159,3.14159,3.14159)

'3.14159，3.14159，003.14' # 指定保留浮点数两位，前面剩余用0补全，

"{:x}，{:o}，{:b}".format(230,230,230) # 显示不同进制结果

'e6，346，11100110'

# 以下是乘法口诀表

for x inrange(1,10):

for y in range(1,x+1):

print("{0} x {1} ={2}".format(x,y,x*y),end = " ")

print('\n')

13. s.center() #

name = ("王，冯")
print(name.center(50,"-")) # 一共打印50个字符串，不够用-补齐

----------------------王，冯----------------------

14. join()和os.path.join()

Python中有 join()和os.path.join()两个函数，具体作用如下：
join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
os.path.join()：将多个路径组合后返回
join()函数

语法： 'sep'.join(seq)

参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

#列表

name = ["Tom","Jerry","Peter"]
print("--->".join(name))

Tom--->Jerry--->Peter

#字符串

name = "你好我的世界"
print("|".join(name))

你|好|我|的|世|界

# 元组

name =("100","200","10","00")
print("--".join(name))

100- -200- -10--00

os.path.join()函数

语法： os.path.join(path1[,path2[,......]])

返回值：将多个路径组合后返回

注：第一个绝对路径之前的参数将被忽略

import os
print(os.path.join('/hello/','good/boy/','doiido'))

/hello/good/boy/doiido

15. strip()函数介绍

函数原型

声明：s为字符串，rm为要删除的字符序列

s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符

s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符

s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符

注意：

1. 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')

例如：

>>>a = ' 123'
>>> a.strip()
'123'
>>> a='\t\tabc'
'abc'
>>> a = 'sdff\r\n'
>>> a.strip()
'sdff'

2. 这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。

>>>a = '123abc'
>>> a.strip('21')
'3abc' 结果是一样的
>>> a.strip('12')
'3abc'

%s%d%f

%s 字符串

1. string="hello"

3. #%s打印时结果是hello

4. print "string=%s" % string # output: string=hello

6. #%2s意思是字符串长度为2，当原字符串的长度超过2时，按原长度打印，所以%2s的打印结果还是hello

7. print "string=%2s" % string # output: string=hello

9. #%7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串左侧补空格，

10. #所以%7s的打印结果是 hello

11. print "string=%7s" % string # output: string= hello

12.

13. #%-7s意思是字符串长度为7，当原字符串的长度小于7时，在原字符串右侧补空格，

14. #所以%-7s的打印结果是 hello

15. print "string=%-7s!" % string # output: string=hello !

16.

17. #%.2s意思是截取字符串的前2个字符，所以%.2s的打印结果是he

18. print "string=%.2s" % string # output: string=he

19.

20. #%.7s意思是截取字符串的前7个字符，当原字符串长度小于7时，即是字符串本身，

21. #所以%.7s的打印结果是hello

22. print "string=%.7s" % string # output: string=hello

23.

24. #%a.bs这种格式是上面两种格式的综合，首先根据小数点后面的数b截取字符串，

25. #当截取的字符串长度小于a时，还需要在其左侧补空格

26. print "string=%7.2s" % string # output: string= he

27. print "string=%2.7s" % string # output: string=hello

28. print "string=%10.7s" % string # output: string= hello

29.

30. #还可以用%*.*s来表示精度，两个*的值分别在后面小括号的前两位数值指定

31. print "string=%*.*s" % (7,2,string) # output: string= he

%d 整型

1. num=14

3. #%d打印时结果是14

4. print "num=%d" % num # output: num=14

6. #%1d意思是打印结果为1位整数，当整数的位数超过1位时，按整数原值打印，所以%1d的打印结果还是14

7. print "num=%1d" % num # output: num=14

9. #%3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数左侧补空格，所以%3d的打印结果是 14

10. print "num=%3d" % num # output: num= 14

11.

12. #%-3d意思是打印结果为3位整数，当整数的位数不够3位时，在整数右侧补空格，所以%3d的打印结果是14_

13. print "num=%-3d" % num # output: num=14_

14.

15. #%05d意思是打印结果为5位整数，当整数的位数不够5位时，在整数左侧补0，所以%05d的打印结果是00014

16. print "num=%05d" % num # output: num=00014

17.

18. #%.3d小数点后面的3意思是打印结果为3位整数，

19. #当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果是014

20. print "num=%.3d" % num # output: num=014

21.

22. #%.0003d小数点后面的0003和3一样，都表示3，意思是打印结果为3位整数，

23. #当整数的位数不够3位时，在整数左侧补0，所以%.3d的打印结果还是014

24. print "num=%.0003d" % num # output: num=014

25.

26. #%5.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，再在左侧补空格，

27. #规则就是补0优先，最终的长度选数值较大的那个，所以%5.3d的打印结果还是 014

28. print "num=%5.3d" % num # output: num= 014

29.

30. #%05.3d是两种补齐方式的综合，当整数的位数不够3时，先在左侧补0，还是不够5位时，

31. #由于是05，再在左侧补0，最终的长度选数值较大的那个，所以%05.3d的打印结果还是00014

32. print "num=%05.3d" % num # output: num=00014

33.

34. #还可以用%*.*d来表示精度，两个*的值分别在后面小括号的前两位数值指定

35. #如下，不过这种方式04就失去补0的功能，只能补空格，只有小数点后面的3才能补0

36. print "num=%*.*d" % (04,3,num) # output: num= 014

%f 浮点型

1. import math

3. #%a.bf，a表示浮点数的打印长度，b表示浮点数小数点后面的精度

5. #只是%f时表示原值，默认是小数点后5位数

6. print "PI=%f" % math.pi # output: PI=3.141593

8. #只是%9f时，表示打印长度9位数，小数点也占一位，不够左侧补空格

9. print "PI=%9f" % math.pi # output: PI=_3.141593

10.

11. #只有.没有后面的数字时，表示去掉小数输出整数，03表示不够3位数左侧补0

12. print "PI=%03.f" % math.pi # output: PI=003

13.

14. #%6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格

15. print "PI=%6.3f" % math.pi # output: PI=_3.142

16.

17. #%-6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够右侧补空格

18. print "PI=%-6.3f" % math.pi # output: PI=3.142_

19.

20. #还可以用%*.*f来表示精度，两个*的值分别在后面小括号的前两位数值指定

21. #如下，不过这种方式06就失去补0的功能，只能补空格

22. print "PI=%*.*f" % (06,3,math.pi) # output: PI=_3.142

% 是把后面的值赋给前面

name = ("王，冯")
print("myname is %s"% (name))

my name is 王，冯

% 2 可以用来判断 n 是否被 2 整除，检测奇，偶数

#!/usr/bin/python3

numbers =[11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:

if num%2==0:

print('the listcontains an even number')

break

else:

print('the listdoesnot contain even number')

Python

当执行上述代码时，会产生以下结果 -

the list does not contain even number

可变list列表和不可变tuple元组的通用操作

>>>x = ("我爱学")

>>>x

'我爱学'

>>>x = list("我爱学")

>>>x

['我', '爱', '学']

>>>list(range(5)) # range和list是一个函数

[0, 1, 2,3, 4]

(1) 判断元素是否在序列之内

1. xin s

>>> name =["tom","jerry","mike","peter","john"]

>>> scores = [44,55,78.7,60.7,77]

>>>"mike" in name # 注意是要区分大小写

True

>>>"Mike" in name

False

>>>60.7 in scores

True

>>>102 in scores

False

2. xnot in s

>>>60.7 not in scores

False

>>>102 not in scores

True

(2) 连接序列

1. S1+ s2

>>> name =["tom","jerry","mike","peter","john"]

>>> scores = [44,55,78.7,60.7,77]

>>> name + scores

['tom', 'jerry', 'mike', 'peter', 'john',44, 55, 78.7, 60.7, 77]

>>> name

['tom', 'jerry', 'mike', 'peter', 'john'] #name本身并没有改变

（3）重复序列元素

1. S* n # s 表示序列 n表示重复的次数 *表示的乘号

>>> [3] * 4

[3, 3, 3, 3]

（4）下标获取元素

1.s[i]

>>> name =["tom","jerry","mike","peter","john"]

>>> scores =[44,55,78.7,60.7,77]

>>> name[2]

'mike'

>>> scores[3]

60.7

>>> name[-2]

'peter'

(5) 访问指定索引范围

1. s[i:j]

>>>name =["tom","jerry","mike","peter","john"]

>>>name[0:3]

['tom','jerry', 'mike']

(6) 按步长访问指定索引范围

1. s[i:j:k]

(7) 获取序列长度

1. len(S) # S 指序列 len 表示返回长度

>>>name =["tom","jerry","mike","peter","john"]

>>>len(name)

（8）获取最小值 # 内容为课比较

1. min(s)

>>> scores = [44,55,78.7,60.7,77]

>>> min(scores)

（9）获取最大值 # 内容为课比较

1. Max(s)

>>> max(scores)

78.7

（10）统计总和

1.Sum（s）

>>> sum(scores) # 统计列表元素总和

315.4

(11)检索某个元素第一次出现位置下标 # s.index(x) 是方法不是函数

1. s.index(x) s 是我们检索的序列 x是我们检索元素的值

>>>name=["tom","jerry","mike","peter","john"]

>>>name.index("mike")

name = ["tom","jerry","mike","peter","john"]
print(name[name.index("mike")])  # 打印元素，注意添加列表括号

>>>scores = [44,55,78.7,60.7,77]

>>>scores.index(60.7)

（12）统计元素出现的次数 # s.count(x) 是方法不是函数

1.s.count(x) s是统计的序列 x是统计次数的元素

>>> name =["tom","jerry","mike","peter","john"]

>>> name.count("tom")

>>> name.count("mike")

>>> name.count("ask")