首页 > 编程语言 > 详细

第三章 python的数据类型(下)

时间:2019-06-16 12:39:08      阅读:51      评论:0      收藏:0      [点我收藏+]

标签:logs   eache   names   位数   并集   报错   总量   als   用法   

上一篇我们介绍了一些基础的数据类型和方法。
在这篇里,我们来了解下python特有的数据类型及其方法。

3.4 列表(list)

列表可以存储多个数据,有点类似于powershell里的数组

字符串也可以看做是一个列表

names = ["name1","name2","name3"]  # 有点像数组

print(names[0])  # 可以用下标来调用

3.4.1 列表的特点(有序,可变)

列表有以下特点

  1. 可以存放多个值。(值也可以是列表,元组等)
  2. 有序:从左到右顺序,索引从0开始。
  3. 可变:可修改指定索引位置对应的值。
  4. 容量大:内存有多大就能存多少,类似于python3的int型。

3.4.2 列表的方法

以下分用途(增删改查)介绍列表的方法:

1. 增加:append,insert,extend

append,insert,extend都不返回结果,会返回None

  1. .append(self,object) 追加:将object插到列表最后并且直接赋值给列表

  2. .insert(self,index,object) 插入:将object插入到index的位置,并且直接赋值给列表

  3. .extend(self,iterable) 合并(扩展):将原列表与iterable(列表) 合并,并且直接赋值给原列表
s = [1, 2, 3, 4]
b = [1,2,3,4]

s.extend(b)  # 这里直接把合并后的列表赋值给s
print(S)

2. 删除: del,pop,remove,clear
  1. del 删除:python的通用方法
del list1  # 删除整个列表
del list2[2]  # 删除一个元素
  1. .remove(self, object) 删除第一个匹配的元素(从左到右找),如果不存在就报错
s = ['a', 'b', 'c', 'd']
s.remove('c')
print(s)

s.remove('e')  # 报错:ValueError
  1. .pop(self, index) 弹出:删除并返回元素
list1.pop(3)  # 删除并返回索引指定的元素
list1.pop()  # 删除并返回最后一个元素
  1. .clear(self) 清空列表

3. 修改(赋值): =

可以直接用‘=‘赋值
list01[2] = "name250"

4. 查询:index,count,in,len
  • .index(self,object,start,stop) 返回 从左开始匹配到的第一个object的索引,可以设置开始和结束位置。

    如果查找元素不存在,报错ValueError

s = ['a', 'b', 'c', 'd']
print(s.index('c'))
print(s.index('c', 0, 2))  # 范围中没有'c',报错
  • .count(self, object) 返回 object的个数。
s = ['a', 'b', 'c', 'd']
print(s.count('c'))  # 有1个'c',返回1
print(s.count('e'))  # 没有'e',返回0
  • in / not in 运算符判断是否包含
s = ['a', 'b', 'c', 'd']
print('a' in s)
  • len(o) 返回 o 的长度
s = ['a', 'b', 'c', 'd']
print(len(s))
5. 其他函数 reverse,sort
  • .reverse()
    把列表中的元素反转,也可以用list1[::-1]来实现
s = ['a', 'b', 'c', 'd']
a = ['a', 'b', 'c', 'd']
print(id(s), id(a))  # 显示s和a的内存地址

s.reverse()  # 反转s内元素

a1 = a[::-1]  # 拷贝一份反转了的a给a1

print(s, a1)  #输出一样
print(id(s), id(a1))  # 两种实现方式的区别:s地址不变,a1地址和a不同
  • .sort(self, key, reverse) 把列表的元素排序并且赋值给列表,只能sort同种类型数据(内部使用的是比较运算符)
s = ['a', 'd', 'b', 'c', 5, 7, 3]
s.sort()  # 数据类型不同,报错:TypeError: '<' not supported between instances of 'int' and 'str'

s = ['a', 'd', 'b', 'c']

s.sort()
print(s)

s.sort(reverse=True)  # reverse = False 升序(默认),reverse = True 降序
print(s)

当元素是元组等多值数据类型的时候,可以使用key来指定以哪个元素为标准

def takeSecond(elem):
    return elem[1]
 
# 列表
s = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
s.sort(key=takeSecond)
 
# 输出类别
print(s)

3.4.3 列表的切片(顾头不顾尾)

列表切片就是截取列表的一部分(截取后的列表是一个拷贝)

可以切片的数据类型:列表(list),元组(tuple),字符串(str)。

拷贝:在内存的别的地方再建一份数据

list1[start:end:step]


  • 切片方法:
    • start是开始索引,end其实是从扣掉元素的开始索引(从end开始全切掉)
    • end使用负数,-2 就是扣掉倒数2个
    • 不写end就是从start开始后面全取
    • 不写start就是取到end为止的所有元素
    • step设为负数可以从后往前取(即倒着切)
list1 = ["0","1","2","3","4","5","6"]

print(list1[3:4]) # 从索引3开始取,索引4开始切掉不要:结果只剩下索引3的元素["3"]
print(list1[3:-2])  # -2表示倒数第2个,也就是从倒数第2个往后切掉不要:结果["3","4"]
print(list1[1:])  # 从索引1开始到最后
print(list1[:3])  # 从开始到索引2,索引3开始切掉不要
print(list1[-4:-2])  # 从倒数第4个开始取,倒数第二个开始往后切掉不要
print(list1[1:5:2])  # 从索引1开始,隔1(步长-1)个取1个,索引5开始切掉不要
print(list1[-2:-4:-1])  # 从倒数第2个开始从后往前取,从倒数第4个开始切掉不要:结果["5","4"]

执行结果:

['3']
['3', '4']
['1', '2', '3', '4', '5', '6']
['0', '1', '2']
['3', '4']
['1', '3']
['5', '4']

  • 切片的特殊用法

列表反转(类似reverse()),字符串反转

print(list1[::-1])  # 把列表反转过来(拷贝)
# 因为字符串也可以看做是一个列表(但是不可变),所以也可以用来**反转字符串**

列表拷贝

list2 = list1[:]  # 把list1的拷贝赋值给list2

插入赋值

list1 = [1,2,3,4,5,6,7,8,9,0]
list1[1:6] = 'abcdefghijk'  # 先把1-5切掉,然后把'abcdefghijk'的元素插进去。
# 切掉的位数和插入的位数没有直接关系,只是插入这个切掉的空间罢了。这可能导致插入后,后面的索引发生变化。
# list1[1] = 'abc' 是单纯的列表赋值,不要搞错了哦
print(list1)

执行结果:

[1, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 7, 8, 9, 0]

3.5 字典(dict)

字典定义用{},取值的时候用[]

3.5.1 字典的特点(无序,key唯一,key不可变类型,查询速度快)

字典有以下特点:

  1. 只有key没有索引。key-value 结构
  2. key必须为不可变数据类型(字符串,元组,数字),必须唯一。

    原因:hash运算只能对不可变的类型进行运算:可变的hash就没意义了。
  3. 可存放任意多个value,value可修改,可以不唯一
  4. 无序(因为没有索引)
  5. 查询速度非常快,并且不受dict的大小影响(不管有多少条,查询速度也差不多)

    原因: 字典dict 的key 都是要经过hash 生成一个固定长度的hash值 然后dict会把这些hash值(数字)排序号,放入一个列表里 当查其中一个"元素A"的时候,先把元素A hash一下,生成个数字 再用二分法找到列表里的相应数字就可以了。 ※因此数据的插入就要慢点,hash值得列表要插入后重新排序。

二分法搜索的比较次数: 如果 2**n >= 数据总量,那么 n 次比较就可以找到相应数据

3.5.2 字典的方法

以下分用途(增删改查)介绍列表的方法:

1. 创建:直接定义‘{}‘,dict,fromkeys
  1. 直接定义
    person = {"name":"Alex","age":22} # 注意这里用":"来连接key和value

  2. dict()
    person = dict(name="Alex",age=22) # 注意这里用"="来连接key和value ,并且key没有引号

  3. 直接定义 + dict()
    person = dict({"name":"Alex","age":22}) # 把方法1的定义放在方法2的函数中

  4. fromkeys() 批量生成字典
keys = [0,1,2,3,4,5]
{}.fromkeys(keys,100)  # 每个key 都赋给 100 的value ,如果不写赋值,value就都是"None"

执行结果:
{0: 100, 1: 100, 2: 100, 3: 100, 4: 100, 5: 100}

注意:用fromkeys()创建字典,value如果是数组。
在用append给这个数组追加元素的时候,会把给所有key的value都append。
参考

2. 增加: = ,setdefault
  1. 用 ‘=‘ 直接定义
person = {"name":"Alex","age":22}
person["job"] = "Teacher"  # 如果字典里存在指定的key,就会覆盖原有的value`

注意:如果是存在的key,就会覆盖原有的value

  1. .setdefault(self, k, default) 添加key和value(default),并且返回value。如果是存在的key,不会覆盖原有的value。
person = {"name":"Alex","age":22}
person.setdefault("salary",[1,2,3])  # 添加key和value,并且返回value`

比较安全的方法,不会覆盖原有值

3. 删除: del,pop,popitem,clear
  1. del 删除:python的通用方法
person = {"name":"Alex","age":22}  # 创建字典
del person["name"]  # 删除指定key,value
del person  # 删除字典
  1. .pop(self, k) 弹出:删除并返回指定key的value,如果不指定则会报错。
person = dict(name="Alex",age=22)  # 创建字典

print(person.pop("name"))  # 弹出name,并返回'Alex'
#输出: 'Alex'

person.pop()  # 报错:必须指定参数
  1. .popitem(self) 随机弹出: 删除并返回随机一个元素,并以元组(key,value)的形式返回。空字典会报错(KeyError)
person = dict(name="Alex",age=22)  # 创建字典

print(person.pop('name'))  # 弹出
item1 = person.popitem()  # 取得返回的结果
print(type(item1))  # 打印返回结果的类型:tuple
print(person.popitem())  # 弹出
print(person.popitem())  # 报错:KeyError
  1. .clear() 清空字典
person = dict(name="Alex",age=22)  # 创建字典

person.clear()  # 清空
4. 修改: = ,update
  1. 用 ‘=‘ 赋值修改
person = {"name":"Alex","age":22}
person["name"] = "aaaa"  # 修改name的Alex->aaaa
  1. .update(self, __m, kwagrs)
    更新(合并):合并两个字典,如果有相同的key,则覆盖原来的value。
dict1 = dict(name="aaaa",age=22) 
dict2 = dict(a="bbbb",age=23)

dict1.update(dict2)  #  #如果有重复的key,dict1的值会被dict2的值覆盖 (用dict2来更新dict1)
print(dict1)
5. 查询: get,keys,values,items
  1. .get(self, k) 取得指定k的value。如果不存在,返回default指定的值(默认是None)
dict1 = dict(name="Alex",age=22) 

print(dict1.get('name'))  # 返回'Alex'
print(dict1.get('aaaa'))  # 'aaaa'不存在,返回None
print(dict1.get('aaaa', 'lalalala'))  # 'aaaa'不存在,返回'lalalala'
# 最后一行也可以写成:
# print(dict1.get(k='aaaa', default='lalalala'))

执行结果:

Alex
None
lalalala
  1. .keys(self) 返回 所有的keys(dict_keys类型)

  2. .values(self) 返回 所有的values(dict_values类型)

  3. .items(self) 返回 所有items(dict_items类型)
dict1 = dict(name="Alex",age=22) 

k = dict1.keys()
v = dict1.values()
i = dict1.items()

print(k, v, i)
print(type(k), type(v), type(i))

# print(k[0])  # 因为不是列表类型,会报错:TypeError
# print(v[0])  # 因为不是列表类型,会报错:TypeError
# print(i[0])  # 因为不是列表类型,会报错:TypeError

for k_ in k:  # 可以用for来访问
    print(k_)

执行结果:

dict_keys(['name', 'age'])
dict_values(['Alex', 22])
dict_items([('name', 'Alex'), ('age', 22)])
<class 'dict_keys'> <class 'dict_values'> <class 'dict_items'>
name
age

扩展知识

person = dict(name="Alex",age=22)  # 定义一个字典

# 方式1 官方推荐,效率最高

for i in person:
    print(i)  # 只会输出key
    print(i,person[i]  # 这样会打印key和value

# 方式2 
for i in person.keys():

# 方式3.1
for i in person.items():                
    print(i)  # 这样会以元组的形式打印出所有(key,vaule)

# 方式3.2
# for可以声明复数个临时变量,不过in后面的变量必须有对应的值

for k,v in person.items():  # 声明两个临时变量分别储存key和value  
    print(k,v)

注意:字典无序,所以不能切片

3.6 元组(tuple)

元组其实就相当于一个只读的列表。

3.6.1 元组的特点(不能修改)

元组的特点类似于列表,唯一区别就是

  • 不能修改,只能查询

    可以切片:因为切片的本质是拷贝,并不是修改

3.6.2 元组的方法

以下分用途(因为只读所以只有:查)介绍列表的方法:

1. 创建: 直接定义‘()‘,tuple
  1. 直接定义
tuple1 = (99,12,32,["name1","name2"],12,43)  # 用()定义
  1. 用tuple()函数转换 >这个方法其他数据类型也有类似的,比如int(),str()等。
list1 = ['a', 'b', 'c', 'd']
str1 = 'abcde'
tuple1 = tuple(list1)
tuple2 = tuple(str1)

print(tuple1)
print(tuple2)

执行结果:

('a', 'b', 'c', 'd')
('a', 'b', 'c', 'd', 'e')
当元组里的元素只有一个的时候,不会被视为元组。
a = ('aaa')
print(a,type(a))  # 结果是str型
# 正确的定义方法
a = ('aaa',)  # 加个,就是元组了
2. 查询: count,index,in,len

元组的查询和列表相同,参考3.4.2

3.6.3 元组中的可变数据类型

如果元组中包含可变数据类型的元素,那么这些元素可以修改: 比如包含一个列表。

为什么呢?:因为元组里保存的是各个元素的内存地址,如果元素是另一个容器(比如列表),容器内的内容并不能管理

data = (99,12,32,["name1","name2"],12,43)
data[3][0] = "Alex"
print(data)

执行结果: (99, 12, 32, [‘Alex‘, ‘name2‘], 12, 43)

3.7 集合(set)

集合是个很有特点的数据类型。

3.7.1 集合的特点(元素不可变类型,去重,无序)

集合有以下特点:

  1. 元素必须是不可变数据类型(但是可以增删)

    ··可变数据类型: 列表(list),字典(dict)(key不能变) ··不可变数据类型: 元组(tuple),集合(set),int,float,str --可变数据和不可变数据类型的区别是能否被hash。不可变数据类型能被hash

  2. 天生去重复(集合里没有重复元素)

    定义的时候如果有重复元素,会自动去重

  3. 无序

根据集合的特点,我们经常使用它做

  • 去重复: 但是要注意集合无序
  • 关系运算: 可以取两个集合的交集等

3.7.2 集合的方法

这次我们也以创建,增删改查的顺序罗列方法:

1. 创建: 直接定义‘{elems}‘,set
  1. 直接定义: set1 = {1,2,3,4,5,‘rain‘,‘alex‘}

    注意:我们定义集合的时候不能用set1 = {} ,因为这样会定义一个字典。 定义空集合,我们用set1 = set()

  2. set()
list1 = ['aaa', 'bbb']
tuple1 = ('ccc', 'ddd')
dict1 = {'a': 1, 'b': 2}

set1 = set()
set2 = set(list1)
set3 = set(tuple1)
set4 = set(dict1)  # 只把key放入集合里

print(set1, type(set1))
print(set2)
print(set3)
print(set4)  # 输出key的集合

执行结果:

set() <class 'set'>
{'bbb', 'aaa'}
{'ccc', 'ddd'}
{'b', 'a'}
2. 增加: add
  1. .add(self, element) 往集合里追加元素
set1 = {1,2,3,4,5,'rain','alex'}  # 定义

set1.add(5)  # 不报错,因为重复只是不增加元素
set1.add([1,2,3])  # 报错,元素不能被hash -> 原因:可变的数据类型不能被添加
set1.add((1,2,3))  
3. 删除: discard,remove,pop
  1. .discard(self, element)
    删除指定元素
set1 = {1,2,3,4,5,'rain','alex'}

set1.discard(5)  # 删除 5 
set1.discard(5)  # 删除不存在的元素不会报错
  1. .remove(self, element) 删除指定元素(指定元素不存在:报错)
set1 = {1,2,3,4,5,'rain','alex'}

set1.remove(4)  # 删除 4
set1.remove(4)  # 报错,KeyError
  1. .pop(self)
    弹出:随机(其实是hash值顺序?)删除一个元素,并且返回
set1 = {1, 2, 'rain', 'alex'}

print(set1.pop())
print(set1.pop())
print(set1.pop())
print(set1.pop())  
print(set1.pop())  # 报错:对空集合pop报错-KeyError
4. 查询: in,for

用 in 来判断是否包含指定元素 用 for 来遍历元素

集合不能修改,不能切片(因为无序)

3.7.3 集合的关系运算

1. 交集 &

取两个集合的交集并返回。相同于 .intersection()

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 & set2
print(temp_set)
2. 合集(并集) |

取两个集合的合集并返回。 相同于 .union()

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 | set2
print(temp_set)
3. 差集 -

从被减集合中扣去共有元素并返回。 相同于 .difference()

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 - set2    # 从set1 中扣去 set1和set2都有的元素
print(temp_set)
4. 对称差集 ^

取交集以外的元素并返回。相同于 .symmetric_difference()

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 ^ set2    # 除了set1和set2共有的元素,其他都保留
print(temp_set)
5. .intersection_update,.difference_update

关系运算并覆盖
交集: .intersection_update()
差集: .difference_update()
set1.difference_update(set2) # 作用是取完差集,并且将结果赋值给set1

6. 集合判断: isdisjoint,issubset
  1. .isdisjoint(self, s)
    判断不相交:不相交返回True

  2. .issubset(self, s)
    判断是子集:左是右的自己返回True

7. 运算符 == < >

运算符只是表示两个集合的包含关系
python3解释器执行 {2, 3, 4} >= {2, 3}和执行{2, 3, 4} > {2, 3}的结果为:True,True


3.8 公共功能

  • len() # 数字和bool以外的数据类型都可以用
  • 索引 # 集合不可以索引(无序)
  • 切片 # 列表,元组,字符串
  • 步长 # 列表,元组,字符串
  • for循环 # int,bool以外的全部

第三章 python的数据类型(下)

标签:logs   eache   names   位数   并集   报错   总量   als   用法   

原文:https://www.cnblogs.com/py-xiaoqiang/p/11030883.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 bubuko.com 版权所有 鲁ICP备09046678号-4
打开技术之扣,分享程序人生!
             

鲁公网安备 37021202000002号