python（二）
目录
- 字符串
-
- 字符串切片
- 字符串常用方法
- 列表
-
- 将列表元素倒序输出
- 将列表中元素值排序
- 字典
-
- 创建字典
- 增加字典中数据
- 删除字典中的数据
- 更改字典中数据
- 遍历字典中数据
- 元祖
-
- 元祖与列表只之间相互转换
- 集合
-
- 合并两个集合
- 两个集合的交集
- 两个集合的并集
- 两个集合的差集
- 非空即真
- 文件读写
-
- 文件打开、关闭
- 常用文件操作模式
- 读取文件的三种方式
- 遍历文件
字符串
字符串切片
字符串切片就是截取字符串，取子串。Python中字符串切片方法为：
“字符串[开始索引：结束索引：步长]”
截取字符串为开始索引到（结束索引-1）内的字符串，步长不指定时步长为1：字符串[开始索引:结束索引]。
n = '123456789'
print(n[2:]) # 如果只有开始索引，没有结束索引，则代表从开始索引到字符串最后
print(n[:5]) # 如果只有结束索引，没有开始索引，则表示索引从0开始到结束索引前一个字符
print(n[2:5]) # 如果开始和结束索引均设置，则输出指定的内容（左闭右开）
print(n[::2]) # 如果需要跳一位输出，则要设置步长
print(n[:-1]) # 取字符串最后一个字符之前的所有字符
print(n[-1]) # 取字符串最后一个字符
运行结果：
3456789
12345
345
13579
12345678
9
字符串常用方法
- count()：统计某个字符在字符串中出现的次数
a ="hahaha"
print(a.count("a"))
print(a.count("b"))
运行结果：
3
0
- find()：检查字符串中是否包含要找的内容片断，从左向右找，当找到第一个就返回被找到的内容索引值，不包含则返回-1。
a ="hahaha"
print(a.find("a"))
print(a.find("b"))
print(a.find("ha"))
运行结果：
1
-1
0
- index()：检测字符串中是否包含子字符串，从左向右查找，如果包含子字符串返回被找到的内容索引值，否则抛出异常。
a ="hahaha"
print(a.index("a"))
print(a.index("ha"))
运行结果：
1
0
- format()：用于格式化字符串，使用{}来标明被替换的字符串
un="姓名：{name}，年龄：{age}"
print(un.format(name="xiaoli",age=20))
运行结果：
姓名：xiaoli，年龄：20
- format_map()：用于格式化字符串，把字典中的每个key和字符串中声明的占位去进行查找，format_map相比较format更灵活。
un="姓名：{name}，年龄：{age}"
print(un.format_map({
"name":"xiaoli","age":20}))
运行结果：
姓名：xiaoli，年龄：20
- strip()：去除字符串前后空格，但是不会去除中间的空格。
print(" abc".strip())
print("abc ".strip())
print(" abc ".strip())
print(" a b c ".strip())
运行结果：
abc
abc
abc
a b c
- lstrip()：去除字符串左边的空格或指定字符。
print(" dksjfak ".lstrip())
运行结果
dksjfak
- rstrip()：去除字符串右边的空格或指定字符。
print(" dksjfak ".rstrip())
运行结果：
dksjfak
- isspace()：判断字符串中的所有字符都是空格
print(" ".isspace())
print(" 1".isspace())
print("".isspace())
运行结果：
True
False
False
- isalpha()：判断字符串中的所有字符都是字母或文字，并且至少有一个字符，返回 True ，否则返回 False。
print("今天".isalpha())
print("123".isalpha())
运行结果：
True
False
- upper()：将字符串中所有字符大写
print("HHHeee".upper())
运行结果：
HHHEEE
- lower()：将字符串中所有字符大写
print("HHHeee".lower())
运行结果：
hhheee
- replace()：把字符串中某个子字符串，替换成新的字符串
print("xiaowang,xiaoli".replace(",","\n"))
运行结果：
xiaowang
xiaoli
- split()：通过指定分隔符对字符串进行切片。
f = "xiaowang,xiaoli,xiaobai,xiaohong"
new_f=f.split(",")
print(new_f)
运行结果：
['xiaowang', 'xiaoli', 'xiaobai', 'xiaohong']
- startswith()：检查字符串是否是以指定字符串开头，如果是则返回 True，否则返回 False。
print("egda".startswith("e"))
运行结果：
True
- endswith()：判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。
print("egda".endswith("e"))
运行结果：
False
列表
将列表元素倒序输出
list1=[1, 4, 7, 2, 4, 9, 7, 5, 9, 18]
list1.reverse()
print(list1)
运行结果
[18, 9, 5, 7, 9, 4, 2, 7, 4, 1]
将列表中元素值排序
- 升序
list1=[1, 4, 7, 2, 4, 9, 7, 5, 9, 18]
list1.sort()
print("升序：",list1)
运行结果：
升序： [1, 2, 4, 4, 5, 7, 7, 9, 9, 18]
- 降序
list1=[1, 4, 7, 2, 4, 9, 7, 5, 9, 18]
list1.sort(reverse=True)
print("降序：",list1)
运行结果：
降序： [18, 9, 9, 7, 7, 5, 4, 4, 2, 1]
字典
- 字典是另一种可变容器模型，且可存储任意类型对象。
- 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = { key1 : value1, key2 : value2 } - 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
- 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
- python中的字典（dict）与json字符串可通过“import json”相互转化。
创建字典
user={
} #创建一个空字典
new_user={
"name":"xiaoli","age":18,"address":"beijing"}
print(user)
print(new_user)
运行结果：
{
}
{
'name': 'xiaoli', 'age': 18, 'address': 'beijing'}
增加字典中数据
new_user={
}
new_user["name"]="xiaozhang"
new_user["age"]=18
new_user["interest"]=['计算机',"英文","跑步"]
new_user['score']=95.5
print(new_user)
运行结果：
{
'name': 'xiaozhang', 'age': 18, 'interest': ['计算机', '英文', '跑步'], 'score': 95.5}
删除字典中的数据
- 通过del删除
user={
"name":"xiaoli","age":18,"address":"beijing"}
del user["name"] # 指定字典中的key删除
print(user)
运行结果：
{
'age': 18, 'address': 'beijing'}
- 通过pop()删除
user={
"name":"xiaoli","age":18,"address":"beijing"}
print(user.pop("name")) # pop()可将删除的数据打印出来
print(user)
运行结果：
xiaoli
{
'age': 18, 'address': 'beijing'}
更改字典中数据
更改字典中的数据，就是做重写操作。
user={
"name":"xiaoli","age":18,"address":"beijing"}
user["age"]=20
print(user)
运行结果：
{
'name': 'xiaoli', 'age': 20, 'address': 'beijing'}
遍历字典中数据
- 遍历字典中key值
user={
"name":"xiaoli","age":18,"address":"beijing"}
for i in user.keys():
print(i ,"的值是：",user[i])
运行结果：
name 的值是： xiaoli
age 的值是： 18
address 的值是： beijing
- 遍历字典中的value值
user={
"name":"xiaoli","age":18,"address":"beijing"}
for i in user.values():
print(i)
运行结果：
xiaoli
18
beijing
- 遍历字典项
user={
"name":"xiaoli","age":18,"address":"beijing"}
for i in user.items():
print(i)
运行结果：
('name', 'xiaoli')
('age', 18)
('address', 'beijing')
- 遍历字典key：value
user={
"name":"xiaoli","age":18,"address":"beijing"}
for k,v in user.items():
print(k,v)
运行结果：
name xiaoli
age 18
address beijing
元祖
Python 的元组与列表类似，不同之处在于
- 元组的元素不能修改。
- 声明方式不同：元组使用小括号，列表使用方括号。
- 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
- 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
tup1 = (50)
print(type(tup1))
tup2 = (50,)
print(type(tup2))
运行结果：
<class 'int'>
<class 'tuple'>
Python 的元组与列表共同点：取值及常用方法类似，只要不修改元祖数据的操作都可以执行。
t=(0,1,2,3,4)
l1=[0,1,2,3,4]
print(t)
print(l1)
print(t.index(1))
print(t.count(2))
运行结果：
(0, 1, 2, 3, 4)
[0, 1, 2, 3, 4]
1
1
元祖与列表只之间相互转换
- 将列表转化为元组
l1 = [1, 2, 3]
t = tuple(l1)
print(t)
print(type(t))
运行结果：
(1, 2, 3)
<class 'tuple'>
- 将元组转换成列表
t=(1,2,3)
l=list(t)
print(l)
print(type(l))
运行结果：
[1, 2, 3]
<class 'list'>
集合
- 集合（set）是一个无序的不重复元素序列。
- 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
l1=[1,3,5,6,5,2,8,5,1,3,20]
s1=set(l1)
l2=list(s1) # 将集合转换为列表
s2=set() # 定义一个空集合
print(s1)
print(l2)
print(s2)
运行结果：
{
1, 2, 3, 5, 6, 8, 20}
[1, 2, 3, 5, 6, 8, 20]
set()
- 添加元素，将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s1 = {
1,2,3,4,5,6}
s1.add(5)
s1.add(9)
print(s1)
运行结果：
{
1, 2, 3, 4, 5, 6, 9}
合并两个集合
s1={
1,2,3,4}
s2={
2,3,4,5}
s1.update(s2)
print(s1)
运行结果：
{
1, 2, 3, 4, 5}
两个集合的交集
s1={
1,2,3,4}
s2={
2,3,4,5}
s3=s1.intersection(s2)
print(s3)
运行结果：
{
2, 3, 4}
两个集合的并集
s1={
1,2,3,4}
s2={
2,3,4,5}
s3=s1.union(s2)
print(s3)
运行结果：
{
1, 2, 3, 4, 5}
两个集合的差集
s1={
1,2,3,4}
s2={
2,3,4,5}
s3=s1^s2
print(s3)
运行结果：
{
1, 5}
非空即真
Python程序语言指定任何非0和非空（none）值为true，0 或者 None为false
- 字符串类型，空字符串表示False，其他为True
- 整数和浮点数，0表示False，其他为True
- 序列类型（包括列表，元组，字典，集合等），空表示False，非空表示True
- 布尔类型，False为假，True为真
- None永远表示False
# str 空/非空字符串
print(bool(None))
print(bool(''))
print(bool("1"))
#list 空和有参数
print(bool([]))
print(bool([1]))
#dict 空和有参数
print(bool({
}))
print(bool({
"name":"lili"}))
运行结果：
False
False
True
False
True
False
True
文件读写
文件打开、关闭
- 打开
Python打开文件使用open()方法，一般基础语法为：
open(file, mode=‘r’, encoding=)
file: 必需，文件路径（相对或者绝对路径），文件在当前代码文件路径下可以直接写文件名，使用绝对路径时一般加r’，表示取原字符
mode: 可选，文件打开模式
encoding: 一般使用utf8
- 关闭
使用close()关闭文件。
常用文件操作模式
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头，文件打开模式不写默认为r模式 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头 |
读取文件的三种方式
- read()
用于从文件读取指定的字节数
语法如下：
fileObject.read(size)
size – 从文件中读取的字节数，默认或者指定负数读所有
file=open("a.txt",encoding="utf-8")
print(file.read()) # 全部读取出来
file.close()
运行结果：
1234
a123
fj
大富科技
嗯嗯嗯
- readline()
用于从文件读取整行，包括 “\n” 字符。
语法如下：
fileObject.readline(size)
size – 从文件中读取的字节数，默认或者指定负数读整行
file=open("a.txt",encoding="utf-8")
print("readline::",file.readline(3))
file.close()
运行结果：
readline:: 123
- readlines()
用于读取所有行(直到结束符 EOF)并以列表形式返回，如有换行，会把换行符写入字符串中
语法如下：
fileObject.readlines( )
file=open("a.txt",encoding="utf-8")
print("readlines:::",file.readlines()) # 将数据转为一个list
file.close()
运行结果：
readlines::: ['1234\n', 'a123\n', 'fj\n', '大富科技\n', '嗯嗯嗯']
遍历文件
- 全部读取并转为list
file=open("a.txt",encoding="utf-8")
for line in file.readlines():
print("line:::",line.strip())
file.close()
运行结果：
line::: 1234
line::: a123
line::: fj
line::: 大富科技
line::: 嗯嗯嗯
- 逐行读取进行操作，不会提前加载到内存中，解决性能问题
file=open("a.txt",encoding="utf-8")
for line in file:
print("line:::", line.strip())
file.close()
运行结果：
line::: 1234
line::: a123
line::: fj
line::: 大富科技
line::: 嗯嗯嗯