Python基础 Day2数据类型

列表

定义:[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

再回顾下列表的特点：

1.可存放多个值

2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

元素名	Zifeiyu	Coragem	Jack	Rachel	Mack
下标(索引)	0	1	2	3	4

3.可修改指定索引位置对应的值，可变

列表的增加操作

追加 数据会追加到尾部

>>> names
['zifeiyu', 'coragem']
>>> names.append("jack")
>>> names.append("rachel")
>>> 
>>> names
['zifieyu', 'coragem', 'jack', 'rachel']

插入 可插入任何位置

>>> names.insert(2,"黑姑娘")
>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel']

合并 可以把另一外列表的值合并进来

>>> n2 = ["狗蛋","绿毛","鸡头"]
>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel']
>>> names.extend(n2)
>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel', '狗蛋', '绿毛', '鸡头']

列表嵌套

>>> names.insert(2,[1,2,3])
>>> names 
['zifieyu', 'coragem', [1, 2, 3], '黑姑娘','jack', 'rachel', '狗蛋', '绿毛', '鸡头']
>>> names[2][1]
2

删除操作

del 直接删

>>> names
['zifieyu', 'coragem', [1, 2, 3], '黑姑娘','jack', 'rachel', '狗蛋', '绿毛', '鸡头']
>>> del names[2]
>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel', '狗蛋', '绿毛', '鸡头']

pop 删

>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel', '狗蛋', '绿毛', '鸡头']
>>> names.pop() #默认删除最后一个元素并返回被删除的值
'鸡头'
>>> names
['zifieyu', 'coragem', '黑姑娘','jack', 'rachel', '狗蛋', '绿毛']
>>> names.pop(3)  #删除指定元素
'jack'

clear 清空

>>> n2
['狗蛋', '绿毛', '鸡头']
>>> n2.clear()
>>> n2
[]

修改操作

>>> names
['zifieyu', 'coragem', '黑姑娘', 'rachel', '狗蛋', '绿毛']
>>> names[0] = "部长"
>>> names[-1] = "副部"
>>> names
['部长', 'coragem', '黑姑娘', 'rachel', '狗蛋',  '副部']

查操作

>>> names
['部长', 'coragem', '黑姑娘', 'rachel', '狗蛋',  '副部',  'coragem']
>>> 
>>> names.index("coragem") #返回从左开始匹配到的第一个eva的索引
1
>>> names.count("coragem") #返回eva的个数
2

切片

切片就像切面包，可以同时取出元素的多个值

names[start:end] 

>>> names
['部长', 'coragem', '黑姑娘', 'rachel', '狗蛋',  '副部',  'coragem']
>>> names[1:4]  #不包含下标4的元素
[''coragem', '黑姑娘', 'rachel']

*切片的特性是顾头不顾尾，即start的元素会被包含，end-1是实际取出来的值
倒着切

>>> names[-5:-1]
['黑姑娘', 'rachel', '狗蛋',  '副部']

但其实我想要的是后5个，只打印了4个，’eva’这个值没出来，为什么，因为上面提到的顾头不顾尾

可是想把后5个全取出来如何做呢？

>>> names[-5:]
['黑姑娘', 'rachel', '狗蛋',  '副部',  'coragem']

如果取前几个值 ，一样可以把:号左边的省掉

>>> names
['部长', 'coragem', '黑姑娘', 'rachel', '狗蛋',  '副部',  'coragem']
>>> names[0:3]
['部长', 'coragem', '黑姑娘']
>>> names[:3]  #跟上面一样的效果
['部长', 'coragem', '黑姑娘']

步长 允许跳着取值

names[start:end:step] #step 默认是1

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[0:7:2]  #设置步长为2
[0, 2, 4, 6]

>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[::3] #按步长3打印列表，第1个:是省略掉的start:end
[0, 3, 6, 9]

列表反转

>>> a[::-1] #通过把步长设置成负值，可达到列表返转的效果
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 
>>> a[::-2]
[9, 7, 5, 3, 1]

元组

有些时候我们的列表数据不想被人修改时怎么办？ 就可以用元组存放，元组又被称为只读列表，不能修改。

定义：与列表类似，只不过［］改成（）

特性：
　　1.可存放多个值
　　
　　2.不可变
　　
　　3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

创建

ages = (11, 22, 33, 44, 55)
#或
ages = tuple((11, 22, 33, 44, 55))

常用操作

索引

>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55

#切片:同list
循环

>>> for age in ages:
    print(age)
11
22
33
44
55

长度

>>> len(ages)
5

包含

>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False

注意：元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变

>>> data 
(99, 88, 77, ['zifieyu', 'coragem'], 33)
>>> data[3][0] = 'Alex'
>>> data
(99, 88, 77, ['Alex',  'coragem'], 33)

字符串

定义

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，’ ‘或’’ ‘’或’’’ ‘’’中间包含的内容称之为字符串

创建

 s = 'Hello,Eva！How are you?'

特性

1.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
2.

str	h	e	l	l	o
索引	0	1	2	3	4

3.可以进行切片操作

4.不可变，字符串是不可变的，不能像列表一样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了一份新数据。

补充：

字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r’l\thf’

字典

引子
我们学了列表 ， 现在有个需求， 把你们公司每个员工的姓名、年龄、职务、工资存到列表里，你怎么存？

staff_list = [
    ["Xifeiyu",20,"CEO",66000],
    ["Coragem",19,"讲师",40000],
    ["Jack","行政",4000],
    # [xxx,xx,xx,xxx]
    # [xxx,xx,xx,xxx]
    # [xxx,xx,xx,xxx]  
]

这样存没问题，不过你要查一个人的工资的话， 是不是得把列表遍历一遍

for i in staff_list:
    if i[0] == 'Coragem':
        print(i)
        break

但假如你公司有2万人，如果你要找的黑姑娘正好在列表末尾，那意味着你要遍历2万次，才能找到这个信息。列表越大，查找速度越慢。

好了，现在福音来了， 接下来学要的字典可以 查询数据又快、操作又方便，简直堪称神器。

定义

｛key1:value1,key2:value2｝

1、键与值用冒号“：”分开；
2、项与项用逗号“，”分开；

示例：

info = {
    "name":"小猿圈",
    "mission": "帮一千万极客高效学编程",
    "website": "http://apeland.com"
}

特性

1.key-value结构

2.key必须为不可变数据类型、必须唯一

3.可存放任意多个value、可修改、可以不唯一

4.无序

5.询速度快，且不受dict的大小影响，至于为何快？我们学完hash再解释。

操作

创建操作

>>>person = {"name": "alex", 'age': 20} 
#或
>>>person = dict(name='seven', age=20)
#或
>>>person = dict({"name": "egon", 'age': 20})
#或
>>> {}.fromkeys([1,2,3,4,5,6,7,8],100)
{1: 100, 2: 100, 3: 100, 4: 100, 5: 100, 6: 100, 7: 100, 8: 100} 

增加操作

names = {
    "alex": [23, "CEO", 66000],
    "黑姑娘": [24, "行政", 4000],
}

#新增k
names["佩奇"] = [26, "讲师", 40000]
names.setdefault("oldboy",[50,"boss",100000])  # D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

删除操作

names.pop("alex") # 删除指定key
names.popitem()   # 随便删除1个key
del names["oldboy"] # 删除指定key,同pop方法
names.clear()     # 清空dict

修改操作

dic['key'] = 'new_value',如果key在字典中存在，'new_value'将会替代原来的value值；
dic.update(dic2) 将字典dic2的键值对添加到字典dic中

查操作

dic['key'] #返回字典中key对应的值，若key不存在字典中，则报错；
dic.get(key, default = None)#返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）
'key' in dic #若存在则返回True，没有则返回False
dic.keys() 返回一个包含字典所有KEY的列表；
dic.values() 返回一个包含字典所有value的列表；
dic.items() 返回一个包含所有（键，值）元组的列表；

循环

for k in dic.keys()
for k,v in dic.items() 
for k in dic   # 推荐用这种，效率速度最快
info = {
    "name":"废材",
    "mission": "学不会编程",
    "website": "http://apeland.com"
}
for k in info:
    print(k,info[k])
输出
name 废材
mission	学不会编程
website http://apeland.com

求长度

len(dic)

集合

特点

1. 里面的元素不可变，代表你不能存一个list、dict 在集合里，字符串、数字、元组等不可变类型可以存
2. 天生去重，在集合里没办法存重复的元素
3. 无序，不像列表一样通过索引来标记在列表中的位置 ，元素是无序的，集合中的元素没有先后之分，如集合{3,4,5}和{3,5,4}算作同一个集合
4. 基于上面的特性，我们可以用集合来干2件事，去重和关系运算

语法

创建语法

>>> a = {1,2,3,4,2,'alex',3,'rain','alex'}
>>> a
{1, 2, 3, 4, 'alex', 'rain'}

由于它是天生去重的，重复的值你根本存不进去

帮列表去重

帮列表去重最快速的办法是什么？ 就是把它转成集合，去重完，再转回列表

>>> b
[1, 2, 3, 4, 2, 'alex', 3, 'rain', 'alex']
>>> set(b)
{1, 2, 3, 4, 'alex', 'rain'}
>>> 
>>> b = list(set(b)) #一句代码搞定
>>> b
[1, 2, 3, 4, 'alex', 'rain']

增删改查

>>> a
{1, 2, 3, 4, 'alex', 'rain'}
#新增
>>> a.add('黑姑娘')  
#删除discard
>>> a
{2, 3, '黑姑娘', 'alex', 'rain'}
>>> a.discard('rain')   #删除一个存在的值
>>> a.discard('rain2')   #如果这个值不存在，do nothing.
>>> a
{2, 3, '黑姑娘', 'alex'}
>>> 
#随机删除,少用，或特定场景用
>>> a.pop() #删除并返回
1
#删除remove
>>> a.remove(4)
#查
>>> a
{2, 3, '黑姑娘', 'alex', 'rain'}
>>> 'alex' in a
True
#改
呵呵，不能改。。。 

关系运算

s_1024 = {"佩奇","老男孩","海峰","马JJ","老村长","黑姑娘","Alex"}
s_pornhub = {"Alex","Egon","Rain","马JJ","Nick","Jack"}
print(s_1024 & s_pornhub)  # 交集, elements in both set
print(s_1024 | s_pornhub)  # 并集 or 合集
print(s_1024 - s_pornhub)  # 差集 , only in 1024
print(s_pornhub - s_1024)  # 差集,  only in pornhub
print(s_1024 ^ s_pornhub)  # 对称差集, 把脚踩2只船的人T出去

两个集合之间一般有三种关系，相交、包含、不相交。在Python中分别用下面的方法判断：

print(s_1024.isdisjoint(s_pornhub))     # 判断2个集合是不是不相交，返回True or False
print(s_1024.issubset(s_pornhub))       # 判断s_1024是不是s_pornhub的子集，返回True or False
print(s_1024.issuperset(s_pornhub))     # 判断s_1024是不是s_pornhub的父集，返回True or False