格式化字符串_列表_元组

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,*d=1,2,3,4,5,6,7
>>> a
1
>>> b
2
>>> c
3
>>> d
[4, 5, 6, 7]
>>> print(a,b,c,d,sep="$")
1$2$3$[4, 5, 6, 7]

格式化字符串

%号格式化

占位符

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

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

# print("%d" % 6688)
name="dyk"
age=18
print("His name is %s,his age is %d."%(name,age))
print("His name is",name,",his age is",age,".")
print("His name is" + name + ",his age is" + str(age) + ".")

结果：
His name is dyk,his age is 18.
His name is dyk ,his age is 18 .
His name isdyk,his age is18.

>>> a=100
>>> "%d%%"%a
'100%'

format格式化

（1）位置映射

print("{}:{}".format('dyk',18))
print("Name:{},age:{}".format('dyk',18))

结果：
dyk:18
Name:dyk,age:18

（2）关键字映射

print("Name:{},age:{}, {address}".format('dyk',18,address="Gongshu,Hangzhou"))
print("{address},Name:{},age:{}".format('dyk',18,address="Gongshu,Hangzhou"))

结果：
Name:dyk,age:18, Gongshu,Hangzhou
Gongshu,Hangzhou,Name:dyk,age:18

（3）元素访问

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

结果：
第一个元素是www.，第二个元素是google，第三个元素是com;第四个元素是baidu.,第五个元素是com.

%格式化和format格式化，字符串对齐

列表

列表使用方括号括起来的[]，每个元素以逗号分隔；

可以储存不同的数据类型数据

数组

特点：

• 是一个有序的

• 可以重复的

• 可变类型

创建

• 创建空列表

  li=[]
  print(type(li))

• 创建多元素列表

  li=[1,2,3,"abcd","city",["i","love","dyk"]]
  print((li,type(li)))

• 强转

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

（1）拼接

li1=["I"]
li2=["love","dyk"]
print(li1+li2)

结果：['I', 'love', 'dyk']

（2）重复

li2=["love","dyk"]
print(li2*3)

结果：
['love', 'dyk', 'love', 'dyk', 'love', 'dyk']

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

li=["C","i","t","y","City","College","Zhejiang",["City","College","Zhejiang"]]
print(len(li))
print((li[0],li[-7]))
print(li[:5])
print(li[::-1])
print(li[7][1])

结果：
8
('C', 'i')
['C', 'i', 't', 'y', 'City']
[['City', 'College', 'Zhejiang'], 'Zhejiang', 'College', 'City', 'y', 't', 'i', 'C']
College

（4）列表的常见操作

增删改查

1.增

• append()

  li = ["City", "College"]
  print(id(li))
  li1 = ["a", "b", "c"]
  li.append(li1)
  print((li, id(li)))
  li=["a","b"]
  print(id(li))
  
  结果：
  57044584
  (['City', 'College', ['a', 'b', 'c']], 57044584)
  56889832

• extend()

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

• insert()，按照索引添加

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

结果：
['City', ['a', 'b', 'c'], 'College']

2.改

li=["C","i","t","y","City","College","Zhejiang"]
li[1]="6666"
li[2:6]=["x","y","z"]
print(li)

结果：
['C', '6666', 'x', 'y', 'z', 'Zhejiang']

3.删

• pop()

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

  • 删除指定索引对应的元素

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

• remove()，移除第一次遇到的指定元素

  li=["a","b","c","d","e","city","e"]
  print(li.remove("e"))
  print(li)
  
  结果：
  None
  ['a', 'b', 'c', 'd', 'city', 'e']

• del

  li=["a","b","c","d","e","city","e"]
  del li[5]
  print(li)
  
  结果：
  ['a', 'b', 'c', 'd', 'e', 'e']

• clear()

li.clear()
print(li)

4.查

• 索引，切片

遍历

（1）元素遍历

li=["a","b","c"]
for i in li:
    print(i)
    
结果：
a
b
c

（2）索引遍历

li=["a","b","c"]
for i in range(len(li)):
    print(li[i])
    
结果：
a
b
c

（3）枚举遍历

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

li = ["a", "b", "c"]
for i in enumerate(li,2):
    print(i)

li = ["a", "b", "c"]
for index,value in enumerate(li,2):
    print(index,value)
    
li = ["a", "b", "c"]
for index,value in enumerate(li[:2],2):
    print(index,value)
结果：
(2, 'a')
(3, 'b')
(4, 'c')

2 a
3 b
4 c

2 a
3 b

堆和栈，用列表实现

• 计数，count(),查找元素出现的次数

• 反转，reverse()

  li=list("abcd")
  print(li)
  li.reverse()
  print(li)
  
  li=[["a","b","c"],["d","e"]]
  print(li)
  li.reverse()
  print(li)
  
  结果：
  ['a', 'b', 'c', 'd']
  ['d', 'c', 'b', 'a']
  
  [['a', 'b', 'c'], ['d', 'e']]
  [['d', 'e'], ['a', 'b', 'c']]

• 排序，sort()

  #按照ASCII码排序

  li=list("abcd")
  li.sort()
  print(li)
  li.sort(reverse=True)
  print(li)
  
  结果：
  ['a', 'b', 'c', 'd']
  ['d', 'c', 'b', 'a']

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

li = []
while True:
    inp = input("请输入元素： \t")
    if inp == "q":
        break
    else:
        li.append(inp)
print(li)

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

import random
list1 = []
list2 = []
for i in range(30):
    list1.append(random.randint(0, 10))
print(list1)

for i in range(11):
    list2.append([i, list1.count(i)])
print(list2)

结果：
[2, 0, 4, 5, 0, 5, 1, 7, 3, 0, 9, 5, 1, 10, 2, 3, 4, 7, 4, 5, 7, 7, 3, 4, 0, 3, 10, 3, 7, 8]
[[0, 4], [1, 2], [2, 2], [3, 5], [4, 4], [5, 4], [6, 0], [7, 5], [8, 1], [9, 1], [10, 2]]

赋值与深浅拷贝

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

la=[1,2,3,4,5,'a',['b1','b2']]
lb=la
print(la)
print(lb)
print(id(la),id(lb))
print(la is lb)

la[5]="aaa"
print(la)
print(lb)

结果：
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
[1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
52194760 52194760
True
[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]
[1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]

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

三种实现方法：

• 切片操作[ : ]

  la=[1,2,3,4,5,'a',['b1','b2']]
  lb=la
  lb2=la[:]
  print(id(la),id(lb),id(lb2))
  
  结果：
  58748200 58748200 58593648

• 工厂函数list(li)

• copy模块内的copy函数。

  浅拷贝#浅拷贝只能拷贝最外层，修改内层则原列表和新列表都会变化。

  import copy
  la=[1,2,3,4,5,'a',['b1','b2']]
  lb_copy=copy.copy(la)
  print(id(la),id(lb_copy))
  
  la.append('test')#添加原子类型，不会影响lb_copy
  print(la)
  print(lb_copy)
  
  import copy
  la=[1,2,3,4,5,'a',['b1','b2']]
  lb_copy=copy.copy(la)
  la[6][0]="bbb"
  print(la)
  print(lb_copy)
  结果：
  47447416 47539744
  
  [1, 2, 3, 4, 5, 'a', ['b1', 'b2'], 'test']
  [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]
  
  [1, 2, 3, 4, 5, 'a', ['bbb', 'b2']]
  [1, 2, 3, 4, 5, 'a', ['bbb', 'b2']]

  深拷贝#深拷贝是指将原列表完全克隆一份新的

  import copy
  la=[1,2,3,4,5,'a',['b1','b2']]
  lb_deepcopy=copy.deepcopy(la)
  print(la,id(la))
  print(lb_deepcopy,id(lb_deepcopy))
  
  la[6][1]="aaa"
  print(la)
  print(lb_deepcopy)
  
  结果：
  [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 47644224
  [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 47736512
  [1, 2, 3, 4, 5, 'a', ['b1', 'aaa']]
  [1, 2, 3, 4, 5, 'a', ['b1', 'b2']]

对象的引用

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

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

列表解析式

li=[]
for x in range(10):
    li.append(x)
print(li)

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

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

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

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

结果：
[22478, 24066, 23398, 38498]

格式：

[表达式 for 迭代元素 in 可迭代对象]
[exp for iter_val in iter]

实现原理：

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

三目运算符

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

带过滤功能格式

[exp for iter_val in iter if if_condition]

li=[]
for iter_val in iter:
    if if_condition:
        li.append(iter_val)
print(li)

name=["dyk","yhh"]
subject=["Python","Java","C","C++"]
li=[]
for i in name:
    for j in subject:
        li.append([i,j])
print(li)

print([[i,j] for i in name for j in subject])

结果：
[['dyk', 'Python'], ['dyk', 'Java'], ['dyk', 'C'], ['dyk', 'C++'], ['yhh', 'Python'], ['yhh', 'Java'], ['yhh', 'C'], ['yhh', 'C++']]
[['dyk', 'Python'], ['dyk', 'Java'], ['dyk', 'C'], ['dyk', 'C++'], ['yhh', 'Python'], ['yhh', 'Java'], ['yhh', 'C'], ['yhh', 'C++']]

元组

• 有序
• 可以重复的
• 不可更改

符号使用()

定义：

元组的创建

• 空元组的创建,不能添加元素

• 单元素元组的创建，需要在单元素后面添加逗号

• 多元素元组的创建，包含多种数据类型

（1）拼接

（2）重复

（3）索引（偏移） 切片

查

• 索引查

• 切片查

• index()

tp=(1,2,3,"a","b",["aa","bb","cc"])
print(tp.index("a"))#只能查看第一层
print(tp[5].index("aa"))

结果：3   0

增，不能

删,删除某个元素，不能；但可以全部删了

del tp
print(tp)

改

最大值、最小值

print(max(tp),min(tp))

遍历

• 元素遍历
• 索引遍历
• 枚举enymerate