Python之路Day2_python挑出张三和李四行-CSDN博客

本文链接：https://blog.csdn.net/qq_20060031/article/details/79008118

本文主要内容

1、容器的操作

2、字符串操作

3、文件操作

1、容器的操作

我是java出身的，基本上接触一门语言，都会去思考，这门语言是否存在与java类似的List，Map，Set容器。下面我将一一对其进行介绍

1）python中的list

在python中，list写法十分简单，只需要如此定义即可：

list = ['张三','李四','王五']

在list中并不像java一样提供get方法，但是同样是提供根据下标进行查询，写法类似于java数组。例如，我想要找到李四，我可以如此写

print(list[1])

python对于list还提供其他的一些方法，具体如下：

切片操作：

list = ['张三','李四','王五','赵六','钱七']

# 切片
# 取0到2之间的元素，包括0但是不包括2
print(list[0:2])
# 也可以这么写,这么写的意思是从头开始取
print(list[:2])
# 如果想从中间某一位开始截取，一直到尾部，如此写
print(list[2:])
# 索引可以为负数，从最后一直往前以此为-1，-2，-3
print(list[1:-3])
# 如果需要跳着取数据，其中最后一个冒号后面表示跳跃的幅度
print(list[1::2])
# 最后，谨记一点，包含头部不包含尾部

追加操作:

list = ['张三','李四','王五','赵六','钱七']

list.append('测试添加')

print(list)

修改操作：

list = ['张三','李四','王五','赵六','钱七']

list[0] = '张三（修改）'
print(list)

插入：

list = ['张三','李四','王五','赵六','钱七']
# 插入就是直接将原本下标为1的元素往后顶，然后将下标为1的地方赋一个新的值
list.insert(1,"我是新插入的")
print(list)

删除：

list = ['张三','李四','王五','赵六','钱七']
# 使用pop删除，如果不传递参数，默认删除最后一个
list.pop(1)
# 必须传递传递参数，而且参数必须存在于集合之中，否则会报异常
list.remove("张三")
# 使用delete方法删除
del list[0]
print(list)

继承：

list = ['张三','李四','王五','赵六','钱七']
list_extends = ["地主"]
list_extends.extend(list)
print(list_extends)
# 注意不能写成list_extends = ["地主"].extend(list),否则list_extends中将什么值都没有

排序：

# 不同类型无法进行排序
#list = ['张三','李四','王五','赵六','钱七',1,2]
#list.sort()
list = ['张三','李四','王五','赵六','钱七',"1","2","#","s"]
# 从小到大进行排序,排序优先级为特殊字符>数字>英文>汉字
list.sort()
print(list)
# 排序反转
list.reverse()
print(list)

统计：

list = ['张三','李四','王五','赵六','钱七',"1","2","#","s"]
print(list.count('张三'))

获取下标：

list = ['张三','李四','王五','赵六','钱七',"1","2","#","s"]
print(list.index("张三"))

list还提供许多其他的方法，此处不做一一列举，如果读者有兴趣，可以直接点击进去自行查看。值得一提的是python有一个元组的概念。元组只提供统计和获取下标的功能，具体定义如下：

list = ('张三','李四','王五','赵六','钱七',"1","2","#","s")

2）python中的Set

python中如此定义Set：

set = set([1,1,2,31,2,3,4,4,5])

和java的set类似，python的set提供去重且自动排序的功能。但是python的set功能远远不止于此。它提供对数据的关系功能测试。这个说法有些官方，具体来说的话，就是提供数据的并集，差集这样关系的方法。

并集：

# 测试集合
set_test = set([1,2,3,4,5,6])
# 测试并集
set_union = set([2,3,7,8,9,10])
# 两者并集
print(set_test.union(set_union))
# 输出结果
# {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

交集：

# 测试集合
set_test = set([1,2,3,4,5,6])
# 测试交集
set_union = set([2,3,7,8,9,10])
# 两者交集
print(set_test.intersection(set_union))
# 输出结果
# {2, 3}

差集：

# 测试集合
set_test = set([1,2,3,4,5,6])
# 测试交集
set_union = set([2,3,7,8,9,10])
# 两者差集
print(set_test.difference(set_union))
# 输出结果
# {1, 4, 5, 6}

将差集更新到主集合中：

# 测试集合
set_test = set([1,2,3,4,5,6])
# 测试交集
set_union = set([2,3,7,8,9,10])
# 两者差集
print(set_test.difference(set_union))
# 输出结果
# {1, 4, 5, 6}
set_test.difference_update(set_union)
print(set_test)
# 输出结果
# {1, 4, 5, 6}

简易写法：

a = t | s          # t 和 s的并集  
  
b = t & s          # t 和 s的交集  
  
c = t – s          # 求差集（项在t中，但不在s中）  
  
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）

除去此几种，Set还提供add，remove，pop这些和list没什么区别的方法。也有一些例如issuperset这种判断是否包含子集的方法。此处不做一一列举，有兴趣的读者，可以自行去查看。

3）map（又称为字典）

python的字典相当于java的map，都是key-value的数据类型。也由于是key-value数据类型，所以一个key只能对应一个value。

定义：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
print(map_test)

取数据：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
# 两种方式取数据
# 第一种方式
print(map_test['name'])
# 输出结果
# zhiweiHong
# 第二种方式
print(map_test.get('name'))
# 输出结果
# zhiweiHong
# 建议使用第二种，第二种如果取不到数据，返回none，第一种会直接报错
#print(map_test['test'])
'''Traceback (most recent call last):
  File "E:/workForMyself/pythonTest/Blog/map.py", line 14, in <module>
    print(map_test['test'])
KeyError: 'test'''
print(map_test.get('test'))
# 输出结果
# None

追加：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
# 追加节点
map_test['wife'] = 'nana'
print(map_test)
# 输出结果
# {'name': 'zhiweiHong', 'age': 23, 'job': 'java', 'wife': 'nana'}

更新一个节点：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
# 更新一个节点
map_test['name'] = 'Navice'
print(map_test)
# 输出结果
# {'name': 'Navice', 'age': 23, 'job': 'java'}

删除一个节点：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
# 删除一个节点
# 标准删除
map_test.pop('name')
print(map_test)
# 输出结果
# {'age': 23, 'job': 'java'}
# del方法删除
del map_test['age']
print(map_test)
# 输出结果
# {'job': 'java'}
# 随机删除
map_test.popitem()
print(map_test)

将一个字典更新到另一个字典中：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
map_wife = {
    'wife':'nana'
}
map_test.update(map_wife)
print(map_test)
# 输出结果
# {'name': 'zhiweiHong', 'age': 23, 'job': 'java', 'wife': 'nana'}

像java一样获取ke'ySet和values：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'job' : 'java'
    }
print(map_test.keys())
# 输出结果
# dict_keys(['name', 'age', 'job'])
print(map_test.values())
# 输出结果：
# dict_values(['zhiweiHong', 23, 'java'])

字典同样可以多层嵌套：

map_test = {
        'name':'zhiweiHong',
        'age' : 23,
        'havebook' : [{
            'name':'java编程'
        },{
            'name':'网络编程'
        }
        ]
    }
print(map_test)
# 输出结果
# {'name': 'zhiweiHong', 'age': 23, 'havebook': [{'name': 'java编程'}, {'name': '网络编程'}]}

2、字符串操作

python的字符串依循在着和java一样的原则，不可变。不可变的意思是如果我顶一个变量s = ‘1’，s=s+'2',这是s实际上不在指向1，而是创建了一个新的s。

string = 'testString'
# 用于查找某一个字符串在string字符串中的位置,要求查找的必须属于此字符串
print(string.index('e'))
#将一个集合拼装成一个字符串
list = ['1','2','3']
print(''.join(list))
# 在此字符串中查找传入参数，如果不存在则返回-1
print(string.find('s'))
# repalce 将s替换成1
string = string.replace('e','1')
print(string)
# 已t为分割条件进行分割
array =string.split('t')
print(array)
# 格式化字符串，{}中的是变量部分
str1 = '{name}:{age}'.format(name='zhiweiHong',age='23')
print(str1)
# 返回布尔值，意思为是否以t做为字符串的开头
print(string.startswith('t'))
# 编码
# encode  表示已utf-8的格式进行编码
# decode  表示已utf-8的格式进行解码
print(string.encode('utf-8').decode('utf-8'))
# 将\t 转成空格
tabs = '\tss'
print(tabs.expandtabs())
# 计算传入参数
print(string.count('t'))
# 改成标题格式，首字母大写,其他字母小写
print(string.capitalize())
# 将字符串居中，传入值为所在行长度
print(string.center(50))
# 使用字典进行格式化
map = {
        'name':'Navice',
        'age':'23'
    }
print('My name is {name},i am {age} old'.format_map(map))
# 全部小写
print(string.lower())
# 全部大写
print(string.upper())
# 以\n为分隔符
lines = 'sssss\nssss'
print(lines.splitlines())

# 运行结果
# 1
# 123
# 2
# t1stString
# ['', '1s', 'S', 'ring']
# zhiweiHong:23
# True
# t1stString
#         ss
# 3
# T1ststring
#                     t1stString                    
# My name is Navice,i am 23 old
# t1ststring
# T1STSTRING
# ['sssss', 'ssss']

python还提供一些判断方法，有兴趣的朋友可以去自行查看。

3、文件操作
python的文件操作令人惊讶的简单。

file = open('happroxy','r',encoding = 'utf-8')
# open（）方法
# 第一个参数： 文件名
# 第二个参数： 操作类型
# r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
# r+	打开一个文件用于读写。文件指针将会放在文件的开头。
# rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
# w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
# wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
# w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
# wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
# a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
# a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
# ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
# 第三个为默认参数，不传入默认是utf-8，为了规范起见，建议传入
for line in file.readlines():
    print(line)

python的文件操作令人惊讶的简单。就读取数据来说，除去直接file.readlines()这种方法，还有另外一种方法。前者是预先将文件全部读取传入内存。如果文件还小，这种做法尚可接受，如果文件远超1G，甚至于上百G。这种方法必然会让内存溢出。下面介绍一种提升性能的方法。