python程序设计案例教程-笔记【2】

10.字符串切片与连接

字符串是由一个或多个单字符组成的一串字符，在python中定义字符串用“ '' ”或“ "" ”，访问字符串需要给其分配一个变量。字符串在被打印出来的时候，不显示引号。

在python中，可以对字符串进行遍历操作，以及使用切片来截取片段。基本形式如下：

string[start:end:step]

string是字符串的所存在的变量名，中括号中的各个值以英文半角冒号分隔，第一个值是指开始值，第二个值是结尾值，第三个是步长，有点类似之前random模块中randrange。步长的默认值是1。需要注意的一点是，遍历操作时，第一个位置的索引是0，即从0开始查，字符串有n个字符时，最后一位的索引就是n-1。

当start的值为负数时，遍历会从最后一个开始，因为-0还是0，如果反着开始的第一位的索引也是0，则无法区分是从哪里开始了，所以反着开始的第一位的索引是-1。

当step的值为负数时，遍历会反着进行，比如你可以从中间开始，分别朝着两个方向开始遍历。

start和end不填时，默认为两端，当其中一个有值时，另一个不填的为另一个的对侧，例如start为-1时，end不填即为字符串的第一位。

例如：

var = 'https://blog.csdn.net/2302_78610972?spm=1000.2115.3001.5343'

print(var[::-1])

此操作为反转字符串，

3435.1003.5112.0001=mps?27901687_2032/ten.ndsc.golb//:sptth

字符串的拼接

最常用的拼接方式是用加号 + 

书上的例子是：

import datetime

message = "今天是："
ToDay = datetime.datetime.today().date()
message1 = "，星期"
weekDay = datetime.datetime.now().weekday()
# 使用”+“符号将字符串拼接，输出”今天是：xxxx-xx-xx，星期x“
print(message +str(ToDay) + message1 + 
      str(weekDay))

运行结果：

今天是：2023-09-20，星期2

还可以通过在print()函数中分为多行来拼接：

varStr = ("python"
          "字符串"
          "拼接")
print(varStr)

结果：

python字符串拼接

但是这种只能用于字符串的直接拼接，不能用变量名拼接，如：

a = "字符串"

varStr = ("python"
          a
          "拼接")
print(varStr)

结果就会报错：

11.字符串的replace()方法

不知道大家有没有注意到方法和函数的区别，方法是一种特殊的函数，深入的要到后面讲class的时候做对比，（我靠我翻了翻这本书好像没讲class），最直观的区别就是调用方法不同，函数是在括号里面进行操作，比如最简单的print()函数，而方法是用“点”调取的。

replace vt.更换;(用…)替换;取代;代替;更新;(以…)接替;把…放回原处。
replace()方法用于将某一字符串中一部分字符替换为指定的新字符，如果不指定新字符那么原字符将被删除(替换为没有)。

语法格式：

str.replace(old[,new[,count]])

old是要被替换的字符串，new是替换old的字符串。count，可选参数，表示要替换的次数，如果不指定该参数，则会替换所有匹配字符，而指定替换次数时的替换是从左向右依次进行的。

书中的几个例子：

str1 = '333333201501012222'
s1 = str1[6:14]
print(str1.replace(s1, '********'))

结果：

333333********2222

删除任意位置的相同字符，书上删除了全部的\t，这里可以只删除部分：

s = "\tmrsoft\t888\tbook"
print(s.replace('\t', '', 2))

结果：（从左往右依次替换，执行两次，所以第三个\t仍然起作用）

mrsoft888	book

replace()方法可以多次连续使用：

temp = '天生/ 我_材/必*有用'
print(temp.replace(' ', '').replace('*', '').replace('_', '').replace('/', ''))

如果要删除两侧的符号，可以用strip方法，当其参数为空时，默认可删除空格、制表符\t、回车符\r、换行符\n。也可以自行设置替换掉的符号。两侧无论有几个该字符都会被删除：

sss = "             hello world "

print(sss.strip())

结果：

hello world

也可以只去掉左边L或右边R的，在strip前加上左右的标识即可。

12.字符串检索与查询

1.count()方法

可用于查询一个子字符串在其本身字符串对象中出现的次数，格式如下：

str.count(sub[, beg[, end]])

sub表示要检索的子字符串，beg和end都是可选参数，分别表示检索范围的起始位置索引值和结束位置索引值。不指定这两个参数则作用对象是全部。

该方法区分大小写。

2.find()方法

find()方法用于查询一个子字符串在其父字符串中首次出现的索引位置。若无结果则返回-1。

语法格式与count相同，仅需将count换成find。

3.index()方法

功能与find()方法相同，但是在没有检索到结果的时候，会抛出ValueError异常。

两种方法的检索方向都是从左往右，若想从右往左，需要在方法名前加字母“r”。

4.len()函数

len()函数用于计算字符串的长度或列表元组的元素个数。

语法格式，直接作用于对象：

len(s)

13.字符串的split()方法

split()方法用于分隔字符串，分隔之后会得到一个列表，列表元素的类型为字符串。

str.split(sep, maxsplit)

sep表示按什么分隔，分隔后该字符会被去掉，maxsplit表示分隔的次数，如果不指定将分隔所有匹配字符。

s1 = 'a,b,c'                # 定义字符串
s2 = 'a b c d'              # 定义字符串
s1Split = s1.split(',')     # 按逗号分隔
s2Split1 = s2.split()       # 按默认值分隔。默认为None，包括空格、换行符和制表符等等
s2Split2 = s2.split(' ',2)  # 按空格分隔，同时只分隔两次，也就是前两个空格
print(s2Split2)             # 只打印出来最后一个作为演示

显示结果：

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

本节原书中涉及列表的部分放到后面列表的操作时再提。

14.字符串大小写转换

书中讲了四种转换大小写的方法。

str.upper()
str.lower()
str.capitalize()
str.title()

第一个方法将全部的字符串中的英文字母变为大写，第二个则变为小写。第三个方法则不论之前的字符串的大小写情况，字符串中只有第一个单词的第一个字母为大写，其他的都为小写，这是文章段落的写法。第四个是将全文的单词都变为首字母大写，文章的标题大致就是这样做的。

15.16.17.18.列表

这里集中到一起说一下列表。列表是python中的一种数据结构，内有若干互不相关的元素，元素的类型不受限制，可以是整数浮点数字符串甚至也可以是另一个列表，这个另一个列表之中可以包含着有另一个列表的还包含着下一个列表的又双叒叕包含着下下个......

list6 = [6, [6, [6, [6, [6, [6, [...]]]]]]]

    [禁止套娃]

 列表用英文半角中括号包裹，元素之间以英文逗号隔开，PEP8的习惯是第二个元素开始，和上一个逗号之间加一个空格，空格不会算在元素之内，但是会使列表看上去更美观。

访问列表元素

访问元素就是使用某这个列表中的一个元素，只要知道这个元素的索引就可以访问：

list6 = [6, [6, [6, [6, [6, [6, [...]]]]]]]
print(list6[1])

这个列表中就两个元素，前面说过，第一个元素的索引是0，我们现在把第二个元素打印出来：

[6, [6, [6, [6, [6, [Ellipsis]]]]]]

还可以在访问之后打印出列表的索引。

oi = ['1', '2', '3', '4']
for index, team in enumerate(oi):
    print(index, team,)

结果：（enumerate()函数可以同时输出索引值和元素内容）

0 1
1 2
2 3
3 4

修改列表元素

下面可以对列表内的东西做出改变了！

替换元素

在知到元素的索引之后，可以直接用赋值语句进行替换，

list6 = [6, [6, [6, [6, [6, [6, [...]]]]]]]
print(list6)
list6[1] = [7, [7, [7, [7, [7, [...]]]]]]
print(list6)

结果：

[6, [6, [6, [6, [6, [6, [Ellipsis]]]]]]]
[6, [7, [7, [7, [7, [7, [Ellipsis]]]]]]]

添加元素

用append()方法将元素添加到列表的末尾：（列表可以没有元素，即空列表）

list0 = []
list0.append(1)
list0.append(2)
list0.append(3)
print(list0)

结果：

[1, 2, 3]

用insert()方法插入元素，可以将新元素指定到确定的索引位置，原索引位置的元素及后续元素的索引都加一。

list0 = [1, 2, 3, 6, 9]
list0.insert(3, 666)
print(list0)

结果：

[1, 2, 3, 666, 6, 9]

删除元素

分两种情况，知道索引值或知道元素的值。

1.知道索引值

可用 del 语句：

list6 = [6, [6, [6, [6, [6, [6, [...]]]]]]]
del list6[1]
print(list6)

运行之后就剩下一个元素...6

2.知道元素值，但是不知道索引位置

可用remove()方法，但是同一个值出现多次只会删除出现的第一个：

listy = [1, 2, 3, 3, 3, 4]
listy.remove(3)
listy.remove(3)
print(listy)

结果会剩余一个3：

[1, 2, 3, 4]

3.弹出已知索引值的元素

pop，这个单词有一个意思就是弹出，很形象，或者说是取出来一个元素使用，既然取出来了，这个元素就不属于原列表了，但是仍然可以使用这个值。

在pop()方法中，如果不添加索引，则默认弹出列表的最后一个元素。如果列表中没有元素，则会报错。

pop1 = [1, 2, 3, 4]
lp = pop1.pop(2)
print(lp)

弹出的3会被关联到变量 lp 中。

使用列表对象的remove()方法和pop()方法时，若元素不存在或者为空列表，会报错，最好提前检查一下是否存在，remove()方法使用前可以使用一个count()方法判断列表中是否存在该元素，pop()方法使用前可以先用len()函数算出列表的元素个数。

这一节后面的习题中出现了一个join()方法，我也不知道为什么这个书的后面总是喜欢讲一些奇奇怪怪的前面还没讲的东西，然后也不讲就直接用，比如for，if；else，这些。这里简单提一下join()方法。

join()方法用于将列表中的元素提出来拼成字符串，并且可以设置拼接之间的符号，但是前提是列表中的元素的Type必须是str。语法格式如下：

symbol = value
symbol.join(list)

示例如下：

listnb = ['mayun', 'mahuateng', 'masike']
sym = '牛逼'
listn = sym.join(listnb)
print(listn)

结果：

mayun牛逼mahuateng牛逼masike

排序列表元素

永久性排列

用sort()方法进行永久性排序，此操作改变列表顺序后不能再改回去。排序按字母表的顺序，且默认区分大小写。语法格式入下：

listname.sort(key=xxx, reverse=False)

其中key决定是否区分大小写，默认区分，先大写后小写，若设置为“key=str.upper”或“key=str.lower”则不区分大小写。reverse表示是否倒序，默认否，改为True则为按字母表顺序倒序排序。示例如下：

life = ['Python', 'Java', 'c','c++', 'Go']

life.sort(key=str.upper, reverse=True)
print(life)

结果：

['Python', 'Java', 'Go', 'c++', 'c']

临时排序/创建副本后排序

其实就是sort变成“过去式”，方法sorted()可以创建原列表的副本之后再排序。

排序之后需要给这个新的列表关联一个变量，除此之外其他的和sort()方法相同

倒着打印列表

前面已经提到了一个单词reverse，意思就是反向，所以reverse()方法可以对列表进行反向操作，将所有的元素反着排一遍。

使用列表元素

三个数学函数：sum()、min()、max()。

分别可以对列表或元组的元素求和，取最小值，取最大值。

至于书上说的那个可迭代对象（Iterable），太抽象了，，，暂时不理解我觉得也可以，反正书上也没解释。。。下面的看不看都行↴

An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an iter() method or with a getitem() method that implements Sequence semantics.

能够一次返回一个成员的对象。可迭代对象的示例包括所有序列类型（如列表、str 和元组）和一些非序列类型，如字典、文件对象以及使用 iter（） 方法或实现序列语义的 getitem（） 方法定义的任何类的对象。

Iterables can be used in a for loop and in many other places where a sequence is needed (zip(), map(), …). When an iterable object is passed as an argument to the built-in function iter(), it returns an iterator for the object. This iterator is good for one pass over the set of values. When using iterables, it is usually not necessary to call iter() or deal with iterator objects yourself. The for statement does that automatically for you, creating a temporary unnamed variable to hold the iterator for the duration of the loop. See also iterator, sequence, and generator.

可迭代对象可以在 for 循环和许多其他需要序列的地方使用（zip（）、map（）、...）。当可迭代对象作为参数传递给内置函数 iter（） 时，它会返回该对象的迭代器。此迭代器适用于对值集的一次传递。使用可迭代对象时，通常不需要调用 iter（） 或自己处理迭代器对象。for 语句会自动为您执行此操作，创建一个临时的未命名变量以在循环期间保存迭代器。另请参阅迭代器、序列和生成器。

以上来自官方文档和bing翻译。

对列表整体操作

切片

方法和字符串的切片一样，也可以设置开始结束和步数，类似的后面还会遇见。

life = ['Python', 'Java', 'c','c++', 'Go']
new_life = life[::2]
print(new_life)

['Python', 'Go', 'c']

复制列表

如果你尝试把一个列表的变量名赋值给一个新的名字，你会发现最后这俩变量名最后都指向了刚刚那个列表，如果你改动了列表的元素，无论你用哪个变量名访问，都是那个列表，所以肯定不能这样复制，那怎么复制呢？已经讲过了，请往上看⇑

life = ['Python', 'Java', 'c','c++', 'Go']
duplicate_life = life[:]
del life[3]
del duplicate_life[2]
print(life)
print(duplicate_life)

打印出来两个列表：（可以看出是两个不同的列表）

['Python', 'Java', 'c', 'Go']
['Python', 'Java', 'c++', 'Go']

合并列表

将两个列表合并成一个大列表,可以用extend()方法：

life_one = ['c','c++', 'Go']
life_two = ['Python', 'Java']
life_one.extend(life_two)
print(life_one)

输出：

['c', 'c++', 'Go', 'Python', 'Java']

按要求生成列表

range()函数

用range()函数可以生成一串指定范围的整数型的列表。前面有类似的结构，第一个值是开始，第二个是结束，第三个是步长。

range(start,end,step)

列表推导式

基本构成：

 此式子是将一个for循环套入了列表之中，甚至还可以后接一个 if 判断，以及，，，中间那个for其实也可以套娃。

式子含义，首先 if 进行判断，没学没关系，只需要知道满足后面的限定条件，就可以从前面的range这个范围里面提取出来一个东西，这个range是指一个范围，可以是range()函数，可以是一个列表，元组等等。提取出来的元素会分配到变量 i 中，i 将作为list列表的新元素。

书上的例子：

import random
random_number = [random.randint(10,100) for i in range(10)]
print(random_number)

输出：

[23, 52, 92, 61, 15, 91, 28, 40, 51, 59]

for...in...在此处是可以嵌套的，这里举个栗子：

z = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
z_1 = [x for y in z for x in y]
print(z_1)

这个for的嵌套的运行是从左到右的，先进行左边的再右边，所以先从z中提取y，y此时仍然是一个列表，所以再从y中提取x作为x，x为z_1列表的元素，就将前面的双层列表的元素都提取到一层了，所以...

v = [[[11, 12], [13, 14]],[[21, 22], [23, 24]]]
v_0 = [z for x in v for y in x for z in y]
print(v_0)

当然也可以套好几层来循环啦，结果：

[11, 12, 13, 14, 21, 22, 23, 24]

至于那个 if 没什么好说的，和后面的if语句还是有很大差距的，这里比较简单。

19.decode()方法

个人学识浅薄，实在不知这一节放在这里是干什么，两个方法，encode，编码，decode，解码，方法格式如下：

str.encode([encoding[,errors]])

参数encoding表示要进行编码的格式，默认为UTF-8，errors用了指定错误的处理方式，默认的strict是报错；ignore是忽视，当作没看见；replace是替换成 ?；xmlcharrefreplace，使用XML的字符引用等。

decode就是反过来，参数的设置一样。

本章的最最后，还提到了一个zip函数，简单说说，zip压缩包都用过吧，这个就是把几个列表竖着压缩，打包成一个元组，然后把这一个一个元组包放到一个新的列表里面，当列表的长度不一样时，以最短的列表为基础。

list_1 = [11, 12, 13, 14]
list_2 = [21, 22, 23, 24]
list_3 = [31, 32, 33, 34, 35, 36, 37]
zip_list = zip(list_1, list_2)
print(zip_list)
print(list(zip_list))
zip_list_three = zip(list_1, list_2, list_3)
print(list(zip_list_three))

但是压缩完的zip_list并不是一个列表，只是一个位置，需要用list()函数转换为列表才可用。

<zip object at 0x0000026B5E97C200>
[(11, 21), (12, 22), (13, 23), (14, 24)]
[(11, 21, 31), (12, 22, 32), (13, 23, 33), (14, 24, 34)]

压缩后的元组还可以拆分回去，但是拆出来的列表的长度都相同。在zip函数的内部加 * 就可以解压缩：

# 接上面代码：
zip0 = zip(list_1, list_2, list_3)
zip_star = zip(*zip0)
for x in zip_star:
    print(list(x))

解压结果：

[11, 12, 13, 14]
[21, 22, 23, 24]
[31, 32, 33, 34]

小声逼逼：感觉这本书这里写的有点乱。。。