python学习第二天-基本数据类型常用方法

1.直入主题

python中基本的数据类型有

数字（整形，长整形，浮点型，复数）

　　字符串

　　字节串：在介绍字符编码时介绍字节bytes类型

　　列表

　　元组

　　字典

　　集合

下面我们直接将以下面几个点进行学习

#一：基本使用
1 用途

2 定义方式

3 常用操作+内置的方法

#二：该类型总结
1 存一个值or存多个值
    只能存一个值
    可以存多个值，值都可以是什么类型

2 有序or无序

3 可变or不可变
    ！！！可变：值变，id不变。可变==不可hash
    ！！！不可变：值变，id就变。不可变==可hash

2.常用方法总结

1.数字(常用就是表达一个值，没有专用的方法)

数字类型中(比如整形，浮点型等)

2.字符串

#常用作描述性质的数据
#定义：在单引号\双引号\三引号内，由一串字符组成

name = 'zhang san'

#常用的字符串操作方法
#1按索引取值,只能去不能修改
char1 = name[0]#输出第一个元素
print(char1)

#2.切片(顾头不顾尾)
# 输出从0-4的字符，不包括4这个索引对应的值，返回的是一个新的=字符串
char2 = name[0:4]
print(char2)

#3.长度计算
print(len(name))

#4.成员运算in 和 not in
if 'z' in name:
    print('我在')
else:
    print('赶紧加我')

#5.移除空白和指定的字符串,只能去除两边的空白和指定字符串，中间的去除不了
message = '      我就是我    颜色不一样的烟火       '
print(message.strip())
test = '……&*&（&（&……这就是你们想的(*^*%^&%'
print(test.strip('……&*&（&（&……(*^*%^&%'))

#6.大小写转换
print(name.lower())
print(name.upper())
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
print(name.title()) #每个单词的首字母大写

#7.判断字符串的开始和结束
print(name.startswith('zhang'))
print(name.endswith('g'))

#8.格式化字符串的三种方法
res1 = '{} {} {}'.format('zhang','san','ni hao')
res2 = '{1} {0} {1}'.format('我就是我','你看啥','说你呢')
res3 = '{name} {age} {sex}'.format(sex='male',age=19,name='zhangsan')
print(res1)
print(res2)
print(res3)

#9.字符串分割
res4 = '18|张三|男|上海科技学院|计算机科学与技术专业'
print(res4.split('|'))

#10.拼接字符串,添加字符串分割符，在添加字符数组
res5 = '--'.join(res4.split('|'))
print(res5)

#11.替换字符串,替换res4中的|为++，后面的参数还可以指定替换的次数
res6 = res4.replace('|','++')
print(res6)

#12.判断是bytes和unicode类型，是最常用的用于判断字符是否为数字的方法
age = input('请输入年级>>:')
print(age.isdigit())
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

#13.查找字符中特定字符出现的次数
print(name.count('z'))

3.列表

#常用作描述多个值
#定义：[]内，有多个任意值，逗号分隔

#1.按值索引 可以存也可以取
showList = ['我','就是','我','不一样','的','烟火']
print(showList[3])
showList[0] = '还有谁'

#2.切片,[0:5:2],从0-5这六个元素按着步长为2获取
# 步长可以为负值，开始 结束都是可以省略的，步长为-1 就是反转列表
# 初始值 或者结束值省略都是默认从最前面或者到最后面
print(showList[0:5:2])
print(showList[::-1])

#3.列表的长度
print(len(showList))

#4.成员运算in和not in
print('haha' in showList)

#5.列表中添加元素和删除元素
# 添加在列表最后
showList.append('哈哈哈')
print(showList)
#插入列表中的任意位置
showList.insert(3,'插入的数据')
print(showList)

#6.删除
del showList[0] #这是一种通用的删除方式

res = showList.remove('哈哈哈') #单纯的删除 没有返回值
res1 = showList.pop()#默认是删除列表最后一个元素 返回删除的元素
res2 = showList.pop(2)#指定删除元素的位置

#7.循环
#没有索引值，要手动拿到索引值
for value in showList:
    index = showList.index(value)
    print(index,value)
#添加索引值和元素
for index,value in enumerate(showList):
    print(index,value)

4.元祖

#一：tuple基本使用
# 用途：不可变的列表
# 定义方式：()内用逗号分隔开多个任意类型的元素
t=('a',1,3.3) #t=tuple(('a',1,3.3))
print(t,type(t))

t1=tuple('hello') # 任意可以被for循环的数据类型都可以被tuple转成元组
print(t1,type(t1))

# 常用操作+内置的方法
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
t1=(1,2,3,4,5)
print(t1[0:3])

#3、长度
#4、成员运算in和not in

#5、循环
for item in t1:
    print(item)

#二：该类型总结
# 多个值

# 有序

# 不可变:
# 元组可变指的元组内索引对应的内存地址不变
# 列表可变指的列表内索引对应的内存地址可以改变

l1=['a','b','c']
print(id(l1[0]))

l1[0]='A'
print(id(l1[0]))

t1=('a','b',[3.1,'bbb'])
print(id(t1[0]),id(t1[1]),id(t1[2]))

t1[2][0]=3.2
print(id(t1[0]),id(t1[1]),id(t1[2]))
#
#
#
#

# 需要掌握的操作：
t=('a','b','a','a')

t.index('c')
print(t.index('a',5,7))

print(t.count('a'))

5.字典

#一：基本使用
# 用途:存多个种类不同的值
# 定义方式：在{}内用逗号分隔开多个元素，每一个元素都是key:value的形式，key应该对value有描述性的功能
# 注意：value可以是任意类型，而key必须是不可变类型且唯一，
# 即字典的key可以是int、float、tuple、str，通常是字符串类型
d={3.1:1,(1,2,3):2222} #d=dict({3.1:1,(1,2,3):2222} )
print(d[(1,2,3)])

# 了解
d1=dict(x=1,y=2,z=3)
print(d1)
# 了解
d2=dict([('name','egon'),['age',18],('sex','male')])
print(d2)

# 常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
d={'name':'egon','age':18}
print(id(d))
d['name']='EGON'
print(id(d))
print(d)

l=['a','b']
l[2]='c'
d={'name':'egon','age':18}
d['sex']='male'
print(d)

#2、长度len
d={'name':'egon','age':18,'age':19,'age':20}
print(d)
print(len(d))

#3、成员运算in和not in:判断的是字典的key
d={'name':'egon','age':18}
print('name' in d)

#4、删除
d={'name':'egon','age':18}
res=d.pop('sex',None)
print(res)

res=d.pop('name',None) # 删除key对应的元素，返回的是value值
print(res)
print(d)

#5、键keys()，值values()，键值对items()
#了解：python2中的格式
# >>> d={'name':'egon','age':18}
# >>>
# >>> d.keys()
# ['age', 'name']
# >>> d.values()
# [18, 'egon']
# >>>
# >>> d.items()
# [('age', 18), ('name', 'egon')]

#python3中的格式
d={'name':'egon','age':18}

# print(d.keys())
# print(d.values())
# print(d.items())

# print(list(d.keys()))
# print(list(d.values()))
# print(list(d.items()))

#6、循环
d={'name':'egon','age':18}
# for k in d.keys():
#     print(k)

#
# for k in d:
#     print(k,d[k])

# for v in d.values():
#     print(v)

# for k,v in d.items(): #k,v=('name', 'egon')
#     print(k,v)

#7:get取值
# d={'name':'egon','age':18}
# d['sex']
# res=d.get('sex',None)
# print(res)

# res1=d.get('name',None)
# print(res1)

#二：该类型总结
# 存多个值

# 无序

# 可变

# 需要掌握
d={'name':'egon','age':18}

# res=d.popitem()
# print(d,res)

# d.update({'x':1,'name':'EGON'}) # 老字典d没有的则添加，有的则以新字典为准进行修改
# print(d)

# 了解

# d={'name':'egon','age':18}
# res1=d.setdefault('name','EGON') # 当key存在时，不修改值，会返回key对应的原值
# print(res1)
#
# res2=d.setdefault('sex','male') # 当key不存在时，则新增一个元素'sex':'male'，会返回新增的value
# print(res2)

# s='hello alex alex say hello sb sb'
# # {'hello':2,'alex':2,'say':1,'sb':2}
# d={}
# words=s.split()
#
# for word in words:
#     print(word,words.count(word))
#     # d[word]=words.count(word)
#     d.setdefault(word,words.count(word)) #{'hello':2}
# print(d)
#

items=('name','age','sex')
# dic=d.fromkeys(items,None)
# {'name':None,'age':None,'sex':None}
# print(dic)

# dic={}
# for item in items:
#     dic[item]=None
# print(dic)

6.集合

#作用：去重，关系运算，

#定义：
知识点回顾
可变类型是不可hash类型
不可变类型是可hash类型

#定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序

注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
#优先掌握的操作：
#1、长度len
#2、成员运算in和not in

#3、|合集
#4、&交集
#5、-差集
#6、^对称差集
#7、==
#8、父集：>,>=
#9、子集：<,<=

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 求出所有报名的学生名字集合
print(pythons | linuxs)
# 求出只报名python课程的学员名字
print(pythons - linuxs)
# 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

去重
showlist=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]

#去重,无需保持原来的顺序
l=['a','b',1,'a','a']
print(set(l))

#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)
#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)

print(l1)

#同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

#列表中元素为可变类型时,去重,并且保持原来顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)

print(l1)

#定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))