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

阅读目录

• 一 引子
• 二 数字
• 三 字符串
• 四 列表
• 五 元组
• 六 字典
• 七 集合
• 八 数据类型总结
• 九 字符编码
• 十 文件处理

 

一 引子

 

  1 什么是数据　　

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

2 为何数据要分不同的类型

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

3 数据类型

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

　　字符串

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

　　列表

　　元组

　　字典

　　集合

二 数字

 

 

数字类型的值不可变，无序。

数字类型分为两种：

1.int类型

作用：

　　可以表示等级，年龄等

定义方法：

a=int(10)
#表示显示a的id号，id号是这个值申请的内存空间。a的数据类型。
#要判断两个值是不是在一个内存空间可以用is判断
#要是id值一样的话说明两个值是在一个内存空间
#两个值怎样判断是在一个内存空间，1.值得长度比较短，2.值是一样的
print(id(a),type(a),a)

2.浮点型

作用：

　　可以表示薪资，身高，体重。

定于方法：

b=3.1
print(id(a),type(a),a)

三 字符串

 

常用操作

索引

取字符串中第一个值。

#正向取值

name = 'meng'
print(name[0])
#打印结果
m

取字符串中最后一个值。

#反向取值

name = 'meng'
print(name[-1])
#打印结果
g

结论：

　　字符串类型只能取，不能变

 

切片

切片操作顾头不顾尾

name = 'meng'
print(name[1:3])
#打印
eng

可以指定步长，步长默认是1（下面指定步长是2，意思就是隔一个取一个）。

name = 'hello world'
print(name[0:5:2])
#打印
hlo

可以倒这取

name='hello world'
print(name[-5:-1])
#打印
worl

 

len（长度统计）

注：

　　数字没有长度。其他字符串有长度

统计字符串长度

name='hello world'
print(len(name))
#打印（这就是字符串的个数）
11

 

成员运算

查看‘h’在没在这个变量中

name='hello world'
print('h' in name)
#打印
True

内置方法

strip(移除空格)

注：

　　只是移除值两端，中间的不移除。

#strip()没有指定参数，没有指定参数默认是取出空格

name= '  hello world    '
print(name.strip())

#打印
hello world

#strip()指定参数，这个参数是指你要移除的值，但是只能移除两面的中间的不可以移除

name= '******hello*** world*********'
print(name.strip('*'))

#打印
hello*** world

 

lstrip（移除左变空格）

name='   root:admin:0:1:/home/etc/a.txt   '
print(name.lstrip())

#打印
root:admin:0:1:/home/etc/a.txt   

 

rstrip（移除右变空格）

name='   root:admin:0:1:/home/etc/a.txt   '
print(name.rstrip())

#打印
root:admin:0:1:/home/etc/a.txt

 

startswith(判断开头)

name='root:admin:0:1:/home/etc/a.txt'
print(name.startswith('root'))

#打印
True

 

endswith（判断结尾）

name='root:admin:0:1:/home/etc/a.txt'
print(name.endswith('txt'))


#打印
True

 

replace（更换字符串）

name='root:admin:0:1:/home/etc/a.txt'
print(name.replace('root','meng'))

#打印
meng:admin:0:1:/home/etc/a.txt

还可以指定替换的次数

name='root:admin:0:1:/home/etc/a.txt:root'
print(name.replace('root','meng',1))

#打印
meng:admin:0:1:/home/etc/a.txt:root

 

format\%（字符串格式化）

format字符串格式化方法

name = input("name:")
age = int(input("age:"))
work = input("work:")
wage = input("wage:")
info = '''
---------info fo {_name}---------
name:{_name}
age:{_age}
work:{_work}
wage:{_wage}'''.format(_name=name,
                 _age=age,
                 _work=work,
                 _wage=wage)
print(info)

#打印
---------info fo meng---------
name:meng
age:13
work:it
wage:1000

 

%字符串格式化方法

name = input("name:")
age = int(input("age:"))
work = input("work:")
wage = input("wage:")
info = '''
---------info of %s-----------
name:%s
age:%d
work:%s
wage:%s
''' %(name,name,age,work,wage)

#打印
---------info fo meng---------
name:meng
age:13
work:it
wage:1000

 

find(查找)

需求：查找‘t’的位置

name='root:admin:0:1:/home/etc/a.txt:root'
print(name.find('t'))

#打印
3

注：查找一个字符串在什么位置，并返回索引。找不到就返回-1

 

count（统计）

统计在字符串有几个值

name='root:admin:0:1:/home/etc/a.txt:root'
print(name.count('r'))

#打印
2

还可以指定步长只统计这个范围的

name='root:admin:0:1:/home/etc/a.txt:root'
print(name.count('r',0,2))

#打印
1

 

join（字符串拼接）

把原先的字符串经过split后再拼回去

name='root:admin:0:1:home:etc/a.txt:root'
name=name.split(':')
print(name)
print(':'.join(name))

#打印
['root', 'admin', '0', '1', 'home', 'etc/a.txt', 'root']
root:admin:0:1:home:etc/a.txt:root

 

center（填充）

需求：宽带30用=填充

name='meng'
print(name.center(30,'='))

#打印
=============meng=============

注：有两个参数一个是宽带，一个是用什么填充

 

rjust（左填充）

name='meng'
print(name.rjust(30,'='))

#打印
==========================meng

 

ljust(右填充)

name='meng'
print(name.ljust(30,'='))

#打印
meng==========================

 

zfill(用0填充)

name='meng'
print(name.zfill(30))

#打印
00000000000000000000000000meng

 

expandtabs（指定几个空格）

name='me\tng'
print(name.expandtabs(5))

#打印
me   ng

 

capitalize（首字母大写）

name='meng'
print(name.capitalize())

#打印
Meng

 

upper（全部大写）

name='meng'
print(name.upper())

#打印
MENG

 

lower（全部小写）

name='meng'
print(name.lower())

#打印
meng

 

title（每个首字母大写）

name='meng asd das'
print(name.title())

#打印
Meng Asd Das

 

swapcase（大小写转换）

name='Meng aSd das'
print(name.swapcase())

#打印
mENG AsD DAS

 

split（切分）

解释：他会帮你按照指定的字符进行切分并把切分的结果存到列表里面

需求1：按照‘“：”’切分并取出root（默认按空格切）

name='root:admin:/home/etc/a.txt'
print(name.split(':'))
print(name.split(':')[0])

#打印
['root', 'admin', '/home/etc/a.txt']
root

还可以指定它切分几次

name='root:admin:0:1:/home/etc/a.txt'
print(name.split(':',2))
#打印
['root', 'admin', '0:1:/home/etc/a.txt']

is系列

isupper（判断是否大写）

name='Meng aSd das'
print(name.isupper())

#打印
False

 

islower（判断是否是小写）

name='Meng aSd das'
print(name.islower())

#打印
False

 

istitle(判读首字母是否大写)

name='Meng aSd das'
print(name.istitle())

#打印
False

 

isspace（判读变量是不是由空格组成）

name='   '
print(name.isspace())

#打印
True

 

isidentifier（判断是不是关键字）

name='if'
print(name.isidentifier())

#打印
True

 

isdigit（判断是不是数字组成的）

name='123'
print(name.isdigit())

#打印
True

 

isalnum（判断是否有字母或者数字组成的）

name='asdas123'
print(name.isalnum())

#打印
True

 

isalpha（判断是不是字母组成的）

name='asdas'
print(name.isalpha())

#打印
True

四 列表

 

常用操作

用途：存任意类型的值

按索引取值

name=['dick','admin','meng']
print(name[1])

#打印
admin

 

修改列表值

name=['dick','admin','meng']
name[2]='root'
print(name)

#打印
['dick', 'admin', 'root']

 

切片

请参考字符串的切片

 

len（统计长度）

请参考字符串的操作

 

成员运算

请参考字符串的操作

 

append（追加）

name=['dick','admin','meng']
name.append('root')
print(name)

#打印
['dick', 'admin', 'meng', 'root']

 

del（删除）

name=['dick','admin','meng']
del name[1]
print(name)

#打印
['dick', 'meng']

 

remove（列表内部删除）

name=['dick','admin','meng']
name.remove('admin')
print(name)

#打印
['dick', 'meng']

 

pop（剪切）

注：如果不知道索引他会送最后一个剪切

name=['dick','admin','meng']
print(name.pop())
print(name)

#打印（meng是被剪切掉的）
meng
['dick', 'admin']

指定索引删

name=['dick','admin','meng']
print(name.pop(1))
print(name)

#打印
admin
['dick', 'meng']

 

insert（插入）

name=['dick','admin','meng']
name.insert(1,'666')
print(name)

#打印
['dick', '666', 'admin', 'meng']

 

extend(插多个值)

name=['dick','admin','meng']
a=[1,2,3,4]
name.extend(a)
print(name)

#打印
['dick', 'admin', 'meng', 1, 2, 3, 4]

 

count（统计相同元素的个数）

name=['dick','admin','meng']
print(name.count('dick'))

#打印
1

了解

clear（清空）

name=['dick','admin','meng']
name.clear()
print(name)

#打印
[]

 

copy（复制）

name=['dick','admin','meng']
l=name.copy()
print(l)

#打印
['dick', 'admin', 'meng']

 

reverse（反转）

name=['dick','admin','meng']
name.reverse()
print(name)

#打印
['meng', 'admin', 'dick']

 

sort（排序）

默认从小到大

name=['dick','admin','meng']
name.sort()
print(name)

#打印
['admin', 'dick', 'meng']

还可以从大到小

name=name=[1,3,9,7,-1]
name.sort(reverse=True)
print(name)

#打印
[9, 7, 3, 1, -1]

列表练习

需求1：有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生年月日赋值给不同的变量。

data=['alex',49,[1900,3,18]]
name=data[0]
age=data[1]
year=data[2][0]
mothe=data[2][1]
day=data[2][2]

user_info='''
    姓名：{name}
    年龄：{age}
    出生日期：{year}:{mothe}:{day}
            '''.format(name=name,age=age,year=year,mothe=mothe,day=day)
print(user_info)

需求2：用列表模拟队列（先进先出）

a=[]
a.append(1)
a.append(2)
a.append(3)
print(a.pop(1))
print(a.pop(1))
print(a.pop(1))

#打印
1
2
3

需求3：用列表模拟队列（先进后出）

a=[]
a.append(1)
a.append(2)
a.append(3)
print(a.pop())
print(a.pop())
print(a.pop())

#打印
3
2
1

需求4：根据下列列表中字典里的age值进行排序

l=[
    {'name':'alex','age':18},
    {'name': 'dick', 'age': 20},
    {'name': 'admin', 'age': 19},
]
l.sort(key=lambda item:item['age'])
print(l)

#打印
[{'name': 'alex', 'age': 18}, {'name': 'admin', 'age': 19}, {'name': 'dick', 'age': 20}]

五 元组

 

常用操作

#定义方式：age=(1,2,3,4,5,6)

#注：元组和列表一样，但是元组是不可变类型只是做查询取值用。

#列表别元组站内存多

按索引取值（正反向）
请参考列表操作

 

切片

请参考列表操作

 

 

len（统计长度）

请参考列表操作

 

 

成员运算

请参考列表操作

 

 

index（获取坐标）

a=('a','c','v','a')
print(a.index('v'))

#打印
2

 

count（统计）

a=('a','c','v','a')
print(a.count('a'))

#打印
2

 

六 字典

 

常用操作

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

#定义：key必须是不可变类型，value可以是任意类型

#按key存取值

取值操作

l=[
    {'name':'alex'},
    {'name': 'dick'},
    {'name': 'admin'},]
print(l[1]['name'])

#打印
dick

 

添加\修改操作

注：如果key一样时就修改这个key的值，如果key不一样时就新建一个键值对

#添加
l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
l['3']=1
print(l)

#打印
{'0': 'alex', '1': 'dick', '2': 'admin', '3': 1}


#修改
l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
l['0']=1
print(l)

#打印
{'0': 1, '1': 'dick', '2': 'admin'}

 

len（统计长度）

参考列表

 

成员运算

参考列表

 

pop（剪切）

注：剪切的内容是字典里删除的key的对应得值，没有值会报错但是没有值可以自定义添加错误信息，就不会报错会打印你定义的错误信息。

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.pop('0'))
print(l)

#打印
alex
{'1': 'dick', '2': 'admin'}


#添加自定义错误信息
l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.pop('3','没有'))

#打印
没有

 

get操作

注：get操作会取字典里面的值，有值就返回值，没有就返回none，但是不会报错

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.get('0'))
print(l.get('3'))

#打印
alex
None

 

keys（只取字典里面的key）

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.keys())

#打印
dict_keys(['0', '1', '2'])

 

values（只取字典里面的值）

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.values)

#打印
dict_values(['alex', 'dick', 'admin'])

 

items（键值对都取出来）

取出来的是一个个的元组

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.items())

#打印
dict_items([('0', 'alex'), ('1', 'dick'), ('2', 'admin')])

直接取把键值对都取出来

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
for key,values in l.items():
    print(key,values)

#打印
0 alex
1 dick
2 admin

 

popitmes（随机删除一个键值对）

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.popitem())

#打印
('2', 'admin')

 

update（更新操作）

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
a={'0':'Alex',
   '3':"root"}
l.update(a)
print(l)

#打印
{'0': 'Alex', '1': 'dick', '2': 'admin', '3': 'root'}

解释：

　　update操作是把其他的字典和自己的字典合在一个，如果自己字典和另一个字典键重复的时候自己字典的面的值则会被覆盖

 

fromkeys（初始新字典）

dic={}.fromkeys(['admin','dick','root'],None)
print(dic)

#打印
{'admin': None, 'dick': None, 'root': None}

 

setdefault（添加默认值）

l={'0':'alex',
    '1': 'dick',
    '2': 'admin'}
print(l.setdefault('0','aaa'))
print(l.setdefault('3','bbb'))
print(l)

#打印
alex
bbb
{'0': 'alex', '1': 'dick', '2': 'admin', '3': 'bbb'}

解释：

　　当字典里面有这个key的话就返回字典里面key的值，如果没有就添加这个键值对并返回添加的值。

练习

交互两个变量的值

a=10
b=20
a,b=b,a
print(a,b)

#打印
20 10

 

链式赋值

a=b=c=10
print(a,b,c)

#打印
10 10 10

 

解压赋值

a,b,c=('admin','root','dick')
print(a,b,c)

#打印
admin root dick

 

只留匹前后的值其他的都不要

a,*_,c=('admin','root','dick')
print(a,c)

#打印
admin  dick

 

七 集合

 

 

#作用：
　　去重，关系运算

#定义：

　　#可以包含多个元素，用逗号分割，

#集合的元素遵循三个原则：

    #1：每个元素必须是不可变类型(可hash，可作为字典的key)

    #2：没有重复的元素

    #3：无序

    a={1,2,3,4}
    a=set({1,2,3,4})

常用操作

len（统计长度）

参考列表类型的操作

 

成员运算

参考列表类型的操作

 

并集（两个集合合一起并去重）

python={'alex','dick','admin','root'}
linux={'dick','root','meng'}
print(python | linux)

#打印
{'root', 'alex', 'dick', 'admin', 'meng'}

 

交集（取出两个集合相同的值）

python={'alex','dick','admin','root'}
linux={'dick','root','meng'}
print(python & linux)

#打印
{'root', 'dick'}

 

差集（去除集合里面其他集合有的值）

python={'alex','dick','admin','root'}
linux={'dick','root','meng'}
print(python - linux)

#打印
{'alex', 'admin'}

 

对称差集（取两个集合重复值之外的值）

python={'alex','dick','admin','root'}
linux={'dick','root','meng'}
print(python ^ linux)

#打印
{'meng', 'alex', 'admin'}

 

>（一个集合到底包不包含另一个集合）

意思就是一个集合里面的值是不是在另外的集合里面全有。

下面这个例子python是linux的父集。

python={'alex','dick','admin','root','meng'}
linux={'dick','root','meng'}
print(python > linux)

#打印
True


python={'alex','dick','admin','root',}
linux={'dick','root','meng'}
print(python > linux)

#打印
false

 

>=（包含或者两个集合值一样）

python={'dick','root','meng'}
linux={'dick','root','meng'}
print(python >= linux)

#打印
True

 

issuperset（判断是不是父集）

python={'alex','dick','admin','root','meng'}
linux={'dick','root','meng'}
print(python.issuperset(linux))

#打印
True

 

issubset（判断是不是子集）

python={'alex','dick','admin','root','meng'}
linux={'dick','root','meng'}
print(linux.issubset(python))

#打印
True

 

pop（随机删除）

linux={'dick','root','meng'}
print(linux.pop())
print(linux)

#打印
root
{'meng', 'dick'}

解释：

　　随机删除并返回删除的值

 

remove（直接删除）

linux={'dick','root','meng'}
print(linux.remove('dick'))
print(linux)

#打印
None
{'meng', 'root'}

解释：

　　只是单纯的删没有返回值，没有的话会报错

 

discard（删除但是没有不会报错）

linux={'dick','root','meng'}
print(linux.discard('dick123'))
print(linux)

#打印
None
{'root', 'dick', 'meng'}

注：

　　没有返回值，但是没有值得话不会报错

 

add（添加值）

linux={'dick','root','meng'}
print(linux.add('dick123'))
print(linux)

#打印
None
{'meng', 'root', 'dick123', 'dick'}

 

isdisjoint（判断有没有交集）

python={'alex','dick','admin','root',}
linux={'meng'}
print(linux.isdisjoint(python))

#打印
True

 

练习

列表去重

但是这样列表顺序就乱了。

python=['alex','dick','admin','dick']
python=list(set(python))
print(python)

#打印
['admin', 'dick', 'alex']

改良版，顺序不会变

python=['alex','dick','admin','dick']
python_list=[]
python_set=set()
for i in python:
    if i not in python_set:
        python_set.add(i)
        python_list.append(i)
print(python_list)

#打印
['alex', 'dick', 'admin']

 

字典去重

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_list=list()
l_set=set()
for i in l:
    res=(i['name'],i['age'],i['sex'])
    if res not in l_set:
        l_set.add(res)
        l_list.append(i)
print(l_list)

#打印
[{'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'alex', 'age': 73, 'sex': 'male'}, {'name': 'egon', 'age': 20, 'sex': 'female'}]

八 数据类型总结

 

 

按存值个数区分

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

 

按可变不可变区分

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

 

按访问顺序区分

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

九 字符编码

 

暂无

十 文件处理

 

 

基本操作

1.打开文件

f=open('a.txt',mode='r',encoding='utf-8')
#这步操作是发送系统调用，告诉操作系统我要打开文件，然后操作系统打开完成后会返回一个文件句柄赋值到f。这时有两个资源被占用一个是系统内存资源因为操作系统打开的文件，还有一个是python的内存资源，因为python正拿着文件句柄。
#第一个参数是指文件的路径，
#第二个参数是指打开文件的模式，r是读
#第三个参数是指字符编码，否则就会出现乱码的情况，原则就是以什么方式存就以什么方式取

2.读，写文件

data=f.read()
#这步操作是根据系统返回的文件句柄来读取文件里面的内容，根据文件句柄让操作系统找到要操作那个文件（也是给操作系统发送一个系统调用），并赋值到data变量中。

3.关闭文件

f.close()
#发送系统调用告诉操作系统你把这个文件句柄对应的文件给关闭掉（这是系统级别的关闭）。
#python当这个变量使用完后python自动回收用完的变量（这时python级别的关闭）

流程分析

1.向操作系统发起系统调用（就是向操作系统发起打开文件的信号）

2.操作系统打开这个文件后返回一个文件句柄给应用程序。

3.在应用程序中把文件句柄赋值给有一个变量（这个变量就是f）

注意两点：

　　1.打开一个文件对应两部分：一个是python级别的文件句柄，一个是操作系统打开的文件。（默认打开文件的编码是以操作系统为准的 ，除非自己知道编码 ）

　　2.当文件操作完成后会回收两部分资源：

del f ：是回收应用程序的资源（这步python已经帮你做了）

f.close()：是回收操作系统的资源

上下文管理：with

这个方法可以帮你自动关闭系统级别的文件（就不用f.close了）

with open('a.txt','r',encoding='utf-8') as f:
    print(f.read)

 

文件打开的格式

'r'：读模式，默认的打开模式，只读不能写，没有找到文件的话会报错。

f=open('a.txt',mode='r',encoding='utf-8')
    #读模式的方法
    print(f.readable())    #判断是不是可读文件，返回布尔值
    print(f.read())        #读文件里面的所有内容到内存
    print（f.readline()）   #一次读一行
    print（f.readlines()）  #也是读所有，但是把读出来的结果放到列表里。

‘w’：写模式不能读，如果文件不存在会自动创建一个文件，如果文件存在把里面的内容清空后打开。

f=open('a.txt',mode='w',encoding='utf-8')
    #写模式的方法
    print(f.wirtable())              #判断文件是不是可写问件，返回布尔值。
    f.wirt('1111\n')                 #往文件里的写操作
    f.wirtlines(['444\n','555\n'])   #把列表里面的内容放到文件里面去

'a'：追加写模式，如果文件不存在则新建，存在则把光标移动到末尾

f=open('a.txt',mode='w',encoding='utf-8')
    #追加写的方法
    #完全可以采用写的方法

遍历文件

利用for循环也是一行一行的读：这样的好处是节省内存，内存同时只有一行内容。

with open('a.txt','r',encoding='utf-8') as f:
    for line in f:
        print(line)