类型使用分解
2021-08-02 本文已影响0人
慕知
一，数字类型
1) 定义,整型
age=10
print(age,type(age))
10 <class 'int'>
2) 类型转换
# 字符串类型转换为数字类型
a='123'
print(type(a))
a=int(a)
print(type(a))
<class 'str'>
<class 'int'>
二，字符串类型
1) 定义
# 定义：在单引号\双引号\三引号内包含一串字符
name1='lili'
name2="pp"
name3='''bb'''
2) 类型转换
# 列表转字符串
name1=['lili','pp','bb']
print(type(name1))
name1=str(['lili','pp','bb'])
print(type(name1))
<class 'list'>
<class 'str'>
# 字典转字符串
info={"name":"mz","gender":"male"}
print(type(info))
info=str({"name":"mz","gender":"male"})
print(type(info))
<class 'dict'>
<class 'str'>
3) 索引取值
info = 'good morning'
# 正向取值
print(info[0])
g
# 反向取值
print(info[-2])
n
4）切片
info = 'good morning'
# 取出索引为0-12的所有字符
print(info[0:12])
good morning
# 反向切片，-1代表从右往左一次取值
print(info[::-1])
gninrom doog
# 第三个参数3代表步长，从索引0开始，每次累加3
info = 'good morning'
print(info[0:12:3])
gdoi
# 复制切片
msg='hello world'
print(msg[:])
print(msg[::-1])
hello world
dlrow olleh
# 取值第五个索引到第0个索引，反着取，顾头不顾尾
print(msg[5:0:-1])
olle
5) 字符串长度
# 空格也算一个字符
info = 'good morning'
print(len(info))
12
6）in / not in 判断
info = 'good morning'
# 判断good是否在字符info里
print('good' in info)
# 判断bad是否不在字符info里
print('bad' not in info)
True
True
7) strip lstrip rstrip移除字符串首尾制定的字符
--------------------------------strip
# 默认去除空格
name=' mz '
print(name)
print(name.strip())
mz
mz
# 去除制定字符
info='###mz###%'
print(info.strip('#%'))
mz
--------------------------------lstrip
# 移除左边的字符
info = '&&&& mz $$$'
print(info.lstrip('& '))
mz $$$
--------------------------------rstrip
# 移除右边的字符
info = '&&&& mz $$?'
print(info.rstrip('$ ?'))
&&&& mz
8) split / rsplit切分
--------------------------split
# 括号内不指定字符，默认以空格作为切分符号
info='hello baby'
print(info.split())
['hello', 'baby']
info='10.0.0.6'
print(info.split('.'))
['10', '0', '0', '6']
abc='C:/a/c/c.txt'
# 切割1次
print(abc.split('/',1))
# 切割2次
print(abc.split('/',2))
['C:', 'a/c/c.txt']
['C:', 'a', 'c/c.txt']
info="egon:16:female"
# 代表取出0，1，2的索引的值
res=info.split(':',2)
print(res)
['egon', '16', 'female']
注意:
split切割得到的结果是列表数据类型
---------------------------rsplit
# rsplit刚好与split相反，从右往左切割，可以指定切割次数
abc='a|b|c|d'
# 切割1次
print(abc.rsplit('|',1))
# 切割2次
print(abc.rsplit('|',2))
['a|b|c', 'd']
['a|b', 'c', 'd']
备注：
例（2www2eee2rrr）
如果以上按照2切分，那么得到第一个字符合作最后一个字符都是空
info="2www2ee2"
print(info.split('2'))
['', 'www', 'ee', '']
9) 循环
info='hello?'
for i in info:
print(i)
h
e
l
l
o
?
10) lower(),upper() 字符串大小写
# 将英文字符串全部变成大写
name='muzhi'
print(name.upper())
MUZHI
# 将英文字符串全部变成小写
name='MUzHI'
print(name.lower())
muzhi
11）startswith,endswith
----- 判断字符串是否以括号内指定的字符结尾 / 开始
# 判断字符info是否以girl为结尾
info='beautiful_girl'
print(info.endswith('girl'))
True
# 判断字符info是否以abc为开始
info='beautiful_girl'
print(info.startswith('abc'))
False
12）格式化输出 format
# 方式一
info='my name is %s,my age is %s' %('mz',13)
print(info)
# 方式二
info='my name is {x},my age is {y}'.format(x='mz',y=13)
print(info)
# 方式三
# 类似于%s的用法，传入的值会按照位置与{}一一对应
info='my name is {},my age is {}'.format('mz',13)
print(info)
# 方式四：
# 把format传入的多个值当作一个列表，然后用{索引}取值
info='my name is {0},my age is {1}'.format('mz',13)
print(info)
my name is mz,my age is 13
PS:
info='my name is {x}{x},my age is {y}{y}'.format(x='mz',y=13)
print(info)
my name is mzmz,my age is 1313
13）join 拼接（把一个纯字符串组成的列表拼接成字符串）
#join拼接：把一个纯字符串组成的列表拼接成字符串
l=["mz","18",'female']
rres=":".join(l)
print(rres)
mz:18:female
print('---'.join('abc'))
print('**'.join('hello'))
a=('11','22','33')
aa="*".join(a)
print(aa)
a---b---c
h**e**l**l**o
11*22*33
注意：
必须是字符串，数字类型会报错
a=('11','22','33')要加引号
14) replace 新的字符替换字符串中旧的字符
# 以下出现2个“mz”， 1代表只把第一个mz替换
info='my name is mz , my bbs name is mz,my age is 88'
info2=info.replace('mz','mm',1)
print(info2)
my name is mm , my bbs name is mz,my age is 88
15） isdigit
--------- 判断字符串是否是纯数字组成，返回结果为True或False
a='333'
print(a.isdigit())
True
b='333lg'
print(b.isdigit())
False
三，列表类型
1，用途
用途：按照索引记录多个值，索引反映的是位置
2，定义方式
定义方式： 在[ ]内用逗号分隔开个多个任意类型的元素
#例
res=["aaa",222,['aa','bb'],"pp"]
print(type(res))
<class 'list'>
#例1
info='hello'
print(type(info))
<class 'str'>
# 例2
info=list(info)
print(type(info))
<class 'list'>
# 例3
# # list数据类型转换：能够被for循环遍历的类型，都可以被list转成列表
res = list({'k1':111,"k2":222,'k3':333})
print(res)
['k1', 'k2', 'k3']
3，取 / 替换值
# 按照索引取值
info=["mz","egon",33]
# 正向取值
print(info[0])
# mz
# 反向取值
print(info[-1])
# 33
# 查看id
print(id(info))
# 4333209728
# 根据列表索引替换对应的值，字符串不可以这么做
info[2]="tom"
print(info)
# ['mz', 'egon', 'tom']
# 不可以操作不存在的索引
info[2]="pp" # 会报错
# 可以insert，补充索引和对应的值
info.insert(3,"lily")
print(info)
# ['mz', 'egon', 'tom', 'lily']
4，切片
#切片(顾头不顾尾，步长)
info=[11,22,33,44,55]
# 索引0-4，步长为1（0索引累加1个索引，得出值）
print(info[0:4:1])
# [11, 22, 33, 44]
# 索引1-4之间，步长为2（索引1开始，累加2个索引，得出值）
print(info[1:4:2])
# [22, 44]
# 浅拷贝
print(info[:])
# [11, 22, 33, 44, 55]
# 反向取值
print(info[::-1])
# [55, 44, 33, 22, 11]
5，长度
# 长度
info = [11,22,33]
print(len(info))
# 3
6，成员运算in / not in
info=[11,22,33]
# 判断22是否在列表info里
print(22 in info)
# True
易错
# 注意这里22加上引号是字符串
print("22" in info)
# False
info=[11,22,33]
print(77 not in info)
# True
7，追加 / 插入
# append 默认追加在最后，只能追加一个元素
info=[11,22,33]
info.append(44)
print(info)
# [11, 22, 33, 44]
# extend 一次性在列表最后加入多个元素，注意要加上列表中括号
info=[11,22,33,44]
info.extend([55,'66'])
print(info)
# [11, 22, 33, 44, 55, '66']
# insert 在指定位置上插入元素,注意这里可以不用给元素加上引号，不然识别的元素也会加上引号
info=[11,22,33]
info.insert(3,'44')
print(info)
# [11, 22, 33, '44']
# insert 指定索引更改元素
info=[11,22,33]
# 索引0增加元素99
info.insert(0,99)
print((info))
# [99, 11, 22, 33]
8，删除 del / pop / remove
1) del
# del删除，不返回删除值
info=[11,22,33]
del info[2]
print(info)
# [11, 22]
2) pop
# pop pop()默认删除列表最后一个元素,也可以指定索引删除
info=[11,22,33]
print(info.pop())
# 33
print(info)
# [11, 22]
# 指定索引,删除索引1的值
info=[11,22,33]
print(info.pop(1))
# 22
3) remove
# remove()括号内指名道姓表示要删除哪个元素，没有返回值
info=[11,22,33]
info.remove(11)
print(info)
# [22, 33]
9，reverse( ) 颠倒列表内元素的顺序
info=[11,22,33]
info.reverse()
print(info)
# [33, 22, 11]
等同于
info=[11,22,33]
print(info[::-1])
# [33, 22, 11]
10，sort()给列表内所有元素排序
# sort排序（从小到大）
info=[88,33,22]
info.sort()
print(info)
# [22, 33, 88]
# sort + reverse,指定排序并颠倒
info=[3,5,1,4,3]
info.sort(reverse=True)
print(info)
# [5, 4, 3, 3, 1]
# sort + reverse,指定排序并从小到大排列（多余，可以直接用sort）
info=[3,5,1,4,3]
info.sort(reverse=False)
print(info)
# [1, 3, 3, 4, 5]
PS：
# 列表元素数量不同，也比较大小
a=[1,2]
b=[3]
print(a > b)
# 字符也可以比大小
s1='abc'
s2='t'
print(s1 > s2)
# 列表里的字符排序
info=['aw','bb','kk']
info.sort()
print(info)
# ['aw', 'bb', 'kk']
# 列表里的字符和数字不可以排序（会报错）
info=['aw',44,'kk']
info.sort()
print(info)
# 44加引号 "44",不会报错
# # ['44', 'aw', 'kk']
11，循环
# 循环
my_friend=['tom','peter','bb']
for i in my_friend:
print(i)
# tom
# peter
# bb
四，元祖类型
1，元祖类型定义
info=('abc','bcd')
print(type(info))
# <class 'tuple'>
PS:
# 不要混淆字符串类型是一个元素，元祖类型是多个元素
info=('abc')
print(type(info))
# <class 'str'>
2，类型转换
# 类型转换
# 列表类型转元祖类型
info=tuple([1,2,3])
print(info)
# (1, 2, 3)
# 字典类型转元祖类型
info=tuple({"name":"mz","age":25})
print(info)
# ('name', 'age')
3，使用
1) 索引取值
tuple1=(11,22,33)
print(tuple1[0])
2) 切片（顾头不顾尾，步长）
tuple1=(11,22,33)
# 倒序取值
print(tuple1[::-1])
# (33, 22, 11)
# 索引1-3之间，索引3不算（顾头不顾尾），步长为1 取值
tuple1=(11,22,33,44,55)
print(tuple1[1:3:1])
# (22, 33)
3) 长度
tuple1=(11,22,33)
print(len(tuple1))
4) 成员运算
tuple1=(11,22,33)
print('aa' in tuple1)
# False
print(11 in tuple1)
# True
5）循环
# 循环
tuple1=(11,22,33)
for i in tuple1:
print(i)
# 11
# 22
# 33
五，字典类型
1，定义方式
在{}内用逗号分割开多个元素，其中每个元素都是由key:value的格式的组成
key， 必须是不可变类型（通常为字符串类型）
value， 可以是任意类型
dicc={"k1":22,"k2":"dd"}
print(type(dicc))
print(dicc["k1"])
#<class 'dict'>
#22
2，类型转换
# 字符串类型转换为列表类型
info=list('hello')
print(info)
# ['h', 'e', 'l', 'l', 'o']
# 原列表类型，转换为字典类型
info=[("name","muzhi"),("age",18)]
print(info,type(info))
#[('name', 'muzhi'), ('age', 18)] <class 'list'>
new_info=dict(info)
print(new_info)
# {'name': 'muzhi', 'age': 18}
3，常用操作+内置的方法
1.1)按key存取值（可存可取）
info={"name":"muzhi","age":66,"gender":"male"}
print(info["name"])
# muzhi
# 对于字典类型，可以根据不存在的key往里添加一组元素
info["hobby"]="sing"
print(info)
# {'name': 'muzhi', 'age': 66, 'gender': 'male', 'hobby': 'sing'}
1.2)get取值
info={"name":"muzhi","age":66,"gender":"male"}
print(info.get("name"))
# muzhi
# 取一个不存在的key值，返回None
print(info.get("name2"))
# None
2，长度
# 按照多少个key值得出长度
info={"name":"muzhi","age":66,"gender":"male"}
print(len(info))
# 3
3，成员运算in和not in
根据key判断
info={"name":"tom","age":18,"gender":"male"}
# 根据key值判断
print("name" in info)
# True
# 根据value判断，False
print("male" in info)
# False
4，删除
#del 万能删除
info={"name":"tom","age":18}
del info['age']
print(info)
# {'name': 'tom'}
# pop 删除（有返回值，返回value值）
info={"name":"tom","age":18}
res=info.pop("name")
print(res)
#tom
# popitem 随机删
info={"name":"tom","age":18}
res=info.popitem()
print(res)
# ('age', 18)
5，键keys()，值values()，键值对items()
# dic.keys()
# dic.values()
# dic.items()
info={"name":"tom","age":18,"gender":"female"}
# 只取出key值
print(info.keys())
# dict_keys(['name', 'age', 'gender'])
# 只取出value值
print(info.values())
# dict_values(['tom', 18, 'female'])
print(info.items())
#dict_items([('name', 'tom'), ('age', 18), ('gender', 'female')])
6，循环
info={"name":"tom","age":18,"gender":"female"}
# 取出key值
for k in info.keys():
print(k)
# name
# age
# gender
# 取出value值
for v in info.values():
print(v)
# tom
# 18
# female
for i in info.items():
print(i)
# ('name', 'tom')
# ('age', 18)
# ('gender', 'female')
7，update / copy
info={"name":"tom","age":18,"gender":"female"}
# 把字典的name和age更新对应的值，注意语法格式update({ })有中括号
info.update({"name":"muzhi","age":99})
print(info)
# {'name': 'muzhi', 'age': 99, 'gender': 'female'}
res=info.copy()
print(res)
# {'name': 'muzhi', 'age': 99, 'gender': 'female'}
8，fromkeys
#初始化返回一个新字典，通过append赋值value
info={}.fromkeys({"id","name"},[])
info["name"].append('mmm')
print(info)
# {'name': ['mmm'], 'id': ['mmm']}
# 以上指定的是[ ] 字典，如果像赋值字符串，不可以使用append
abc={}.fromkeys({"name","age"},"")
print(abc)
abc["name"]='xxxxxx'
print(abc)
# {'age': '', 'name': 'xxxxxx'}
9，setdefault
# key不存在则新增键值对，并将新增的value返回
dic = {'name': 'egon', 'age': 18, 'gender': 'male', "level": 19}
res=dic.setdefault("hobby","sing")
print(res)
# sing
print(dic)
# {'name': 'egon', 'age': 18, 'gender': 'male', 'level': 19, 'hobby': 'sing'}
# key存在则返回对应key的value值
dic = {'name': 'egon', 'age': 18, 'gender': 'male', "level": 19}
res=dic.setdefault("name","muzhi")
print(res)
# egon
PS：
注意setdefault后面括号跟的是逗号，不是冒号
======================== 等同于 ========================
dic = {'name': 'egon', 'age': 18, 'gender': 'male'}
if 'level' in dic:
pass
else:
dic['level']=19
print(dic)
# {'name': 'egon', 'age': 18, 'gender': 'male', 'level': 19}```
六，集合
1，作用
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
2，定义
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
info={1,3,5,2} # 等同于 info=set({1,3,5,2})
print(info)
# {1, 2, 3, 5}
# 注意1：
列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值;
而集合类型既没有索引也没有key与值对应，所以无法取得单个的值;
对于集合来说,主要用于去重与关系元素，根本没有取出单个指定值这种需求。
# 注意2:
{}既可以用于定义dict，也可以用于定义集合
但是字典内的元素必须是key:value的格式
d = {} # 默认是空字典
s = set() # 这才是定义空集合
3，使用
1，关系运算
- 例：for去重
例：取出以下的都有的名字
# 方式一
fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
for name in fridens1:
if name in friends2:
print(name)
# tom
# lily
# 方式二
fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
l=[]
for name in fridens1:
if name in friends2:
l.append(name)
print(l)
# ['lily', 'tom']
- 符号运算
fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
# 1，合集 / 并集 （ ｜ ）
print(fridens1 | friends2)
# {'mmmzhi', 'huahua', 'lily', 'pepe', 'tom', 'egggg', 'dogdog', 'mimi'}
# 2，交集（ & ）
# 用户一独有的好友
print(fridens1 & friends2)
# {'tom', 'lily'}
# 用户2独有的好友
print(friends2 - fridens1)
# {'mimi', 'dogdog', 'huahua'}
# 3，差集 （ - ）
print(fridens1 - friends2)
# {'egggg', 'pepe', 'mmmzhi'}
# 4，对称差集 ( ^ )
# 两个用户独有的好友，即去掉共同的好友,结果是无序的！！
print(fridens1 ^ friends2)
# {'mmmzhi', 'dogdog', 'huahua', 'pepe', 'mimi', 'egggg'}
# 5，值是否相等 ( == )
print(fridens1 == friends2)
# False
# 6，父集：一个集合是否包含另一个集合
##1） 包含则返回True
res={1,3,5} > {1,3}
print(res)
# True
res1={1,3,5} >= {1,3}
print(res1)
# True
##2） 不包含则返回False
info={1,2} > {1,2,22}
print(info)
# False
# 7，子集
res={1,2} <= {1,12,3,2}
print(res)
# True
2，类型转换 / 去重（只针对不可变类型）
1）无序去重
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
例：
# 列表类型转集合
l=[1,2,2,"a","c","a"]
print(type(l))
# <class 'list'>
# 转为集合
new_l=set(l)
print(new_l)
# {1, 2, 'c', 'a'}
# 再转回列表,去除了重复，但是打乱了顺序
s=list(new_l)
print(s)
# ['a', 1, 2, 'c']
2）for 循环去重（有序）
针对不可变类型，并且保证顺序则需要我们自己写代码实现
# 列表转集合（去重，无序）
相比下面的例子，同样是列表，但是列表的元素不同，这个例子中的元素是不可变类型
info=["abc","bbb","cbb","abc","bbb"]
# 转集合
new_info=set(info)
print(new_info)
# {'bbb', 'abc', 'cbb'}
info=[
{"namw":"tom","age":77,"gender":"female","level":10},
{"namw":"egon","age":7,"gender":"female","level":19},
{"namw":"muzhi","age":97,"gender":"male","level":1},
{"namw":"egon","age":7,"gender":"female","level":19},
]
# 如下列表会报错，只适用于不可变类型
new_info=set(info)
print(info)
# TypeError: unhashable type: 'dict'
new_info=[]
for name in info:
if name not in new_info:
new_info.append(name)
print(new_info)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
# [{'namw': 'tom', 'age': 77, 'gender': 'female', 'level': 10}, {'namw': 'egon', 'age': 7, 'gender': 'female', 'level': 19}, {'namw': 'muzhi', 'age': 97, 'gender': 'male', 'level': 1}]
3，其他操作
#1,长度
l={1,3,6,"a"}
print(len(l))
# 4
#2，成员运算
l={1,3,6,"a"}
print("s" in l)
# False
#3, 循环
l={1,3,6,"a"}
for i in l:
print(i)
# 1
# 3
# 6
# a
补充：可变类型/不可变类型
1）数字类型 (不可变)
x=10
print(id(x))
# 4380713520
x=3
print(id(x))
# 4380713296
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样
2）字符串 (不可变)
y='tt'
print(id(y))
# 4300352880
y='uu'
print(id(y))
# 4299950064
# 内存地址改变了，说明字符串是不可变数据类型
3）列表（可变）
list1=[11,22,"tom"]
print(id(list1))
# 4314417280
list1[2]="egon"
print(id(list1))
# 4314417280
list1.append('xxx')
print(id(list1))
# 4314417280
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型
3） 元祖（不可变）
如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
t1=(33,'yy',['aa','bb'])
print(id(t1))
#t1[0]=66 # 会报错
#t1.append('p') # 会报错
print(id(t1[0]),id(t1[1]),id(t1[2]))
# 4337640720 4338970096 4338681984
t1[2][1]='pp'
print(id(t1[0]),id(t1[1]),id(t1[2]))
# 4337640720 4338970096 4338681984
# 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变
4）字典（可变）
dic={"name":"xxx","age":99,"gender":9}
print(id(dic))
# 4332807808
dic['age']=100
print(id(dic))
# 4332807808
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型
