文章目录

Print()函数查看帮助文件格式化字符串%号格式化占位符 fotmat格式化（1）位置映射（2）关键字映射（3）索引 列表创建（1）拼接（2）重复（3）索引（偏移）[],切片[:],[::]（4）列表的常见操作 赋值与深浅拷贝赋值深浅拷贝 列表解析式元组元组的创建

Print()函数查看帮助文件

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, ..., sep=' ', end='\n', file=sys.stdout, flush=False) a, b, c, *d = 1, 2, 3, 4, 5, 6 print(a, b, c, d) for i in range(5): print(i, end=" ") print(i, end="#")

格式化字符串

%号格式化

占位符

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

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

x = 230000.0 print("%e" % x) print("%f" % x) print("%d%%" % x)#注意%个数 print("%o" % 21) 2.300000e+05 230000.000000 230000% 25

fotmat格式化

（1）位置映射

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

（2）关键字映射

print("Name:{},age:{}，{address}".format('Tom', '18', address="Gongshu,Hangzhou")) #关键字内容要放在后面

（3）索引

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

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

列表

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

可以储存不同的数据类型

特点

是一个有序的可以重复的可变类型

创建

创建空列表

li = [] print(type(li)) <class 'list'>

创建多元列表

li = [1, 2, 3, "abcd", "City", "College", ["I", "love", "python"]]

强转

sr = "abcd" li = list(sr) print((li,type(li)))

（1）拼接

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

（2）重复

print(li2*3)

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

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

（4）列表的常见操作

增删改查

增

append()

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

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.extend(li1) print(li) li.insert(1,li1) print(li)

2.删

pop()

如果不指定索引，默认删除最后一个元素删除指定索引对应的元素 li = ["a","b","c","d","e"] print(li.pop()) print(li) e ['a', 'b', 'c', 'd'] 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)

clear()

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

3.查

索引，切片

遍历

（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（），对于一个可迭代的/可遍历的对象（如列表，字符串等），enumberate（）将其组成一个索引序列，利用它，我们可以同时获得索引和值

li = ["a", "b", "c"] for i in enumerate(li): print(i) (0, 'a') (1, 'b') (2, 'c') li = ["a", "b", "c"] for i in enumerate(li,1): print(i) (1, 'a') (2, 'b') (3, 'c') li = ["a", "b", "c"] for index, value in enumerate(li, 1): print(index, value) 1 a 2 b 3 c li = ["a", "b", "c"] for index, value in enumerate(li[:2], 1): print(index, value) 1 a 2 b

堆和栈，用列表实现

其他操作

计数，count（），查找元素出现的次数

反转，reverse（）必须同一种数据类型

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

排序，sort（）

按照ASCII码排序

li = list("abcd") print(li) li.reverse() print(li) li.sort(reverse=True) print(li) ['a', 'b', 'c', 'd'] ['d', 'c', 'b', 'a'] ['d', 'c', 'b', 'a'] li1 = ["a", "b", "c", "d"] li2 = ["c", "d", "e", "f"] # 输出，两个表的交集 for i in li1: for j in li2: if i == j: print(i) c d

input（）函数实现往空列表中添加元素，但输入“q“的时候，结束输入，并返回列表

li = [] while True: x = input() if x == "q": break li.append(x) print(li)

随机生成30个0-10的随机整数，并统计每个数出现的个数，

返回结果的形式为[[0,3],[1,4],…,[10,5]]

import random li = [] for i in range(0, 11): li.append([i]) li[i].append(0) for i in range(0, 30): a = random.randint(0, 10) for j in range(0, 11): if a == j: li[j][1] += 1 print(li) import random #li.count（x）是计算列表中x的个数 rand_int = [] result_li = [] for i in range(30): rand_int.append(random.randint(0, 10)) print(rand_int) sum = 0 for i in range(0, 11): result_li.append([i, rand_int.count(i)]) sum += rand_int.count(i) print(result_li) print(sum)

赋值与深浅拷贝

赋值

赋值是对对象的引用

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']] 4326256584 4326256584 True [1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']] [1, 2, 3, 4, 5, 'aaa', ['b1', 'b2']]

深浅拷贝

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

三种实现方法：

切片方法[:]工厂函数list(li)copy模块内的copy函数。 la = [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] lb = la lb2 = la[:] print(id(la), id(lb2)) import copy lb_cpoy = copy.copy(la) print(id(la), id(lb_cpoy)) la.append('test')#添加原子类型，不会影响lb_cpoy print(la) print(lb_cpoy) 4326256584 4328216136 4326256584 4328467720 [1, 2, 3, 4, 5, 'a', ['b1', 'b2'], 'test'] [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] import copy lb_cpoy = copy.copy(la) print(id(la), id(lb_cpoy)) la.append('test') la[5] = "aaa"#不变 la[6][0]="bbb"#会变 print(la) print(lb_cpoy) 4326256584 4328216136 4326256584 4328467912 [1, 2, 3, 4, 5, 'aaa', ['bbb', 'b2'], 'test'] [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[5] = ["aaa"] la[6][1] = ["aaa"] print(la) print(lb_deepcopy) [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 4328466568 [1, 2, 3, 4, 5, 'a', ['b1', 'b2']] 4337123272 [1, 2, 3, 4, 5, ['aaa'], ['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]

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

x = "城市学院" print([ord(x) for x in x]) name = ["Tom", "Jack", "Lucy"] 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]) [['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Lucy', 'Python'], ['Lucy', 'Java'], ['Lucy', 'C'], ['Lucy', 'C++']] [['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Lucy', 'Python'], ['Lucy', 'Java'], ['Lucy', 'C'], ['Lucy', 'C++']]

格式：

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

实现原理：

迭代[可迭代对象]中的每一个元素每迭代一次的结果赋值给对应的迭代元素，再通过表达式运算得到一个新的值最后所有通过表达式计算的值以一个列表的形式返回

三目运算符

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

带过滤功能格式

[exp for iter_val in iter if if_condyion]

元组

有序可重复不可更改

符号使用（）

定义：x =（a,b,c）

元组的创建

空元组创建

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

tp1 = ("abc") tp2 = ("abc",) print(type(tp1)) print(type(tp2)) <class 'str'> <class 'tuple'>

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

拼接

tp1 = ("abc",) tp2 = ("abc",) print(tp2+tp1) ('abc', 'abc')

重复

tp2 = ("abc",) print(tp2*3) ('abc', 'abc', 'abc')

索引（偏移） 切片

tp2 = ("abc", "sdf", "sad") print(tp2[1]) print(tp2[:2]) sdf ('abc', 'sdf')

元组内部的列表可以改变

tp2 = ("abc", "sdf", "sad", ["aa", "bb", "cc", "dd"]) tp2[3][0]="123" print(tp2) ('abc', 'sdf', 'sad', ['123', 'bb', 'cc', 'dd'])

索引查

切片查

index（）

tp2 = ("abc", "sdf", "sad", ["aa", "bb", "cc", "dd"]) tp2[3][0]="123" print(tp2) print(tp2.index("sad")) ('abc', 'sdf', 'sad', ['123', 'bb', 'cc', 'dd']) 2

增 不能

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

tp2 = ("abc", "sdf", "sad", ["aa", "bb", "cc", "dd"]) print(tp2) del tp2 print(tp2) ('abc', 'sdf', 'sad', ['aa', 'bb', 'cc', 'dd']) Traceback (most recent call last): File "/Users/shaojun/PycharmProjects/7.18/8.py", line 5, in <module> print(tp2) NameError: name 'tp2' is not defined

最大值,最小值

tp = ("a", "b", "c") print("a" in tp) print(max(tp)) print(min(tp)) True c a

遍历

元素遍历

tp = ("a", "b", "c") for i in tp: print(i) a b c

索引遍历

tp = ("a", "b", "c") for i in range(len(tp)): print(tp[i]) a b c

枚举enumerate

tp = ("a", "b", "c") for i in enumerate(tp): print(i) (0, 'a') (1, 'b') (2, 'c')