1.文本类型:字符串(str)

字符串 就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号，如下所示：

"this is  a string"
'this is a string'
'I told my friend, "Python is my favorite language!"'
"The language 'Python' is named after Monty Python, not the snake."
"One of Python's strengths is its diverse and supportive community."

1.1修改字符串的字母大小写

对于字符串，可执行的最简单的操作之一是修改其中的单词的大小写。请看下面的代码，并尝试判断其作用：

name='my name is python!'
print(name.title())

在这个示例中，小写的字符串"my name is python!" 存储到了变量name 中。在print() 语句中，方法title() 出现在这个变量的后面。方法 是Python可对数据执行的操作。在name.title() 中，name 后面的句点（. ）让Python对变量name 执行方法title() 指定的操作。每个方法后面都跟着一对括号，这是因为方法通常需要额外的信息来完成
其工作。这种信息是在括号内提供的。函数title() 不需要额外的信息，因此它后面的括号是空的。
title() 以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。这很有用，因为你经常需要将名字视为信息。例如，你可能希望程序将值 My name is python!、my name is python! 和 MY NAME IS PYTHON!视为同一个名字，并将它们都显示为My name is python! 。
还有其他几个很有用的大小写处理方法。例如，要将字符串改为全部大写或全部小写，可以像下面这样做：

name='my name is python!'
print(name.upper()) // 全部转成大写
print(name.lower()) //全部转成小写

1.2 合并(拼接)字符串

在很多情况下，都需要合并字符串。例如，你可能想将姓和名存储在不同的变量中，等要显示姓名时再将它们合而为一：

first_name='wang'
last_name='xianjin'
full_name=fitst_name=last_name
print(full_name)

Python使用加号（+ ）来合并字符串。在这个示例中，我们使用+ 来合并first_name 、空格和last_name ，以得到完整的姓名,这种合并字符串的方法称为拼接 。通过拼接，可使用存储在变量中的信息来创建完整的消息。下面来看一个例子

first_name='wang'
last_name='xianjin'
full_name=fitst_name=last_name
print(Hello,+full_name.title()+"!")

1.3去除空格

    name=' pyhton '
    name=name.rstrip()//去除结尾处的空格
    name=name.lstrip()  //去除开头处的空格
    name=name.strip()  //去除首尾两头的空格

2.数值类型

在编程中，经常使用数字来记录游戏得分、表示可视化数据、存储Web应用信息等。Python根据数字的用法以不同的方式处理它们。鉴于整数使用起来最简单，下面就先来看看Python是如何管理它们的。

2.1 整数(int)

在Python中，可对整数执行加（+ ）减（- ）乘（ ）除（/ ）运算.

>>> 2 + 3
5
>>> 3 - 2
1
>>> 2 * 3
6
>>> 3 / 2
1.5

在终端会话中，Python直接返回运算结果。Python使用两个乘号表示乘方运算：

>>> 3 ** 2
9
>>> 3 ** 3
27
>>> 10 ** 6
1000000

Python还支持运算次序，因此你可在同一个表达式中使用多种运算。你还可以使用括号来修改运算次序，让Python按你指定的次序执行运算，如下所示：

>>> 2 + 3*4
14
>>> (2 + 3) * 4
20

在这些示例中，空格不影响Python计算表达式的方式，它们的存在旨在让你阅读代码时，能迅速确定先执行哪些运算。

2.2浮点数(float)

Python将带小数点的数字都称为浮点数 。大多数编程语言都使用了这个术语，它指出了这样一个事实：小数点可出现在数字的任何位置。每种编程语言都须细心设计，以妥善地处理浮点数，确保不管小数点出现在什么位置，数字的行为都是正常的。从很大程度上说，使用浮点数时都无需考虑其行为。你只需输入要使用的数字，Python通常都会按你期望的方式处理它们：

>>> 0.1 + 0.1
0.2
>>> 0.2 + 0.2
0.4
>>> 2 * 0.1
0.2
>>> 2 * 0.2
0.4

但需要注意的是，结果包含的小数位数可能是不确定的：

>>> 0.2 + 0.1
0.30000000000000004
>>> 3 * 0.1
0.30000000000000004

所有语言都存在这种问题，没有什么可担心的。Python会尽力找到一种方式，以尽可能精确地表示结果，但鉴于计算机内部表示数字的方式，这在有些情况下很难。就现在而言，暂时忽略多余的小数位数即可；在第二部分的项目中，你将学习在需要时处理多余小数位的方式。

2.3复数(complex)

complex （复数）：+ BJ的形式，其中a，b是彩车和J（或J）表示-1的平方根（这是一个虚数）。 a是真正的数字部分，b是虚部。复数不使用Python编程。
定义：复数是由一个实数和一个虚数组合构成
结构：a±bj ,(a+bj)
其中a是实部，b是虚部，j是虚部的标志符号
示例:

print(type(3 + 3j))  # python 用j代表虚部,j前面必须要有代表虚数部分的数
print((3j)**2)

3.列表

列表 由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意。在Python中，用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。下面是一个简单的列表示例，这个列表包含几种自行车：

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

如果你让Python将列表打印出来，Python将打印列表的内部表示，包括方括号

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

鉴于这不是你要让用户看到的输出，下面来学习如何访问列表元素。

3.1访问列表元素

列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉Python即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。例如，下面的代码从列表bicycles 中提取第一款自行车：

  bicycles = ['trek', 'cannondale
  print(bicycles[0])

上面代码演示了访问列表元素的语法。当你请求获取列表元素时，Python只返回该元素，而不包括方括号和引号：

trek

这正是你要让用户看到的结果——整洁、干净的输出。
你还可以对任何列表元素调用第2章介绍的字符串方法。例如，可使用方法title() 让元素'trek' 的格式更整洁

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

这个示例的输出与前一个示例相同，只是首字母T是大写的。

3.1.1索引从0而不是1开始

在Python中，第一个列表元素的索引为0，而不是1。在大多数编程语言中都是如此，这与列表操作的底层实现相关。如果结果出乎意料，请看看你是否犯了简单的差一错误。
第二个列表元素的索引为1。根据这种简单的计数方式，要访问列表的任何元素，都可将其位置减1，并将结果作为索引。例如，要访问第四个列表元素，可使用索引3。下面的代码访问索引1 和3 处的自行车：

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

这些代码返回列表中的第二个和第四个元素：

cannondale
specialized

Python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1 ，可让Python返回最后一个列表元素：

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

这些代码返回'specialized' 。这种语法很有用，因为你经常需要在不知道列表长度的情况下访问最后的元素。这种约定也适用于其他负数索引，例如，索引-2 返回倒数第二个列表元素，索引-3 返回倒数第三个列表元素，以此类推。

3.1.2使用列表中的各个值

可像使用其他变量一样使用列表中的各个值。例如，你可以使用拼接根据列表中的值来创建消息。
下面来尝试从列表中提取第一款自行车，并使用这个值来创建一条消息：

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
message = "My first bicycle was a " + bicycles[0].title() + "."
print(message)
结果:My first bicycle was a Trek.

3.2 修改添加和删除元素

你创建的大多数列表都将是动态的，这意味着列表创建后，将随着程序的运行增删元素。例如，你创建一个游戏，要求玩家射杀从天而降的外星人；为此，可在开始时将一些外星人存储在列表中，然后每当有外星人被射杀时，都将其从列表中删除，而每次有新的外星人出现在屏幕上时，都将其添加到列表中。在整个游戏运行期间，外星人列表的长度将不断变化。

3.2.1修改列表元素

修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。
例如，假设有一个摩托车列表，其中的第一个元素为'honda' ，如何修改它的值呢？

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

❷ motorcycles[0] = 'ducati'
  print(motorcycles)

我们首先定义一个摩托车列表，其中的第一个元素为'honda' （见❶）。接下来，我们将第一个元素的值改为'ducati' （见❷）。输出表明，第一个元素的值确实变了，但其他列表元素的值没变：

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

你可以修改任何列表元素的值，而不仅仅是第一个元素的值。

3.2.2在列表中添加元素

你可能出于众多原因要在列表中添加新元素，例如，你可能希望游戏中出现新的外星人、添加可视化数据或给网站添加新注册的用户。Python提供了多种在既有列表中添加新数据的方式。

• 在列表末尾添加元素
  在列表中添加新元素时，最简单的方式是将元素附加到列表末尾。给列表附加元素时，它将添加到列表末尾。继续使用前一个示例中的列表，在其末尾添加新元素'ducati'

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

❶ motorcycles.append('ducati')
  print(motorcycles)

方法append() 将元素'ducati' 添加到了列表末尾（见❶ ），而不影响列表中的其他所有元素：

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

方法append() 让动态地创建列表易如反掌，例如，你可以先创建一个空列表，再使用一系列的append() 语句添加元素。下面来创建一个空列表，再在其中添加元素'honda' 、'yamaha' 和'suzuki' ：

motorcycles = []

motorcycles.append('honda')
motorcycles.append('yamaha')
motorcycles.append('suzuki')

print(motorcycles)

最终的列表与前述示例中的列表完全相同：

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

这种创建列表的方式极其常见，因为经常要等程序运行后，你才知道用户要在程序中存储哪些数据。为控制用户，可首先创建一个空列表，用于存储用户将要输入的值，然后将
用户提供的每个新值附加到列表中。

• 在列表中插入元素
  使用方法insert() 可在列表的任何位置添加新元素。为此，你需要指定新元素的索引和值。

 motorcycles = ['honda', 'yamaha', 'suzuki']

❶ motorcycles.insert(0, 'ducati')
  print(motorcycles)

在这个示例中，值'ducati' 被插入到了列表开头（见❶）；方法insert() 在索引0 处添加空间，并将值'ducati' 存储到这个地方。这种操作将列表中既有的每个元素都右移一个位置：

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

3.2.3 从列表中删除元素

你经常需要从列表中删除一个或多个元素。例如，玩家将空中的一个外星人射杀后，你很可能要将其从存活的外星人列表中删除；当用户在你创建的Web应用中注销其账户时，你需要将该用户从活跃用户列表中删除。你可以根据位置或值来删除列表中的元素。

• 使用del语句删除元素

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

❶ del motorcycles[0]
  print(motorcycles)

❶ 处的代码使用del 删除了列表motorcycles 中的第一个元素——'honda' ：

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

使用del 可删除任何位置处的列表元素，条件是知道其索引。下例演示了如何删除前述列表中的第二个元素——'yamaha' ：

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

del motorcycles[1]
print(motorcycles)

下面的输出表明，已经将第二款摩托车从列表中删除了：

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

在这两个示例中，使用del 语句将值从列表中删除后，你就无法再访问它了。

• 使用方法pop()删除元素
  有时候，你要将元素从列表中删除，并接着使用它的值。例如，你可能需要获取刚被射杀的外星人的 x 和 y 坐标，以便在相应的位置显示爆炸效果；在Web应用程序中，你可能要将用户从活跃成员列表中删除，并将其加入到非活跃成员列表中。

方法pop() 可删除列表末尾的元素，并让你能够接着使用它。术语弹出 （pop）源自这样的类比：列表就 像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。
下面从列表motorcycles 中弹出一款摩托车：

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

❷ popped_motorcycle = motorcycles.pop()
❸ print(motorcycles)
❹ print(popped_motorcycle)

我们首先定义并打印了列表motorcycles （见❶）。接下来，我们从这个列表中弹出一个值，并将其存储到变量popped_motorcycle 中（见❷）。然后我们打印这个列表，以核实从其中删除了一个值（见❸）。最后，我们打印弹出的值，以证明我们依然能够访问被删除的值（见❹）。

输出表明，列表末尾的值'suzuki' 已删除，它现在存储在变量popped_motorcycle 中：

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

方法pop() 是怎么起作用的呢？假设列表中的摩托车是按购买时间存储的，就可使用方法pop() 打印一条消息，指出最后购买的是哪款摩托车：

motorcycles = ['honda', 'yamaha', 'suzuki']

last_owned = motorcycles.pop()
print("The last motorcycle I owned was a " + last_owned.title() + ".")

输出是一个简单的句子，指出了最新购买的是哪款摩托车：

The last motorcycle I owned was a 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.

别忘了，每当你使用pop() 时，被弹出的元素就不再在列表中了。

如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

• 根据值来删除元素
  有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove() 。
  例如，假设我们要从列表motorcycles 中删除值'ducati' 。

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

❶ motorcycles.remove('ducati')
  print(motorcycles)

❶ 处的代码让Python确定'ducati' 出现在列表的什么地方，并将该元素删除：

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

使用remove() 从列表中删除元素时，也可接着使用它的值。下面删除值'ducati' ，并打印一条消息，指出要将其从列表中删除的原因：

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

❷ too_expensive = 'ducati'
❸ motorcycles.remove(too_expensive)
  print(motorcycles)
❹ print("\nA " + too_expensive.title() + " is too expensive for me.")

**在❶处定义列表后，我们将值'ducati' 存储在变量too_expensive 中（见❷）。接下来，我们使用这个变量来告诉Python将哪个值从列表中删除（见❸）。最后，值'ducati' 已经从列表中删除，但它还存储在变量too_expensive 中（见❹），让我们能够打印一条消息，指出将'ducati' 从列表motorcycles 中删除的原因：

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

A Ducati is too expensive for me.

注意 :　方法remove() 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值。

3.3组织列表

**在你创建的列表中，元素的排列顺序常常是无法预测的，因为你并非总能控制用户提供数据的顺序。这虽然在大多数情况下都是不可避免的，但你经常需要以特定的顺序呈现信息。有时候，你希望保留列表元素最初的排列顺序，而有时候又需要调整排列顺序。Python提供了很多组织列表的方式，可根据具体情况选用。

3.3.1 使用方法sort() 对列表进行永久性排序

Python方法sort() 让你能够较为轻松地对列表进行排序。假设你有一个汽车列表，并要让其中的汽车按字母顺序排列。为简化这项任务，我们假设该列表中的所有值都是小写的。**

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

方法sort() （见❶）永久性地修改了列表元素的排列顺序。现在，汽车是按字母顺序排列的，再也无法恢复到原来的排列顺序：

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

你还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort() 方法传递参数reverse=True 。下面的示例将汽车列表按与字母顺序相反的顺序排列：

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

同样，对列表元素排列顺序的修改是永久性的：

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

3.3.2　　使用函数sorted() 对列表进行临时排序

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted() 。函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。
下面尝试对汽车列表调用这个函数。

 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']

注意，调用函数sorted() 后，列表元素的排列顺序并没有变（见❹）。如果你要按与字母顺序相反的顺序显示列表，也可向函数sorted() 传递参数reverse=True 。
注意: 　在并非所有的值都是小写时，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的要复杂。

3.3.3 倒着打印列表

要反转列表元素的排列顺序，可使用方法reverse() 。假设汽车列表是按购买时间排列的，可轻松地按相反的顺序排列其中的汽车：

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

cars.reverse()
print(cars)

注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：

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

3.3.1 确定列表的长度

使用函数len() 可快速获悉列表的长度。在下面的示例中，列表包含4个元素，因此其长度为4：

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

在你需要完成如下任务时，len() 很有用：确定还有多少个外星人未被射杀，需要管理多少项可视化数据，网站有多少注册用户等。
注意 :　Python计算列表元素数时从1开始，因此确定列表长度时，你应该不会遇到差一错误。

3.4 使用列表是避免索引错误

刚开始使用列表时，经常会遇到一种错误。假设你有一个包含三个元素的列表，却要求获取第四个元素：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[3]

这将导致索引错误 ：

Traceback (most recent call last):
  File "motorcycles.py", line 3, in <module>
    print(motorcycles[3])
IndexError: list index out of range

Python试图向你提供位于索引3处的元素，但它搜索列表motorcycles 时，却发现索引3处没有元素。鉴于列表索引差一的特征，这种错误很常见。有些人从1开始数，因此以为第三个元素的索引为3；但在Python中，第三个元素的索引为2，因为索引是从0开始的。

索引错误意味着Python无法理解你指定的索引。程序发生索引错误时，请尝试将你指定的索引减1，然后再次运行程序，看看结果是否正确。

别忘了，每当需要访问最后一个列表元素时，都可使用索引-1 。这在任何情况下都行之有效，即便你最后一次访问列表后，其长度发生了变化：

motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles[-1])

索引-1 总是返回最后一个列表元素，这里为值'suzuki' ：

'suzuki'

仅当列表为空时，这种访问最后一个元素的方式才会导致错误：

motorcycles = []
print(motorcycles[-1])

列表motorcycles 不包含任何元素，因此Python返回一条索引错误消息：

Traceback (most recent call last):
  File "motorcyles.py", line 3, in <module>
    print(motorcycles[-1])
IndexError: list index out of range

注意 　发生索引错误却找不到解决办法时，请尝试将列表或其长度打印出来。列表可能与你以为的截然不同，在程序对其进行了动态处理时尤其如此。通过查看列表或其包含的元素数，可帮助你找出这种逻辑错误。

<>-------------------------------------------------字典元组啥的的先不写了----------------------------------------->>