Python学习（列表）

一、列表

• 用方括号括起来的[ ]，每一个元素以逗号分割，可以储存不同的数据类型数据
• 特点：是一个有序的、可重复的、可变类型

1.1 创建

• 创建空列表

  li = []
  

• 创建多元素列表

  li = [1,2,3,"abcd",["1","2","3"]]
  

• 强转

  sr = "abcd"
  li = list(sr)
  print(li,type(li))	#['a', 'b', 'c', 'd'] <class 'list'>
  

1.2 拼接

li1 = ["I"]
li2 = ["Love"]
print(li1 + li2)	#['I', 'Love']

1.3 重复

li2 = ["Love"]
print(li2*3)	#['Love', 'Love', 'Love']

1.4 索引（偏移）[ ] ，切片 [ : ] ,[ : : ]

li = ["C","i","t","y","city"]
print(li[0])	#C
print(li[:2])	#['C', 'i']
print(li[::-1])	#['city', 'y', 't', 'i', 'C']
print(li[4][2])	#t

1.5 列表的常见操作

1.5.1 增

• append( )：整体加入
• extend( )：按元素加入
• insert( )：按照索引添加
• 通过索引增加，单不能超过已有索引的最大值

li = ["City", "College"]
li1 = ["a", "b", "c"]
li.append(li1)
print(li)  # ['City', 'College', ['a', 'b', 'c']]

li = ["City", "College"]
li1 = ["a", "b", "c"]
li.extend(li1)
print(li)  # ['City', 'College', 'a', 'b', 'c']

li = ["City", "College"]
li1 = ["a", "b", "c"]
li.insert(1, li1)
print(li)  # ['City', ['a', 'b', 'c'], 'College']

li1 = ["a", "b", "c"]
li1[1:1] = [1, 2, 3]
print(li1)  # ['a', 1, 2, 3, 'b', 'c']

1.5.2 删

• pop( )：返回被删除的元素

  • 如果不指定索引，默认删除最后一个元素
  • 删除指定索引对应的元素

• remove( )：移除第一次遇到的指定元素，无返回值

• del list[ ]：默认删除整个列表，有索引参数则删除该索引对应的元素

• clear()：清空整个列表

li = ["a", "b", "c", "d", "e"]
li.pop()
print(li)  # ['a', 'b', 'c', 'd']
li.pop(2)
print(li)  # ['a', 'b', 'd']

li = ["a", "b", "c", "d", "e", "c"]
li.remove("c")
print(li)  # ['a', 'b', 'd', 'e', 'c']

li = ["a", "b", "c", "d", "e", "c"]
del li[2]
print(li)  # ['a', 'b', 'd', 'e', 'c']

li = ["a", "b", "c", "d", "e", "c"]
li.clear()
print(li)  # []

1.5.3 改

按照索引或切片直接修改

li1 = ["a", "b", "c"]
li1[2] = "6666"
print(li1)  # ['a', 'b', '6666']
li1[1:2] = ["x", "y", "z"]
print(li1)  # ['a', 'x', 'y', 'z', '6666']

1.5.4 查

按照索引、切片、遍历查找

遍历：

• 元素遍历
• 索引遍历
• 枚举遍历：enumerate( )，对于一个可迭代/可遍历的对象（如列表、字符串等），将其组成一个索引序列，利用它，我们可以同时获得索引和值

# 元素遍历
li = ["a", "b", "c", "d", "e", "c"]
for i in li:
    print(i, end=" ")
# a b c d e c

# 索引遍历
li = ["a", "b", "c", "d", "e", "c"]
for i in range(len(li)):
    print(li[i], end=" ")
# a b c d e c

# 枚举遍历
li = ["a", "b", "c", "d", "e", "c"]
for i in enumerate(li, 2):
    print(i, end=" ")
# (2, 'a') (3, 'b') (4, 'c') (5, 'd') (6, 'e') (7, 'c')
li = ["a", "b", "c", "d", "e", "c"]
for index, value in enumerate(li, 2):
    print(index, value, end=" ")
# 2 a 3 b 4 c 5 d 6 e 7 c

练习：

1.input( )函数实现往空列表中添加元素，当输入“q”的时候，结束输入，并返回列表。

2.随机生成30个1`10的随机整数，并统计每个数出现的次数，返回的结果形式为[[0,3],[1,4]…]

#1
li = []
while True:
    sr = input("请输入元素（输入“q”表示结束）：")
    if sr == 'q':
        break
    else:
        li.append(sr)
print(li)

#2 方法一
import random
rand_int = []
result_li = []
for i in range(30):
    rand_int.append(random.randint(0,10))
for i in range(0,11):
    result_li.append([i,rand_int.count(i)])
print(result_li)

#2 方法二
import random
li = [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [5, 0], [6, 0], [7, 0], [8, 0], [9, 0], [10, 0]]
for i in range(30):
    num = random.randint(0, 10)
    li[num][1] += 1
print(li)

1.6 赋值与深浅拷贝

• 赋值赋值是对对象的引用

la = [1,2,3,4,5,'a',['b1','b2']]
lb = la
print(id(la))   #1915507906504
print(id(lb))   #1915507906504
la[5] = "aaa"
print(la)       #[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]
print(lb)       #[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]

• 浅拷贝会创建新对象，内容是原对象的引用

  三种实现方法：

  • 切片操作[ : ]

  • 工厂函数list(li)

  • copy模块内的copy函数

    la = [1,2,3,4,5,'a',['b1','b2']]
    lb2 = la[:]
    print(id(la))       #2784803493960
    print(id(lb2))      #2784804309832
    
    import copy
    lb_copy = copy.copy(la)
    print(id(la))       #2784803493960
    print(id(lb_copy))  #2784805803720
    
    la.append("test")	#添加原子类型，不会影响lb_copy和lb2
    print(la)           #[1, 2, 3, 4, 5, 'a', ['b1', 'b2'], 'test']
    print(lb2)          #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
    print(lb_copy)      #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
    
    la[5] = 'aaa'
    print(la)       #[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]
    print(lb_copy)  #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
    
    la[6][1] = 'bbb'
    print(la)       #[1, 2, 3, 4, 5, 'aaa', ['b1', 'bbb']]
    print(lb_copy)  #[1, 2, 3, 4, 5, 'a', ['b1', 'bbb']]
    

• 深拷贝

  import copy
  la = [1,2,3,4,5,'a',['b1','b2']]
  lb_deepcopy = copy.deepcopy(la)
  print(id(la))           #2351498155784
  print(id(lb_deepcopy))  #2351498157064
  
  la[5] = 'aaa'
  print(la)               #[1, 2, 3, 4, 5, ['aaa'], ['b1', 'b2']]
  print(lb_deepcopy)      #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
  
  la[6][1] = 'bbb'
  print(la)               #[1, 2, 3, 4, 5, 'aaa', ['b1', 'bbb']]
  print(lb_deepcopy)      #[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
  

浅拷贝相当于我们只拷贝了一层，修改外层元素，就会修改引用，让它们指向另一个位置；修改嵌套列表的元素，列表地址没有发生变化，指向的还是同一个位置

深拷贝拷贝对象的所有元素，包括多层嵌套的元素。因此，是开辟了一个新的内存储存区，和数据源没有关系了

1.7 列表解析式和列表生成式

格式：

[exp for iter_val in iter]

列表生成式：用来生成列表的特定的语法形式

sr = "城市学院"
print([ord(x) for x in sr])

实现原理：

迭代 iter 中的每一个元素，每迭代一次的结果赋值给 iter_val ，再通过 exp 运算得到一个新的值，最后所有通过表达式计数的值以一个列表的形式返回

补充:

三目运算符

y = 10
x = y + 1 if y > 10 else y - 1
print(x)

带过滤功能格式

[exp for iter_val in iter if if_condtiom]

如：

print([i for i in range(10) if i % 2 == 0])

嵌套

name = ["Tom","Jack","Lucy"]
subject = ["Python","Java","C","C++"]
print([[i,j] for i in name for j in subject])

二、语句补充

2.1 print()函数查看帮助文件

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

语法格式

 print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

等价于

print(value1,value2,...,valuen,sep=' ', end='\n', file=sys.stdout, flush=False)

如：

a,b,c = 1,2,3
print(a,b,c,sep = '*')		#1*2*3
for i in range(3):
    print(i,end = '*')		#0*1*2*

2.2 格式化字符串

%号格式化

print("%d" % 666)       #666
print("His name is %s, his age is %d." % ("Tom", 18))       #His name is Tom, his age is 18.
print("His name is ","Tom", "his age is",18,".")            #His name is  Tom his age is 18 .
print("His name is "+"Tom"+ "his age is"+str(18)+".")       #His name is Tomhis age is18.

占位符

格式	描述
%d	有符号的整数
%s	字符串
%c	字符及ASCII码
%o	无符号八进制整数
%x/%X	无符号十六进制整数
%e/%E	浮点数，科学计数法
%f	浮点数

% 格式化字符串 用%匹配参数，注意个数一一对应

print("%d%%"%100)		#100%

2.3 format格式化

• 位置映射

print("{}:{}".format('Tom',18))                 #Tom:18
print("name:{},age:{}".format('Tom',18))        #name:Tom,age:18

• 关键字映射

print("name:{},age:{},{address}".format('Tom', 18, address="Hangzhou"))  # name:Tom,age:18,Hangzhou

• 元素访问

print("第一个元素是{0[0]},第二个元素是{0[1]},第三个元素是{0[2]},\
第四个元素是{1[0]}.".format(('www.','google.','com'),("baidu.","com")))
#第一个元素是www.,第二个元素是google.,第三个元素是com,第四个元素是baidu..