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

数据类型主要用一下 一二三点来进行分析#一：基本使用
1 用途

2 定义方式

3 常用操作+内置的方法

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

2 有序or无序

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

---

一：整型和浮点型

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)浮点型和整型：没有可变不可变直说，存一个值

#二进制，十进制，八进制，十六进制 

---

二：字符串

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成
name='egon'

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
#2、切片(顾头不顾尾，步长)
#3、长度len
#4、成员运算in和not in

#1、按索引取值(正向取+反向取) ：只能取
# msg='he lo'
# print(msg[0])
# print(msg[2])
# msg[2]='A'

#2、切片(顾头不顾尾，步长)
# msg='hello world'
# print(msg[0:4]) #hell
# print(msg[0:4:2]) #hell

#3、长度len
# msg='hello'
# print(len(msg))

#4、成员运算in和not in
# msg='alex say my name is alex'
# if 'alex' in msg:
#     print('存在')

# print('alex' not in msg) # 推荐使用
# print(not 'alex' in msg)

　　

#5、移除空白strip #6、切分split #7、循环

#1、strip（移除空白）,lstrip（移除左边空白）,rstrip （移除右边空白）
#2、lower（全部小写）,upper（全部大写）
#3、startswith（是否什么开头）,endswith（是否什么结尾）
#4、format的三种玩法（格式化处理方式）
#5、split（分隔符）,rsplit
#6、join（加入字符串）
#7、replace（替代）
#8、isdigit（是否为整数）

#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#lower,upper
name='egon'
print(name.lower())
print(name.upper())

#startswith,endswith
name='alex_SB'
print(name.endswith('SB'))
print(name.startswith('alex'))

#format的三种玩法
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#split
name='root:x:0:0::/root:/bin/bash'
print(name.split(':')) #默认分隔符为空格
name='C:/a/b/c/d.txt' #只想拿到顶级目录
print(name.split('/',1))

name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分

#join
tag=' '
print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age=input('>>: ')
print(age.isdigit())

示例

只需要了解#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他

#find,rfind,index,rindex,count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e',1,3)) #顾头不顾尾,如果不指定范围则查找所有

#center,ljust,rjust,zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs
name='egon\thello'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

#is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

示例

---

三：列表

 

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

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

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取      
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、追加
#6、删除
#7、循环

#ps:反向步长
l=[1,2,3,4,5,6]

#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
#列表翻转
l[::-1] #[6, 5, 4, 3, 2, 1]列表属于有序的，存多个值，可变的的类型

#一：list基本使用
# 1 用途：存放多个值

# 2 定义方式：[]内用逗号分隔开多个元素，每个元素可以是任意数据类型
# l=[1,'a',[1,2]] #l=list([1,'a',[1,2]])

# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可以取也可以改
names=['egon','alex','wxx','xxx','yxx']
# print(names[4])
# print(names[-1])
# print(names[-2])
# print(id(names))
# names[0]='EGON'
# print(id(names))
# print(names)
# names[5]=3 #超出索引限制就会报错

#2、切片(顾头不顾尾，步长)
names=['egon','alex','wxx','xxx','yxx']
# print(names[0:3:2])
# print(names[:])

#了解:反向步长
# print(names[3:-1:-1])
# print(names[-1::-1])

#3、长度
# names=['egon','alex','wxx','xxx','yxx']
# print(len(names))

#4、成员运算in和not in
# names=['egon','alex','wxx','xxx','yxx',1,2,3,4]
# print('alex' in names)
# print(4 in names)


#5、追加与插入
# names=['egon','alex','wxx','xxx','yxx']
# names.append('oldboy1')
# names.append('oldboy2')
# names.append('oldboy3')
# print(names)

# names.insert(2,'oldboy')
# print(names)

#6、删除列表中某一个元素
names=['egon','alex','wxx','xxx','yxx']
# del names[2]
# print(names)

# res=names.remove('wxx') # 指定要删除的元素,remove方法没有返回值
# print(res)
# print(names)

#从列表中取走一个元素
# if 100 < len(names):
#     res=names.pop(100) # 按照索引删除的元素（会返回刚刚删掉的元素）,超过索引限制则报错
#     print(names)
#     print(res)


#7、循环
# names=['egon','alex','wxx','xxx','yxx',1,2,3,4]
# for x in names:
#     print(x)





# 需要掌握的操作
names=['egon','alex','wxx','xxx','xxx','yxx',1,2,3,4]
# names.reverse()
# names.reverse()
# print(names)

# names.count()
# print(names.count('xxx'))

# names.clear()
# names.clear()
# print(names)

# names.copy()
# l=names.copy()
# print(l)

# names.index()
# names=['egon','alex','wxx','xxx','xxx','yxx',1,2,3,4]
# print(names.index('alexasdf'))

# names.sort():  列表中的元素必须是同一类型才能比较排序
# names=['b','a','+']
# names.sort()
# print(names)


# 了解:字符\|列表之间比较大小
# x='hello'
# y='z'

# print(y > x)
#排序:'A-Za-z'


# l1=[1,2,'a','b']
# l2=[1,2,'b']
#
# print(l2 > l1)


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

# 2 有序

# 3 可变



#练习题:
#1 队列:先进先出
l=[]
#  入队:first->second->third
# l.append('first')
# l.append('second')
# l.append('third')
# print(l)
# 出队:
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))


#2 堆栈:先进后出
#  入栈:first->second->third
l.append('first')
l.append('second')
l.append('third')

# 出栈:third->second->first
print(l.pop(-1))
print(l.pop())
print(l.pop())

四：元祖

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取   
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、循环

---

五：字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)

#优先掌握的操作：
#1、按key存取值：可存可取
#2、长度len
#3、成员运算in和not in

#4、删除
#5、键keys()，值values()，键值对items()
#6、循环

一：dict基本使用
1 用途：存多个值，key：value，key对value有描述的作用

2 定义方式:{}内用逗号分开多个元素，每一个元素都是key:value的形式
其中key必须是不可变类型，key通常都应该是字符串类型
其中value可以是任意数据类型
info={'name':'egon',(1,2):18}  #info=dict({'name':'egon','age':18})
print(info['name'])
print(info[(1,2)])

3 常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
d={'x':1}
print(id(d))
d['x']=2
print(id(d))
print(d)

d['y']=3
print(d)


2、长度len
info={'x':1,'y':2,'z':3}
print(len(info))

3、成员运算in和not in ：判断的是字典的key
info={'x':1,'y':2,'z':3}
print('x' in info)

4、删除
info={'x':1,'y':2,'z':3}
del  info['x']
print(info)

print(info.popitem())

print(info.pop('xxxxx',None))
print(info)

5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
print(msg_dic.keys())

6、循环
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}如果我想根据key来取对应的值，在值不存在的情况下会抛出异常KeyError，如何避免该问题？答：用get方法取值可以避免异常
7、更新、增加
update更新 字典 用新数据更新原来表格数据
msg_dic.update
d1={'x':1,'y':2}
d1.update({'x':2,'z':3})
print(d1)

msg_dic.setdefault
1、key存在，则不改变key对应的值,放回原值
d={'x':1,'y':2}
res=d.setdefault('x',1000)
# print(d)
print(res)

2、key不存在，则增加一个key：value，返回新增的value
d={'x':1,'y':2}
res=d.setdefault('z',1000)
print(d)
print(res)

总结：setdefault有则不变，无则增加
s='hello alex alex say hello sb sb'
words=s.split()
d={}
for word in words:
    if word not in d:
        d[word]=1 #d={'hello':1,'alex':1}
    else:
        d[word]+=1
    d.setdefault(word,words.count(word))

print(d)

 文件处理：

一 介绍

计算机系统分为：计算机硬件，操作系统，应用程序三部分。

我们用python或其他语言编写的应用程序若想要把数据永久保存下来，必须要保存于硬盘中，这就涉及到应用程序要操作硬件，众所周知，应用程序是无法直接操作硬件的，这就用到了操作系统。操作系统把复杂的硬件操作封装成简单的接口给用户/应用程序使用，其中文件就是操作系统提供给应用程序来操作硬盘虚拟概念，用户或应用程序通过操作文件，可以将自己的数据永久保存下来。

有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：

#1. 打开文件，得到文件句柄并赋值给一个变量
#2. 通过句柄对文件进行操作
#3. 关闭文件二 在python中

#1. 打开文件，得到文件句柄并赋值给一个变量
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

#2. 通过句柄对文件进行操作
data=f.read()

#3. 关闭文件
f.close()

三 f=open('a.txt','r')的过程分析

#1、由应用程序向操作系统发起系统调用open(...)

#2、操作系统打开该文件，并返回一个文件句柄给应用程序

#3、应用程序将文件句柄赋值给变量f

四 强调！！！

#强调第一点：
打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：
1、f.close() #回收操作系统级打开的文件
2、del f #回收应用程序级的变量

其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源，
而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close()

虽然我这么说，但是很多同学还是会很不要脸地忘记f.close(),对于这些不长脑子的同学，我们推荐傻瓜式操作方式：使用with关键字来帮我们管理上下文
with open('a.txt','w') as f:
    pass
 
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
    data=read_f.read()
    write_f.write(data)
#强调第二点：
f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。

f=open('a.txt','r',encoding='utf-8')

 

练习，利用b模式，编写一个cp工具，要求如下：

　　1. 既可以拷贝文本又可以拷贝视频，图片等文件

　　2. 用户一旦参数错误，打印命令的正确使用方法，如usage: cp source_file target_file

　　提示：可以用import sys，然后用sys.argv获取脚本后面跟的参数

import sys
if len(sys.argv) != 3:
    print('usage: cp source_file target_file')
    sys.exit()

source_file,target_file=sys.argv[1],sys.argv[2]
with open(source_file,'rb') as read_f,open(target_file,'wb') as write_f:
    for line in read_f:
        write_f.write(line)

五 文件的修改

文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：

方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
    data=read_f.read() #全部读入内存,如果文件很大,会很卡
    data=data.replace('alex','SB') #在内存中完成修改

    write_f.write(data) #一次性写入新文件

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt') 

 方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
    for line in read_f:
        line=line.replace('alex','SB')
        write_f.write(line)

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt') 

 

 

 

来源：https://www.cnblogs.com/LoganY/p/8758461.html