Step2 - Python基础2 列表、字典、集合

一、sys模块

导入模块使用import命令

命令1：sys.path

import sys
print(sys.path)

打印出的路径为Python寻找模块路径，即你要导入的模块必须存在于以下路径中：

'D:\\Python实战\\Day2'

'D:\\Python实战'

'C:\\ProgramData\\Anaconda3\\python36.zip'

'C:\\ProgramData\\Anaconda3\\DLLs'

'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Sphinx-1.5.6-py3.6.egg'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin'

'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\setuptools-27.2.0-py3.6.egg'

如若不存在，则提示模块未找到，若存在，则直接加载模块

默认先从当前目录下找，找不到再去全局变量中找

Python标准库一般都会存在于'C:\\ProgramData\\Anaconda3\\lib\\site-packages'中

命令2：sys.argv

import sys
print(sys.argv) #打印当前脚本的绝对路径

在PyCharm中打印的是绝对路径，在cmd中打印相对路径

注：绝对路径为从盘符开始的路径，如C:\windows\system32\cmd.exe

相对路径为从当前路径开始的路径

二、os模块

os模块就是和操作系统进行交互的模块

命令1：os.system

import os
os.system("dir") #显示当前磁盘目录下的所有文件

接下来尝试将该命令返回的结果存入一个变量中

import os
cmd_res = os.system("dir") #显示当前磁盘目录下的所有文件
print("-->",cmd_res)

得到的结果为：

打印出的结果为0

其原因为os.system命令直接输出到屏幕上，直执行命令，不保存结果，无法存入变量中，结果0为该命令执行成功与否的状态码，0表示执行成功，非0值表示执行失败

命令2：os.popen

cmd_res = os.popen("dir") #显示当前磁盘目录下的所有文件，执行命令且保存结果
print("-->",cmd_res)

但是得到的结果为

是一个内存地址，如果想要读取结果，需再加一行代码

cmd_res = os.popen("dir").read() 
print("-->",cmd_res)

得到的结果为

可见，不仅读取了结果，乱码也没有了

加read()命令是因为，os.popen命令将结果存入了内存中，需要read()命令进行调取

命令3：os.mkdir

在当前目录下创建新目录

os.mkdir("new!") #在当前目录下创建新目录

 三、数据类型

1. 数字

int（整型）

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（长整型）

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

float（浮点型）

浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

complex（复数）

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

2、布尔值 

真或假

1 或 0

3、字符串

"hello world"

万恶的字符串拼接：python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

字符串格式化输出

name = "Nick"
print("I am %s" % name)
#输出I am Nick

PS: 字符串是 %s;整数 %d;浮点数%f

字符串常用功能：

• 移除空白

• 分割

• 长度

• 索引

• 切片

四、列表、元组操作

定义列表，并访问列表中的元素

names = ['Nick','Peggy','Samantha']
print(names)
print(names[0]) #下标从0开始计数
print(names[1])
print(names[2])
print(names[-1]) #也可以倒着取值
print(names[-2])

切片：取多个元素

names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
names[0:3] 
['Alex', 'Tenglan', 'Eric']
names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom'] 
names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']

 追加：

names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
names.append('我是新来的')
print(names)
-->['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

插入：

names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
names.insert(3,'插到Rain前面')
print(names)
-->['Alex', 'Tenglan', 'Eric', '插到Rain前面', 'Rain', 'Tom', 'Amy']

修改：

names['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
names[2] = "该换人了"
names
-->['Alex', 'Tenglan', '该换人了', 'Rain', 'Tom', 'Amy', '我是新来的']

删除：

names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
print(names)
-->['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
names.remove("Alex") #直接指定元素删除
print(names)
-->['Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
del names[3] #通过下标删除
print(names)
-->['Tenglan', 'Eric', 'Rain', 'Amy']
names.pop() #默认删除最后一个元素，输入下标即删除指定下标元素
print(names)
-->['Tenglan', 'Eric', 'Rain']

扩展：

a = [1,2,3,4]
b = [33,45,2]
a.extend(b)
print(a)
-->[1, 2, 3, 4, 33, 45, 2]

获取下标：

names = ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
print(names)
print(names.index("Eric")) #只返回找到的第一个下标

统计：

names = ['Alex', 'Amy','Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
print(names.count('Amy'))

拷贝：

>>> names['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
>>> name_copy = names.copy()
>>> name_copy['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

注意，copy命令是浅copy，第一层元素独立拷贝，如果列表中还有子列表，则拷贝的是该子列表的内存地址，所以在原列表中修改子列表的元素，拷贝的列表的子列表元素也会相应变化

要想完整copy需引用copy模块使用copy.deepcopy命令

程序练习：购物车程序

要求:

1. 启动程序后，让用户输入工资，然后打印商品列表

2. 允许用户根据商品编号购买商品

3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 

4. 可随时退出，退出时，打印已购买商品和余额

代码：

goods_list = [["towel",20],["tissue",10],["food",25],["water",5]]
salary = int(input("Please input your salary:")) #输入工资，强制转换格式为整型
balance = salary
cart = []
for i in range(1,5):
    print("item %d :" % i,goods_list[i-1][0],"   ","price:",goods_list[i-1][1]) #打印商品编号及价格
while True:
    x = int(input("Please type item number:")) #输入想要购买的商品编号
    if balance >= goods_list[x-1][1]: #判断余额是否大于商品价格
        balance = balance - goods_list[x-1][1]
        print("balance:",balance)
        cart.append(goods_list[x-1][0])  #将购买的商品名称插入到cart列表中
    else:
        print("Insufficient balance!") #若余额不足，则提醒
    continue_res = input("Do you want to buy more item? Y/N:")
    if continue_res == "N": #判断是否继续购物
        break
print(cart,"\n","balance:",balance) #打印商品购买清单和余额

优化后代码：

goods_list = [["towel",20],["tissue",10],["food",25],["water",5]]
salary = int(input("Please input your salary:")) #输入工资，强制转换格式为整型
balance = salary
cart = []
while True:
    for index,item in enumerate(goods_list):
        print(index,item) #打印商品编号及价格
    x = int(input("Please type item number:")) #输入想要购买的商品编号
    if balance >= goods_list[x][1]: #判断余额是否大于商品价格
        balance = balance - goods_list[x][1]
        print("\033[31;1mbalance\033[0m:",balance) #\033[31;1m%s\033[0m 高亮显示31表示红色，32表示绿色
        cart.append(goods_list[x][0])  #将购买的商品名称插入到cart列表中
    else:
        print("Insufficient balance!") #若余额不足，则提醒
    continue_res = input("Do you want to buy more item? Y/N:")
    if continue_res == "N": #判断是否继续购物
        break
print(cart,"\n","\033[32;1mbalance\033[0m:",balance) #打印商品购买清单和余额

视频教程代码太过繁琐，现在先不考虑这些

五、字符串操作

 1 name.capitalize()  #首字母大写
 2 name.casefold()  #大写全部变小写
 3 name.center(50,"-")  #输出 '---------------------Alex Li----------------------'
 4 name.count('lex') #统计 lex出现次数
 5 name.encode()  #将字符串编码成bytes格式
 6 name.endswith("Li")  #判断字符串是否以 Li结尾
 7  "Alex\tLi".expandtabs(10) #输出'Alex      Li'， 将\t转换成多长的空格 
 8  name.find('A')  #查找A,找到返回其索引， 找不到返回-1 
 9 
10 format :
11     >>> msg = "my name is {}, and age is {}"
12     >>> msg.format("alex",22)
13     'my name is alex, and age is 22'
14     >>> msg = "my name is {1}, and age is {0}"
15     >>> msg.format("alex",22)
16     'my name is 22, and age is alex'
17     >>> msg = "my name is {name}, and age is {age}"
18     >>> msg.format(age=22,name="ale")
19     'my name is ale, and age is 22'
20 format_map
21     >>> msg.format_map({'name':'alex','age':22})
22     'my name is alex, and age is 22'
23 
24 
25 msg.index('a')  #返回a所在字符串的索引
26 '9aA'.isalnum()   True
27 
28 '9'.isdigit() #是否整数
29 name.isnumeric #是否为数字
30 name.isprintable #是否能打印，对于字符串不存在此问题
31 name.isspace #是否为空格
32 name.istitle #是否单词首字母均为大写
33 name.isupper #是否全大写
34  "|".join(['alex','jack','rain']) #可以将列表变为字符串
35 'alex|jack|rain'
36 
37 
38 maketrans
39     >>> intab = "aeiou"  #This is the string having actual characters. 
40     >>> outtab = "12345" #This is the string having corresponding mapping character
41     >>> trantab = str.maketrans(intab, outtab)
42     >>> 
43     >>> str = "this is string example....wow!!!"
44     >>> str.translate(trantab)
45     'th3s 3s str3ng 2x1mpl2....w4w!!!'
46 
47  msg.partition('is')   #输出 ('my name ', 'is', ' {name}, and age is {age}') 
48 
49  >>> "alex li, chinese name is lijie".replace("li","LI",1)
50      'alex LI, chinese name is lijie'
51 
52  msg.swapcase #大小写互换
53 
54 
55  >>> msg.zfill(40)
56 '00000my name is {name}, and age is {age}'
57 
58 
59 
60 >>> n4.ljust(40,"-")
61 'Hello 2orld-----------------------------'
62 >>> n4.rjust(40,"-")
63 '-----------------------------Hello 2orld'
64 
65 
66 >>> b="ddefdsdff_哈哈" 
67 >>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
68 True
69 
70 .split(" ") #以括号内的内容将字符串分成列表

六、字典操作

字典是一种特殊的key-value数据类型

语法：

info = {
    "stu0001":"Nick",
    "stu0002":"Peggy",
    "stu0003":"Daye",
    "stu0004":"Hange",
}

字典的特性：1.字典是无序的；2.key必须唯一

增加修改命令很直接

删除：

>>> info {'stu1102': 'Nick', 'stu1103': 'Peggy', 'stu1101': 'Daye'}
>>> info.pop("stu1101") #标准删除
'Daye'
>>> info {'stu1102': 'Nick', 'stu1103': 'Peggy'}
>>> del info["stu1103"] #换个删除方式
>>> info {'stu1102': 'Nick'}
>>> 
>>> 
>>> 
>>> info = {'stu1102': 'Nick', 'stu1103': 'Peggy'}
>>> info {'stu1102': 'Nick', 'stu1103': 'Peggy'} #随机删除
>>> info.popitem()
('stu1102', 'Nick')
>>> info
{'stu1103': 'Peggy'}

 查找：

info = {
    "stu0001":"Nick",
    "stu0002":"Peggy",
    "stu0003":"Daye",
    "stu0004":"Hange",
}
print(info.get("stu0005"))
None #存在则返回值，不存在则返回none，更合理

print("stu0003" in info) #判断是否字典中是否存在
True

字典循环：

#方法1
for key in info:
    print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
    print(k,v)

程序练习：三级菜单

 要求：

1. 打印省、市、县三级菜单

2. 可返回上一级

3. 可随时退出程序

代码：

data = {
    "重庆":{
        "渝北区":{
            "水晶郦城":["一组团","二组团"],
            "紫都城":["一单元","二单元"]
        },
        "江北区":{
            "围城国际公寓":["2801","2802"],
            "无专厂":["流星花园","锦瑟年华"]
        }
    },
    "北京":{
        "海淀区":["北京交通大学","中央民族大学"],
        "朝阳区":["蓝色港湾","三里屯"]
    },
    "香港":{
        "九龙":["港科大","坑口"],
        "香港岛":["中环","紫荆广场"]
    }
}

while True: #建立死循环
    for i in data:
        print(i) #打印第一级菜单
    choice = input("请选择1，或输入任意键退出：")
    if choice in data:
        while True:
            for j in data[choice]:
                print("\t", j) #打印第二级菜单
            choice2 = input("请选择2，或输入b返回上一级菜单：")
            if choice2 in data[choice]:
                while True:
                    for k in data[choice][choice2]:
                        print("\t\t", k) #打印第三级菜单
                    choice3 = input("请选择3，或输入b返回上一级菜单：")
                    if choice3 in data[choice][choice2]:
                        for z in data[choice][choice2][choice3]:
                            print("\t\t\t",z) #打印第三级菜单具体内容
                        print("这是最后一级菜单了，即将返回上一级菜单") #不用break，循环自动返回至上一级菜单
                    if choice3 == "b":
                        break #跳出循环，返回第二级菜单
            if choice2 == "b":
                break #跳出循环，返回第一级菜单
    else:
        break #结束程序
print("感谢使用小戴版三级菜单")

 

七、集合操作

集合是一个无序的，不重复的数据组合，作用如下：

1. 去重，将列表变为集合，自动去重

2. 关系测试，测试两组数据之间的交集、差集、并集等关系

常用操作：

list_1 = [1,4,5,5,2,3,5]
list_1 = set(list_1)
list_2 = set([2,5,3,1,2,3,5,6])
print(list_1,list_2)

print(list_1.intersection(list_2))
print(list_1 & list_2) #交集

print(list_1.union(list_2))
print(list_1 | list_2) #并集

print(list_1.difference(list_2))
print(list_1 - list_2) #差集

print(list_1.symmetric_difference(list_2))
print(list_1 ^ list_2) #对称差集

list_3 = set([1,4,5])
print(list_3.issubset(list_1)) #判断是否为其子集
print(list_1.issuperset(list_3)) #判断是否为其父集

list_3.remove(4) #删除一项元素，如果该元素不在集合中，报错
print(list_3)

list_3.discard(1) #删除一项元素，如果该元素不在集合中，不作任何处理
print(list_3)

 

八、文件操作

对文件操作流程：

1. 打开文件，得到文件句柄并赋值给一个变量

2. 通过句柄对文件进行操作

3. 关闭文件

 基本操作：

f = open("yesterday",encoding="utf-8") #得到文件句柄，即文件的内存对象，可以对文件进行操作
data = f.read() #读第一遍时从最头开始读
data2 = f.read() #读第二遍时从末尾开始读
print(data)
print("------------data2------------","\n",data2) #data2什么都没有

f.close()

打开文件的模式有：

r，只读模式（默认） 

w，只写模式，不存在则创建文件，存在则覆盖原文件

a，追加模式，可读，不存在则创建文件，存在只能追加内容

“+”表示可以同时读写某文件

r+，可读写模式，只读模式的特性，再加上可写

w+，写读模式，只写模式的特性，再加上可读

a+，同a

小文件读取前N行内容：

for index,line in enumerate(f.readlines()): #预先将文件内容一行行转成列表，并读下标和内容
    print(line.strip()) #去除空格和换行
    if index ==9:
        break #读前十行

 大文件一行行读，并一行行保存提取：

count = 0
for line in f:
    print(line.strip())
    count += 1
    if count == 10:
        break

其他操作：

read，readline，tell，seek，buffer，flush。truncate

*代码：进度条

import sys,time
for i in range(100):
    sys.stdout.write("#") #一个个输出#号
    sys.stdout.flush() #刷新内存
    time.sleep(0.5) #延迟处理

 对文件要进行修改操作，只能将文件内容存进内存中修改

f = open("yesterday","r",encoding="utf-8")
f_new = open("yesterday.bak","w",encoding="utf-8")
for line in f:
    if "那么多甜美的曲儿" in line:
        line = line.replace("那么多甜美的曲儿","那么少")
    f_new.write(line)

f.close()
f_new.close()