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
222
')  # 针对文本模式的写,需要自己写换行符
f.write('1111
222
'.encode('utf-8'))  # 针对b模式的写,需要自己写换行符
f.writelines(['333
','444
'])  # 文件模式
f.writelines([bytes('333
',encoding='utf-8'),'444
'.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')