[C++知识库]Python编程：从C语言到实践（适合有C语言基础的同学使用）

字符串
使用方法修改字符串的大小写

name = "Ada Lovelace" 
print(name.title())
print(name.upper()) 
print(name.lower())

定义一个字符串变量，有三个内置函数功能分别为

1. 每个单词的首字母大写
2. 全为大写
3. 全为小写

Ada Lovelace
ADA LOVELACE 
ada lovelace

合并（拼接）字符串
python用+来拼接字符串

first_name = "ada" 
last_name = "lovelace" 
full_name = first_name + " " + last_name 
print(full_name)

其结果如下：

ada lovelace

使用制表符或换行符来添加空白
制表符：\t，相当于TAB，可以添加空白
换行符：\n，另起一行，和c语言一致

>>> print("Python") 
Python
>>> print("\tPython") 
	Python

>>> print("Languages:\nPython\nC\nJavaScript")
Languages: 
Python 
C 
JavaScript

>>> print("Languages:\n\tPython\n\tC\n\tJavaScript") 
Languages: 
	Python 
	C 
	JavaScript

删除空白
一般删除的是字符串中的空白，有三个函数

1. rstrip()：剔除字符串末尾空白
2. lstrip()：剔除字符串开头的空白
3. strip()：同时剔除字符串两端的空白

>>> favorite_language = ' python '
>>> favorite_language.rstrip()
' python' 
 >>> favorite_language.lstrip()
'python ' 
 >>> favorite_language.strip() 
'python'

使用函数 str()避免类型错误
例如，假设你要祝人生日快乐，可能会编写类似于下面的代码：

age = '23' 
message = "Happy " + age + "rd Birthday!"
print(message)

但如果你运行这些代码，将发现它们会引发错误
因为23是int型变量，并不是字符串，为此，可调用函数str()，它让Python将非字符串值表示为字符串：

age = 23 
message = "Happy " + str(age) + "rd Birthday!" 
print(message)

#结果为Happy 23rd Birthday!在python中#为注释符

列表
列表当中可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表。
例如：一个自行车列表

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles)

结果

['trek', 'cannondale', 'redline', 'specialized']

访问列表元素
方式：采用下标的方式，索引还是从0开始，特殊的一点是当索引为-1的时候代表列表倒数第一个元素，-2代表倒数第二个，以此类推

bicycles = ['trek', 'cannondale', 'redline', 'specialized'] 
print(bicycles[1]) 
print(bicycles[3])

cannondale 
specialized

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])

specialized

修改、添加和删除元素
修改列表元素
方式：将新的元素值赋值给列表中的元素（元素用下标表示）

 motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
 motorcycles[0] = 'ducati' 
print(motorcycles)

['honda', 'yamaha', 'suzuki'] 
['ducati', 'yamaha', 'suzuki']

在列表中添加元素
有两种添加元素的方法：

1. 在列表末尾添加元素，要用到一个函数append()
2. 在列表中插入元素，insert(a，b)，a表示所插入的位置，b表示要插入的元素值

例一:

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
motorcycles.append('ducati') 
print(motorcycles) 

['honda', 'yamaha', 'suzuki'] 
['honda', 'yamaha', 'suzuki', 'ducati']

例二：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
motorcycles.insert(0, 'ducati') 
print(motorcycles) 

['ducati', 'honda', 'yamaha', 'suzuki']

从列表中删除元素
有三种删除方法：

1. 使用del语句删除元素，需要知道元素的位置(下标)，使用次语句后，被删除的元素就再也无法访问了。
2. 使用方法pop()删除元素，不指出pop的下标，便是删除末尾的元素；指出要pop的元素的下标，那表示删除此下标元素
3. 根据值删除元素，要用到方法remove()，括号内是要删除的元素，元素要用引号引起来。

例一：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
del motorcycles[0] 
print(motorcycles) 

['honda', 'yamaha', 'suzuki'] 
['yamaha', 'suzuki']

例二：

motorcycles = ['honda', 'yamaha', 'suzuki'] 
print(motorcycles) 
popped_motorcycle = motorcycles.pop() 
print(motorcycles) 
print(popped_motorcycle)

['honda', 'yamaha', 'suzuki'] 
['honda', 'yamaha'] 
suzuki

motorcycles = ['honda', 'yamaha', 'suzuki'] 
first_owned = motorcycles.pop(0) 
print('The first motorcycle I owned was a ' + first_owned.title() + '.') 

The first motorcycle I owned was a Honda.

例三：

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati'] 
print(motorcycles) 
motorcycles.remove('ducati') 
print(motorcycles) 
 
['honda', 'yamaha', 'suzuki', 'ducati'] 
['honda', 'yamaha', 'suzuki']

因为我们知道要删除的值是什么，所以可以预先将其存放在一个变量当中，这样就算我们删除了列表中的值，我们变量中还备份了。
注意：方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。
组织列表
通俗来讲，组织列表的意思是对列表中的元素进行整理组织
那么字符元素怎么整理呢？
就要用到字母排序了
我们通过介绍四个函数来掌握这节内容：

• sort（）：对列表进行永久性的字母顺序排序，也可以使用sort(reverse=True)来按照字母顺序相反的顺序排列
• sorted（）：对列表元素进行临时排序，同时不影响它们在列表中的原始排列顺序
• reverse（）：反转列表元素的排列顺序；注意，reverse()不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序
• len（）：确定列表的长度

例一：

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
cars.sort()
print(cars) 

['audi', 'bmw', 'subaru', 'toyota']

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
cars.sort(reverse=True) 
print(cars) 

['toyota', 'subaru', 'bmw', 'audi']

例二：

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
print("Here is the original list:") 
print(cars) 
print("\nHere is the sorted list:") 
print(sorted(cars)) 
print("\nHere is the original list again:") 
print(cars) 

Here is the original list: 
['bmw', 'audi', 'toyota', 'subaru'] 
Here is the sorted list: 
['audi', 'bmw', 'subaru', 'toyota'] 
? Here is the original list again: 
['bmw', 'audi', 'toyota', 'subaru']

例三：

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
print(cars) 
cars.reverse() 
print(cars) 

['bmw', 'audi', 'toyota', 'subaru'] 
['subaru', 'toyota', 'audi', 'bmw']

例四：

>>> cars = ['bmw', 'audi', 'toyota', 'subaru']
>>> len(cars)
4

操作列表
遍历整个列表
在Python中我们遍历整个列表用的还是for循环，跟c语言中是一致的，不过就是for语句的形式不一样，先感受一下这俩例子：
例一：

magicians = ['alice', 'david', 'carolina'] 
for magician in magicians: 
	print(magician)

alice 
david 
carolina

例二：

magicians = ['alice', 'david', 'carolina'] 
for magician in magicians:
print(magician.title() + ", that was a great trick!") 

Alice, that was a great trick! 
David, that was a great trick! 
Carolina, that was a great trick!

看例一，关键字for后面紧跟着的是一个变量magician，用来存放列表magicians中的第一个元素，冒号后面是要进行的操作，完成之后再取列表的第二个元素。我们仔细一点可以发现for语句和下方的print语句并不是对齐的，而是有缩进的，原来在Python中要用缩进来表示语句与语句之间的从属或者并列关系。例如：

magicians = ['alice', 'david', 'carolina']
for magician in magicians:
	print(magician.title() + ", that was a great trick!")
	print("I can't wait to see your next trick, " + magician.title() + ".\n") 

Alice, that was a great trick! 
I can't wait to see your next trick, Alice. 

David, that was a great trick! 
I can't wait to see your next trick, David.

Carolina, that was a great trick! 
I can't wait to see your next trick, Carolina.

上面这个例子中两个print语句均缩进了，所以他们都需要在循环中执行

magicians = ['alice', 'david', 'carolina'] 
for magician in magicians: 
	print(magician.title() + ", that was a great trick!") 
print("I can't wait to see your next trick, " + magician.title() + ".\n")

Alice, that was a great trick! 
David, that was a great trick! 
Carolina, that was a great trick! 
I can't wait to see your next trick, Carolina.

而在这个例子中，第二个print语句并没有缩进，也就是不在循环操作中

切片是对什么的切片？
是对列表的，其方法是：列表名[a:b],其中a代表开始元素的索引，b代表的是结束元素的索引，切片当中不包含下标为b的元素跟range函数的性质一样

切片技巧：

• 如果你要提取列表的第n~m个元素，可将起始索引指定为n-1，并将终止索引指定为m，可使用列表名[n-1:m]。
• 如果你要提取列表的前n个元素，可使用列表名[:n]
• 如果你要输出列表中的最后n名元素，可使用切片列表名[-n:]

元组用圆括号来标识，列表用方括号来标识
元组的元素不可更改，列表的元素可多可少可更改
修改元组的元素只能重新定义元组

单从作用来说：

• 元组和c语言的数组是相近的，但是有点区别，元组是只要定义了，整个元组的值和长度都不可更改，但是数组的值是可以改变的
• 列表 和c++中的向量vector是相近的

现在回忆一下自己学过的知识：

1. 如何高效地处理列表中的元素？
2. 如何使用for循环遍历列表？
3. Python如何根据缩进来确定程序的结构以及如何避免一些常见的缩进错误？
4. 如何创建简单的数字列表？以及可对数字列表执行的一些操作？
5. 如何通过切片来使用列表的一部分和复制列表
6. 你还学习了元组（它对不应变化的值提供了一定程度的保护），以及在代码变得越来越复杂时如何设置格式

复制列表
复制列表有两种：

1. 将一个列表赋值给另一个列表，此时这两个列表指向的是同一份数据，对其中的一个列表操作就是对这份数据的操作
2. 利用对列表的切片操作[:]，实现对副本列表和原生列表的各自操作

例一：

my_foods = ['pizza', 'falafel', 'carrot cake'] 
? friend_foods = my_foods[:] 
print("My favorite foods are:") 
print(my_foods) 
print("\nMy friend's favorite foods are:") 
print(friend_foods) 

My favorite foods are: 
['pizza', 'falafel', 'carrot cake'] 
My friend's favorite foods are: 
['pizza', 'falafel', 'carrot cake']

例二：

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
my_foods.append('cannoli') 
friend_foods.append('ice cream') 
print("My favorite foods are:")
print(my_foods) 
print("\nMy friend's favorite foods are:")
print(friend_foods)

My favorite foods are: 
['pizza', 'falafel', 'carrot cake', 'cannoli'] 
My friend's favorite foods are: 
['pizza', 'falafel', 'carrot cake', 'ice cream']

元组
元组创建一系列不可修改的元素，用圆括号标注
定义元组

元组名 = （a,b,c）     #其中a,b,c为元素

定义好元组，使用元组的元素时也是用索引跟列表一样
例一：

dimensions = (200, 50) 
print(dimensions[0]) 
print(dimensions[1]) 

200 
50

元组不允许单独修改其中的某个元素的值

遍历元组中的所有值
同列表的for循环
例一：

dimensions = (200, 50) 
for dimension in dimensions: 
	print(dimension) 

200 
50

修改元组变量
因为不能单独地修改某个元素的值，所以只能对元组进行重新定义，可以不修改元组名，将所要替换的元组内容直接赋值给元组名：

dimensions = (200, 50)
print("Original dimensions:") 
for dimension in dimensions: 
	print(dimension) 
dimensions = (400, 100) 
print("\nModified dimensions:") 
for dimension in dimensions: 
	print(dimension) 

Original dimensions: 
200 
50 
Modified dimensions: 
400 
100

元组和列表的区别
元组：不可单独修改
列表：随意动态修改

if语句