菜鸟学Python第五天
数据类型常用操作及内置方法
列表(list)
======================================基本使用======================================
-
用途
用来存取多个同属性的值，用索引对应值，索引反映的是位置
-
定义方式
在[]内用逗号分隔开多个任意类型的值
l = [1, 2.2, 'str', 'list', '...'] # l= list([1, 2.2, 'str', 'list', '...'])
-
类型转换
list可以将str、list、dict、tuple等可以被for循环循环的类型转换为列表。
注：list只可以将dict的key遍历出来
d = {'name': 'Jason', 'age': 23, 'weight': 78, 'height': 183}
L = list(d)
print(L)
['name', 'age', 'weight', 'height']
-
-
常用操作+内置的方法
-
优先掌握的操作
-
按索引取值：可以正向存取、也可以反向存取
names = ['james', 'curry', 'paul', 'rose']
print(names[3]) # 正向取值
print(names[-3]) # 反向取值
names[1] = 'irving' # 按索引更改列表元素
print(names)
rose
curry
['james', 'irving', 'paul', 'rose']
# 注意：当索引超出范围时，按索引更改列表元素则会报错
-
切片(顾头不顾尾，步长)
names = ['james', 'curry', 'paul', 'rose']
print(names[1:4])
['curry', 'paul', 'rose'] -
长度list.len()：统计列表元素个数
names = ['james', 'curry', 'paul', 'rose']
print(len(names))
4 成员运算in 、 not in：判断字符是否在列表内
-
list.append() & list.insert() : 追加&插入
names = ['james', 'curry', 'paul', 'rose']
names.append('ivring')
print(names)
['james', 'curry', 'paul', 'rose', 'ivring']
-----------------------------------------------------------
names = ['james', 'curry', 'paul', 'rose']
names.insert(1,'ivring')
print(names)
['james', 'ivring', 'curry', 'paul', 'rose']注：append的只能从列表的末尾进行添加，insert可以在设定索引位置的前面添加，不设置索引时默认添加在开头
-
del list[索引]、list.remove(object)、list.pop(索引)：删除
del、remove、 pop的区别
del是通用的删除方式，并不为list特有
remove是按照list内的成员进行删除，而del、pop是按照索引进行删除操作。。
del、remove删除后没有返回值，pop则返回删除的那个成员
names = ['james', 'curry', 'paul', 'rose']
del names[3] # 删除'rose'
print(names.remove('paul')) # 删除‘paul’并打印返回值
print(names.pop(1)) # 删除'curry'并打印返回值
print(names) #打印最终列表
None # remove返回值为空
curry # pop返回值为‘curry’
['james'] # 最终列表 -
循环
for循环
names = ['james', 'curry', 'paul', 'rose']
for i in names:
print(i)
-
-
需要掌握内容
-
list.count(object):统计列表中某元素的个数
names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']
print(names.count('rose'))
4 -
list.extend(iterable):将另一列表内元素添加到原列表中，并赋值给原列表
names = ['james', 'curry', 'paul', 'rose']
# print(names.count('rose'))
names1 = ['love', 'Hardon']
names.extend(names1) # 将names1添加到names后面并赋值给names，此操作无返回值
print(names)
['james', 'curry', 'paul', 'rose', 'love', 'Hardon'] -
list.index(iterable):从左到右查找列表中某元素第一次出现的位置
names = ['james', 'curry', 'paul', 'rose', 'rose', 'rose', 'rose']
print(names.index('rose'))
3 -
list.reverse()：将list翻转，并赋值给原列表
names = ['james', 'curry', 'paul', 'rose']
names.reverse() # 翻转，此操作无返回值
print(names)
['rose', 'paul', 'curry', 'james'] -
list.sort()：排序（默认从小到大，列表内必须为同一可比较类型）
names = ['james', 'curry', 'paul', 'rose']
names.sort() # 排序操作，无返回值
print(names)
['curry', 'james', 'paul', 'rose']
-
-
======================================该类型总结====================================
存多个值
有序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
元组(tuple)
======================================基本使用======================================
-
用途
元组就是一个不可变的列表
-
定义方式
在()内用逗号分隔开多个任意类型的元素（逗号才是关键）
t = (1, 2.2, 'aa') # t = tuple()
print(type(t))
<class 'tuple'>类型转换：
t1=tuple('hello')
t2=tuple([1,2,3])
print(t1)
print(t2)
('h', 'e', 'l', 'l', 'o')
(1, 2, 3)
-
常用操作+内置的方法
优先掌握操作：
按照索引取值
切片
长度
成员运算
-
循环
t = (1, 2, 3, 4, 5)
print(t[3]) # 索引取值
print(t[1: 3]) # 切片操作
print(len(t)) # 长度计算
print(2 in t) # 成员运算
4
(2, 3)
5
True
-
需要掌握操作：
tuple.index(object):从左到右查找某元素在元组中第一次出现的位置
tuple.count(object):统计元组中某元素的个数
t = (1, 2, 3, 3, 4, 5)
print(t.index(2))
print(t.count(3))
1
2
======================================该类型总结====================================
存多个值
有序
不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
字典(dict)
======================================基本使用======================================
-
用途
记录多个值，列表是索引对应值，而字典是key对应值，其中key对value有描述性功能
-
定义方式
在{}内用逗号分隔开多个元素，每个元素都是key：value的形式，其中key是不可变类型，通常是字符串类型，而value可以是任意类型。
s = {'name':'James','age':'','height':'203 cm', 'T_tpye':'all_round'}
# s = dict({'name':'James','age':'34','height':'203 cm', 'T_tpye':'all_round'})类型转换：加深理解
# 第一种
d=dict(x=1,y=2,z=3)
print(d)
{'x': 1, 'y': 2, 'z': 3}
# 第二种
items = [('name', 'egon'), ('age', 18), ('gender', 'male')]
d = dict(items)
print(d)
{'name': 'egon', 'age': 18, 'gender': 'male'} -
常用操作+内置的方法
-
优先掌握
-
按key存取值：可存可取
key存在则为赋值操作，key不存在则添加字典key：value
msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
msg['name'] = 'Lebron' # 修改key对应的value
msg['team'] = 'lakers' # 添加字典key：value
print(msg)
{'name': 'Lebron', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round', 'team': 'lakers'}dict['key']:没有则报错
dict.get(key):没有报none
msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
print(dsg['team']) # key 不存在字典中，会报错
print(msg.get('team')) #key 不在字典中返回None
KeyError: 'team'
None 长度len()：统计字典中键值对的个数
成员运算in 或者not in（以字典的key为准）
-
pop 、popitem(随机删)：删除
使用方法同字典pop，并返回删除key
-
键keys()，值values()，键值对items()
>>> msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
>>> msg.keys()
dict_keys(['name', 'age', 'height', 'T_tpye'])
>>> msg.values()
dict_values(['James', '', '203 cm', 'all_round'])
>>> msg.items()
dict_items([('name', 'James'), ('age', ''), ('height', '203 cm'), ('T_tpye', 'all_round')]) -
循环
msg = {'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'}
for k, v in msg.items(): # k,v=('name', 'egon')
print(k, v)
name James
age 34
height 203 cm
T_tpye all_round
-
-
需要掌握
-
dict.update():函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
msg = {'name': 'James', 'age': ''}
msg1 = {'height': '203 cm', 'T_tpye': 'all_round'}
msg.update(msg1) # 更新操作，无返回值
print(msg)
{'name': 'James', 'age': '', 'height': '203 cm', 'T_tpye': 'all_round'} -
dict.setdefault(key,value)：当key存在时不改原值，并返回原值，当key不存在时增加新value
msg = {'name': 'James', 'age': ''}
print(msg.setdefault('age', ''))
print(msg.setdefault('height', ''))
print(msg)
34
203
{'name': 'James', 'age': '', 'height': ''}注：当返回的value不是输入的新value时，标明字典中包含该key，当返回value是输入的心value时则表明之前字典中不包含该key，可以用来判断字典中是否含有某元素。
-
-
======================================该类型总结==================================== 存多个值 无序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
集合(set)
======================================基本使用======================================
-
用途
关系运算
去重
-
定义方式
在{}内用逗号分隔开多个元素
S = {1,2,3,4,5} # S = set({1,2,3,4,5})元素的特点：
集合内元素必须是不可变类型
集合内元素无序
集合内元素不可重复
类型转换：
set可以将能用for循环循环的数据类型转换为集合
3. 常用操作+内置的方法
-
优先掌握
长度len():返回集合内元素个数
成员运算in、not in：判断集合中是否存在某元素
并（合）集set.union(set1, set2...)，快捷键：|
交集set.intersection(set1, set2 ... )，快捷键：&
差集set.difference(set)，快捷键：-
对称差集set.symmetric_difference(set)，快捷键：^
a_club = {'jason', 'tony', 'jay', 'allen'}
b_club = {'rose', 'alice', 'allen', 'tony'}
print(a_club | b_club) # 并集
print(a_club & b_club) # 交集
print(a_club - b_club) # 差集，只在a_club中的成员
print(b_club - a_club) # 差集，只在b_club中的成员
print(a_club ^ b_club) # 对称差集 没有同时在两个集合的成员
{'allen', 'jason', 'rose', 'jay', 'alice', 'tony'}
{'allen', 'tony'}
{'jason', 'jay'}
{'alice', 'rose'}
{'jason', 'rose', 'jay', 'alice'}==：集合中元素完全一致
-
父集和子集>=、<=：描述的是一种包含和被包含的关系
s1 = {1, 2, 3}
s2 = {1, 2, 3}
s3 = {1, 2, 3, 4}
print(s1 == s2)
print(s3 >= s1)
print(s1 <= s3)
True
True
True
-
需要掌握
-
update();更新
s1={1,2,3}
s1.update({3,4,5,6})
print(s1)
{1, 2, 3, 4, 5, 6} -
pop():随机删，并返回删除元素
s1={1,'aa','bb',3}
print(s1.pop())
1 remove()：按元素删，当元素不存在时报错
-
discard()：按元素删，当元素不存在时不报错
# remove
s1 = {1,'aa','bb',3}
res = s1.remove('bbbbbb')
print(s1) # 不存在即报错
print(res) # 打印返回值（无返回值）
KeyError:'bbbbbb'
# discard
s1 = {1,'aa','bb',3}
res = s1.diiscard('bbbbbb')
print(s1) # 不存在不报错
print(res) # 没有返回值
{3, 1, 'aa', 'bb'}
None -
add()：添加
s1 = {1,'aa','bb',3}
s1.add(4)
print(s1)
{1, 3, 'aa', 4, 'bb'}集合的去重的局限性：
只能针对不可变类型*
不能保证原来的顺序
-
-
======================================该类型总结====================================
存多个值
无序
可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）