python的数据类型字符串列表字典元祖集合编码补充等

Posted 2020-10-30

1、字符串 ： ‘内容‘ 少量数据的存储
索引：就是下标就是从0开始

s = ‘python自动化学习‘
s1 = s[0]
print(s1) #通过索引找到元素

切片：就是一段，【0：4】顾头不顾尾

s = ‘python自动化学习‘
#通过切片查找python
s1 = s[0:6]
print(s1)

步长：跳着取

s = ‘python自动化学习‘
#通过跳着切片查找
s2 = s[:5:2] #0可以省略
print(s2)

反方向取值：必须加反向步长-1
s = ‘python自动化学习‘
#倒着取值必须加反向步长 -1
s3 = s[-1:-6:-1]
print(s3)

字符串操作方法：
.capitalize()首字母大写，其他小写

s = ‘nxfxxy‘
s1=s.capitalize() #新的字符串,
print(s1)

.upper()全部都大写

s = ‘nxfxxy‘
s1 = s.upper()
print(s1)

.lower()全部小写

s = ‘nxfxxy‘
s1 = s.lower()
print(s1)

小练习：
code = ‘QeAr‘.upper().lower()
you = input(‘>>plese:‘).upper().lower()
if you ==code:
print(‘yes‘)
else:
print(‘no‘)

.swapcase()大小写反转大变小，小变大

s = ‘nxFxxy‘
s1 = s.swapcase()
print(s1)

.title() 每个首字母大写，非字符隔开的每个单词

s = ‘nxFxxy ycq q77*&bai‘
a=s.title()
print(a) #非字母隔开首字母大写全部

.center（）居中,默认填充为None

s = ‘nxFxxy‘
a =s.center(20,‘&‘)
print(a) #居中，长度自己设定

.startswith（）以什么开头

s = ‘nxFxxy‘
a = s.startswith(‘n‘)#以什么开头
print(a)

.endswith（）以什么结尾
s = ‘nxFxxy‘
a = s.endswith(‘y‘)#以什么结尾
print(a)

.strip() 去可以写填充，去除字母、除空格，制表符\t 换行符 非常有用
s = ‘ nxFxxy‘

a = s.strip()
print(a)

.lstrip（）去左边
.rstrip（）去右边 #和上面的一样，不进行举例

.split() 字符串转换成列表 重要，设置切割次数

s = ‘sss lll ddd ggg eee‘
sq = s.split()
print(sq) #相当于字符串转换成列表

.join（）通过连接符连接之前的字符串，也可以对列表进行操作，吧列表转化为字符串，不能有非字符串的内容如数字
字符串：
s = ‘sfnxFxxy‘
sw = ‘+‘.join(s)
print(sw) # s+f+n+x+F+x+x+y

列表：
ll =[‘xxx‘,‘ddd‘,‘222‘]
l2 = ‘-‘.join(ll)
print(l2) # xxx-ddd-222

.replace（）用于替换

s = ‘sfnxFxxy‘
sq = s.replace(‘xx‘,‘TT‘)
print(sq) # sfnxFTTy

.find () 找字符串的索引如果有多个那就只找一个

s = ‘sfnxFxxy‘
sq = s.find(‘F‘)
print(sq) #4

.index() 如果找不到就报错不如find好使

s = ‘sfnxFxxy‘
sq = s.index(‘F‘)
print(sq) #4

.isdigit（）用于字符串转换成数字的判断是否有

i = ‘123a‘
if i.isdigit():
i = int(i)
else:
print(‘输入错误‘)

.isalpha（）字符组成判断

i = ‘sdf‘
if i.isalpha():
i = str(i)
print(‘正确‘)
else:
print(‘输入错误‘)

.isalnum（）是否有字符和字母组成判断
公共方法：
.len（）查看长度

s= ‘sdfsadfasdfasdfadsfadsfdsafewtr‘
sq = len(s)
print(sq) #31

.count（）某个元素出现的次数

s= ‘sdfsadfasdfasdfadsfadsfdsafewtr‘
sq = s.count(‘s‘)
print(sq) #7

格式化输出：
.format
%s %d 占位符

res = ‘我叫{} 今年{}岁，爱好{}‘.format(‘egon‘,18,‘male‘)
print(res) #我叫egon 今年18岁，爱好male

res = ‘我叫{0} 今年{0}岁，爱好{0}‘.format(‘egon‘,18,‘male‘)
print(res)

res = ‘我叫{name} 今年{age}岁，爱好{hobby}‘.format(name=‘egon‘,age=18,hobby=‘male‘)
print(res)

2、数字 ：int 多用于计算 1 2 3 .。。
i = 3
i = 6
print(i.bit_length())

‘‘‘
二进制 十进制
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
‘‘‘

3、bool ： True False

4、list ： 【】列表，存放各种数据类型容器类型
索引：取出来之后就是字符串

切片 ： 之后的是列表

小练习：

li = [111,‘alex‘,22,‘wusir‘]
print(li[1])
print(li[:4:2])

增删改查、

增、
.append（）后面加
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.append(‘葫芦娃‘)
print(l)

insert 插入

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]

l.insert(1,‘天使‘)
print(l)

迭代添加：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.extend(‘xxxx‘)
print(l)
看效果：[‘lxf‘, ‘sdf‘, ‘pp‘, ‘sdf‘, ‘x‘, ‘x‘, ‘x‘, ‘x‘]

删除：、

按照索引删除： pop
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.pop(0)
print(l)

按照元素删除、 remove
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.remove(‘pp‘)
print(l)

清空列表： clear
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l.clear()
print(l)

删除列表 del
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l
print(l)

按照索引删除：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l[3]
print(l)

按照切片删除：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
del l[:3]
print(l)

改：

按照索引改：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘]
l[0]=‘zookeeper‘
print(l)

按照切片去改：
l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘,‘df‘]
l[:2]=‘iopl‘
print(l)

查、:
按照索引查：

按照切片查：

l = [‘lxf‘,‘sdf‘,‘pp‘,‘sdf‘,‘df‘]
for i in l:
print(i)

其他方法：
计数count出现的次数
和长度：
l = [1,1,2,3,4,5,76,1,1,6]
print(l.count(1))
print(len(l))

#通过元素找索引
print(l.index(4))

l2 = [3,2,4,5,6,7,8,10,9]
l2.sort()#从小到大
print(l2)
l2.sort(reverse=True) #从大倒小
print(l2)
l2.reverse() #反方向排序
print(l2)

列表的嵌套：

ll = [1, 2, ‘lxf‘, ‘wusir‘,[‘oldboy‘, ‘ycq‘, 99], ‘taibai‘]
ll[2]= ll[2].upper()
print(ll)
ll[4].append(‘女神‘)
print(ll)

5、元祖 ： （）多种数据类型，只读列表，只限制子集的，孙子的可以改

tu = (1,2,True,[2,3,4],‘alssx‘)
for i in tu:
print(i)

tu = (1,2,True,[2,3,4],‘alssx‘)
#切片、索引
print(tu[2])
print(tu[:4])

6、字典 ：{} 键值对key value 大量数据，关联数据，查询快，二分查找

key是唯一的，必须是不可变的数据类型：(可hash )： str bool tuple int ：value 是 任意数据类型

数据分类型：
可变： dict list set
容器类型： list tuple dict set
不可变： 不可变的数据类型：(可hash )： str bool tuple int

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘byc‘:[1,2,3]}
print(dic)

增删改查、

增、
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘high‘] = 180
print(dic)

如果有key在加入有责覆盖，无责添加
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘] = 180
print(dic)

这个是有责不变，无责添加：
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.setdefault(‘name‘,180)
print(dic)

删除：、4中方法
通过键删除，相当于list的索引
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.pop(‘name‘)
print(dic)

清空字典：
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.clear()
print(dic)

删除字典：

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
del dic[‘age‘]
print(dic)

删除最后一个3.6之后3.5 之前是随机删除
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.popitem()
print(dic)

改、

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘]=‘ppp‘
print(dic)

update：

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)

查、

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic[‘name‘]
print(dic)
推荐用这个，不报错
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
dic.get(‘name2‘)
print(dic)

#keys
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
#keys()可以转化成列表
print(dic.keys())
print(list(dic.keys()))

#values()
print(list(dic.values()))

#.tiems（）
print(list(dic.items()))

for i in dic.items():
print(i)

小练习题：：

dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
for k,v in dic.items():
print(k,v)

#len（）查看长度
dic = {‘name‘:‘taivai‘,‘age‘:21,‘hobby‘:‘girl‘,‘alex‘:[1,2,3]}
#len
print(len(dic))

#fromkeys
dic1 = dict.fromkeys(‘abc‘,[1,2,3])
print(dic1)

备注：如果要是list当中是空的时候，如果要写入数据之后，那么将会给所有都变成写入的数据不会只有一个有

7、集合 ： 关系型数据的交集/并集/差集/子集。。列表的去重
无序不重复的数据类型，里面的元素必须是可哈希的，但是集合本身是不可hash

关系测试： 交集、子集、并集、差集
去重（列表去重）

增、
.add
ss = {‘sss‘,‘bbb‘}
ss.add(‘ddd‘)
print(ss)

.update

ss={‘eee‘,‘eee‘,‘ddd‘}
ss.update(‘abc‘)
print(ss)

删除、

.remove
ss={‘eee‘,‘eee‘,‘ddd‘}
ss.remove(‘ddd‘)
print(ss)

其他集合：
#交集
set1 = {1,2,3,4,5}
set2= {4,5,6,7,8}
print(set1 & set2)

#并集
print(set1 | set2)

#差集
print(set1 - set2 )

反交集

print(set1 ^ set2)

frozenset 不可变集合，让集合变成不可变的

s = frozenset(‘barry‘)
s1 = frozenset({1,2,3,4})
print(s,type(s))
print(s1,type(s1))

8、数据类型补充

#range 可制定数字列表
for i in range(1,10,2): #有步长
print(i)

注意：
不要改变、列表、字典的大小
如果元祖里面只有一个元素，并且没有逗号隔开，那么他的数据类型与该元素一致
小数据池：int: -5 ~ 256中相同的数全都指向一个内存地址
str: s = ‘a‘* 20 以内都是同一个内存地址，21就不可以了

深浅copy：
对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变   

9、编码 ：

电信号01010101010101010
电脑：
a‘siic码128
7位标识一个字节
升级到8位一个字节256 2的8次方
00000001 ===一个字符
万国码啊： unicode包括所有国家
16字节表示一个字符
00000001 00000001 ==一个字符 2的16次方

改变：4个字节表一个字符就是三十二次方
11111111 11111111 11111111 11111111 表示一个字节 2的32次方
资源浪费：

升级utf-8：最少用8位：
英文8位一个字节，00000001
欧洲16位两个字节，00000001 00000001
亚洲24位三个字节，00000001 00000001 00000001

python3下：
不同编码之间的二进制是不能互相识别的
pthon3x str 内部编码方式为unicode（内存）
但是，对于文件的存储、和传输不能用unicode

bytes类型：内部编码方式（内存）为非unicode
s1 = b‘ffff‘
print(s1,type(s1))

对于中文：