Python基础知识-pycharm版 第三节

可变字符串

String被视为immutable对象，默认情况下无法进行in-place操作。如果需要对字符串进行直接修改，请考虑以下方法：可被建议采用的方法包括io.StringIO类和array模块。

import io

s = "hello, sxt"

sio = io.StringIO(s)

sio.getvalue()

'hello, sxt'

sio.seek(7)

7

sio.write("g")

1

sio.getvalue()

'hello, gxt'

基本语法[]创建

a = [10,20,'gaoqi','sxt']

a = [] #创建一个空的列表对象

list()创建

使用 list()可以将任何可迭代的数据转化成列表。

a = list() #创建一个空的列表对象

a = list(range(10))

a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a = list("gaoqi,sxt")

a

['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']

range()创建整数列表

range([start,] end [,step])

start 参数：可选，表示起始数字。默认是 0

end 参数：必选，表示结尾数字。

step 参数：可选，表示步长，默认为 1

range()生成的是一个 range 对象而非列表类型；为了将其转换为列表形式，请使用 list()方法。

list(range(3,15,2))

[3, 5, 7, 9, 11, 13]

list(range(15,3,-1))

[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]

list(range(3,-10,-1))

[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

列表元素的增加和删除

我们一般只在列表的尾部添加元素或删除元素，提高列表的操作效率。

append()方法

原地修改列表对象，列表尾部添加新的元素。

a = [20,40]

a.append(80)

a

[20, 40, 80]

+运算符操作

生成一个新的列表对象；用于将原列表中的每个元素以及新生成的相应元素逐个复制到新生成的列表对象中。

a = [20,40]

id(a)

46016072

a = a+[50]

id(a)

46015432

变量 a 的地址发生了变化。也就是创建了新的列表对象。

extend()方法

将此目标列表的所有元素加入到当前列表的末尾部分属于就地操作无需生成新的数据结构

a = [20,40]

id(a)

46016072

a.extend([50,60])

id(a)

46016072

insert()插入元素

用于将指定元素插入到列表对象中的任意特定位置的操作会使得所有后续元素向前移动，并从而导致处理速度受到影响。

用于将指定元素插入到列表对象中的任意特定位置的操作会使得所有后续元素向前移动，并从而导致处理速度受到影响。

a = [10,20,30]

a.insert(2,100)

a

[10, 20, 100, 30]

乘法扩展

通过乘法扩展列表的方法来创建一个新的集合体。此集合体中的每一个元素均由原始集合体中的各个成员按指定倍数进行重复组合而成。

a = ['sxt',100]

b = a*3

a

['sxt', 100]

b

['sxt', 100, 'sxt', 100, 'sxt', 100]

del 删除

删除列表指定位置的元素。

a = [100,200,888,300,400]

del a[1]

a

[100,200,300,400]

pop()方法

pop()函数用于移除并返回指定索引位置的元素；如果没有指定索引，则默认从列表末尾移除元素。

a = [10,20,30,40,50]

a.pop() 50

a

[10, 20, 30, 40]

a.pop(1)

20

a

[10, 30, 40]

remove()方法

删除首次出现的指定元素，若不存在该元素抛出异常。

a = [10,20,30,40,50,20,30,20,30]

a.remove(20)

a

[10, 30, 40, 50, 20, 30, 20, 30]

通过索引直接访问元素

通过索引可以直接获取元素；其中索引值位于[0, 列表长度-1]这一确定范围内；当超出该范围时则无法进行有效的数据访问

会抛出异常。

a = [10,20,30,40,50,20,30,20,30]

a[2]

30

index()获得指定元素在列表中首次出现的索引

index()可用于获取特定元素第一次出现的位置。遵循以下语法：index(value, [start, [end]])。其中参数start和end定义了搜索范围

a = [10,20,30,40,50,20,30,20,30]

a.index(20)

1

a.index(20,3)

5

a.index(20,3) #从索引位置 3 开始往后搜索的第一个 20

5

a.index(30,5,7) #从索引位置 5 到 7 这个区间，第一次出现 30 元素的位置

6

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

count()可以返回指定元素在列表中出现的次数。

a = [10,20,30,40,50,20,30,20,30]

a.count(20)

3

len()返回列表长度

len()返回列表长度，即列表中包含元素的个数。

a = [10,20,30]

len(a)

3

成员资格判断

检查列表中是否包含某个特定的元素；我们可以通过调用count()方法来实现这一目标。若返回值为0，则说明该元素不存在；若返回值大于0，则表明该元素确实存在。可借助in关键字来进行判断；最终将得到True或False的结果。

a = [10,20,30,40,50,20,30,20,30]

20 in a

True

100 not in a

True

30 not in a

False

切片操作

该切片操作 slice operation允许我们高效地提取子列表并进行修改。其标准格式表示为[start:end:step]。

注：当步长省略时顺便可以省略第二个冒号

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

list1 = [30,40,50]

list2 = list1

仅仅是让 list2 同样指向了一个列表对象；换句话说, list1 和 list2 之间共享了地址值,并且一致地引用同一个列表对象;其内部元素并未进行复制

我们可以通过如下简单方式，实现列表元素内容的复制：

list1 = [30,40,50]

list2 = [] + list1

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

a = [20,10,30,40]

id(a)

46017416

a.sort() #默认是升序排列

a

[10, 20, 30, 40]

a = [10,20,30,40]

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

a

[40, 30, 20, 10]

import random

random.shuffle(a) #打乱顺序

a

[20, 40, 30, 10]

建新列表的排序

内置函数 sorted()进行排序，这个方法返回新列表，不对原列表做修改。

a = [20,10,30,40]

id(a)

46016008

a = sorted(a) #默认升序

a

[10, 20, 30, 40]

id(a)

45907848

a = [20,10,30,40]

id(a)

45840584

b = sorted(a) >>> b

[10, 20, 30, 40]

id(a)

45840584

id(b)

46016072

c = sorted(a,reverse=True) #降序

c

[40, 30, 20, 10]

reversed()返回迭代器

reversed()不对原列表做任何修改，返回一个逆序排列的迭代器对象。

a = [20,10,30,40]

c = reversed(a)

c

<list_reverseiterator object at 0x0000000002BCCEB8>

list(c)

[40, 30, 10, 20]

list(c)

[]

max 和 min

用于返回列表中最大和最小值。

[40, 30, 20, 10]

a = [3,10,20,15,9]

max(a)

20

min(a)

3

sum

对数值型列表的所有元素进行求和操作。

a = [3,10,20,15,9]

sum(a)

57

二维列表

a = [ ["高小一",18,30000,"北京"],

["高小二",19,20000,"上海"],

["高小一",20,10000,"深圳"],

]

print(a[1][0],a[1][1],a[1][2])

高小二 19 20000

元组 tuple

元组属于不可变序列，不能修改元组中的元素。

元组支持如下操作：

1. 索引访问

2. 切片操作

3. 连接操作

4. 成员关系操作

5. 比较运算操作

6. 计数：元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。

元组的创建

1. 通过()创建元组。小括号可以省略。

a = (10,20,30)

或者

a = 10,20,30

当一个元组仅包含一个元素时，则必须紧跟一个逗号以避免歧义。其原因在于Python解释器会将(1)识别为整数1，而(1,)则被解析为一个元组。

a = (1)

type(a)

<class 'int'>

a = (1,) #或者 a = 1,

type(a)

<class 'tuple'>

2. 通过 tuple()创建元组

tuple(可迭代的对象)

b = tuple() #创建一个空元组对象

b = tuple("abc")

b = tuple(range(3))

b = tuple([2,3,4])

总结：

tuple()被用来生成元组，并支持输入的参数包括列表、字符串和其他序列类型以及迭代器等结构。而list()则用于创建列表，并同样接受元组、字符串和其他序列类型以及迭代器作为输入参数。

元组的元素访问和计数

1. 元组的元素不能修改

a = (20,10,30,9,8)

a[3]=33

Traceback (most recent call last):

File "<pyshell#313>", line 1, in

a[3]=33

TypeError: 'tuple' object does not support item assignment

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

a = (20,10,30,9,8)

a[1]

10

a[1:3]

(10, 30)

a[:4]

(20, 10, 30, 9)

3. 列表有关列表排序的方法 list.sorted()会修改原始列表对象；而元组不具备这一功能。如果需要为元组进行排序，则只能用内置函数 sorted(tupleObj)来生成新的列表对象

a = (20,10,30,9,8)

sorted(a)

[8, 9, 10, 20, 30]

zip

zip函数能够将各个输入列表中的元素按照相应的位置配对生成元组，并返回该迭代对象

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

生成器推导式创建元组

基于小括号的结构上进行操作的小程序片段属于一种特定语法形式，在编程语言中通常被称为"generator expression"（生成器表达式）。这种语法形式与"list comprehension"（列表构造）不同，在语法层次上具有显著差异：前者仅用于创建迭代执行的行为序列而非存储静态的数据集合；后者则明确构造数据集合的具体元素并进行一次性计算。值得注意的是，在某些编程范例中可能混淆这两者之间的区别导致误解；因此在实际应用中应当严格区分两者的作用机制及其适用场景以避免潜在的逻辑错误和效率问题。

我们可以将生成器对象转化为列表或元组。另外一种方式是使用生成器对象的__next__()方法来进行遍历；另一种方式则是直接将其视为迭代器对象来使用。

无论采用何种方式使用，在进行元素访问之后（即完成一次元素访问后），若需再次访问其中的元素，则需重新创建该生成器对象。

元组总结

1. 元组的核心特点是：不可变序列。

2. 元组的访问和处理速度比列表快。

与整数和字符串同样地，在Python中元组也可以被用作字典的键。而列表绝对不可以被用作字典的键使用。