Python day2 数据类型字符类型文件处理

阅读量：6525 次

发布时间：2019-06-24

本文共 14804 字，大约阅读时间需要 49 分钟。

阅读目录

一数据

二数字

三字符串

四列表

五元组

六字典

七集合

八数据类型总结

九运算符

十字符编码

十一文件处理

一数据

1 . 数据

x=10，10是我们要存储的数据

数据

2. 为何要分为不同类型

数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

为什么要分不同数据类型

3. 数据类型

数字（整形，长整形，浮点型，复数）字符串字节串：在介绍字符编码时介绍字节bytes类型列表元组字典集合

数据类型分类

4. 如何学习数据类型

#一：基本使用1 用途2 定义方式3 常用操作+内置的方法#二：该类型总结1 存一个值or存多个值    只能存一个值    可以存多个值，值都可以是什么类型2 有序or无序3 可变or不可变    ！！！可变：值变，id不变。可变==不可hash    ！！！不可变：值变，id就变。不可变==可hash

学习数据类型

二数字

1. 整形和浮点型

#整型int　　#作用：年纪，等级，身份证号，qq号等整型数字相关　　#定义：　　　　age=10 #本质age=int(10)            print(id(x),type(x),x)#二：float#作用：工资，身高，体重salary=3.1 #salary=float(3.1)print(id(salary),type(salary),salary)

整形和浮点型

2. 其他数字类型

#长整形（了解）    在python2中（python3中没有长整形的概念）：　　　　　　    >>> num=2L    >>> type(num)    
      
       #复数（了解）　　    >>> x=1-2j    >>> x.real    1.0    >>> x.imag    -2.0

其他数字类型

三字符串

1. 字符串

1 #用途：名字，性别，地址2 # name='egon' #name=str('egon')3 # print(id(name),type(name),name)

字符串

#优先掌握的操作# 按照索引取值（正向取值和反向取值）：只能取name='egon' #name=str('egon')print(name[0],type(name[0]))print(name[-2])print(name[-1])name[0]='E'

取值 *

#切片（顾头不顾尾，步长）msg='hello world'print(msg[1:3])print(msg[1:7:3])msg='abcdefg'print(msg[1:6:2])print(msg[:]) #取所有print(msg[::2])#取所有，步长为2print(msg[6::-1])#了解，倒取所有。

切片（顾头不顾尾，步长） *

#长度(len)msg='ab c'print(len(msg))

长度（len） *

#成员运算in和not inmsg='hello alex'print('a' in msg)print('alex' in msg)print('ae' in msg)  #必须是连续的字符

成员运算in 与 not in *

#移除空白strippassword='alex3714    '# password=password.strip()# print(password) #简化为print(password.strip())#取出空格msg='****egon***'print(msg.strip('*'))#去除两端，字符串中间不去。

移除空白strip *

#切分splituser_info='root:x:0:0::/root:/bin/bash'print(user_info.split(':')[0])cmd='put a.txt'print(cmd.split()[0])#默认以空格为分隔符。flit='put /a/b/c/d/a.txt'print(flit.split('/',1))#以'/'为分隔符，切分一次。

切分split *

#在python3中num1=b'4' #bytesnum2=u'4' #unicode,python3中无需加u就是unicodenum3='四' #中文数字num4='Ⅳ' #罗马数字#isdigt:bytes,unicodeprint(num1.isdigit()) #Trueprint(num2.isdigit()) #Trueprint(num3.isdigit()) #Falseprint(num4.isdigit()) #False

isdigt ，判断字符串中只有单纯数字组成 *

msg='***alex****'print(msg.strip('*'))print(msg.lstrip('*'))print(msg.rstrip('*'))

trip与lstrip与rstrip 清楚空白 *

#startswith与endswith ，以什么开头与以什么结尾。msg='alex_SB'print(msg.startswith('alex')) #以什么开头print(msg.endswith('SB')) #以什么结尾

startswith与endswith ，以什么开头与以什么结尾 *

#replace ，替换字符msg='alex say i have on telsa,my name is alex'print(msg.replace('alex', 'sb',1))#替换某个字符串

replace ，替换字符 *

#format ，占位print('my name is %s my age is %s'%('egon',18))print('my mame is {} my age is {}'.format('egon',18))#占位符print('{0} {0} {1}'.format('egon',18))print('my mame is {x} my age is {y}'.format(x='egon',y=18))

format ，占位 *

#find,rfind,index,rindex,count，查找字符串位置msg='hello world'print(msg.find('ell')) #查找字符串的子字符串，有返回第一个的索引。print(msg.find('x'))#没有返回-1.print(msg.index('w'))#查找字符串的子字符串，有返回第一个的索引。#print(msg.index('x'))#找不到，报错print(msg.count('l',0,4))#统计子字符串的个数

find,rfind,index,rindex,count，查找字符串位置

#join,还原切分的字符创uesr_info='root:x:0:0:: asdfdff'l=uesr_info.split(':')print(':'.join(l))print(''.join(l))

join,还原切分的字符创

#center,ljust,rjust,zerofill ,居中显示，左对齐，右对齐，以0填充占位print('egon'.center(30,'='))print('egon'.ljust(30,'='))print('egon'.rjust(30,'='))print('egon'.zfill(30))

center,ljust,rjust,zerofill ,居中显示，左对齐，右对齐，以0填充占位 *

msg='abc\tdeft' #制表符print(msg.expandtabs(3))

制表符

msg='alex Say hello'print(msg.capitalize()) #首字母大写print(msg.upper()) #全部大写print(msg.lower())#全部小写print(msg.title())#所有首字母大写print(msg.swapcase())#大小写字母转换

字母大小写

# #is 系列msg='Alex Say Hello'print(msg.isupper()) #必须全部是大写print(msg.islower())#必须全部是小写print(msg.istitle())#必须首字母全部是大写msg='abc'print(msg.isalpha())#只能包含字母msg='abc123'print(msg.isalnum())#字符串是有字母或数字组成msg='   1'print(msg.isspace())#是否是全部是空格组成msg='ifaaa'print(msg.isidentifier()) #是否含有判读的关键字

is 系列

#is数字系列#在python3中num1=b'4' #bytesnum2=u'4' #unicode,python3中无需加u就是unicodenum3='四' #中文数字num4='Ⅳ' #罗马数字#isdigt:bytes,unicodeprint(num1.isdigit()) #Trueprint(num2.isdigit()) #Trueprint(num3.isdigit()) #Falseprint(num4.isdigit()) #False#isdecimal:uncicode#bytes类型无isdecimal方法print(num2.isdecimal()) #Trueprint(num3.isdecimal()) #Falseprint(num4.isdecimal()) #False#isnumberic:unicode,中文数字,罗马数字#bytes类型无isnumberic方法print(num2.isnumeric()) #Trueprint(num3.isnumeric()) #Trueprint(num4.isnumeric()) #True#三者不能判断浮点数num5='4.3'print(num5.isdigit()) print(num5.isdecimal())print(num5.isnumeric())'''总结:    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景    如果要判断中文数字或罗马数字,则需要用到isnumeric'''

isdigt ，判断字符串中只有单纯数字组成

2. 练习

#练习name = " aleX"# 1)    移除 name 变量对应的值两边的空格,并输出处理结果print(name.strip())# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果 print(name.startswith('al'))# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果 print(name.endswith('X'))# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果print(name.replace('l','p'))# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。print(name.split('l'))# 6)    将 name 变量对应的值变大写,并输出结果 print(name.upper())# 7)    将 name 变量对应的值变小写,并输出结果 print(name.lower())# 8)    请输出 name 变量对应的值的第 2 个字符?print(name.strip()[1])# 9)    请输出 name 变量对应的值的前 3 个字符?print(name.strip()[0:4])# 10)    请输出 name 变量对应的值的后 2 个字符? print(name.strip()[-2:])# 11)    请输出 name 变量对应的值中 “e” 所在索引位置? print(name.find('e'))# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。print(name.strip()[:-1])

练习

四列表

1. 列表

作用：多个装备，多个爱好，多门课程，多个女朋友等#定义：[]内可以有多个任意类型的值，逗号分隔my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])或l=list('abc')#优先掌握的操作：按索引存取值(正向存取+反向存取)：即可存也可以取      切片(顾头不顾尾，步长)长度成员运算in和not in追加删除循环

列表

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]print(my_girl_friends[2]) #正取print(my_girl_friends[-1])#反取print(id(my_girl_friends))my_girl_friends[0]='SB' #存值print(id(my_girl_friends))

取值存值 *

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]print(my_girl_friends[0:2])#取前两个print(my_girl_friends[0:4:2])#步长为2

切片（顾头不顾尾，步长） *

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]print(len(my_girl_friends))

长度 len *

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]print('alex' in my_girl_friends)

成员运算in 和not in *

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.append('6号')print(my_girl_friends)

追加 append *

#删除my_girl_friends=['alex','wupeiqi','yuanhao',4,5]del my_girl_friends[2] #删除任意类型的值print(my_girl_friends.remove('yuanhao'))#remove 只是单纯删除，不会返回删除的值。并且按照值去删my_girl_friends.pop()#按照索引删除，默认从末尾删除print(my_girl_friends)

删除 remove与pop *

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.insert(2,'sb_alex')print(my_girl_friends)

插入单个元素 insert *

#extendmy_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.extend([1,2,3,4,5]) #插入多个元素print(my_girl_friends)

插入多个元素 extend *

#count 统计元素my_girl_friends=['alex','wupeiqi','alex','yuanhao',4,5]print(my_girl_friends.count('alex'))

统计元素 count *

#clear 清除所有元素my_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.clear()print(my_girl_friends)

清理所有元素 clear

#copy 拷贝my_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.copy()print(my_girl_friends)

拷贝 copy

#翻转 reversemy_girl_friends=['alex','wupeiqi','yuanhao',4,5]my_girl_friends.reverse()print(my_girl_friends)

翻转 reverse

#排序 sortl=[3,1,2,4]l.sort()  #排序l.sort(reverse=True)# 排序翻转print(l)

排序 sort

#队列：先进先出,案例：坐扶梯#append ,popl=[]l.append('first')l.append('second')l.append('three')print(l.pop(0))print(l.pop(0))print(l.pop(0))#堆栈：先进后出，案例：叠衣服往箱子里放#insert，popn=[]n.insert(0,'first')n.insert(0,'second')n.insert(0,'three')print(n.pop(0))print(n.pop(0))print(n.pop(0))

队列与堆栈 *

#1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量data=['alex',49,[1900,3,18]]name=data[0]print(name)age=data[1]print(age)year=data[2][0]print(year)months=data[2][1]print(months)day=data[2][2]print(day)

练习

五元组

1. 元组

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读#定义方式：ages=(10,12,18,33,18) #ages=tuple((10,12,18,33))# print(id(ages),type(ages),ages)

元组

#按照索引（正向取和反向取）：只能取ages=(10,12,18,33,18)print(ages[0])print(ages[-1])

取值 *

#切片（顾头不顾尾，步长）ages=(10,12,18,33,18)print(ages[1:3])print(ages[1:4:2])

切片 *

#长度 lenages=(10,12,18,33,18)print(len(ages))

长度 len *

#成员运算in 和 not inages=(10,12,18,33,18)print(10 in ages)

成员运算 *

ages=(10,12,18,33,18)print(ages.index(18))# 查找元素的索引

定位元素的索引 index *

ages=(10,12,18,33,18)print(ages.count(18))#统计元组中元素的个数

统计元组中元素的个数 count *

2. for ...in

l=['a','b','c','d']l='abcdef'l=('a','b','c','d','f')index=0while index < len(l):    print(l[index])    index+=1

利用while 根据索引在字符串、列表、元组里取值 *

l=['a','b','c','d']for item in l:    print(item)l=['a','b','c','d']for i in range(len(l)):    print(i,l[i])

用 for.....range取字符串、列表、元组的索引与元素 *

l=['a','b','c','d']for i in range(len(l)):    print(i,l[i])

用 for.....range取字符串、列表、元组的索引与元素 *

msg_dic={'apple':10,'tesla':100000,'mac':3000,'lenovo':30000,'chicken':10,}for key in msg_dic:    print(key,msg_dic[key])

用for...in 循环在字典里取值 *

#for + elsefor i in range(5):    if i == 3:break    print(i)else:    print('ok')

for....else

3. 练习

实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　msg_dic={'apple':10,'tesla':100000,'mac':3000,'lenovo':30000,'chicken':10,} goods_l=[]while True:    for key in msg_dic:        print(key,msg_dic[key])    choice=input('请输入商品名称：').strip()    if choice not in msg_dic:        continue    count = input('请输入商品个数：').strip()    if count.isdigit():      goods_l.append((choice,msg_dic[choice],int(count)))    print(goods_l)

打印购物车菜单

六字典

1. 字典

#作用：存多个值,key-value存取，取值速度快#定义：key必须是不可变类型，value可以是任意类型d={
    'a':1}d={
    0:1}d={[1,2,3]:1} #列表不能当做字典的keyd={(0,'mac'):3000}print(d[(0,'mac')])info={
    'name':'egon','age':18,'sex':'male'} #本质info=dict({....})

字典

#按照key存取值：可存可取info={
    'name':'egon','age':18,'sex':'male'}print(info['name'])#取info['hobbies']=['read','music','play']# 存print(info)

存取

#长度 len  ,统计简直对的个数info={
    'name':'egon','age':18,'sex':'male'}print(len(info))

长度len ,统计键值对的个数

#成员运算in 和 not ininfo={
    'name':'egon','age':18,'sex':'male'}print('name' in info)

成员运算in 和 not in

#删除info={
    'name':'egon','age':18,'sex':'male'}print(info.pop('name'))print(info.pop('name1222',None)) #没有返回None

删除 pop 返回value

# # 键keys()，值values()，键值对items()print(info.keys())print(info.values())print(info.items())for key in info.keys():    print(key)for val in info.values():    print(val)for item in info.items():    print(item[0],item[1])

键keys()，值values()，键值对items()

#补充两种赋值方式：#一：链式赋值x=10y=xx=y=z=10print(id(x),id(y),id(z))#交换两个变量的值m=10n=20temp=nn=m #n=10m=tempprint(m,n)m,n=n,mprint(m,n)#二：从一个数据类型中解压出我们想要的值t=(10.3,11.2,12.1,14.3,3.1)x,y,z,a,b=tprint(x,y,z,a,b)x,_,_,_,b=tprint(x,b)print(_)x,*_,b=tprint(x,b)x,*_='hello'print(x)x,y,z={
    'a':1,'b':2,'c':3}print(x,y,z)

两种赋值方式：赋值与解压

info={
    'name':'egon','age':18,'sex':'male'}for k,v in info.items(): #k,v=('name', 'egon')     print(k,v)

解压取值

info={
    'name':'egon','age':18,'sex':'male'}print(info.get('name'))print(info.get('name123'))#key不存在，返回None

取值 get ,key 值不存在返回None

info={
    'name':'egon','age':18,'sex':'male'}print(info.popitem())

删除 popitem 返回键值对

info={
    'name':'egon','age':18,'sex':'male',}info_new={
    'a':1,'age':19}info.update(info_new)print(info)

更新 update ,没有的添加，有的覆盖

dic={
    'name':None,'age':None,'sex':None,'hobbies':None}dic1={}.fromkeys(['name','age','hobbies'],None)print(dic1)

初始化字典 fromkeys

info={'name':'egon','age':18,'sex':'male',}print(info.setdefault('hobbies',['read','music'])) #有则不改，返回已经有的值，没有则新增，返回新增的值print(info)print(id(info.setdefault('hobbies',[])))print(id(info['hobbies']))if 'hobbies' not in info:    info['hobbies']=[]    info['hobbies'].append('music')else:    info['hobbies'].append('read')if 'hobbies' not in info:    info['hobbies'] = []    info['hobbies'].append('music')else:    info['hobbies'].append('read')print(info)info.setdefault('hobbies',[]).append('music')# {'name': 'egon', 'age': 18, 'sex': 'male', 'hobbies': ['music', ]}info.setdefault('hobbies',[]).append('read') #['music', ].append('read')print(info)

赋值 setdefault ，有则不改，返回已经有的值，没有则新增，返回新增的值

1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中即： {
     'k1': 大于66的所有值, 'k2': 小于66的所有值}numer=[11,22,33,44,55,66,77,88,99]l={
    'k1':[],'k2':[]}for i in numer:   if i > 66:      l['k1'].append(i)   else:       l['k2'].append(i)print(l)

练习1

2 统计s='hello alex alex say hello sb sb'中每个单词的个数结果如：{
     'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}#方法一s='hello alex alex say hello sb sb'l=s.split()dic={}for item in l:    if item in dic:        dic[item]+=1    else:        dic[item]=1print(dic)#方法二：复制代码s='hello alex alex say hello sb sb'dic={}words=s.split()print(words)for word in words: #word='alex'    dic[word]=s.count(word)    print(dic)#方法三：#利用setdefault解决重复赋值'''setdefault的功能1：key存在，则不赋值，key不存在则设置默认值2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值d={}print(d.setdefault('a',1)) #返回1d={
    'a':2222}print(d.setdefault('a',1)) #返回2222'''s='hello alex alex say hello sb sb'dic={}words=s.split()for word in words: #word='alex'    dic.setdefault(word,s.count(word))    print(dic)#方法四：#利用集合，去掉重复，减少循环次数s='hello alex alex say hello sb sb'dic={}words=s.split()words_set=set(words)for word in words_set:    dic[word]=s.count(word)    print(dic)

练习二

七集合

1. 集合

pythons=['alex','wupeiqi','egon','yuanhao','gangdan','oldboy']linuxs=['egon','oldboy','tiedan','liudan']l=[]for item in pythons:    if item in linuxs:        l.append(item)print(l)作用：去重，关系运算，定义：1：每个元素必须是不可变类型(可hash，可作为字典的key)2:没有重复的元素3：无序s={
    1,2,'a','b','c','d','e','f'} #s=set({
    1,2,'a'})print(type(s),s)

集合

长度lens={
    1,2,'a','b','c','d','e','f'}print(len(s))

长度

#长度lens={
    1,2,'a','b','c','d','e','f'}print(len(s))

成员运算in和not in

s={
    1,2,'a','b','c','d','e','f'}print('a' in s)

成员运算in和not in

s={
    1,2,'a','b','c','d','e','f'}for item in s:    print(item)

取值

#| 并集s1={
    1,2,3}s2={
    3,4,5}print(s1 | s2)#& 交集print(s1 & s2)#-差集print(s1 - s2)print(s2 - s1)#^ 对称差集s1={
    1,2,3}s2={
    3,4,5}==> ， >= ， <, <= 父集，子集s1={
    1,2,3,4}s2={
    3,4,5}print(len(s1) > len(s2))s1={
    1,2,3,4}s2={
    3,4}print(s1 > s2)print(s1 >= s2)#| 并集print(s1.union(s2))#& 交集print(s1.intersection(s2))s1.intersection_update(s2) #s1=s1.intersection(s2)print(s1)#-差集print(s1.difference(s2))#^ 对称差集print(s1.symmetric_difference(s2))

交、差、并、对称差集

l=['a','b',1,'a','a']print(list(set(l)))l=['a','b',1,'a','a']l_new=list()s=set()for item in l:    if item not in s:        s.add(item)        l_new.append(item)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'},]l_new=list()s=set()for item in l:    res = (item['name'], item['age'], item['sex'])    if res not in s:        s.add(res)        l_new.append(item)

去重

八数据类型总结

1.按存储空间的占用分（从低到高）

数字字符串集合：无序，即无序存索引相关信息元组：有序，需要存索引相关信息，不可变列表：有序，需要存索引相关信息，可变，需要处理数据的增删改字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按照存储空间

2.按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

3.按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

4.按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

九字符编码

转载于:https://www.cnblogs.com/wxp20170901/p/7506388.html

你可能感兴趣的文章

Android 4.0 开发者指南(27) —— Resource Types - String

影响谷歌排名算法的因素(2) – 页面的外链数量和质量

查看>>

POJ-1753 Flip Game 枚举状态压缩

查看>>

DZ!NT论坛 3.6.711删除用户各种错解决方案

查看>>

Python的函数参数传递：传值？引用？

查看>>

HDU 1426 Sudoku Killer（搜索）

查看>>

[转]分享2011年8个最新的jQuery Mobile在线教程

查看>>

云平台测试

查看>>

64位Win8企业版终于使用Hyper-V功能了！

查看>>

android call require api level

Visual Studio及TFS进行单元测试、负载测试、代码覆盖率、每日构建配置

查看>>

创建Visual Studio项目模版向导的几篇参考文章

查看>>

阅读目录

一 数据

1 . 数据

二 数字

1. 整形和浮点型

2. 其他数字类型

三 字符串

1. 字符串

2. 练习

四 列表

1. 列表

五 元组

1. 元组

2. for ...in

3. 练习

六 字典

1. 字典

七 集合

1. 集合

八 数据类型总结

1.按存储空间的占用分（从低到高）

2.按存值个数区分

3.按可变不可变区分

4.按访问顺序区分

九 字符编码

一数据

二数字

三字符串

四列表

五元组

六字典

七集合

八数据类型总结

九字符编码