1.1 数值型
（1）数值型包括int（整型）、float(浮点型)与complex（复数型）等。
1.1.1整型
（1）整型可以表示成十进制、八进制、十六进制以及二进制形式。
（2）十进制整型常量：数码为0~9，比如：123、-123。
（3）八进制整型常量：前缀以0O（第一个字符为数字0，第二个字符为字母O，字母大小写均可）开头，数码为0~7，且通常为无符号数，比如：0O11（表示十进制数9）。
（4）十六进制整型常量;前缀以0X（第一个字符为数字0，第二个字符为字母X，字母大小写均可）开头，数码为0~9，以及用A~F(小写字母a~f也可)来代表10~15.比如:0X1A（表示十进制数26）、0XFFFF（表示十进制数65535）。
（5）二进制整型常量：前缀以0B（第一个字符为数字0，第二个字符为字母B，字母大小写均可）开头，数码为0和1，比如0B1010（表示十进制数10）。
以上整型常量的运算示例如下：
1.1.2浮点型
（1）浮点型常量就是包含小数的常量，可表示为带小数点的小数形式，比如：123.4、-1.5，也可表示为指数形式：小数+E+阶码(小写字母e也可)，比如:2.3E-1，错误示例：e-10(e前需有数字)、2.1e（e后需要有阶码）。
运算示例如下：
（2）相关模块拓展
【1】decimal模块（用于进行非常精确的运算）的使用示例如下：
【2】fractions模块的使用示例如下：
1.1.3复数型
（1）复数包含实数与虚数。复数形如：-6.1+5j,即实部+虚部j形式。complex(a,[b])可以创建复数a+bj。使用“复数.real”和“复数.imag”可从复数中提取它的实部和虚部。python内置函数abs(复数)可以用来计算复数的模，使用复数.conjugate()可得到共轭复数。python还支持复数之间的加减乘除等运算。
复数间的运算示例如下：
2.1布尔型
（1）布尔型数据是布尔值，它有自己的运算符。使用比较运算符和判断运算符进行运算产生的结果就是布尔值。
2.1.1布尔值
（1）布尔值只有两个：True和False。
【1】False符合下列情况：
【1.1】None。
【1.2】数值中的0、0.0、0j(虚数)、Decimal(0)、Fraction(0,1)。
【1.3】空字符串（' '）、空元组(( ))、空列表（[ ]）、空字典（{ }）、空集合（set( )）。
【2】True ：除【1】中举例外的情况中对象的布尔值默认为True，除非使用bool()方法且返回False或使用了len()方法且返回0。
（2）布尔运算
【1】布尔运算包括非、与、或，优先级从高到低。
【1.1】非运算 (not x):如果x为 False，则结果为 True，否则为 False。
【1.2】与运算(x and y);如果x为False，则不用考虑y，结果为False; 如果x为True，则结果取决于y为True还是False
【1.3】或运算(xor y)如果x为False，则结果取决于y为True还是False;如果x为True，则结果为True，不用考虑y。
（3）比较运算
【1】Python 中比较运算符用于比较运算，它们有相同的优先级，并且比布尔运算符的优先级高比较运算符如下。
<:小于。
<=:小于等于
>:大于。
>=:大于等于。
==:等于。
l=:不等于
is:是对象。
is not:不是对象。
（4）比较+布尔运算
【1】使用运算符and和or 执行运算后并不一定会返回 True 或False，可能会得到最后一个被计算的表达式的值，但是使用运算符 not 执行运算后一定会返回 True 或 False。
3.1字符串型
（1）字符串使用单引号、双引号、3个单引号、3个双引号作为定界符，并且不同的定界符可以互相嵌套。例如：
3.1.1字符编码及其python支持
（1）文字信息是由一系列“字符”组成的，我们常用的字符包括西文字符和中文字符。此外，世界上还有许多其他的文字和符号。为了在计算机中表达这些字符，需要对字符进行编码。以下是
几种常用的编码方式：ASCLL、GB2312-80编码、GBK编码、Unicode编码、GB18030编码。
3.1.2转义字符
（1）python中常用一些字符来表达特殊意义，常用的转义字符及示例如下：
3.1.3字符串常量
（1）Python 标准库中的 string 模块提供了英文字母大小写、数字字符、标点符号等字符串常量编程时可以直接使用。
3.1.3内置字符串函数
（1）python语言提供了一些对字符串进行处理的内置函数：
(2)更多常用字符串内建函数：
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize() |
| 2 | 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string))
|
| 4 | bytes.decode(encoding="utf-8", errors="strict")
|
| 5 | encode(encoding='UTF-8',errors='strict')
|
| 6 | endswith(suffix, beg=0, end=len(string)) |
| 7 |
|
| 8 | find(str, beg=0, end=len(string))
|
| 9 | index(str, beg=0, end=len(string))
|
| 10 |
|
| 11 |
|
| 12 |
|
| 13 |
|
| 14 |
|
| 15 |
|
| 16 |
|
| 17 |
|
| 18 |
|
| 19 |
|
| 20 |
|
| 21 |
|
| 22 |
|
| 23 |
|
| 24 |
|
| 25 |
|
| 26 |
|
| 27 | rfind(str, beg=0,end=len(string))
|
| 28 | rindex( str, beg=0, end=len(string))
|
| 29 |
|
| 30 |
|
| 31 | split(str="", num=string.count(str))
|
| 32 |
|
| 33 | startswith(substr, beg=0,end=len(string))
|
| 34 |
|
| 35 |
|
| 36 |
|
| 37 | translate(table, deletechars="")
|
| 38 |
|
| 39 |
|
| 40 |
|
3.1.4字符串运算符
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | 'H' in a 输出结果 True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | 'M' not in a 输出结果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
（1）运算符实例如下：
str = "hello world"
# 判断所有字符都是小写
print (str.islower())
# 判断所有字符都是大写
print (str.islower())
# 把所有字符中的小写字母转换成大写字母
print ( str.swapcase() )
# 把每个单词的第一个字母转化为大写，其余小写
print (str.title())
# 获取切片：world
print(str[6:11])
# 判断字符串是否存在子字符串“or”
str1 = "or"
print(str1 in str)
print(str.find(str1)) #查询指定字符串的位置（第一次出现的位置/）当指定字符串不存在不存在时返回-1
print(str.index(str1))#查询指定字符串的位置（第一次出现的位置/）当指定字符串不存在不存在时直接报错
# 将字符串翻转
print(str[::-1])
print("".join(reversed(str)))
# 判断该字符串的长度 是不是20，然后输出每一个字符
print(len(str)==20)
for i in range(len(str)):
print(str[i])
3.1.5字符串格式化
（1）python字符串格式化常用格式字符:
| 符号 | 说明 | 符号 | 说明 |
| %s | 字符串 (采用str()的显示) | %r | 字符串 (采用repr()的显示) |
| %c | 单字符 | %b | 二进制整数 |
| %d | 十进制整数 | %i | 十进制整数 |
| %o | 八进制整数 | %x | 十六进制整数 |
| %e | 指数 (基底写为e) | %E | 指数 (基底写为E) |
| %f | 浮点数 | %F | 浮点数，与左相同 |
| %g | 指数(e)或浮点数 (根据显示长度) | %G | 指数(E)或浮点数 (根据显示长度) |
（2）格式化运算符辅助指令：
| 符号 | 功能 |
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
3.1.6数据类型转换
（1）在数字的算术运算表达式求值时会进行隐式的数据类型转换，如果表达式中存在复数则将数据都变成复数，如果没有复数但是有实数就将数据都变成实数，如果都是整数则不进行类型转换。显式数据类型的转换通过转换函数进行，以要转换到的目标类型作为函数名。常用的转换函数如下表：
| 函数 | 描述 |
|---|---|
| 将x转换为一个整数 | |
| 将x转换到一个浮点数 | |
| 创建一个复数 | |
| 将对象 x 转换为字符串 | |
| 将对象 x 转换为表达式字符串 | |
| 用来计算在字符串中的有效Python表达式,并返回一个对象 | |
| 将序列 s 转换为一个元组 | |
| 将序列 s 转换为一个列表 | |
| 转换为可变集合 | |
| 创建一个字典。d 必须是一个 (key, value)元组序列。 | |
| 转换为不可变集合 | |
| 将一个整数转换为一个字符 | |
| 将一个字符转换为它的整数值 | |
| 将一个整数转换为一个十六进制字符串 | |
| 将一个整数转换为一个八进制字符串 |
4.1 组合数据类型
4.1.1列表
（1）列表将所有元素放在方括号([ ])中并用逗号分隔。列表中的元素的类型可以是基本数据类型，也可以是组合数据类型，而且可以互不相同。列表可以通过多种方式创建。创建列表的示例如下:
（2）列表的特性：索引和切片、运算符、内置函数
【1】索引和切片：列表中的每个成员都称为元素，所有元素都是有编号的，可以通过编号分别对它们进行访问。每个元素在列表中的编号又称为索引，索引从0开始递增，从前向后排列，第一个元素的索引是0，第二个元素的是 1，以此类推。从列表左边开始访问，从前向后各元素的索引为 ，1，2，3，4，5，6，7。若是从列表右边开始访问，从前到后各元素索引变为-8,-7,-,-5,-4,-3,-2,-1。实例如下：
【2】运算符与内置函数：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。运算符与内置函数实例如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
（3）列表方法：
| 序号 | 函数 |
|---|---|
| 1 | len(list) 列表元素个数 |
| 2 | max(list) 返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq) 将元组转换为列表 |
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort( key=None, reverse=False) 对原列表进行排序 |
| 10 | list.clear() 清空列表 |
| 11 | list.copy() 复制列表 |
4.1.2元组
（1）元组和列表一样，也是一种序列，列表的方法、函数一般也能应用于元组，二者之间唯一的不同就是元组不能修改。
【1】运算：与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
|---|---|---|
len((1, 2, 3)) | 3 | 计算元素个数 |
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。 |
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。 |
('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 |
3 in (1, 2, 3) | True | 元素是否存在 |
for x in (1, 2, 3):
print (x, end=" ") | 1 2 3 | 迭代 |
【2】索引、截取：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| tup[1] | 'Runoob' | 读取第二个元素 |
| tup[-2] | 'Weibo' | 反向读取，读取倒数第二个元素 |
| tup[1:] | ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') | 截取元素，从第二个开始后的所有元素。 |
| tup[1:4] | ('Runoob', 'Taobao', 'Wiki') | 截取元素，从第二个开始到第四个元素（索引为 3）。 |
【3】内置函数：
| 序号 | 方法及描述 | 实例 |
|---|---|---|
| 1 | len(tuple) 计算元组元素个数。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3
>>> |
| 2 | max(tuple) 返回元组中元素最大值。 | >>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>> |
| 3 | min(tuple) 返回元组中元素最小值。 | >>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>> |
| 4 | tuple(iterable) 将可迭代系列转换为元组。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu'） |
5.1 程序基本结构
5.1.1输入输出，条件语句，循环结构的实例应用
6.1解题相关程序：python程序设计课本49页【实训】
6.1.1按照下列要求修改、运行并调试【例 2.1】中的程序
（1）输入表达式格式为 (..) x，x=2,8,16，将x进制 (...) 转换为相应的十进制。相关程序如下：
str069 = input("输入的表达式为（...）x:")
lens = len(str069)
p1 = str069.find("(")
p2 = str069.find(")")
if not(p2 > p1 and p2 + 1 <= lens):
print("输入错误!")
else:
es = str069[p1+1:p2]
jc = str069[p2+1]
if jc == '2':
m = int(es)
elif jc == '8':
m = int(es)
elif jc == 'h':
m = int(es)
print(jc,"进制的",es,"对应十进制=", m)6.1.2按照下列要求修改、运行并调试[例 2.3]中的程序。
(1)采用正则表达式在公司联系方式字符串中获得移动电话号码。相关程序如下：
import re
info = '''本公司的联系方式:
固定电话：025—8541239,
移动电话：13851516136，
QQ：958456969，
泰州分公司：0523-6612319.'''
print(info)
patten = re.compile(r'(\d{11})')
result = patten.search(info,0)
if result:
print('移动电话是:',result.group(0))(2)不采用正则表达式在公司联系方式字符串中获得固定电话号码。相关程序如下：
info="""本公司的联系方式:
固定电话：025—8543295,
移动电话：13851516130，
QQ：958456964，
泰州分公司：0523-6612319."""
print(info)
gddh=info.index("固定电话")
print("固定电话是:",info[gddh+4:gddh+17])
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
