Python基础（模块初识字符串列表元组字典的用法）

Posted 2021-01-24 summerj

模块（Module）初识

python模块是一个python文件，以.py结尾。模块中定义了一些变量及函数，可以在需要的时候引用模块，调用其中的变量及函数。可以调用系统模块或导入第三方模块调用，也可以自行编写模块。

1 # 显示系统中模块存放的路径
2 import sys  # 引入模块
3 print(sys.path)  # 调用sys模块中的函数

字符串（String）及其函数

字符串是python中最常用的数据类型之一，可以适用引号（‘或“）创建，以下为字符串的大部分函数。

 1 name = ‘my name is {n},age is {a}‘  # 创建一个字符串变量
 2 print(name.count(‘m‘))  # 统计m的数量
 3 print(name.capitalize())  # 将第一个字母大写 My name is {n},age is {a}
 4 print(name.center(50, ‘*‘))  # 输出50个字符，不足用*号补齐，将字符串居中
 5 print(name.encode())  # 将字符串编码为二进制，可以使用decode()函数对二进制字符串做解码
 6 print(name.endswith(‘tt‘))  # 字符串是否以tt结尾，返回bool值
 7 print(‘my	name is‘.expandtabs(30))  # 字符串中的tab为30个空格
 8 print(name.format(n=‘catty‘, a=‘23‘))  # 输出结果 my name is catty,age is 23
 9 print(name.format_map({‘n‘: ‘catty‘, ‘a‘: ‘23‘}))  # 输出结果 my name is catty,age is 23
10 print(name.find(‘my‘))  # 查找，若在字符串中找不到目标字符串返回-1
11 print(‘23‘.isdigit())  # 字符串是否为整数，返回bool值
12 print(name.index(‘my‘))  # 与find功能一样，但若在字符串中找不到目标字符串则报错
13 print(‘124‘.isalnum())  # 字符串是否由数字或字母组成，返回bool值
14 print(‘dsfdsewr‘.isalpha())  # 字符串是否由纯字母组成，返回bool值
15 print(‘0x9e8f‘.isdecimal())  # 检查字符串是否只包含十进制字符，返回bool值
16 print(‘_dfoiewfjei‘.isidentifier())  # 判断是否是一个合法的标识符，但系统关键字无法判断
17 print(‘sdjfoiA‘.islower())  # 判断字符串是否全部为小写字符
18 print(‘654623sdoi‘.isnumeric())  # 检测字符串是否只由数字组成
19 print(‘ioew‘.isprintable())  # 是否可打印，linux中tty无法打印
20 print(‘‘.isspace())  # 是否是纯空格
21 print(‘My Name ‘.istitle())  # 是否每个单词首字符大写
22 print(‘SFEGE‘.isupper())  # 是否全部为大写字母
23 print(‘+‘.join([‘1‘, ‘2‘, ‘e‘]))  # 输出结果 1+2+e
24 print(name.ljust(50, ‘*‘))  # 将字符串在右侧使用*补齐50个字符
25 print(name.rjust(50, ‘*‘))  # 将字符串在左侧使用*补齐50个字符
26 print(name.lower())  # 转为小写
27 print(name.upper())  # 转为大写
28 print(‘-------------‘)
29 print(‘  
  alex
‘.lstrip())  # 删除字符串左侧的空格及换行
30 print(‘-------------‘)
31 print(‘  
  alex
‘.rstrip())  # 删除字符串右侧的空格及换行
32 print(‘-------------‘)
33 print(‘  
  alex
‘.strip())  # 删除字符串两侧的空格及换行
34 print(‘-------------‘)
35 # maketrans()与translate()两个函数搭配使用
36 p = str.maketrans(‘abcdefg‘, ‘*%UE%@M‘)  # 编码
37 print(‘apple very good‘.translate(p))  # 翻译
38 
39 print(name.partition(‘ ‘))  # 按照参数的字符串（空格），将原始字符串切割为3部分
40 print(‘siiiioiefi‘.replace(‘i‘, ‘b‘, 5))  # 将字符串中的i替换为b，替换5次
41 print(‘sdioewawd‘.rfind(‘w‘))  # 从右侧查找第一个w，返回其位置，若在字符串中找不到目标字符串返回-1
42 print(‘sdioewawd‘.rindex(‘w‘))  # 从右侧查找第一个w，返回其位置，若在字符串中找不到目标字符串则报错
43 print(‘apple very good‘.rpartition(‘ ‘))
44 print(‘apple very good‘.rsplit(‘ ‘))
45 print(‘  
  alex
2483‘.splitlines())  # 按行分割
46 print(‘siiiioiefi‘.startswith(‘efo‘))  # 字符串是否以efo开头，返回bool值
47 print(‘My Name ‘.swapcase())  # 输出结果 mY nAME
48 print(‘apple very good‘.title())  # 输出结果 Apple Very Good
49 print(‘apple very good‘.zfill(50))  # 左侧用0填充

列表（List）及其函数

列表是python最基础的数据结构，是一个有序的元素集合；列表中每个元素都有其索引，从0开始计数即第一个元素的索引为0；列表可以做嵌套，即列表中以子列表作为元素；列表中的元素可以做增、删、改、查等操作，具体函数如下。

 1 zj = [‘杭州市‘, ‘湖州市‘, ‘嘉兴市‘, ‘衢州市‘, ‘绍兴市‘, ‘台州市‘, ‘温州市‘, ‘舟山市‘]
 2 list_t = [‘a‘, ‘b‘, ‘3‘, ‘4‘]
 3 
 4 print(zj)  # 打印整个列表
 5 for i in zj:  # 循环打印列表
 6     print(i)
 7 # cut
 8 print(zj[4])  # 取list中第五个元素
 9 print(zj[2:6])  # 取list中第三到第六个元素
10 print(zj[:3])  # 取list中第一到第三个元素
11 print(zj[-1])  # 取list中最后一个元素
12 print(zj[-2:])  # 取list中倒数两个元素
13 print(zj[0:-1:2])  # 隔一个元素打印一次，从第一个元素打印至倒数第二个元素，步长为2
14 print(zj[::2])  # 隔一个元素打印一次，从第一个元素打印至最后一个元素，步长为2
15 # insert
16 zj.append(‘test‘)  # 在list最后追加
17 zj.insert(2, ‘retest‘)  # 在list第三位插入元素
18 # alter
19 zj[3] = ‘jinhuashi‘  # 对第四个元素进行修改
20 # delete
21 zj.remove(‘衢州市‘)  # 删除‘衢州市’这个元素
22 zj.pop()  # 默认弹出最后一个元素
23 zj.pop(1)  # 弹出第二个元素
24 del zj[5]  # 删除第六个元素
25 del zj  # 删除列表
26 # other
27 print(zj[zj.index(‘衢州市‘)])  # 查找‘衢州市’这个元素在列表中的索引，将这个索引位置的元素打印
28 print(zj.count(‘杭州市‘))  # 统计‘杭州市’这个元素在list中出现的次数
29 zj.reverse()  # 反转
30 zj.sort()  # 排序（按ascii码表）
31 zj.clear()  # 清空list
32 zj.extend(list_t)  # 将list_t与zj合并

浅谈列表的浅copy和深copy

 1 import copy
 2 
 3 zj = [‘杭州市‘, ‘湖州市‘, ‘嘉兴市‘, ‘衢州市‘, ‘绍兴市‘, [‘越城区‘, ‘柯桥区‘], ‘台州市‘, ‘温州市‘, ‘舟山市‘]
 4 
 5 # 浅copy，只copy列表的第一层，若列表中存在子列表，第一层存储的是子列表的内存地址，故浅copy只能copy子列表的内存地址，
 6 # 那么无论是修改原列表的子列表中元素，还是修改新列表的子列表中元素，两个list中的子列表的元素都会改变
 7 zj2 = zj.copy()
 8 zj[2] = ‘jiaxingshi‘
 9 zj[5][0] = ‘yuechengqu‘
10 print(zj)
11 print(zj2)
12 # 浅copy的三种方式
13 zj1 = copy.copy(zj)
14 zj2 = zj[:]
15 zj3 = list(zj)
16 # 深copy，需要引入copy模块，调用其中的deepcopy()函数，深copy将会copy子列表中的具体元素而不是只coyp子列表的内存地址
17 zj2 = copy.copy(zj)  # 此函数等同于浅copy
18 zj3 = copy.deepcopy(zj)  # 深copy，完全克隆
19 zj[2] = ‘jiaxingshi‘
20 zj[5][0] = ‘yuechengqu‘
21 print(zj)
22 print(zj2)
23 print(zj3)

元组（Tuple）及其函数

元组的使用方法基本与列表一样，唯一的区别是元组中的元素不可修改（修改包括增加元素、修改元素值、删除元素值），可将元组视为只读列表。元组的定义即其函数如下。

1 data = (‘python‘,)
2 names = (‘catty‘, ‘test‘, ‘catty‘)  # 元组 相当于只读列表
3 print(names[0:2])  # 元组切片
4 print(names[1])  # 单个元素打印
5 tup = data + names  # 虽然元组不可修改，但可以将两个元组进行连接组合
6 print(tup)
7 print(names.count(‘catty‘))  # 统计该元素在元组中出现的次数
8 print(names.index(‘test‘))  # 返回该元素第一次出现在元组中的位置

另外，当需要创建只有一个元素的元组时，需要在元素后添加逗号，否则创建出的不是元组而是字符串，可以通过查看变量类型进行验证。

1 data1 = (‘python‘)
2 print(type(data1))  # 输出结果 <class ‘str‘>
3 data2 = (‘python‘,)
4 print(type(data2))  # 输出结果 <class ‘tuple‘>

字典（Dictionary）及其函数

字典是另一种可变容器模型，且可存储任意类型对象。字典中的元素成对存在，一个键（key）对应一个值（value），中间用冒号（：）连接，每对键值用逗号分开，最后用花括号（{}）括起来。字典中也可以嵌套。

 1 info = {
 2     ‘stu001‘: ‘张三‘,
 3     ‘stu002‘: ‘李四‘,
 4     ‘stu003‘: ‘王五‘
 5 }
 6 
 7 print(info)
 8 
 9 # select item
10 print(info[‘stu001‘])
11 # alter item
12 info[‘stu002‘] = ‘tomcat‘
13 # add item
14 info[‘stu004‘] = ‘nginx‘
15 print(info)
16 # delete item
17 del info[‘stu003‘]
18 print(info)
19 info.pop(‘stu001‘)
20 print(info)
21 info.popitem()  # 随机弹出一个元素
22 print(info)

关于字典中键值的查找

1 info[‘stu005‘]  # 若字典中不存在‘stu005‘，则程序报错
2 print(info.get(‘stu005‘))  # 一个安全的查找元素的方式，若字典中不存在则返回none，存在则返回其对应的值
3 print(‘stu003‘ in info)  # info.has_key(‘stu003‘) python2.x  判断字典中是否存在某key值，返回bool值

关于字典的遍历

1 for i in info:
2     print(i, info[i])  # 此种遍历方式效率更高
3 
4 for k, v in info.items():
5     print(k, v)  # 此遍历方式会先将每对键值转换为列表，再输出打印

字典的其他操作

 1 info = {
 2     ‘stu001‘: ‘张三‘,
 3     ‘stu002‘: ‘李四‘,
 4     ‘stu003‘: ‘王五‘
 5 }
 6 
 7 info2 = {
 8     ‘stu003‘: ‘zhaoliu‘,
 9     ‘sut004‘: ‘sdifoe‘,
10     ‘stu006‘: ‘quit‘
11 }
12 
13 info.update(info2)  # 按照info2更新info，若找到相同key值，则将对应的info2的value值赋给info，若找不到key值则插入info
14 print(info)
15 print(info.items())  # 将字典转为列表
16 c = dict.fromkeys([‘a‘, ‘b‘, ‘c‘], ‘test‘)
17 print(c)
18 c = dict.fromkeys([‘a‘, ‘b‘, ‘c‘], [1, {‘name‘: ‘tom‘}, 4444])
19 print(c)
20 c[‘a‘][1][‘name‘] = ‘lily‘  # 类似浅copy机制
21 print(c)

嵌套字典的相关操作

 1 info = {
 2     ‘杭州‘: {
 3         ‘西湖‘: [‘免费‘, ‘三潭映月‘],
 4         ‘灵隐寺‘: [‘香火旺‘, ‘得道高僧‘],
 5         ‘北高峰‘: [‘周末踏青好去处‘, ‘空气好‘],
 6     },
 7     ‘上海‘: {
 8         ‘外滩‘: [‘人山人海‘, ‘繁华‘]
 9     },
10     ‘南京‘: {
11         ‘清凉山‘: [‘雨花石早市‘, ‘郁郁葱葱‘]
12     }
13 }
14 info[‘杭州‘][‘灵隐寺‘][1] = ‘收费‘  
15 info.setdefault(‘无锡‘, {‘鼋头渚‘: [‘樱花‘, ‘太湖‘]})  # 去字典里找这个key，若找不到则创建新值
16 info.setdefault(‘南京‘, {‘whatever‘: [1, 2]})  # 去字典里找这个key，找到了则返回原值
17 print(info)