python核心数据类型——数值、字符串和列表的基本操作

数值、字符串和列表的基本操作举例

**1. 列表 list**
- * --------- ① 下标索引及长度测量
- * --------- ② 追加新列表以及append（）的应用
- * --------- ③ 列表乘积‘*’的应用
- * --------- ④ 列表的扩展extend（）
- * --------- ⑤ 列表新元素的插入insert（）
- * --------- ⑥ 列表排序sort（）& reverse（）
- * --------- ⑦ 列表的删除.pop（）和全局删除delete（）
- * --------- ⑧ 列表的查找索引 .index（）和元素个数统计count（）
- * --------- ⑨ 列表的引用与复制
**2. 字典表 dictionary**
**3. 元组 tuple**
**4. 布尔：Boolean**
- * --------- ① 布尔（True & False）结果初应用
- * --------- ② 布尔（True & False）结果兼容性
**5. 数值型数据类型 -------- 声明通过赋值实现
- * 数值显示
- * 相除与取整
- - * --------- ① 除法取整
  - * --------- ② math.floor()取整
  - * --------- ③ math.trunc()取整
  - * --------- ④ round()取整 **四舍五入取整**
- * **数值的进制转换**
**6. 字符串**
- * --------- ① 转义
- * --------- ② 字符串的输出方式
- * --------- ③ 字符串字符更改的实现
- * --------- ④ 字符串的切割方法
- * --------- ⑤ 字符串的开头与结尾的判断方法——find
- * --------- ⑥ 字符串中的变量交换
**总结**

本节课的主要内容是数值、字符串和列表的基础操作，内容很零碎，把这些知识点统计起来，今后如果不小心忘记了某项操作，还能翻看日志查询。怪不得人们说python是一门语言，的确，我们在组词造句写文章之前必须知道每个单词的含义，这要记。但记住汉字或者英文单词只是学习语言的前提，语句的构造和输出是需要逻辑的，这个逻辑需要自己不断地学习，摸索和体会，学习某个具体操作并不是重点，学习到背后的逻辑支持才是关键，所以一定要会举一反三，触类旁通❤️。

1. 列表 list

* --------- ① 下标索引及长度测量

>>> l=[1,2,3,4]
>>> l
[1, 2, 3, 4]
>>> l[0]  # 下标索引，且用中括号表示
1
>>> len(l) # 查询列表内对象的个数，用小括号
4
>>> l[0],len(l)  # 出现有序数对
(1, 4)

注：可通过下标索引原位改变列表对象

* --------- ② 追加新列表以及append（）的应用

>>> l=[1,2,3,4]
>>> for i in l:
...     print(i**2)   # 与PHP都具有脚本源的特性
...
1
4
9
16
>>> res=[]
>>> for i in l:
...     res.append(i**2)   #将列表的部分内容以一定规则（自定义）追加到新列表中
...
>>> res
[1, 4, 9, 16]
>>> l1=[i**2 for i in l]  # 更简便的新列表内容追加法
>>> l1
[1, 4, 9, 16]
>>> l1[2]=5    # 列表的可变序列特性
>>> l1
[1, 4, 5, 16]
>>> l1.append(31)   # 列表后面直接追加
>>> l1
[1, 4, 5, 16, 31]

* --------- ③ 列表乘积‘*’的应用

>>> ['carla']*3
['carla', 'carla', 'carla']  # 仍然是一个list
>>> s=['carla']
>>> m=[s*3]
>>> m
[['carla', 'carla', 'carla']] # list中的list，类比于数学集合中有一个集合元素{{0,1,2}}
>>> m=s*3
>>> m
['carla', 'carla', 'carla']
>>> m=[c*3 for c in s]
>>> m
['carlacarlacarla']

补充： 如何理解：c*3 for c in s，
<1> 若s是一个列表：返回时以每个列表元素（非字符）为基础，✖️3次显示在同一个列表中，新列表中元素个数不变；
<2>若s是一个字符串：返回时以每个字符✖️3，多少个字符就会呈现多少个列表元素.

>>> s=['carla']           # s声明是list，包含1个元素
>>> m=[c*3 for c in s]    # 返回1个元素
>>> m
['carlacarlacarla']
>>> s=['carla','classroom']   # s声明是list，包含2个元素
>>> m=[c*3 for c in s]
>>> m
['carlacarlacarla', 'classroomclassroomclassroom'] # 返回2个元素
>>> n='carla'           # n声明是str，包含1个元素，5个字符
>>> m=[c*3 for c in n]
>>> m
['ccc', 'aaa', 'rrr', 'lll', 'aaa'] # 返回5个元素，每个元素是每个字符✖️3
>>> m=[c*3 for c in 'carla']    # 直接in 某一个str，效果一样
>>> m
['ccc', 'aaa', 'rrr', 'lll', 'aaa']
>>> n="carla's classroom"
>>> m=[c*3 for c in n]
>>> m
['ccc', 'aaa', 'rrr', 'lll', 'aaa', "'''", 'sss', '   ', 'ccc', 'lll', 'aaa', 'sss', 'sss', 'rrr', 'ooo', 'ooo', 'mmm']

* --------- ④ 列表的扩展extend（）

注意：append（）只能追加一个元素，但extend（）可以扩展列表，追加多个元素

>>> s=[1,2,3,4]
>>> s.extend([5,6,7,8]) # 增加4个元素
>>> s
[1, 2, 3, 4, 5, 6, 7, 8]

* --------- ⑤ 列表新元素的插入insert（）

names=['Lihua','Rain','Jack','Xiuxiu','Peiqi','Black']
names.insert(-1,'Blue')      # 在最后一个位置前插入新元素‘Blue’
print (names)
names[names.index('Xiuxiu')]='秀秀'
print(names)

运行结果：

['Lihua', 'Rain', 'Jack', 'Xiuxiu', 'Peiqi', 'Blue', 'Black']
['Lihua', 'Rain', 'Jack', '秀秀', 'Peiqi', 'Blue', 'Black']

在最后位置插入一个新元素，还可以这样：

>>> names=['Lihua','Rain','Jack','Xiuxiu','Peiqi','Black']
>>> names[5:]='Blue',names[5]
>>> names
['Lihua', 'Rain', 'Jack', 'Xiuxiu', 'Peiqi', 'Blue', 'Black']

* --------- ⑥ 列表排序sort（）& reverse（）

>>> s=[7,4,3,8,5,6]
>>> s.sort()
>>> s
[3, 4, 5, 6, 7, 8]      # 从小到大排序
>>> s.reverse()         # 从大到小排序
>>> s
[8, 7, 6, 5, 4, 3]
>>> s=['carla','hello','nice','go']
>>> s.sort()
>>> s
['carla', 'go', 'hello', 'nice'] # 按首字母在字母表的顺序排列
>>> s.reverse()
>>> s
['nice', 'hello', 'go', 'carla']

* --------- ⑦ 列表的删除.pop（）和全局删除delete（）

<1> list.pop()

>>> s=['nice', 'hello', 'go', 'carla']
>>> s.pop()
'carla'         # 在列表中弹出最后一个元素“carla”
>>> s
['nice', 'hello', 'go']  # 列表已更改
>>> s.pop()               # 在列表中再弹出最后一个元素
'go'
>>> s
['nice', 'hello']
>>> m=[4,3,5,7,1]       # 对于数值元素，道理一样
>>> m.pop()
1
>>> m
[4, 3, 5, 7]
>>> m.pop()
7
>>> m
[4, 3, 5]

注：这种方法类似于堆栈的方法
<2> 全局del（）操作

>>> s=['carla', 'go', 'hello', 'nice']
>>> del(s[0])      # 删除list的第1个元素（可任意选择第几个元素）
>>> s
['go', 'hello', 'nice']

* --------- ⑧ 列表的查找索引 .index（）和元素个数统计count（）

>>> s=['carla', 'go', 'hello', 'nice','nice']
>>> s.index('go')    # 查找“go”这个元素的下表索引
1
>>> s.count('nice')  # 统计“nice”这个元素的个数
2

* --------- ⑨ 列表的引用与复制

注意：引用类型也支持原位改变，所以引用要慎重！！

>>> s=[1,2,3,4]
>>> s=[1,2,3,4]
>>> carla=[1,2,3,4]
>>> david=carla       # 直接赋值时新列表随着原列表的变化而变化
>>> carla[0]=5
>>> carla
[5, 2, 3, 4]
>>> david
[5, 2, 3, 4]          # 新列表david随之变化
>>> david=carla[:]
>>> carla[1]=6
>>> carla
[5, 6, 3, 4]
>>> david
[5, 2, 3, 4]         # 此时david ≠ carla

>>> a=[1,2,3]
>>> b=a[:]            # 方式一：列表切片法，可切局部或者整体
>>> c=list(a)         # 方式二：列表复制法
>>> d=a*1             # 方式三：列表*1法
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]
>>> a[0]=4            # 改变原列表a的某一个元素
>>> a
[4, 2, 3]
>>> b
[1, 2, 3]             # b,c,d 均不变
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]
>>> import copy        # 导入copy
>>> e=copy.copy(a)     # 方式四: copy.copy()法
>>> e
[4, 2, 3]
>>> a[1]=5
>>> a
[4, 5, 3]
>>> e
[4, 2, 3]
>>> f=copy.deepcopy(a)  # 方式五：copy.deepcopy()
>>> f
[4, 5, 3]

所以：<1> 列表切片法 <2> 列表复制法 <3> 列表*1法 <4> copy.copy()法 <5> copy.deepcopy()法

2. 字典表 dictionary

>>> d={"name":"carla","age":20,"job":"student"} # 字典的内容用花括号
>>> d["name"]   #用中括号查询或调取数据
'carla'
>>> d.get('age')
20
>>> d.get('gender') # 这种方式不会报错，可以设置默认返回值
>>> d.get('gender','female')
'female'

3. 元组 tuple

>>> t=(1,2,3,4)
>>> t
(1, 2, 3, 4)
>>> l[3]
4

元组与列表的区别

>>> t=(1,2,3,4)
>>> l=[1,2,3,4]
>>> t[3]          # 都可以使用下标索引查找
4
>>> l[3]
4
>>> l[3]='xyz'     # 列表可以对局部位置进行修改
>>> l
[1, 2, 3, 'xyz']
>>> t[3]='abc'
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment  # 报错！

注：元组内位置不允许修改

4. 布尔：Boolean

* --------- ① 布尔（True & False）结果初应用

>>> score=62.5
>>> score>=60  # 比较返回布尔型结果
True
>>> score==60
False
>>> score!=60
True
>>> s='carla'
>>> 'l' in s      # 判断某个或某几个字符是否在已知str中
True
>>> 'car'in s
True
>>> 'm' in s
False

* --------- ② 布尔（True & False）结果兼容性

>>> 3>1
True
>>> isinstance(True,int)  # 检验类型是否兼容
True
>>> True==1
True
>>> False==0
True
>>> True+2          # 可参与int的运算
3

布尔型返回结果：True和False
比较类型：<,>,<=,>=,==,!=

**5. 数值型数据类型 -------- 声明通过赋值实现

* 数值显示

>>> '3+5*3={0}'.format(18) # 字符串中占位符的使用
'3+5*3=18'
>>> f=2.222222
>>> 'f={0}'.format(2*f)   # format（）仍可以对数值进行运算，再以字符串形式将结果显示出来
'f=4.444444'
>>> 'f={0:.2f}'.format(f)  # 局部调整，占位符部分的数值是与f一样的浮点型，并且保留两位有效数字
'f=2.22'

. ps：
--------- 占位符在字典（dic）中的应用：

>>> d={'name':'carla','age':20,'job':'student'}
>>> '姓名：{0},年龄:{1}'.format(d.get('name'),d.get('age'))
'姓名：carla,年龄:20'

* 相除与取整

* --------- ① 除法取整

>>> 10/4   # 整数除法默认取整
2
>>> 10/4.0  # 按精度高的运算（不取整）
2.5
>>> 10//4   # 除法取整
2
>>> 10//4.0  # 按精度高的运算（取整）
2.0

* --------- ② math.floor()取整

>>> import math
>>> math.floor(4.5)
4.0
>>> math.floor(4.9)
4.0
>>> math.floor(-4.9)
-5.0
>>> math.floor(-4.49)
-5.0

注：math.floor模块取整是以不大于这个数为依据。类似于高斯取整：

* --------- ③ math.trunc()取整

>>> math.trunc(4.35)  # 靠近原点
4
>>> math.trunc(4.85)
4
>>> math.trunc(-4.35)
-4
>>> math.trunc(-4.85)
-4

math.trunc()取整原则：向原点靠近。

* --------- ④ round()取整四舍五入取整

>>> round(3.14)
3
>>> round(3.84)         # 满足常规习惯：四舍五入
4
>>> round(-3.14)
-3
>>> round(-3.84)
-4

* 数值的进制转换

规则	二进制	八进制	十六进制
转入十进制	0b	0o	0x
十进制转出	bin( )	oct( )	hex( )

>>> 0o1
1
>>> 0b11   # 二进制转为十进制
3
>>> 0b110
6
>>> 0o71   # 八进制转为十进制
57
>>> 0x13
19
>>> 0x15   # 十六进制转为十进制
21

注：其他进制转换为十进制的数学方法：

0b110–>2²+2¹=6
0o71–>8*7+1=57
0x15–>16*1+5=21

>>> bin(31)  # 十进制转二进制
'0b11111'
>>> oct(31)   # 十进制转八进制
'0o37'
>>> hex(31)   # 十进制转十六进制
'0x1f'

注：十进制转换为其他进制的数学方法：

bin(31)–>2⁴+2³+2²+2¹+1–> 0b11111
oct(31)–>8*3+7–> 0o37
hex(31)–>16*1+15–> 0xf

import decimal 提高精度

>>> import decimal
>>> decimal.Decimal('1.2')
Decimal('1.2')
>>> decimal.Decimal('1.2')+decimal.Decimal('3.4')
Decimal('4.6')           # 导入decimal计算要比float精度高
>>> 1.2+3.4
4.6
>>> decimal.Decimal('1.1')+decimal.Decimal('2.2')
Decimal('3.3')
>>> 1.1+2.2
3.3000000000000003

6. 字符串

* --------- ① 转义

>>> word="what's your name?"
>>> word
>>> 'what\'s your name?' # 加入转义符
"what's your name?"

常见转义符： '\','\\','\n','\b','\t','\a'

>>> path='D:\桌面\new123.txt' # 路径选择
>>> path
'D:\\桌面\new123.txt'
>>> path='D:\\桌面\\new123.txt' # 可以用'\\'或者'\'表示
>>> path
'D:\\桌面\\new123.txt'
>>> path='D:\桌面\\new123.txt'
>>> path
'D:\\桌面\\new123.txt'
>>> path=r'D:\桌面\new123.txt'  # 路径前面加'r',意为根root，不被转义影响了
>>> path
'D:\\桌面\\new123.txt'

注：忽略转义符，加‘r’

def avg()...""""计算平均数""" ... pass

注：三引号注释与#井号注释的不同： 三引号注释不会被忽略掉，可生成说明性文档，后期可被调取

import math
help(math) # 调取math模块的说明

* --------- ② 字符串的输出方式

>>> print('abc')
abc
>>> print('ok')
ok
>>> print('ok'*5) #  简化步骤
okokokokok
>>> print('-'*5)
-----
>>> print('*'*5) # 简化步骤
*****