第三天

python常用的五大类型

列表 l = [1,2,3]
相当于数组
列表可以存储多种多个数据
python的数据传递，本质都是首地址的传递
列表支持索引操作（下表操作）
列表支持切片操作

可迭代对象
字符串’abce‘
range（10）

切片
l=[4,5,6,7,8,9,1,2,3,4]
l[2:6] 左闭右开 结束下标取不到
6,7,8,9

遍历
for i in l:
print(l)

列表中添加元素

l = [1,2,3]
l.append(4)
l #结果为[1，2，3，4]
l.append('abc')
l #结果为[1,2,3,'abc']  append只能添加一个元素
插多个元素：extend
l.extend('abc')
l #结果为[1,2,3,'a','b','c']
往前插  insert
l.insert(0,99) #在指定的下标前，插入一个数值
l #结果为[99,1,2,3]

元组，tuple,有限制的列表
列表是可以更改元素的（可变类型）
元组是不可以更改元素的（不可变类型）
1.手工创建，2构造函数创建，3访问：1个（下标操作也叫索引操作），多个（划分），全部（遍历） 4.增删改

手工创建
t = (1,2,3)

构造函数
t = tuple(‘abc’)

访问
1.一个
t=(‘a’,’b’,’c’)
t[1] 为b

2.多个
t[0:2]
如果从第一个数据开始切片，起始下标可以省略
t[:2]得到效果和t[0:2]一样
如果切片到最后一个元素结束，结束下标可以省略
t[1:]

t[:]切片全部

3.全部
for i in (1,2,3)
print(i)

t=(1,2,3)
t=1,2,3 书写时可以省略圆括号，系统会自动填补圆括号
t=(1,) 元组中，圆括号可以省略，但是逗号不能省略
t=1,
print(t,type(t)) 结果是
a,b,c=1,2,3 1,2,3是一个元组
a,b,c=(1,2,3)
(a,b,c)=(1,2,3) 元组赋值
[a,b,c]=[1,2,3]
print(a,b,c) 结果是1，2，3
a,b,c=[1,2,3] 序列赋值 序列：支持索引操作，支持切片操作 元组赋值是特殊的序列赋值
print(a,b,c)

字符串
不可变类型，创建好后不能修改
支持索引操作（可以通过下标访问）
s=’’空串
s=str(100) 把整型100改成字符串100
s=str([1,2,3]) 输出s的结果是 [1,2,3] 你给我啥我就把啥转成字符串

s=’abc’ 单引号字符串
s=”abc” 双引号字符串
s
此时s的结果是’abc’ 是单引号
其实双引号是和单引号交叉使用的
s=’abc’
s=”abc” 双引号字符串应用于单双引号的嵌套
s=”Let’s GO”
s
结果为”Let’s GO”

s=’’’ 可以多行打印，和三个双引号字符串效果一样
sdfasd
sdfasd
sdfaaf
‘’’
s
结果为
sdfasd
sdfasd
sdfaaf

转义字符，通常有特殊功能
s=’C:\notebook\test.txt’
print(s)
结果：
C:
outebook est.txt
因为把\n当作了转义字符，换行
\t当作了制表字符空格
所以需要s=r’C:\notebook\test.txt’ r的含义是让所有里面转义字符失效，让它就是它原始的东西 原始字符串，让转义字符失去转义功能
此时在打印s才是C:\notebook\test.txt

二进制字符串：bytes类型
str-bytes:cncode()编码
bytes-str:decode()解码
s1=’abc’
s2=r’abc’
s3=b’abc’
print(type(s1),type(s2),type(s3) 类型分别为str str bytes
print(s1,s2,s3) 结果为abc abc b’abc’

s=’Hello World’
s.upper() 全部大写
s.lower() 全部小写

s1=’abc’
s2=’def’
s1+s2 结果 abcdef
s1*3 abcabcabc

s=’I Love %s Python’%’飞哥’ %s是一个占位符 用于替换
print(s) I Love 飞哥 Python
s=’I Love %s and %s Python’%(‘飞哥’ ,’小波’)
print(s) I Love 飞哥 and 小波 Python
s=’I Love %s and %s Python’%(100 ,[1,2,3])
print(s) I Love 100 and [1,2,3] Python

集合 set
学习法：1.手工创建 2.构造函数 3.访问： 1个，多个，所有 4.增删改

手工创建
s={1,2,3}
s {1,2,3}

构造函数创建
空集合 s= set() 没有手工版的空集合，只有函数构建的空集合
s=set([1,2,3])
s {1,2,3}

访问
s={1,2,3} 集合不支持索引操作，不支持切片操作 不是序列
for i in s: 集合是一个可迭代对象
print(i)
结果是
1
2
3

集合专用方法
1.add给集合添加元素
2.pop随机删除一个元素
3.remove删除指定元素，元素不存在报错

s={1,2,3}
s.add(4)
s
结果为{1,2,3,4}

s={1,2,3,2,2,2,3,5,6}
s {1,2,3,5,6} 集合中的数据是唯一的，不会出现重复的数据
len(s) 返回可迭代对象长度
为5

s={1,2,3,3}
s {1,2,3} 这个3是前面的3 只保留出现过的数据（老数据）

s={1,2,3,4,5}
s.pop() 删除
s {2,3,4,5}

s={‘one’,’two’,three’,’four’,’five’,’six’) 集合是无序的
s.pop() 删除，本质是随机删 python3.6之后多用了底层实现，记录输入顺序，每次随机结果是一样的
s (‘five’,’four’,’one’,’six’,’three’}

s={1,2,3}
s.remove(2)
s {1,3}

字典
是python中唯一的映射类型（一一对应的）
是可迭代对象，列表，字符串，元组，集合，字典都是
字典以键值对的形式进行存储
字典可以存储多个数据
字典的键必须是不可变类型数据
字典的值没有要求
字典是无序的

字典dict
手工：
d={‘one’:1,’two’:2,’three’:3}
len(d) 3
d={1:1,2:2,3:3}
d {1:1,2:2,3:3}

d={}空字典 所以集合不能这样用，因为是给字典用的

构造函数
第一种
d=dict(a=1,b=2,c=3)
d {‘a’:1,’b’:2,’c’:3}

第二种
d=dict([[‘a’,1],[‘b’,2],[‘c’,3]])
d {‘a’:1,’b’:2,’c’:3}

第三种
d=dict({‘a’:1,’b’:2,’c’:3}) 用字典去创建字典
d {‘a’:1,’b’:2,’c’:3}

字典也不支持索引操作，不支持切片操作，支持遍历操作
d={‘a’:1,’b’:2,’c’:3}
for i in d:
print(i) 字典中直接能看到的是只有键
结果是
a
b
c

d={‘a’:1,’b’:2,’c’:3}
d[‘a’] 结果是1 访问一个元素
d[‘c’] 结果是13
d[‘a’]=99 修改字典元素 字典的键是不重复的
d {‘a’:99,’b’:2,’c’:3}
d[‘e’] 会报错 ，因为e不存在
d[‘e’] = 100 如果给不存在的键赋值，表示给字典添加一组键值对
d {‘a’:99,’b’:2,’c’:3,’e’:100}

d={‘a’:1,’b’:2,’c’:3}
d[‘e’]=[1,2,3]
d {‘a’:1,’b’:2,’c’:3,’e’:[1,2,3]}

d={‘a’:1,’b’:2,’c’:3,’e’:[1,2,3]}
d[‘e’][2] 结果为3

d={‘a’:1,’b’:2,’c’:[1,{‘one’:l,’two’:{‘three’:(1,2,9)}},3}
d[c][2] 得到 3e
d[c][1][two][three][2] 得到9