Python基础知识（三）2021.2.2

数字格式化

• 浮点数 f
• 整数 d

可变字符串

在Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象，但是有时确实需要经常对字符串进行修改，可以使用io.StringIO()将其转换，或array模块。

>>> s = "I love you"
>>> sio = io.StringIO(s)
>>> sio
<_io.StringIO object at 0x0000021308EFF940>
>>> sio.getvalue()
'I love you'
>>> sio.seek(4)
4
>>> sio.write("h")
1
>>> sio.getvalue()
'I lohe you'

基本运算符

注意Python中比较运算符可以连用！

1. 比较运算符连用（very convenient）

>>> a = 3
>>> 1 < a <10
True

2. 位操作
   【左移1位相当于×2，右移一位相当于÷2】

>>> a = 0b11001
>>> b = 0b01000
>>> a|b
25
>>> bin(a|b)
'0b11001'
>>> bin(a&b)
'0b1000'
>>> bin(a^b)
'0b10001'
>>> a = 3
>>> a << 2
12
>>> a = 8
>>> a >> 2
2

3. 加法操作
   【1】数字相加
   【2】字符串拼接
   【3】列表、元组等合并

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]

4. 乘法操作
   无论对象是什么类型，乘法操作的本质就是复制
   【1】数字相乘
   【2】字符串相乘
   【3】列表、元组等复制

>>> [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

复合赋值运算符

与C和Java不一样，Python不支持自增(++)和自减(--)

运算符优先级问题（不需要强制记忆）

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

本章实操作业

1. 使用Python表示数学式

(5+10*x)/5 - 13*(y-1)*(a+b)/x + 9*( 5/x +(12+x)/y)

2. 从控制台输入用户的月薪，进行运算计算出年薪。打印输出用户的年薪
   注意：读入的内容为string类型，需要转换成int/float类型

>>> month = input("please input the month salary:")
please input the month salary: 10000
>>> year = 12 * month
>>> print(year)
 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000
>>> year = 12 * float(month)
>>> print(year)
120000.0

3. 使用字符串复制，用计算机打印出“爱你一百遍”，打印 100 次

a = ""
for i in range(100):
    a += "爱你一百遍 "
print(a)

a = []
for i in range(100):
    a.append("爱你一百遍")
print(a)

4. 将”to be or not to be”字符串倒序输出

>>> b = a[::-1]
>>> print(b)
eb ot ton ro eb ot

5. 将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出

>>> a = "sxtsxtsxtsxtsxt"
>>> a[::3]
'sssss'

6. 判断如下输出结果，并文字解释原因：

>>> a = "abd_33"
>>> b = "abd_33"
>>> c = "dd#" 
>>> d = "dd#" 
>>> a is b #输出 true or false? 
True
>>> c is d #输出 true or false? 
False

7. 写出如下代码打印的结果：

>>> c = "名字是{name}，年龄是{age}" 
>>> c.format(age=19,name='高淇')
名字是高淇，年龄是19

第三章 序列

序列是一种数据存储方式，用来存储一系列的整数。在内存中，序列就是一块用于存放多个值的连续的内存空间。Python中常用的序列结构有：字符串、列表、元组、字典、集合。如下图，序列中存储的是整数对象的地址ID，而不是整数对象的值。

列表

• 列表：用于存储任意数目、任意类型的数据集合。列表是内置可变【可以根据需要随时增减大小】序列，是包含多个元素的有序连续的存储空间。列表中的元素可以各不相同，也可以是任意类型。
• 列表对象的常用方法：
  
• 字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。

列表的创建方法（4种）

1. 基本语法创建

# 创建空列表
a = []
a = ["Cairo",2,6,"daga"]

2. list()创建【可以将其他类型的数据转换成列表】
   list可以将任何可迭代的数转换成列表

# 创建空列表
a = list()
a = list(range(10))
print(a)

b = list("gaoqi.sxt")
print(b)

【注】range(10)生成的是range类对象，但不是列表；经常用来转换字符串。

3. range()创建整数列表【重要】
   range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。
   语法格式为： range([start,] end [,step])

• start 参数：可选，表示起始数字。默认是 0
• end 参数：必选，表示结尾数字。
• step 参数：可选，表示步长，默认为 1
  python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其转换成列表对象.
  

4. 推导式生成列表
   使用列表推导式可以非常方便的创建列表，在开发中经常使用。

a = [x**2 for x in range(10)]
print(a)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

a = [x**2 for x in range(100) if x%9==0]
a
[0, 81, 324, 729, 1296, 2025, 2916, 3969, 5184, 6561, 8100, 9801]

列表元素的增加和删除

当列表增加和删除元素时，列表会自动进行内存管理。但这个特点涉及列表元素的大量移动，效率较低。除非必要，一般只在列表的尾部添加元素或者删除元素，这会大大提高列表的操作效率。

1. append方法
   原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
   

2. +运算符操作
   并不是真正的向尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样会涉及到大量的复制操作，对于操作大量元素不建议使用。
   用+=就是同一个地址，如下：
   

3. extend方法【两个列表合并，推荐使用这个！】
   将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。
   

4. insert插入元素
   使用 insert()方法可以将指定的元素插入到列表对象的任意指定位置。这样会让插入位置后 面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。
   

5. 乘法扩展
   使用乘法扩展生成一个新列表，新列表元素是原列表的多次重复。适用于乘法操作的还有：字符串、元组（list/tuple/string)
   

6. 列表元素的删除

【1】del删除
删除列表指定位置的元素。

a=[1,2,3,4]
del a[1]
a
[1, 3, 4]

底层原理实际也是数组的拷贝！

【2】pop方法

pop()删除并返回指定位置的元素，如果未指定位置则默认操作列表最后一个元素。
pop方法的参数是索引

【3】remove方法
删除首次出现的指定元素，若不存在该元素则抛出异常。
remove中的参数是列表元素，而不是index

列表元素的访问和计数

1. 通过索引直接访问元素
   在[0,len-1]范围内，超出范围抛出异常。
   

2. index()获得指定元素在列表中首次出现的索引
   index可以通过指定元素首次出现的索引位置。
   语法：index(value,[start,[end]])
   其中start和end可以省略，指定了搜索范围。

a = [1,2,2,3,4,5,2,4]
a.index(2)
1
a.index(2,2)
2
a.index(4,7)
7

3. count()获得指定元素在列表中出现的次数

count可以获得指定元素在列表中的出现次数。

a = [1,2,2,3,4,5,2,4]
a.count(2)
3

4. len()返回列表长度

a = [1,2,2,3,4,5,2,4]
len(a)
8

成员资格判断

判断列表中是否存在指定的元素，可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是一般使用in判断

切片操作

切片操作可以让我们快速提取子列表或修改。标准格式为：[起始偏移量:终止偏移量[:步长step]]
典型操作：


切片操作时，起始偏移量和终止偏移量不在正常范围内也不会报错，小于0当作0，大于len-1当成len-1

列表的遍历

a = [1,23,4,5]
for i in a:
    print(i)

复制列表所有的元素到新列表对象

直接令新的变量等于原变量并不能达到列表本身元素复制的效果，而只是两个变量指向同一个对象，如果想要进行复制，可以使用下面+[]的方法：

列表排序

1. 修改原列表，不创建新列表的排序

a.sort()# 默认升序排列
a.sort(reverse=True) # 降序排列

打乱顺序：

import random
random.shuffle(a)
a
[62, 6534, 42, 12, 6]

3. 建新列表的排序
   可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。

[6534, 62, 42, 12, 6]
id(a)
1827408973440
import random
random.shuffle(a)
a
[62, 6534, 42, 12, 6]
b = sorted(a)
id(b)
1827408970688
b
[6, 12, 42, 62, 6534]
c = sorted(b,reverse=True)
id(c)
1827409885184
c
[6534, 62, 42, 12, 6]

4. reversed()返回迭代器
   内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

a = [134,2,523,76]
b = reversed(a)
type(b)
<class 'list_reverseiterator'>
list(b)
[76, 523, 2, 134]
list(b)
[]

list_reverseiterator是一个迭代对象，使用list(b)进行输出时，发现只能使用1次，第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。

列表相关的其他内置函数汇总

1. max和min
2. sum
   对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。

a = [1,2,3,4]
max(a)
4
min(a)
1
sum(a)
10

多维列表

二维数组

一维数组可以帮助我们存储一维、线性的数据。
二维数组可以帮助我们存储二维、表格的数据。

元组tuple

列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的元素。因此，元组没有增减元素的相关方法。
元组支持如下操作：

1. 索引访问
2. slice操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：元组长度len()、最大值max()、最小值min()、求和sum()等

元组的创建（2种）

1. 通过（）创建元组，小括号可以省略

a = 13,456,2
a
(13, 456, 2)
b = (1,35,6)
c = (12,)
b
(1, 35, 6)
c
(12,)
type(c)
<class 'tuple'>

【注意】：tuple中若只有一个元素的话，需要在后面添加一个,，否则会被看成整数。
2. 通过tuple()创建元组【大多用于将其他内容转换成元组】

tuple(可迭代的对象)

# 创建一个空的元组
a = tuple()
a = tuple("abd")
a
('a', 'b', 'd')
tuple(range(4))
(0, 1, 2, 3)
tuple([134,546,334])
(134, 546, 334)

【总结】

1. tuple可以接收列表、字符串、其他序列类型、迭代器等生成元组。
2. list可以接收元组、字符串、其他序列类型、迭代器等生成列表。

元组的元素访问和计数（3)

1. 元组的元素不能修改
   

2. 元组的元素访问和列表一样，只不过返回的仍然是元组对象
   

3. 列表关于排序的方法list.sort()是修改原列表对象，元组没有该方法。如果对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象。
   

zip

将多个列表对应位置的元素组合成为元组，并返回这个zip对象。

zip(list1,list2,...)

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
list(d)
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]

>通常将zip对象再包装到list中！

生成器推导式创建元组

• 从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。

• 我们可以通过生成器对象，【1】转化成列表或者元组。也可以【2】使用生成器对象的__next__() 方法进行遍历，或者【3】直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象

【元组总结】

1. 元组的核心：不可变序列
2. 元组的访问和处理速度比列表快
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。