数据类型、字符编码、文件处理

标签：拼接   链式   内容   rem   uda   bsp   常用   数据类型   反向   

数据
数据类型
数字（整形，长整形，浮点型，复数）
存一个值
有序
不可变
小的数字不会申请内存空间.同值会指向同一地址


详细类型：int
用途：年龄，级别，等级，身份证号
使用方法:
x=10 #x=int(10)
print(id(x),type(x),x)
详细类型：float
用途：工资，身高，体重
使用方法:
salary=3.1 #salary=float(3.1)
print(id(salary),type(salary),salary)

字符串(描述性的东西)
存一个值
不可变
用途：名字，性别，地址
使用方法:
name=‘egon‘ #name=str(‘egon‘)
print(id(name),type(name),name)

#优先掌握的操作：
# 按索引取值(正向取+反向取) ：只能取
# print(name[0],type(name[0]))
# print(name[-2])
# name[0]=‘E‘

# 切片(顾头不顾尾，步长)
# print(name[1:3])
# msg=‘hello world‘
# print(msg[1:7])
# print(msg[1:7:2])

# msg=‘abcdefg‘ #bdf
# # print(msg[1:6:2])
# # print(msg[::2])
# print(msg[6::-1]) #了解

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

成员运算in和not in
# msg=‘hello alex‘
# print(‘a‘ in msg)
# print(‘alex‘ in msg)
# print(‘ae‘ not in msg)

移除空白strip
# password=‘ alex3714 ‘
# password=password.strip()
# print(password)
# print(password.strip())
移除多余指定符号
# msg=‘***egon***********‘
# print(msg.strip(‘*‘))
移除多余指定符号,但是不能移除中间
# msg=‘***eg**on***********‘
# print(msg.strip(‘*‘))

# 切分split
user_info=‘root:x:0:0::/root:/bin/bash‘
按字符
# print(user_info[0:4])
按:号分割
# print(user_info.split(‘:‘)[0])
只分割一次
# print(user_info.split(‘:‘,1))

默认按空格分
# cmd=‘put a.txt‘
# print(cmd.split())

# filepath=‘put /a/b/c/d/a.txt‘
# print(filepath.split())

按空格分.只分割一次,只打印第一个
# msg=‘alex say i have on tesla‘
# print(msg.split(maxsplit=1)[0])

#isdigit:用来判断字符是否是由纯数字组成（bytes，unicode）

# 循环

#常用操作

清楚左右两边多余符号
# msg=‘***alex****‘
# print(msg.strip(‘*‘))
# print(msg.lstrip(‘*‘))
# print(msg.rstrip(‘*‘))

以什么开头/结尾
# msg=‘alex_SB‘
# print(msg.startswith(‘alex‘))
# print(msg.endswith(‘SB‘))

替换字符
# msg=‘alex say i have one telsa, my name is alex‘
# print(msg.replace(‘alex‘,‘SB‘,1))

格式化输出
# print(‘my name is %s my age is %s‘ %(‘egon‘,18))
# print(‘my name is {} my age is {}‘.format(‘egon‘,18))
# print(‘{1} {0} {1}‘.format(‘egon‘,18))
# print(‘my name is {x} my age is {y}‘.format(y=18,x=‘egon‘))

split
将指定符号作为分割符号
# user_info=‘root:x:0:0::asdfasdf‘
# l=user_info.split(‘:‘)

join
将一段分开的字符拼接在一起
# print(‘:‘.join(l))
# print(‘‘.join(l))
# print(‘ ‘.join(l))

#center,ljust,rjust,zerofill
将单词放在中间,左填充,右填充,使用0填充
#=================egon===================
# print(‘egon‘.center(30,‘=‘))
# print(‘egon‘.rjust(30,‘=‘))
# print(‘egon‘.ljust(30,‘=‘))
# print(‘egon‘.zfill(30))

#了解部分
#find,rfind,index,rindex,count
(要找的内容,从第几个开始,到第几个结束)
# msg=‘hello world‘
# print(msg.find(‘ell‘))#从左到右找，如果有，则返回第一个字符的索引
# print(msg.find(‘easdfasdf‘))#从左到右找，如果没有，返回-1

# print(msg.index(‘d‘,0,3))#从左到右找，如果有，则返回第一个字符的索引
# print(msg.index(‘x‘))#从左到右找，如果有，则返回第一个字符的索引,如果没有找到就会报错

#找到指定内容技术
# print(msg.count(‘l‘,0,4))
# print(msg.count(‘l‘,0,3))

# 控制几个制表符
# 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=‘asasdf123‘
是否由字母或数字组成
# print(msg.isalnum())

msg=‘asdfasdf‘
是否纯字母
print(msg.isalpha())

#
# msg=‘ 1‘
是否全部空格
# print(msg.isspace())
# msg=‘aaaai fabc‘
是否包含python关键字
# print(msg.isidentifier())

#判断数字
# age=10
# inp=input(‘>>: ‘).strip()
# if inp.isdigit():
# inp=int(inp)
# if inp > age:
# print(‘ok‘)
#
# else:
# print(‘必须输入数字‘)

num1=b‘4‘ #bytes
num2=u‘4‘ #unicode,python3中无需加u就是unicode
num3=‘四‘ #中文数字
num4=‘壹‘ #大写数字
num5=‘Ⅳ‘ #罗马数字

#bytes,unicode*******
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())
# print(num5.isdigit())

#unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# print(num5.isdecimal())

#unicode,汉字，罗马
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())
# print(num5.isnumeric())

列表
#作用：多个装备，多个爱好，多门课程，多个女朋友等

#类型可变

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,4,5] #本质my_girl_friends=list([...])

优先掌握的操作：
按索引存取值(正向存取+反向存取)：即可存也可以取
# 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))
# print(my_girl_friends)

切片(顾头不顾尾，步长)
# print(my_girl_friends[0:2])
# print(my_girl_friends[0:4:2])

长度
# print(len(my_girl_friends))

成员运算in和not in
# print(‘alex‘ in my_girl_friends)
# print(5 in my_girl_friends)

追加
# my_girl_friends.append(‘6号‘)
# print(my_girl_friends)

删除
# del my_girl_friends[2]
# print(my_girl_friends)

# print(my_girl_friends.remove(‘yuanhao‘)) #remove是单纯的删除，不会返回删除的值，并且是按照值去删
# res=my_girl_friends.pop(1) #按照索引取删，默认从末尾开始删
# print(res)

# my_girl_friends.pop() #按照索引取删，默认从末尾开始删

# print(my_girl_friends)

# 循环

#常用操作：

my_girl_friends=[‘alex‘,‘wupeiqi‘,‘alex‘,‘yuanhao‘,4,5] #本质my_girl_friends=list([...])

插入
# my_girl_friends.insert(0,‘sb_alex‘)
# my_girl_friends.insert(2,‘yh‘)

插入多个.从末尾开始
# my_girl_friends.extend([1,2,3,4])

计算列表中有几个指定的值
# print(my_girl_friends.count(‘alex‘))
# print(my_girl_friends)

了解
清空列表
# my_girl_friends.clear()
# print(my_girl_friends)
复制一个新列表
# l=my_girl_friends.copy()
# print(l)

反转整个列表顺序
# my_girl_friends.reverse()
# print(my_girl_friends)

排序
# l=[3,4,-1,2]
# reverse=True #默认从小到大.这个参数从大到小
# l.sort(reverse=True)
# print(l)

#练习：
#队列：先进先出
#append，pop
# l1=[]
# l1.append(‘first‘)
# l1.append(‘second‘)
# l1.append(‘third‘)
#
# print(l1.pop(0))
# print(l1.pop(0))
# print(l1.pop(0))

#堆栈：先进后出

# l1=[]
# l1.append(‘first‘)
# l1.append(‘second‘)
# l1.append(‘third‘)
#
# print(l1.pop())
# print(l1.pop())
# print(l1.pop())

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

#优先掌握的操作：
# 按索引取值(正向取+反向取)：只能取
# 切片(顾头不顾尾，步长)
# print(ages[0:2])
# print(ages)

# 长度
# print(len(ages))
# # 成员运算in和not in
# print(10 in ages)

#其他操作：
# print(ages.index(18))
# print(ages.index(123123123123))

# print(ages.count(18))

根据索引打印值
# l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# # l=‘abcde‘
# l=(‘a‘,‘b‘,‘c‘,‘d‘,‘e‘)
# index=0
# while index < len(l):
# print(l[index])
# index+=1

# l1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# for item in l1:
# print(item)
# l2=‘abcde‘
# for item in l2:
# print(item)
# l=(‘a‘,‘b‘,‘c‘,‘d‘,‘e‘)

# for i in range(1,10,2):
# print(i)
# l1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# for i in range(len(l1)):
# print(i,l1[i])

# 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)

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

字典
作用：存多个值,key-value存取，取值速度快
存多个值
不可变类型
定义：key必须是不可变类型，value可以是任意类型

# d={‘a‘:1}
# d={0:1}
# d={[1,2,3]:1} #列表不能当做字典的key
# d={(0,‘mac‘):3000}
#
# print(d[(0,‘mac‘)])

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘} #本质info=dict({....})

优先掌握的操作：
按key存取值：可存可取
# print(info[‘sex‘])
# info[‘hobbies‘]=[‘read‘,‘music‘,‘play‘,‘sleep‘,‘eat‘]
# print(info)

长度len
# print(len(info))

成员运算in和not in

删除
# print(info.pop(‘name‘))
# print(info.pop(‘name1213‘,‘确实是没有的，我的哥‘))
# print(info.pop(‘name1213‘,None))

键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])

循环

常用方法
# info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘}
# print(info[‘name123‘])
# print(info.get(‘name123‘,123))
# print(info.popitem())
#
#
# for k,v in info.items(): #k,v=(‘name‘, ‘egon‘)
# print(k,v)

# print(info.setdefault(‘hobbies‘,[‘read‘,‘music‘])) #有则不改，返回已经有的值，没有则新增，返回新增的值
# print(info)

# print(id(info.setdefault(‘hobbies‘,[])))
# print(id(info[‘hobbies‘]))
l=[]

info={‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘,}
# 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)

了解
# info_new={‘a‘:1,‘age‘:19}
# info.update(info_new)
# print(info)

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

补充两种赋值方式：
#一：链式赋值
# x=10
# y=x
# x=y=z=10
# print(id(x),id(y),id(z))

交换两个变量的值
# m=10
# n=20
# temp=n
# n=m #n=10
# m=temp
# print(m,n)
# m,n=n,m
# print(m,n)

从一个数据类型中解压出我们想要的值
# t=(10.3,11.2,12.1,14.3,3.1)

# x,y,z,a,b=t
# print(x,y,z,a,b)

# x,_,_,_,b=t
# print(x,b)
# print(_)

# x,*_,b=t
# print(x,b)

# x,*_=‘hello‘
# print(x)

# x,y,z={‘a‘:1,‘b‘:2,‘c‘:3}
# print(x,y,z)


集合
作用：去重，关系运算，
存多个值

# 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)

# 优先掌握的操作：
# 长度len
# s={1,2,‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘}
# print(len(s))
# 成员运算in和not in
# print(‘a‘ in s)
# 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)

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

#常用操作
s1={1,2,3,‘a‘,4}
# print(s1.pop()) #随机删，并返回删除的结果

# s1.remove(‘a‘) #单纯地删，不会返回删除的结果，并且如果删除的元素不存在则报错
# s1.remove(‘asdfasdfa‘) #单纯地删，不会返回删除的结果
# print(s1)
# print(s1.discard(‘a‘)) #单纯地删，不会返回删除的结果，并且如果删除的元素不存在返回None，不会报错
# print(s1)

# s1.add(‘b‘)
# print(s1)

s1={1,2,3}
s2={4,5}
# print(s1.isdisjoint(s2)) #如果s1和s2没有交集则返回True

了解
# s1={1,2,3,4}
# s2={3,4,5}

| 并集
# 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))

==
# > ， >= ， <, <= 父集，子集
# s1={1,2,3,4}
# s2={3,4}
# print(s1.issuperset(s2))
# print(s2.issubset(s1))

去重
# 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)

print(l_new)

了解：不可变集合
fset=frozenset({1,2,3})
fset.

数据类型、字符编码、文件处理

标签：拼接   链式   内容   rem   uda   bsp   常用   数据类型   反向   

原文地址：http://www.cnblogs.com/uulinux/p/7529730.html