文章目录

格式化字符串%号格式化占位符 format格式化（1）位置映射（2）关键字映射（3）元素访问 列表（1）拼接（2）重复（3）索引（偏移）[] , 切片[ : ],[ : : ]（4）列表的常见操作增删改查 遍历堆和栈，用列表实现赋值与深浅拷贝 元组 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