非正式角度说，在Python中，我们使用“材料”来处理“事务”。“事务”指的是像加法或者拼接这样的操作形式，而“材料”指的就是我们操作的对象。

• 程序由模块构成
• 模块包括语句
• 语句包括表达式
• 表达式创建并且处理对象

在之前学习过的C语言中，我们知道：C语言在计算机中创建一块空间区域，然后向这块空间区域存放数据（如int型，字符型）。由于每种数据类型的字节长度各不相同，因此在定义变量时，需要提前说明我们定义的这个变量到底是什么数据类型。
如：

代表的含义是在计算机中开辟一块4个字节的区域，用来存放整型数据10。因为说明了变量a是整型，因此在给a重新赋值的时候，赋予的值也必须是一个整型。
下图展示了C语言变量的示意图，在计算机中地址为1001的位置开始开辟一块区域，如果存放字符型数据‘S’,需要提前声明a为char型，开辟的位置就是1001这一个字节的区域；如果存放整型数据‘10’,需要提前声明a为int型,开辟的位置就是1001至1004这4个字节的区域；

而在Python中，变量代表了一个数据对象的引用，可以将其理解为变量是一个“标签”，可以“贴”在一个整型数据对象上，也可以“贴在”一个字符型数据对象上。
如：

代表的含义是用变量a引用一个整型数据10。下图展示了Python中变量的示意图，变量a首先去引用一个整型数据10，我们对a重新进行赋值时，就是把变量a去引用另一个字符型数据‘S’。

在Python中，基本的数据类型如下图所示，后面将对每种数据类型进行详细介绍。

Python内置的数字类型足以表示绝大部分数值量，包括：整数（不带小数部分的数字）、浮点数（带小数部分的数字）、带虚部的复数、带分子和分母的有理分数···同时，Python还有更多第三方库提供更强大的功能。数字运算符在前面已叙述，这里不再赘述。

序列是一个包含其他对象的有序集合，序列的元素包含了一个从左到右的顺序——序列中的元素根据它们的相对位置进行存储和读取。一般序列包括字符串、列表和元组。

序列操作是通用的，但是方法不通用。一条简明的法则是：Python的工具库是呈层级分布的：可作用于多种类型的通用操作都是以内置函数或者表达式的形式出现的（如len(X)、X[0]），但是类型特定的操作是以方法调用的形式出现的（如：aString.upper()）。

• 索引操作：索引量按照从最前面的偏移量进行编码的，也就是从0开始，第一项索引是0，第二项索引是1，以此类推。能够进行反向索引操作，从右边开始索引（负的索引号会简单地与字符串的长度相加，即：s[-1]=s[len(s)-1]）
• 通过内置的len函数验证其长度。
• 分片（slice）操作：一种一次就可以提取整个分片的方法，一般形式为X[I:J],表示“取出X中从偏移量为I,直到但不包括偏移量为J 的内容”。
• 拼接操作：使用“+”号来将两个相同类型的序列进行拼接。使用“*”来将一个序列进行重复。

对象具有不可变性：在创建后不能原位置改变，即不可能覆盖不可变对象的值。
不可变对象：数字、字符串、元组。
可变对象：列表、字典、集合。

严格意义上，可以在原位置改变基于文本的数据。

• 将其拓展为一个由独立字符构成的列表，进行改变后将其转化为字符串进行输出。

代码示例如下：

S='hello'
# 将字符串S转换为列表L
L=list(S)
# 改变列表L的第二个元素
L[1]='x'
# 将列表L转换为字符串并输出
print(''.join(L))

运行结果如下：
hxllo

• 使用内置函数bytearray，返回一个新字节数组，并且这个数组的元素是可变的。

代码示例如下：

# bytearray函数返回一个新字节数组，并且这个数组的元素是可变的
'''参数如果是bytearray对象，将通过缓冲器协议（buffer protocol）
复制其中的数据，即这里的b'spam'。'''
B=bytearray(b'spam')
B.extend(b'eggs')
print(B)

运行结果如下：
bytearray(b'spameggs')

查看详细的介绍对象方法，需要使用dir函数。使用help函数查询该方法具体是做什么的。

代码示例如下：

line='hello'
# 使用dir函数查看line字符串有哪些方法
print(dir(line))
# 使用help函数查看某个方法具体是干什么用的
print(help(line.upper))

运行结果如下：
 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
Help on built-in function upper:

upper(...) method of builtins.str instance
   S.upper() -> str
    Return a copy of S converted to uppercase.
None

字符串是用来记录文本信息（如你的姓名）和任意字节集合（如图片文件的内容）。

创建。如：

find方法是基本的子字符串查找的操作，它将返回一个传入子字符串的偏移量，或者在没有找到的情况下返回-1。

代码示例如下：

S='hello'
print(S.find('ll'))

运行结果如下：
2

replace方法：字符串的replace方法会对全局进行搜索和替换。

代码示例如下：

S='hello'
T=S.replace('ll','xx')
print(T)

运行结果如下：
hexxo

split方法：使用分隔符将字符串拆分为子字符串，如果参数num 有指定值，则仅分隔 num 个子字符串。

代码示例如下：

line='hello,my,name,is,cola'
# 通过调用split方法，将字符串line按照','将其分割为一个字符集合
# 这个字符集合是['hello','my','name','is','cola']
T=line.split(',')
# 通过for循环依次输出每个子字符串
for str in T:
    print(str,type(str))

运行结果如下：
hello <class 'str'>
my <class 'str'>
name <class 'str'>
is <class 'str'>
cola <class 'str'>

upper方法：所有字母大写。lower方法：所有字母小写。capitalize方法：首字母大写，其他字母小写。title方法：每个单词首字母大写，其他小写。

代码示例如下：

S='hello'
T='WORLD'
# 将字符串S转换为大写字母并输出
print(S.upper())
# 将字符串T转换为小写字母并输出
print(T.lower())
P='ni hao,nice to meet you'
# 将字符串P的首字母转换为大写字母，其他字母保持不变
print(P.capitalize())
# 将字符串P中每个单词的首字母转换为大写字母，其他字母保持不变
print(P.title())

运行结果如下：
HELLO
world
Ni hao,nice to meet you
Ni Hao,Nice To Meet You

strip 方法：同时去掉左右两边的空格。lstrip 方法：去掉左边的空格。rstrip 方法：去掉右边的空格。

代码示例如下：

# S字符串的左边和右边都有一个空格符
S=' hello '
# 将带空格和换行符的字符串S输出
print(S)
# 通过strip方法去掉左边和右边的空格
print(S.strip())
# 通过lstrip方法去掉左边的空格
print(S.lstrip())
# 通过rstrip方法去掉右边的空格
print(S.rstrip())

运行结果如下：
 hello 
hello
hello 
 hello

方法的连用：Python遵循从左至右的执行顺序，每次前一步的方法调用结束，都会为后一步方法调用产生一个临时对象。

代码示例如下：

line='ni hao,nice to meet you'
#先调用capitalize方法，再调用split方法
print(line.capitalize().split(','))

运行结果如下：
['Ni hao', 'nice to meet you']

模式匹配：这里以match 方法为例。首先需要导入一个名为re的模块（这个模块包含了类似搜索、分割、替换等调用），re.match调用返回一个匹配的对象，我们通过group方法来获取这个匹配的对象。

代码示例如下:

# 导入re模块
import re
# 通过re.match调用进行正则表达式匹配
match=re.match('Hello(.*)world(.*)','Hello python world !!')
# group(0)返回整个表达式匹配的字符串
print(match.group(0))
# group(1)返回第一个匹配的子字符串小组，这里是' python'
print(match.group(1))
# group(1)返回第二个匹配的子字符串小组，这里是' ！！'
print(match.group(2))

运行结果如下：
Hello python world !!
 python 
 !!

Python的列表对象是这个语言提供的最通用的序列。它是一个任意类型的对象的位置相关的有序集合，没有固定的大小。列表是可变的，通过对相应偏移量进行赋值可以定位地对列表进行修改。下面包含方法都直接改变了列表。

创建，如：

append方法：列表的append方法增大了列表的大小，并在列表的尾部插入一项。
pop方法：移除给定偏移项的一项，使得列表减少。
insert方法：在指定偏移量位置插入元素,参数为偏移量和元素值。
remove方法：删除指定的元素，参数为元素
extend方法：在尾部插入多个元素，参数为一个列表

代码示例如下：

L=[123,'spam',1.23]
print(L)
# 使用append方法增大列表的大小，并在列表的尾部插入一项
L.append('niro')
print(L)
# 使用pop方法（等效的del语句）移除给定偏移项的一项，使得列表减少
L.pop(2)
print(L)
# 使用insert方法在指定偏移量位置插入元素,参数为偏移量和元素值
L.insert(2,'hello')
print(L)
# 使用remove方法删除指定的元素，参数为元素
L.remove('spam')
print(L)
# 使用extend方法在尾部插入多个元素，参数为一个列表
L.extend(['yyy','jjj'])
print(L)

运行结果如下：
[123, 'spam', 1.23]
[123, 'spam', 1.23, 'niro']
[123, 'spam', 'niro']
[123, 'spam', 'hello', 'niro']
[123, 'hello', 'niro']
[123, 'hello', 'niro', 'yyy', 'jjj']

sort方法：默认升序进行排序。reverse=True时，降序；reverse=Flase时，升序。

代码示例如下：

L=[2,10,9]
print(L)
'''sort方法用来排序，有两个参数，(key主要是用来进行比较的元素，只有一个参数，
 具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
 另一个参数reverse=True时，降序。reverse=Flase时，升序'''
L.sort(reverse=True)
print(L)

运行结果如下：
[2, 10, 9]
[10, 9, 2]

列表没有固定的大小，但Python不允许引用不存在的元素。所以超过列表末尾之外的索引总会导致错误，对列表末尾范围之外赋值也是如此。

• 错误1：有超过列表末尾之外的索引
  代码示例如下：

L=[2,10,9]
# 超过列表末尾的索引会导致错误
print(L[10])

运行错误提示：
IndexError: list index out of range

• 错误2：对列表末尾范围之外赋值

代码示例如下：

L=[2,10,9]
# 对列表范围之外赋值
L[5]=12
print(L)

运行错误提示：
IndexError: list assignment index out of range

Python核心数据类型的一个优秀特性就是它们支持任意的嵌套，能够以任意的组合对其进行嵌套，并可以多个层次进行嵌套。如一个列表可以包含一个字典，并在一个字典里包含一个列表等。这里以列表嵌套列表实现一个矩阵为例。

代码示例如下：

M=[[1,2,3],[4,5,6],[7,8,9]]
# 输出整个矩阵M
print(M)
# 读取矩阵M的整个第二行
print(M[1])
# 读取矩阵M第二行的第三个元素
print(M[1][2])

运行结果如下：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[4, 5, 6]
6

列表推导源自数学中的集合概念。它是一种通过对序列中的每一项运行一个表达式来创建一个新列表的方法，每次一个，从左至右。列表推导是编写在方括号中的，并且由使用了同一个变量名的表达式和循环结构组成。

代码示例如下：

M=[[1,2,3],[4,5,6],[7,8,9]]
# 创建一个数组P,这个数组由数组M中每一项的第二个元素构成
'''这里的row可以是任意可行性变量名'''
P=[row[1] for row in M]
print(P)
# 先对数组中每一项的第二个元素进行判定，是否能被2整除。满足条件的元素进行*2操作
Q=[n[1]*2 for n in M if n[1]%2==0]
print(Q)

运行结果如下：
[2, 5, 8]
[4, 16]

range函数：生成连续整数的功能
代码示例如下：

# 原生函数range生成连续整数的功能
'''range函数如果只有一个参数，这个参数代表计数到这个参数（不包括这个参数）
如果这个函数有三个参数，三个参数分别代表起始点（默认为0），结束点（不包括这个参数），步长'''
S=list(range(5)) 
L=list(range(4,10,2))
print(S,L)

运行结果如下：
[0, 1, 2, 3, 4] [4, 6, 8]

Python中的字典是一种完全不同的东西：它们不是序列，而是一种映射（mapping）。映射同样是一个其他对象的集合，但是它们是通过键（key）而不是相对位置来存储对象的。字典是Python核心对象集合中唯一地一种映射类型，也具有可变性：同列表一样，可以就地改变并随着需求增大或减小。

直接创建字典；
通过dict(name=value)创建字典；
通过dict(zip([names···],[values···]))）创建字典；
通过键对这个字典进行索引来读取、改变键所关联的值；
拓展字典并进行赋值。

代码示例如下：

#创建1：
D={'food':'apple','color':'red','num':4}
#创建2：
D=dict(food='apple',color='red',num=4)
#创建3：
D=dict(zip(['food','color','num'],['apple','red',4]))
# 字典D通过键（key）对这个字典进行索引读取
print(D['food'],D['color'])
# 字典D通过键（key）对这个字典进行索引改变键所关联的值
D['num']=16
print(D)
# 与列表禁止边界外的赋值不同，对字典D拓展一个键并对其赋值
D['value']='great'
print(D)

运行结果如下：
apple red
{'food': 'apple', 'color': 'red', 'num': 16}
{'food': 'apple', 'color': 'red', 'num': 16, 'value': 'great'}

这里以字典中嵌套一个字典为例。

代码示例如下：

D={'name':{'first name':'Jerry','last name':'smith'},
   'sex':'female',
   'age':14}
# 访问字典D的'name'键，访问字典D键'name'嵌套的键'first name'
print(D['name'])
print(D['name']['first name'])

运行结果如下：
{'first name': 'Jerry', 'last name': 'smith'}
Jerry

在访问字典中不存在的键时会报错，我们可以使用if测试不存在键。

代码示例如下：

D={'a':'A','b':'B','c':'C'}
# 字典D中不存在键'd'
print('d' in D)
# 使用if来测试不存在的键
if 'k' not in D:
    print('没有这个键')

运行结果如下：
False
没有这个键

因为字典不是一个序列，因此字典的键从左至右的顺序是被打乱的，映射不是按位置排序的。解决办法是先通过字典的keys方法收集一个键的列表，然后通过列表的sort方法进行排序，然后使用for循环循环逐个进行显示结果。

代码示例如下：

D={'a':1,'c':3,'b':2}
print(D)
# 将字典的键存储在一个列表d1中
d1=list(D.keys())
# 对列表d1的元素进行排序
d1.sort()
# 使用for循环将d1中每个元素输出并根据键将字典输出
for str in d1:
    print(str,'=',D[str])

运行结果如下：
{'a': 1, 'c': 3, 'b': 2}
a = 1
b = 2
c = 3

现在在最新的python版本中，可以将上述步骤用sorted函数一步到位。

代码示例如下：

D={'a':1,'c':3,'b':2}
print(D)
# 使用sorted函数将字典D的键放在一个列表中，并将其按照升序排列
# 使用for循环将每个键和它指示的值输出
for str in sorted(D):
    print(str,'=',D[str])

运行结果如下：
{'a': 1, 'c': 3, 'b': 2}
a = 1
b = 2
c = 3

元组对象（tuple）基本上就像一个不可改变的列表，本质上是一个不可改变的序列，功能上是用来表示确定元素的集合。

创建。（这里元组的括号可以省略）：

如下两种创建方式是一样的:

x=('apple','red',4)
x='apple','red',4

元组有两个专有的可调用方法。index方法查看某个元素的偏移量；count方法查看这个元组中某个元素的个数。

代码示例如下：

x=('apple','red',4)
# 调用index方法查看某个元素的偏移量
print(x.index('apple'))
# 调用count方法查看这个元组中某个元素的个数
print(x.count('apple'))

运行结果如下：
0
1

文件对象是Python代码调用电脑上存放的外部文件的主要接口。它们可以被用于读取和写入文本记录、音频片段、Excel文档、保存邮件以及任何你保存在电脑上的东西。
要创建一个文件对象，需要调用内置的open函数以字符串的形式传递给它一个外部的文件名以及一个可选的表示处理模式的字符串。
这里python和之前的C语言的文件操作有相似的地方，C语言对文件操作需要建立文件指针，python对文件操作需要建立文件对象。在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。

代码示例如下：

# 对文件进行操作，需要open函数创建文件对象，同时与close函数成对出现
# 这里的'w'是写入数据的处理模式字符串
f=open('data.txt','w')
# 使用write方法在文件中写入字符串
f.write('hello\n')
f.write('world\n')
#close方法与open成对出现
f.close()

# 'r'是读取数据的处理模式字符串，可以省略
f=open('C:\\Users\\19354\\PycharmProjects\\pythonProject3\\data.txt','r')
# 调用read方法读取文件中的字符
n=f.read()
print(n)
f.close()

运行结果如下：

hello
world

集合是新增在python中的类型，既不是序列，也不是映射。它们是唯一地不变的对象的无序集合。集合更像是一个无值的字典的键。
集合可以通过调用内置set函数创建，set函数的参数是可迭代对象，也可以集合字面量和表达式创建。

集合创建，创建空集合的方法只有x=set()这一种，因为y={}，默认创建的是一个空字典。

如：

# 通过set函数进行创建一个集合，参数是一个可迭代对象，可为空
x=set('Hello')
# 通过{}直接创建，和字典类似，只是没有value
y={'h','e','l','l','0'}

代码示例如下：

# 通过set函数进行创建一个集合，参数是一个可迭代对象，可为空
x=set('Hello')
# 通过{}直接创建，和字典类似，只是没有value
y={'h','e','l','l','0'}
# 通过&对两个集合取交集
print(x&y)
# 通过|两个集合取并集
print(x|y)

结果运行如下：
{'e', 'l'}
{'0', 'l', 'H', 'e', 'h', 'o'}

【参考书目】：《Python学习手册》（第5版）