python基础 2
基本数据类型及内置方法
一、数字类型int与float
1、定义：age=10 #本质age=int(10)
salary=200.3 #本质salary=float(200.3)
注意：名字+括号的意思是调用某个功能
2、类型转换
数据类型转换：int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则报错
s='123' res=int(s)
print(type(res))
3、数字类型主要就是用来做数学运算与比较运算
二、字符串
1、定义：在单引号、双引号、三引号内包含一串字符
2、类型转换：str()可以将任意数据类型转换成字符串类型
type(str([1,2,3]))
3、使用：
str1 = 'hello world'
1、取（正向取，反向取）只能按索引取
print(str[-4])
2、切片（顾头不顾尾，步长）
print(['0:9])
反向切片 str1[::-1] #-1表示从右往左依次取值
3、长度（len）
4、成员运算no in in
5、切片split
括号内不指定字符，默认以空格作为切分符号
括号内揸定分隔字符，则按照括号内指定的字符切割字符串
注意：split切割得到的结果是列表数据类型
1.strip, lstrip, rstrip
>>> str1 = '**tony***'
>>> str1.strip('*') # 移除左右两边的指定字符
'tony'
>>> str1.lstrip('*') # 只移除左边的指定字符
tony***
>>> str1.rstrip('*') # 只移除右边的指定字符
**tony
2.lower(),upper()
>>> str2 = 'My nAme is tonY！'
>>> str2.lower() # 将英文字符串全部变小写
my name is tony！
>>> str2.upper() # 将英文字符串全部变大写
MY NAME IS TONY！
3.startswith,endswith
>>> str3 = 'tony jam'
# startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False
>>> str3.startswith('t')
True
>>> str3.startswith('j')
False
# endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False
>>> str3.endswith('jam')
True
>>> str3.endswith('tony')
False
4.格式化输出之format
之前我们使用%s来做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖位置的传值方式
案例：
# format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值，name=‘tony’就是传给{name}
>>> str4 = 'my name is {name}, my age is {age}!'.format(age=18,name='tony')
>>> str4
'my name is tony, my age is 18!'
>>> str4 = 'my name is {name}{name}{name}, my age is {name}!'.format(name='tony', age=18)
>>> str4
'my name is tonytonytony, my age is tony!'
format的其他使用方式（了解）
# 类似于%s的用法，传入的值会按照位置与{}一一对应
>>> str4 = 'my name is {}, my age is {}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!
# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4 = 'my name is {0}, my age is {1}!'.format('tony', 18)
>>> str4
my name is tony, my age is 18!
>>> str4 = 'my name is {1}, my age is {0}!'.format('tony', 18)
>>> str4
my name is 18, my age is tony!
>>> str4 = 'my name is {1}, my age is {1}!'.format('tony', 18)
>>> str4
my name is 18, my age is 18!
5.split,rsplit
# split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
>>> str5='C:/a/b/c/d.txt'
>>> str5.split('/',1)
['C:', 'a/b/c/d.txt']
# rsplit刚好与split相反，从右往左切割，可以指定切割次数
>>> str5='a|b|c'
>>> str5.rsplit('|',1)
['a|b', 'c']
6.join
# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '%'.join('hello') # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
'h%e%l%l%o'
>>> '|'.join(['tony','18','read']) # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony|18|read'
7.replace
# 用新的字符替换字符串中旧的字符
>>> str7 = 'my name is tony, my age is 18!' # 将tony的年龄由18岁改成73岁
>>> str7 = str7.replace('18', '73') # 语法:replace('旧内容', '新内容')
>>> str7
my name is tony, my age is 73!
# 可以指定修改的个数
>>> str7 = 'my name is tony, my age is 18!'
>>> str7 = str7.replace('my', 'MY',1) # 只把一个my改为MY
>>> str7
'MY name is tony, my age is 18!'
8.isdigit
# 判断字符串是否是纯数字组成，返回结果为True或False
>>> str8 = '5201314'
>>> str8.isdigit()
True
>>> str8 = '123g123'
>>> str8.isdigit()
False
三、列表
1、定义：在【】内用逗号分隔开多个任意数据类型的值
2、类型转换：但凡能被for循环遍历的数据类型都可以传给List()转换成列表类型，list()会跟for循环一样遍历出数据
3、使用
1、取（从左往右）my_list=['tony','jason','tom',2,3] my_list[0] 反向取【-1】
指定位置的值取，不存在则报错：my_list[1]='marttow'
切片（顾头不顾尾） my_list[0:4:2]
2、增（添加）
append()列表尾部追加元素 my_list.append('d')
extend()一次性在列表尾部添加多个元素 my_list.extend(['a','b'])
insert()在指定位置插入元素 my_list.insert(0,'first')
3、删除
del [2] 删除索引为2的元素
pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
L = [11,22,33,44] res = L.pop()
remove() 括号内指名道姓表示要删除哪个元素，没有返回值
L = [11,22,33,44] res=L.remove(22) #从左往右查找第一个括号内需要删除的元素
4、reverse() 颠例列表内元素顺序
L = [11,22,33,44] L.reverse()
5、sort（）给列表内所有元素排序 #排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
四、元组
1、作用：元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取
2、定义方式：在（）内用逗号分隔开多个任意类型的值
3、类型转换：但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
tuple()会跟for循环一样遍历出数据型中包含每一个元素然后放到元组中‘
4、使用
1、按索引取值（正向取、反向取）只能取，不能改否则报错！
2、切片（顾头不顾尾）[0:6:2]
3、长度 len
4、成员运算in和not in
5、循环
五、字典
1、定义方式：在{ }内用逗号分开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key必须是不可变类型
通常key应该是str类型，因为str类型会对value有描述性的功能
info={'name':'egon','age':18,'sex;'male}
info=dic(name='tony',age=18,sex='male')
2、类型转换
info=dict([['name','tony'],('age',18)])
{}.fromkeys(('name','age','sex'))
3、使用
1、取：按key存取值，可存可取
dic['name]
dic['hobbies'][1]
对于赋值操作，如果key原先不存在于字典，则会新增key:value
dic['gender']='male'
对于赋值操作，如果key原先存在于字典，则会修改对应value的值
dic['name']='tony'
2、删除
dic.pop('name') 通过指定字典的key来删除字典的键值对
v=dic.pop('k2')
dic.popitem() 随机删除一组键值对，并将删除的键值放到元组内返回
# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
... print(key)
...
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
... print(key)
...
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
... print(key)
...
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
... print(key)
...
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')
3、取
get(): dic.get('k1')
4、update() 有则改，无则添加
dic.update({'k1':'jn','k4':'xxx'})
5、fromkeys() 创建字典
dic=dic.fromkeys(['k1','k2','k3'],[])
6、setdefault() key不存在则新增值对，并将新增的value返回
res=dic.setdafault('k3',333)
六、集合
1、作用：集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
2、定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序
3、类型转换
但凡能被for循环遍历的数据类型 s = set([1,2,3,4,5])
4、使用
1、关系运算
# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}
# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}
# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
# 5.值是否相等(==)
>>> friends1 == friends2
False
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False
# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
2、去重：只能针对不可变类型， 集合本身是无序的
可变类型与不可变类型
可变类型：值发生改变时，内存地址不变，即id不变，证明在改变原值 列表、字典
不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值 数字、字符串、元组
文件处理
一、介绍：
计算机系统分为：计算机硬件、操作系统、应用程序三部分。
若想把数据永久保存下来，必须要保存于硬盘中，就涉及到应用程序要操作硬件，应用程序无法直接操作硬件，这就用到了操作系统。用户或诮用程序通过操作文件，可以将自己的数据永久保存下来。
# 1. 打开文件，由应用程序向操作系统发起系统调用open(...)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r
# 2. 调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作
data=f.read()
# 3. 向操作系统发起关闭文件的请求，回收系统资源
f.close()
打开一个文件包含两部分资源：应用程序的变量f和操作系统打开的文件。在操作完毕一个文件时，必须把与该文件的这两部分资源全部回收，回收方法为：
1、f.close() #回收操作系统打开的文件资源
2、del f #回收应用程序级的变量
with关键字来帮我们管理上下文
# 1、在执行完子代码块后，with 会自动执行f.close()
with open('a.txt','w') as f:
pass
# 2、可用用with同时打开多个文件，用逗号分隔开即可
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')
文件的操作模式
r(默认的)：只读 w：只写 a：只追加写
控制文件读写内容的模式
大前提: tb模式均不能单独使用,必须与r/w/a之一结合使用
t（默认的）：文本模式
1. 读写文件都是以字符串为单位的
2. 只能针对文本文件
3. 必须指定encoding参数
b：二进制模式:
1.读写文件都是以bytes/二进制为单位的
2. 可以针对所有文件
3. 一定不能指定encoding参数
操作文件的方法
# 读操作
f.read() # 读取所有内容,执行完该操作后，文件指针会移动到文件末尾
f.readline() # 读取一行内容,光标移动到第二行首部
f.readlines() # 读取每一行内容,存放于列表中
# 强调：
# f.read()与f.readlines()都是将内容一次性读入内容，如果内容过大会导致内存溢出，若还想将内容全读入内存，则必须分多次读入，有两种实现方式：
# 方式一
with open('a.txt',mode='rt',encoding='utf-8') as f:
for line in f:
print(line) # 同一时刻只读入一行内容到内存中
# 方式二
with open('1.mp4',mode='rb') as f:
while True:
data=f.read(1024) # 同一时刻只读入1024个Bytes到内存中
if len(data) == 0:
break
print(data)
# 写操作
f.write('1111\n222\n') # 针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8')) # 针对b模式的写,需要自己写换行符
f.writelines(['333\n','444\n']) # 文件模式
f.writelines([bytes('333\n',encoding='utf-8'),'444\n'.encode('utf-8')]) #b模式
主动控制文件内指针移动
#大前提:文件内指针的移动都是Bytes为单位的,唯一例外的是t模式下的read(n),n以字符为单位
with open('a.txt',mode='rt',encoding='utf-8') as f:
data=f.read(3) # 读取3个字符
with open('a.txt',mode='rb') as f:
data=f.read(3) # 读取3个Bytes
# 之前文件内指针的移动都是由读/写操作而被动触发的，若想读取文件某一特定位置的数据，则则需要用f.seek方法主动控制文件内指针的移动，详细用法如下：
# f.seek(指针移动的字节数,模式控制):
# 模式控制:
# 0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的
# 1: 该模式代表指针移动的字节数是以当前所在的位置为参照的
# 2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的
# 强调:其中0模式可以在t或者b模式使用,而1跟2模式只能在b模式下用
# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）
abc你好
# 0模式的使用
with open('a.txt',mode='rt',encoding='utf-8') as f:
f.seek(3,0) # 参照文件开头移动了3个字节
print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3
print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好
# 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败
with open('a.txt',mode='rb') as f:
f.seek(6,0)
print(f.read().decode('utf-8')) #输出结果为: 好
文件的修改
# 文件a.txt内容如下
张一蛋 山东 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422
# 执行操作
with open('a.txt',mode='r+t',encoding='utf-8') as f:
f.seek(9)
f.write('<妇女主任>')
# 文件修改后的内容如下
张一蛋<妇女主任> 179 49 12344234523
李二蛋 河北 163 57 13913453521
王全蛋 山西 153 62 18651433422
# 强调：
# 1、硬盘空间是无法修改的,硬盘中数据的更新都是用新内容覆盖旧内容
# 2、内存中的数据是可以修改的
# 实现思路：将文件内容发一次性全部读入内存,然后在内存中修改完毕后再覆盖写回原文件
# 优点: 在文件修改过程中同一份数据只有一份
# 缺点: 会过多地占用内存
with open('db.txt',mode='rt',encoding='utf-8') as f:
data=f.read()
with open('db.txt',mode='wt',encoding='utf-8') as f:
f.write(data.replace('kevin','SB'))
# 实现思路：以读的方式打开原文件,以写的方式打开一个临时文件,一行行读取原文件内容,修改完后写入临时文件...,删掉原文件,将临时文件重命名原文件名
# 优点: 不会占用过多的内存
# 缺点: 在文件修改过程中同一份数据存了两份
import os
with open('db.txt',mode='rt',encoding='utf-8') as read_f,\
open('.db.txt.swap',mode='wt',encoding='utf-8') as wrife_f:
for line in read_f:
wrife_f.write(line.replace('SB','kevin'))
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')
浙公网安备 33010602011771号