Python基础练习——内置数据结构（列表list）

内置数据结构（变量类型）

• list
• set
• dict
• tuple ## list(列表）
• 一组由顺序的数据的组合
  • 创建列表
  • 空列表

In [1]:

# 1, 创建空列表
l1 = []
# type是内置函数，负责打印出变量的类型
print(type(l1))
print(l1)

# 2. 创建带值的列表
l2 = [100]
print(type(l2))
print(l2)

# 3. 创建列表，带多个值
l3 = [2,3,1,4,6,4,6]
print(type(l3))
print(l3)

# 4. 使用list()
l4 = list()
print(type(l4))
print(l4)

<class 'list'>
[]
<class 'list'>
[100]
<class 'list'>
[2, 3, 1, 4, 6, 4, 6]
<class 'list'>
[]

列表常用操作

• 访问
  • 使用下标操作（索引）
  • 列表的位置是从0开始
• 分片操作
  • 对列表进行任意一段的截取 l[:]

In [4]:

# 下标访问列表
l = [3,2,1,4,6,3,2]

print(l[3])

4

In [5]:

# 分片操作
# 注意截取的范围，包含左边的下标值，不包含右边的下标值
print(l[1:4])

# 下标值可以为空，如果不写，左边下标值默认为0， 右边下标值为最大数加一，即表示截取到最后一个数据
print(l[:])
print(l[:4])
print(l[2:])

[2, 1, 4]
[3, 2, 1, 4, 6, 3, 2]
[3, 2, 1, 4]
[1, 4, 6, 3, 2]

In [6]:

print(l)
# 分片可以控制增长幅度，默认增长幅度为1
print(l[1:6:1])

# 打印从下标1开始的数字，每次隔一个
print(l[1:6:2])

# 下标可以超出范围，超出后不在考虑多余下标内容
print(l[2:10])

# 下标值，增长幅度可以为负数
# 为负数，表明顺序是从右往左
# 规定： 数组最后一个数字的下标是-1

[3, 2, 1, 4, 6, 3, 2]
[2, 1, 4, 6, 3]
[2, 4, 3]
[1, 4, 6, 3, 2]

In [13]:

# 分片之负数下标
print(l)
# 下面显示的是为空，因为默认分片总是从左向右截取
# 即正常情况，分片左边的值一定小于右边的值
print(l[-2:-4])
print(l[-4:-2])
# 如果分片一定左边值比右边大，则步长参数需要使用负数
# 此案例为一个list直接正反颠倒提供了一种思路
print(l[-2:-6:-1])

[3, 2, 1, 4, 6, 3, 2]
[]
[4, 6]
[3, 6, 4, 1]

分片操作是生成一个新的list

• 内置函数id，负责显示一个变量或者数据的唯一确定编号

In [14]:

# 通过id可以直接判断出分片是从新生成了一份数据还是使用的同一份数据
l = [3,4,56,76,32,21,43,5]
ll = l[:]
lll = ll
# 如果两个id值一样，则表明分片产生的列表是使用的同一地址同一份数据
# 否则，则表明分片是从新生成了一份数据，即一个新的列表，然后把数值拷贝到新列表中
print(id(l))
print(id(ll))
print(id(lll))

# 通过id知道，ll和lll是同一份数据，验证代码如下
l[1] = 100
print(l)
print(ll)

ll[1] = 100
print(ll)
print(lll)

2192643634696
2192625806024
2192625806024
[3, 100, 56, 76, 32, 21, 43, 5]
[3, 4, 56, 76, 32, 21, 43, 5]
[3, 100, 56, 76, 32, 21, 43, 5]
[3, 100, 56, 76, 32, 21, 43, 5]

List(列表）

• 1.修改列表操作

    列表变量[索引位置] = 新值

• 2.删除列表操作

    del 列表变量[索引位置]

• 3.序列相加

    格式：列表 = 列表1 + 列表2
    结果：2个列表组成的新列表
    注意: + 两边必须都是列表才可以运算

• 4.列表相乘

    格式： 列表 = 列表1 * 整数
    结果：将列表重复N分组成新的列表
    注意： 数字必须为整数

• 5.成员资格运算

    格式：数据  in 列表
    作用：检测数据是否在列表当中
    返回值：布尔值
  
    格式：数据  not in 列表
    作用：检测数据是不是不再列表当中
    返回值：布尔值

In [15]:

# del 删除
a = [1,2,3,4,5,6]
del a[2]
print(a)

[1, 2, 4, 5, 6]

In [18]:

# del 删除
# 如果使用del之后，id的值和删除前不一样，则说明删除生成了一个新的list
a = [1,2,3,4,5,6]
print(id(a))
del a[2]
print(id(a))
print(a)

2192643992904
2192643992904
[1, 2, 4, 5, 6]

In [19]:

# 使用加号链接两个列表
a = [1,2,3,4,5]
b = [5,6,7,8,9]
d = ['a', 'b', 'c']
c = a + b + d
print(c)

[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 'a', 'b', 'c']

In [20]:

# 使用乘号操作列表
# 列表直接跟一个整数相乘 
# 相当于把n个列表接在一起
a = [1,2,3,4,5]
b = a *3
print(b)

[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

In [21]:

# 成员资格运算
# 就是判断一个元素是否在爱list里边
a = [1,2,3,4,5,6]
b = 8

#c 的值是一个布尔值
c = b in a
print(c)

b = 4
print(b in a)

False
True

In [22]:

# not in 
a = [1,2,3,4,5]
b = 9

print(b not in a)

True

列表的遍历

• 1.for ... in 遍历

    for i in 列表:
    print(i)

• 2.while循环遍历

    length = len(列表)
    i = 0
    while i < length:
        print(列表[i])
        i += 1

• 3.双层列表循环

    列表 = [[值1,值2],[值1,值2]，[值1,值2]...]
  
    格式： for 变量1,变量2 in 列表：
  
                可以使用变量1和变量2

In [26]:

# for in list
b = ["I love wangxiaojing"]

for i in b:
    print(i)

I love wangxiaojing

In [27]:

# 双层列表循环

#a 为嵌套列表，或者叫双层列表
a = [["one", 1], ["two", 2], ["three", 3] ]

for k,v in a:
    print(k, "--", v)

one -- 1
two -- 2
three -- 3

In [35]:

# while循环访问list
# 一般不用while遍历list
l = [1,2,3,4,5,6]
length = len(l)
i = 0
while i < length:
    print(l[i],end=',')
    i += 1

1,2,3,4,5,6,

列表内涵: list content

• 通过简单方法创作列表

        - 格式：[[变量 for [变量 in 列表]
        - 格式: [变量 for 变量 in 列表 判断条件]
        - 格式：[[变量1+变量2 for 变量1 in 列表1 for 变量2 in 列表2]

In [36]:

# for 创建
a = ['a', 'b', 'c']
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i for i in a]
print(b)

['a', 'b', 'c']

In [37]:

# 对a中所有元素乘以10，生成一个新list
a = [1,2,3,4,5]
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i*10 for i in a]
print(b)

[10, 20, 30, 40, 50]

In [38]:

# 还可以过滤原来list中的内容病放入新列表
# 比如原有列表a， 需要把所有a中的偶数生成新的列表b

a = [x for x in range(1,35)] #生成从1到34的一个列表
# 把a中所有偶数生成一个新的列表 b
b = [m for m in a if m % 2 == 0]
print(b)

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]

In [39]:

# 列表生成式可以嵌套
# 由两个列表a，b
a = [i for i in range(1,4)] # 生成list a
print(a)

b = [i for i in range(100,400) if i % 100 == 0]
print(b)

# 列表生成是可以嵌套,此时等于两个for循环嵌套
c = [  m+n for m in a for n in b]
print(c)

# 上面代码跟下面代码等价
for m in a:
    for n in b:
        print(m+n, end="  ")
print()



# 嵌套的列表生城市也可以用条件表达式
c = [  m+n for m in a for n in b if m+n < 250]
print(c)

[1, 2, 3]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
101  201  301  102  202  302  103  203  303  
[101, 201, 102, 202, 103, 203]

关于列表的常用函数

In [40]:

# len:求列表长度
a = [x for x in range(1,100)]
print(len(a))

# max:求列表中的最大值
# min： 同理
print(max(a))

b = ['man', 'film', 'python']
print(max(b))

99
99
python

In [41]:

# list：将其他格式的数据转换成list
a = [1,2,3]
print(list(a))

[1, 2, 3]

In [42]:

s = "I love wangxiaojing"
print(list(s))

['I', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'a', 'n', 'g', 'x', 'i', 'a', 'o', 'j', 'i', 'n', 'g']

In [43]:

# 把range产生的内容转换成list
print(list(range(12, 19)))

[12, 13, 14, 15, 16, 17, 18]

列表专用函数

• append() 在列表的最后追加新数据

  • 格式： 列表.append(数据)
  • 返回值：无
  • 注意：该操作直接改变原有列表

• insert() 在列表指定的位置插入数据

  • 格式：列表.insert（索引,数据）
  • 返回值：无
  • 注意：该操作直接改变原有列表

• pop() 在列表中移除一个元素

  • 格式：列表.pop()
  • 返回值:移除掉的元素

  • 注意：移除列表最后的元素

  • 格式：列表.pop(索引)

  • 返回值：:移除掉的元素

  • 注意：移除列表中指定索引的元素

  • 无论哪种格式都直接改变原有列表

• remove() 在列表中移除指定的值的元素

  • 格式:列表.remove(值)
  • 返回值：无
  • 注意：该操作直接改变原有列表

• clear() 清空列表

  • 格式：列表.clear()
  • 返回值：无
  • 注意：该操作直接改变原有列表

• reverse() 列表反转

  • 格式：列表.reverse（）
  • 返回值：无
  • 注意：该操作直接改变原有列表

• extend() 在原有列表最后追加新的序列

  • 格式:列表.extend(序列类型)
  • 返回值： 无
  • 注意：该操作直接改变原有列表

• count() 计算指定值在列表中出现的次数

  • 格式: 列表.count(值)
  • 返回值：整数

• copy() 复制原有列表

  • 格式: 列表.copy()
  • 返回值：新的列表