一、学习知识点概要
Task2主要的内容是学习python的数据结构,主要的知识内容有:
- 列表(增删查改,操作符,常用的方法)
- 元组(增删查改,操作符,常用的方法)
- 字符串(增删查改,操作符,常用的方法)
- 字典(增删查改,操作符,常用的方法)
- 集合(增删查改,操作符,常用的方法)
- 序列通用的方法
二、学习内容
1. 列表
定义
列表是有序集合,没有固定大小,能够保存任意数量任意类型的 Python 对象
,因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]
,也有3个指针和3个整数对象。
x = [a] * 4
操作中,如果a是容器类型,则4个a只会有同一个指针,所以修改a里面的内容,其他三个a都会随之改变。
x = [[1] * 3] * 4
# [[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]]
x[0][0] = 2
# [[2, 1, 1], [2, 1, 1], [2, 1, 1], [2, 1, 1]]
创建列表
-
利用range()和list创建列表
x = list(range(10)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
利用推导式创建列表
x = [0 for i in range(5)] # [0, 0, 0, 0, 0]
添加元素
-
list.append(obj)
在列表末尾添加新的对象,参数可以是任何数据类型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] x.append('Thursday') # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
-
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] x.extend(['Thursday', 'Sunday']) # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
-
list.insert(index, obj)
在编号
index
位置插入obj
。x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] x.insert(2, 'Sunday') # ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
删除元素
-
list.remove(obj)
移除列表中某个值的第一个匹配项
-
list.pop([index=-1])
移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
-
del var1[, var2 ……]
删除单个或多个对象。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] del x[0:2] print(x) # ['Wednesday', 'Thursday', 'Friday']
如果你要从列表中删除一个元素,且不再以任何方式使用它,就使用
del
语句;如果你要在删除元素后还能继续使用它,就使用方法pop()
。
获取元素
-
通过元素的索引值,从列表获取单个元素。
-
通过切片
通用写法是
start : stop : step
,所有指定stop的切片都不会切到stop的位置。-
start :
以
step
为 1 (默认) 从编号start
往列表尾部切片 -
: stop
以
step
为 1 (默认) 从列表头部往编号stop
切片。 -
start : stop
以
step
为 1 (默认) 从编号start
往编号stop
切片。 -
start : stop : step
以具体的
step
从编号start
往编号stop
切片。注意最后把step
设为 -1,相当于将列表反向排列。 -
:
复制列表中的所有元素(浅拷贝)。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] print(week[:]) # ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
-
列表常用的操作符
-
等号操作符:
==
只有成员、成员位置都相同时才返回True。
list1 = [123, 456] list2 = [456, 123] list3 = [123, 456] print(list1 == list2) # False print(list1 == list3) # True
-
连接操作符
+
相当于extend()
list4 = list1 + list2 # extend() print(list4) # [123, 456, 456, 123]
前面三种方法(
append
,extend
,insert
)可对列表增加元素,它们没有返回值,是直接修改了原数据对象。 而将两个list相加,需要创建新的 list 对象,从而需要消耗额外的内存,特别是当 list 较大时,尽量不要使用 “+” 来添加list。 -
重复操作符
*
复制拼接
list5 = list3 * 3 print(list5) # [123, 456, 123, 456, 123, 456]
-
成员关系操作符
in
、not in
其他方法
-
list.count(obj)
统计某个元素在列表中出现的次数
-
list.index(x[, start[, end]])
从列表中找出某个值第一个匹配项的索引位置
-
list.reverse()
反向列表中元素
-
list.sort(key=None, reverse=False)
对原列表进行排序。
key
– 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。reverse
– 排序规则,reverse = True
降序,reverse = False
升序(默认)。
# 获取列表的第二个元素 def takeSecond(elem): return elem[1] x = [(2, 2), (3, 4), (4, 1), (1, 3)] x.sort(key=takeSecond) print(x) # [(4, 1), (2, 2), (1, 3), (3, 4)]
2. 元组
定义
与列表相似,不同之处元组(tuple)被创建后不能修改类似于字符串
创建元组
-
可以用小括号 (),也可以什么都不用
t1 = (1, 10.31, 'python') t2 = 1, 10.32, 'python' # (1, 10.31, 'python') <class 'tuple'> # (1, 10.32, 'python') <class 'tuple'>
-
一个元素的元组后面需要添加逗号,否则括号会被当做运算符使用
x = (1,) print(type(x)) # <class 'tuple'>
修改元组
元组有不可更改 (immutable) 的性质,因此不能直接给元组的元素赋值,但如果元素(list)可更改 (mutable),那就可以更改其元素
t1 = (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
# (1, 2, 3, [9, 5, 6])
操作符
==
,+
,*
,in
,not in
,其作用都跟list一样。
内置方法
-
count
记录该元素在元组中出现几次
t = (1, 10.31, 'python') print(t.count('python')) # 1
-
index
返回该元素在元组的索引值
print(t.index(10.31)) # 1
解压
解压也适用于其他容器类型
-
解压元组(变量<=元组个数)
# 一维 t = (1, 10.31, 'python') (a, b, c) = t print(a, b, c) # 1 10.31 python # 二维 t = (1, 10.31, ('OK', 'python')) (a, b, (c, d)) = t print(a, b, c, d) # 1 10.31 OK python
-
解压元组其中几个元素,用通配符[*]
t = 1, 2, 3, 4, 5 a, b, *rest, c = t print(a, b, c) # 1 2 5 print(rest) # [3, 4] <class 'list'>
3. 字符串
定义
字符串具有不可修改性。使用成对的双引号和单引号定义单行字符串,使用成对的三引号(""" “”")定义跨多行的字符串
转义字符
转义字符 | 描述 |
---|---|
\\ | 反斜杠符号 |
\' | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 横向制表符(TAB) |
\r | 回车 |
在字符串前加r,就能得到原始字符串
print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help
内置方法
-
capitalize()
将字符串的第一个字符转换为大写。
str2 = 'xiaoxie' print(str2.capitalize()) # Xiaoxie
-
lower()
转换字符串中所有大写字符为小写。
-
upper()
转换字符串中的小写字母为大写。
-
swapcase()
将字符串中大写转换为小写,小写转换为大写。
-
count(str[, start=0,end=len(string)])
返回
str
在 string 里面出现的次数,start默认为0,end默认为字符串长度。同下。 -
endswith(suffix[, start=0, end=len(string)])
检查字符串是否以指定子字符串
suffix
结束,如果是,返回 True,否则返回 False。 -
startswith(substr[, start=0,end=len(string)])
检查字符串是否以指定子字符串
substr
开头,如果是,返回 True,否则返回 False。 -
find(str[, start=0, end=len(string)])
,rfind(str[, start=0,end=len(string)])
find:检测
str
是否包含在字符串中,如果包含,返回开始的索引值,否则返回 -1。rfind:类似于
find()
函数,不过是从右边开始查找。 -
isnumeric()
如果字符串中只包含数字字符,则返回 True,否则返回 False。
-
ljust(width[, fillchar])
,rjust(width[, fillchar])
ljust:使用
fillchar
(默认空格)从左到右填充至长度width
的新字符串。rjust:使用
fillchar
(默认空格)从右到左填充至长度width
的新字符串。str4 = '1101' print(str4.ljust(8, '0')) # 11010000 print(str4.rjust(8, '0')) # 00001101
-
lstrip([chars])
,rstrip([chars])
,strip([chars])
lstrip:删除字符串左边的空格或指定字符。
rstrip:删除字符串右边的空格或指定字符。
strip:执行
lstrip()
和rstrip()
。 -
partition(sub)
,rpartition(sub)
partition:将字符串分为一个三元组
(pre_sub,sub,fol_sub)
,如果字符串中不包含sub则返回('原字符串','','')
。rpartition:类似于
partition()
方法,不过是从右边开始查找。str5 = ' I Love LsgoGroup ' print(str5.strip().partition('o')) # ('I L', 'o', 've LsgoGroup') print(str5.strip().partition('m')) # ('I Love LsgoGroup', '', '') print(str5.strip().rpartition('o')) # ('I Love LsgoGr', 'o', 'up')
-
replace(old, new [, max])
字符串中的
old
替换成new
,如果max
指定,则替换不超过max
次。 -
split([str="", num])
默认以空格分割字符串,返回分割后的子字符串列表。num表示分割次数。
u = "www.baidu.com.cn" # 分割0次 print((u.split(".", 0))) # ['www.baidu.com.cn'] # 分割一次 print((u.split(".", 1))) # ['www', 'baidu.com.cn']
-
splitlines([keepends])
按照行(’\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,
keepends
为 False,不包含换行符,如果为 True,则保留换行符。str6 = 'I \n Love \n LsgoGroup' print(str6.splitlines()) # ['I ', ' Love ', ' LsgoGroup'] print(str6.splitlines(True)) # ['I \n', ' Love \n', ' LsgoGroup']
-
maketrans(intab, outtab)
,translate(table[, deletechars=""])
maketrans:创建字符映射的转换表。intab表示需要转换的字符,outtab表示字符转换的目标。
translate:根据参数
table
给出的表,转换字符串的字符;deletechars为过滤掉的字符。str7 = 'this is string example....wow!!!' intab = 'aeiou' outtab = '12345' trantab = str7.maketrans(intab, outtab) print(trantab) # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51} print(str7.translate(trantab)) # th3s 3s str3ng 2x1mpl2....w4w!!!
字符串格式化
-
format
格式化函数str8 = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数 print(str8) # I Love Lsgogroup str8 = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数 print(str8) # I Love Lsgogroup str8 = "{0} Love {b}".format('I', b='Lsgogroup') # 位置参数要在关键字参数之前 print(str8) # I Love Lsgogroup str8 = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位 print(str8) # 27.66GB
-
Python 字符串格式化符号
符 号 描述 %c 格式化字符及其ASCII码 %s 格式化字符串,用str()方法处理对象 %r 格式化字符串,用rper()方法处理对象 %d 格式化整数 %o 格式化无符号八进制数 %x, %X 格式化无符号十六进制数(X为大写) %f 格式化浮点数字,可指定小数点后的精度 %e, %E 用科学计数法格式化浮点数 %g, %G 根据值的大小决定使用%f或%e print('%c' % 97) # a print('%c %c %c' % (97, 98, 99)) # a b c print('%d + %d = %d' % (4, 5, 9)) # 4 + 5 = 9 print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁! print('%o' % 10) # 12 print('%x' % 10) # a print('%X' % 10) # A print('%f' % 27.658) # 27.658000 print('%e' % 27.658) # 2.765800e+01 print('%E' % 27.658) # 2.765800E+01 print('%g' % 27.658) # 27.658 text = "I am %d years old." % 22 print("I said: %s." % text) # I said: I am 22 years old.. print("I said: %r." % text) # I said: 'I am 22 years old.'
-
格式化操作符辅助指令
符号 功能 m.n
m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) -
用作左对齐 +
在正数前面显示加号( + ) #
在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) 0
显示的数字前面填充’0’而不是默认的空格 print('%5.1f' % 27.658) # ' 27.7' print('%.2e' % 27.658) # 2.77e+01 print('%10d' % 10) # ' 10' print('%-10d' % 10) # '10 ' print('%+d' % 10) # +10 print('%#o' % 10) # 0o12 print('%#x' % 108) # 0x6c print('%010d' % 5) # 0000000005
4.字典
定义
字典 是无序的 键(key) : 值(value) 对集合。键是任意不可变类型,通常用字符串或数值。
如何分辨数据类型是不是可变类型?
-
id(X)
函数对 X 进行某种操作,比较操作前后的
id
,如果不一样,则X
不可变,如果一样,则X
可变。i = 1 print(id(i)) # 140732167000896 i = i + 2 print(id(i)) # 140732167000960 l = [1, 2] print(id(l)) # 4300825160 l.append('Python') print(id(l)) # 4300825160
-
hash(X)
函数只要不报错,证明
X
可被哈希,即不可变,反过来不可被哈希,即可变。
不可变类型:数值、字符和元组
可变类型:列表、集合、字典
创建字典
-
构造函数
dict()
创建一个空的字典。dic = dict() dic['a'] = 1 dic['b'] = 2 dic['c'] = 3 print(dic) # {'a': 1, 'b': 2, 'c': 3}
-
dict(mapping)
dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)]) print(dic1) # {'cherry': 4098, 'apple': 4139, 'peach': 4127} dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098))) print(dic2) # {'peach': 4127, 'cherry': 4098, 'apple': 4139}
-
dict(**kwargs)
此方式键只能为字符串类型,并且不能加引号
dic = dict(name='Tom', age=10) print(dic) # {'name': 'Tom', 'age': 10}
内置方法
-
dict.fromkeys(seq[, value])
用于创建一个新字典,以序列
seq
中元素做字典的键,value
为字典所有键对应的初始值。seq = ('name', 'age', 'sex') dic1 = dict.fromkeys(seq) print(dic1) # {'name': None, 'age': None, 'sex': None} dic2 = dict.fromkeys(seq, 10) print(dic2) # {'name': 10, 'age': 10, 'sex': 10} dic3 = dict.fromkeys(seq, ('小马', '男')) print(dic3) # {'name': ('小马', '男'), 'age': ('小马', '男'), 'sex': ('小马', '男')}
-
dict.keys()
返回一个可迭代对象,可以使用
list()
来转换为列表,列表为字典中的所有键。 -
dict.values()
与dict.keys()不同的是,列表为字典中的所有值
-
dict.items()
返回 (键, 值) 元组的可迭代对象
-
dict.get(key, default=None)
返回指定键的值,如果值不在字典中返回默认值。
-
dict.setdefault(key, default=None)
返回指定键的值,如果键不存在于字典中,将会添加键并将值设为默认值。
-
dict.pop(key[,default])
,del dict[key]
删除字典给定键
key
所对应的值,返回值为被删除的值。若key
不存在,则返回default
值。 -
dict.popitem()
随机返回并删除字典中的一对键和值,如果字典已经为空,报KeyError异常。
-
dict.clear()
用于删除字典内所有元素。
-
dict.copy()
返回一个字典的浅复制。
-
直接赋值和 copy 的区别
dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]} # 引用对象 dic2 = dic1 # 浅拷贝父对象(一级目录),子对象(二级目录)不拷贝,还是引用 dic3 = dic1.copy() print(id(dic1)) # 148635574728 print(id(dic2)) # 148635574728 print(id(dic3)) # 148635574344 # 修改 data 数据 dic1['user'] = 'root' dic1['num'].remove(1) # 输出结果 print(dic1) # {'user': 'root', 'num': [2, 3]} print(dic2) # {'user': 'root', 'num': [2, 3]} print(dic3) # {'user': 'runoob', 'num': [2, 3]}
-
-
dict.update(dict2)
把字典参数
dict2
的key:value
对 更新到字典dict
里。dic = {'Name': 'Lsgogroup', 'Age': 7} dic2 = {'Sex': 'female', 'Age': 8} dic.update(dic2) print(dic) # {'Sex': 'female', 'Age': 8, 'Name': 'Lsgogroup'}
5. 集合
定义
集合中的元素没有重复值且是无序的,因此不能用索引和切片,也没有key来获取元素。
创建集合
创建空集合只能使用s = set()
,因为s = {}
创建的是空字典。
-
先创建对象再加入元素。用花括号括起来
{元素1, 元素2, ..., 元素n}
的重复元素会在set中自动过滤。num = {} print(type(num)) # <class 'dict'> num = {1, 2, 3, 4} print(type(num)) # <class 'set'> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} print(basket) # {'banana', 'apple', 'pear', 'orange'}
-
使用
set(value)
工厂函数,把字符串、列表或元组转换成集合a = set('abracadabra') print(a) # {'r', 'b', 'd', 'c', 'a'} b = set(("Google", "Lsgogroup", "Taobao", "Taobao")) print(b) # {'Taobao', 'Lsgogroup', 'Google'} # 利用列表转换成集合再转换成列表,可以去除列表中的重复值 c = set(["Google", "Lsgogroup", "Taobao", "Google"]) print(c) # {'Taobao', 'Lsgogroup', 'Google'}
访问集合中的值
-
使用
for
把集合中的数据一个个读取出来。s = set(['Google', 'Baidu', 'Taobao']) for item in s: print(item) # Baidu # Google # Taobao
内置方法
-
set.add(elmnt)
向集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。
-
set.update(set)
用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。
-
set.remove(item)
移除集合中的指定元素。如果元素不存在,则会发生错误。
-
set.discard(value)
用于移除指定的集合元素。如果元素不存在,不会发生错误。
-
set.pop()
用于随机移除一个元素。
-
set.intersection(set1, set2)
、set1 & set2
返回两个集合的交集。
-
set.intersection_update(set1, set2)
在原始的集合上移除不重叠的元素。
-
set.union(set1, set2)
、set1 | set2
返回两个集合的并集。
-
set.difference(set)
、set1 - set2
返回集合的差集。
a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} c = a.difference(b) print(c) # {'b', 'd', 'r'} print(a - b) # {'d', 'b', 'r'}
-
set.difference_update(set)
在原始的集合上移除重叠的元素。
a.difference_update(b) print(a) # {'d', 'r', 'b'}
-
set.symmetric_difference(set)
、set1 ^ set2
返回集合的异或。
a = set('abracadabra') b = set('alacazam') print(a) # {'r', 'a', 'c', 'b', 'd'} print(b) # {'c', 'a', 'l', 'm', 'z'} c = a.symmetric_difference(b) print(c) # {'m', 'r', 'l', 'b', 'z', 'd'} print(a ^ b) # {'m', 'r', 'l', 'b', 'z', 'd'}
-
set.symmetric_difference_update(set)
在当前集合中移除重叠的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
a.symmetric_difference_update(b) print(a) # {'r', 'b', 'm', 'l', 'z', 'd'}
-
set.issubset(set)
、set1 <= set2
判断当前集合是否为另一个集合的子集,是返回true,否则返回false。
x = {"a", "b", "c"} y = {"f", "e", "d", "c", "b", "a"} z = x.issubset(y) print(z) # True print(x <= y) # True
-
set.issuperset(set)
、set1 >= set2
判断当前集合是否为另一个集合的父集,是返回true,否则返回false。
x = {"f", "e", "d", "c", "b", "a"} y = {"a", "b", "c"} z = x.issuperset(y) print(z) # True print(x >= y) # True
-
set.isdisjoint(set)
用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。
x = {"f", "e", "d", "c", "b"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # False x = {"f", "e", "d", "m", "g"} y = {"a", "b", "c"} z = x.isdisjoint(y) print(z) # True
不可变的集合
frozenset
,不能改变的集合,即不能增加或删除元素。frozenset
仍然可以进行集合操作,只是不能用带有update
的方法。
6. 序列
-
list(sub)
把一个可迭代对象转换为列表。
-
tuple(sub)
把一个可迭代对象转换为元组。
-
str(obj)
把obj对象转换为字符串
-
len(s)
返回对象(字符、列表、元组等)长度或元素个数。
-
max(sub)
返回序列或者参数集合中的最大值
print(max(1, 2, 3, 4, 5)) # 5 print(max([-8, 99, 3, 7, 83])) # 99 print(max('IloveLsgoGroup')) # v
-
min(sub)
返回序列或参数集合中的最小值
print(min(1, 2, 3, 4, 5)) # 1 print(min([-8, 99, 3, 7, 83])) # -8 print(min('IloveLsgoGroup')) # G
-
sum(iterable[, start=0])
返回序列
iterable
与可选参数start
的总和。print(sum([1, 3, 5, 7, 9])) # 25 print(sum([1, 3, 5, 7, 9], 10)) # 35
-
sorted(iterable, key=None, reverse=False)
对所有可迭代的对象进行排序操作。
key
– 可以指定可迭代对象中的一个元素来进行排序。reverse
–reverse = True
降序 ,reverse = False
升序(默认)。x = [-8, 99, 3, 7, 83] print(sorted(x)) # [-8, 3, 7, 83, 99] t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"}) x = sorted(t, key=lambda a: a["age"]) print(x)
-
reversed(seq)
函数返回一个反转的迭代器。
seq
– 要转换的序列,可以是 tuple, string, list 或 range。 -
enumerate(sequence, [start=0])
将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
seasons = ['Spring', 'Summer', 'Fall', 'Winter'] a = list(enumerate(seasons)) print(a) # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
-
zip(iter1 [,iter2 [...]])
-
将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
-
可以使用
list()
转换来输出列表。 -
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
a = [1, 2, 3] b = [4, 5, 6] c = [4, 5, 6, 7, 8] zipped = zip(a, b) print(zipped) # <zip object at 0x000000C5D89EDD88> print(list(zipped)) # [(1, 4), (2, 5), (3, 6)] zipped = zip(a, c) print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
-
三、学习问题与解答
无
四、学习思考与总结
task2主要讲了python的数据结构以及操作方法,认识到了浅复制和深复制的区别,如何判断什么是可变和不可变数据类型,序列数据类型的转换。总得来说task2的内容很生动,学到了很多python的数据结构知识。