Python笔记，Day2 —— .pyc、数据类型、列表、元组、字符串、字典、集合

Day2

Note

1. 模块

  模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
  一般情况下：Python或Anaconda目录\lib为标准库位置；Python或Anaconda目录\lib\site-packages为第三方库存放位置。
  自定义的模块名称不要与标准库名称相同。
  导入模块时先从当前目录里查找，再去环境变量里找。

2. .pyc

  Python是一门基于虚拟机的语言，Python程序的运行过程：
  当在命令行输入python xxx.py时，**Python的"解释器"，告诉"解释器"要开始工作了。在"解释"之前，执行一项和Java一样的工作——编译。
  当程序运行时，Python编译器将程序编译成PyCodeObject于内存中。当Python程序运行结束时，Python编译器将PyCodeObject写到.pyc文件中。
  当Python程序第二次运行时，首先程序会在硬盘中寻找.pyc文件，如果找到，则直接载入，否则就重复上述过程。
  所以.pyc文件其实是保存在硬盘上的编译结果。
  当Python程序二次运行时候，判断修改时间，以达到更新修改的效果。

3. 数据类型

  (1)int（整型）在32/64位机器上，整数的位数为32/64位，取值范围为-2^31 ~ 2^31 -1 / -2^63 ~ 2^63 -1。
  Python 3.x只有int没有long int这个概念。

  (2)float（浮点型）这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到。
66.6E2，是一个浮点数，E表示10的幂，这里66.6E2表示66.6*10^2。

  (3)complex（复数）由实部和虚部组成，虚数用j来表示（工程领域的命名为j，数学中为i）。
  (4)boolean（布尔型）True or False，1 或 0 。
  (5)bytes（表示二进制数据）
  Python 3.x 中文本由str类型表示，二进制数据由bytes类型表示。Python 3.x 不能将两者混用。因此不能拼接字符串和字节包，也无法在字节包里搜索字符串，反之亦然，也不能将字符串传入参数为字节包的函数（反之亦然），字符串与字节包之间不能直接操作，需要encode/decode 编码/解码。
  Python 3.x 中数据传输要把字符串转成二进制。

msg = "我是Ldaze"
print(msg.encode())# Python 3.x中encoding默认值为utf-8

4. 列表

list = [1,2,3,4,4,5,6,6]# 声明一个列表（静态）
list = [ i for i in range(0,10) ] #动态声明一个列表，for前面可以是任意关于i的表达式
print(list[0])# 打印第一个元素

print(list[0:3])# 切片，左闭右开，0可以省略不写
print(list[-1])# 输出最后一个元素
print(list[-3:-1])# 切片时要从左向右，-1为最后一位，由于左闭右开，因此取不到最后一位
print(list[-1:-3])# 否则返回空列表
print(list[-3:])# 若想取到最后一位就省略后面的数字
print(list[::2])# 从第一位到最后一位，步长为2

list.append(5)# 追加
list.insert(1,10)# 插入，（a,b）a为想插入（取代）的位置，b为插入的值

list.remove(10)# 直接填写要删除的值
del list[1]# 填写要删除的位置，不填写位置则删除该列表变量
list.pop()# 不输入下标默认删除（弹出）最后一个，此外可以把删除（弹出）的值赋给变量，本质与删除不同

list.index(3)# 下标
list.count(6)# 统计
list.clear()# 清空
list.reverse()# 反转
list.sort()# 排序，优先级：特殊字符、数字、大写字母、小写字母（ASCII码）
list2 = [8,9,10,11,12]
list.extend(list2)# 合并，list2还在
list3 = list.copy()# 复制一份list赋给list3
len(list)# 返回列表长度

  分析下面代码：

demo1 = [1,2,3,[0,0],4,5]
demo2 = demo1.copy()
print(demo1)
print(demo2)
demo1[0] = 0
demo1[3][0] = 1
print(demo1)
print(demo2)

  在修改demo1[0]的值时，显然demo2不会发生改变，因为demo2的赋值发生在demo1改变之前。可为什么demo1[3]位置的列表改变后，demo2的相应的位置发生了改变？这是因为copy只复制第一层（浅复制，也叫引用），而demo1[3]保存的是一个地址，因此demo2[3]的位置也是这个地址，由于demo1[3]和demo2[3]指向的是同一个地址，所以当这个地址内的数据发生改变时，两者相应位置的值会同步，若想让demo1和demo2完全独立，可引用copy模块使用copy.deepcopy()方法。

浅复制的其他方式：

demo3 = demo1[:]
demo4 = list(demo1)

遍历列表：

list = [1,2,3,4,5]
for i in list:
    print(i)

enumerate 取下标和对应的值：

for i,j in enumerate(list):
    print(i,j)

5. 元组

  和列表类似，但只能读，不能改，它只有两个方法，count和index。
  用处：例如保存数据库连接信息。

6. 字符串

  字符串可以索引可以切片，但是不能修改

convertStr = '+'.join(['1','2','3','4'])# 用+连接列表中的每个元素
str()# 和''.join()的区别是str()转的字符串会有原本结构中的分隔符
list()
tuple()# 用以字符串、列表、字典之间的相互转换

str = 'abcdea'
p = str.maketrans('abcde','12345')
print(str.translate(p))# 根据对应值转换，即一种加密方式
str1 = '1+2*3'
res = eval(str1)# 执行一个字符串表达式，并返回表达式的值。

str.strip()# 去除两边的空格或回车即参数为' '或'\n'
str.lstrip()# 去左边
str.rstrip()# 去右边

str.replace('a','b')# 替换

str.split(',')# 将字符串按输入的分隔符分成列表
str.splitlines()# 将字符串按行分成列表

str.lower()# 把大写变成小写
str.upper()# 把小写变大写
str.swapcase()# 大变小、小变大

str.capitalize()# 首字母大写
str.title()# 每个单词首字母变成大写
str.count('a')# 统计有几个a

str.center(100,'*')# 一共打印100个字符，str放在中间，其它位置用*补充
str.ljust(100,'*')# str放在左边
str.rjust(100,'*')# str放在右边
str.expandtabs(tabsize = 30)# 在字符串中植入\t，在\t处打印30个空格

str.find('c')# 返回c的索引，字符串也可以切片，与列表用法相同
str.rfind('c')# 返回最右边那个c的索引

str.startswith('n')# 判断是否以n开头
str.endswith('n')# 判断是否以n结尾

str.isdigit()# 返回一个布尔值，用以判断str是否为一个整数
str.isalnum()# 返回一个布尔值，用以判断str是否以纯阿拉伯字符组成
str.isalpha()# 返回一个布尔值，用以判断str是否以纯英文组成
str.isdecimal()# 返回一个布尔值，用以判断str是否为十进制
str.isidentifier()# 返回一个布尔值，用以判断str是否为一个合法的标识符
str.isnumeric()# 返回一个布尔值，用以判断str是否只有数字
str.isspace()# 返回一个布尔值，用以判断str是否是一个空格
str.istitle()# 返回一个布尔值，用以判断str是否为标题，即首字母大写
str.isprintable()# 返回一个布尔值，用以判断str是否可打印，tty file，drive file
str.isupper()# 返回一个布尔值，用以判断str是否为大写

str.zfill(8)# 前方补8个0，用于16进制

str2 = 'abcde{a}{b}'
print(str2.format(a = 'aaa',b = 222))# 格式化输出
print(str2.format_map({'a':'aaa','b':222}))# 格式化输出，以字典的方式传参

7. 字典

  key-value数据类型，字典是无序的，字典没有下标，因为有key。

dict = {1:'a','2':'b','h':'b'}# key可以为int型也可以为str型
print(dict.get('4'))# 如果有此key输出对应的值，没有则返回Null
print('4' in dict)# 判断是否有此key

dict['h'] = 'c' # 赋值或修改
dict['4'] = 'd' # 如果没有此key，将会添加此key与对应的值

del dict['4']
dict.pop('h')
dict.popitem()# 随机删除一个

dict.keys()
dict.values()
dict.setdefault('5','e')# 如果不存在才创建,存在则不作改动
dict.update()# 更新
dict.items()# 将字典转成列表

newdict1 = dict.fromkeys([6,7,8])# 初始化一个新字典1，key为6、7、8，value为空
newdict2 = dict.fromkeys([6,7,8],'a')# 初始化一个新字典2，key为6、7、8，value都为a
newdict3 = dict.fromkeys([6,7,8],['a','b','c'])# 初始化一个新字典3，key为6、7、8，value都为['a','b','c']
newdict4 = dict.fromkeys([6,7,8],[{1:'x'},'b','c'])
# 对newdict4[6][0][1]进行修改，newdict4[7][0][1]和newdict4[8][0][1]也会改变
# 和浅copy一个道理，共享同块地址
newdict4[6][0][1] = 'b'
print(newdict4)
# 遍历字典
for i in dict:# 快
    print(i,dict[i])

for k,v in dict.items():# 慢，因为要先转成列表
    print(k,v)

8. 集合

  和数学中的集合一样，无序且无重复值。适用in和not in。

list = [1,2,3,4,5,5,5]
list2 = [3,4,5,6,6,8]
list = set(list)
list2 = set(list2)# 可以打印出来看下效果，重复值已经消失了

inters = list.intersection(list2)# 取交集(&)
union = list.union(list2)# 取并集(|)
diff = list.difference(list2)# 取差集(-)，全集-交集即 list - inters
symmetric = list.symmetric_difference(list2)# 取对称差集(^)，并集-交集即 union - inters

list.issubset(list2)# 返回一个布尔值，判断list是否为其子集
list.issuperset(list2)# 返回一个布尔值，判断list是否为其全集
list.isdisjoint(list2)# 返回一个布尔值，判断二者是否不存在交集

list.add(10)# 因为集合是无序的，所以只有添加没有插入
list.update([1,2,3])# 添加多项

list.remove(2)# 删除指定元素，若不存在则报错
list.discard(3)# 删除指定元素，若不存在则什么也不做
list.pop()# 删除(弹出)任意一个元素，集合无下标因此不能指定

list.copy()# 浅复制
len(list)# list的长度

Task

1. 简易购物车

  使用今天学习的列表做一个简易购物车。
  需求：输入存款；打印商品列表；通过商品序号选择商品；如果支付得起则加入购物车，否则提示余额不足；显示当前购物车已加入商品以及总价格；随时可以退出；退出打印已购买物品、总价格以及余额。

goods = [["goods1",500],["goods2",800],["goods3",1500],["goods4",5000]]
ShoppingCart = []
count = 0
saving = int(input("Please input your saving："))
while True:
    for i,j in enumerate(goods):
        print(i,j,'\n')
    print("Press 'q' to exit.")
    goodsIndex = input("Please input your choice：")
    if goodsIndex == 'q':
        break
    else:
        goodsIndex = int(goodsIndex)
        if (goods[goodsIndex][1] + count) <= saving:
            ShoppingCart.append(goods[goodsIndex])
            count = count + goods[goodsIndex][1]
        else:
            print("Your balance is insufficient!")
        print('Added cart item:',ShoppingCart,'Amount to',count)
        ContinueOrNot = input("Do you want to continue shopping? ( Y/y or N/n )")
        if ContinueOrNot == 'Y' or ContinueOrNot == 'y':
            continue
        else:
            break
saving = saving - count
print("Items you have purchased:",ShoppingCart)
print("Amount to:",count)
print("Balance:",saving)

2. 多级菜单

  利用今天学习的字典做一个多级菜单。
  需求：可以依次选择进入各级子菜单，按b返回，按q退出程序。

goods = {'category1':{
                    'c1':{
                         'cc1':['ccc1','ccc2'],
                         'cc2':['ccc3','ccc4'],
                         'cc3':['ccc5','ccc6']},
                    'c11':{
                         'cc4':['ccc7','ccc8'],
                         'cc5':['ccc9','ccc10']}},
         'category2':{
                    'c2': {
                        'cc1': ['ccc1', 'ccc2'],
                        'cc2': ['ccc3', 'ccc4'],
                        'cc3': ['ccc5', 'ccc6']},
                    'c22': {
                        'cc4': ['ccc7', 'ccc8'],
                        'cc5': ['ccc9', 'ccc10']}},
         'category3': {
                    'c3': {
                        'cc1': ['ccc1', 'ccc2'],
                        'cc2': ['ccc3', 'ccc4'],
                        'cc3': ['ccc5', 'ccc6']},
                    'c33': {
                        'cc4': ['ccc7', 'ccc8'],
                        'cc5': ['ccc9', 'ccc10']}}}
restrict = True
while restrict:
    for i in goods:
        print(i)
    print("Entering 'b' to return, entering 'q' to exit.")
    choice = input("Which one?")
    if choice in goods:
        while restrict:
            for i2 in goods[choice]:
                print('\t',i2)
            print("Entering 'b' to return, entering 'q' to exit.")
            choice2 = input("Which one?")
            if choice2 in goods[choice]:
                while restrict:
                    for i3 in goods[choice][choice2]:
                        print('\t\t',i3)
                    print("Entering 'b' to return, entering 'q' to exit.")
                    choice3 = input("Which one?")
                    if choice3 in goods[choice][choice2]:
                        for i4 in goods[choice][choice2][choice3]:
                            print('\t\t\t',i4)
                        while restrict:
                            choice4 = input("Entering 'b' to return, entering 'q' to exit.")
                            if choice4 == 'b':
                                break
                            elif choice4 == 'q':
                                restrict = False
                            else:
                                print("Input error!")
                    elif choice3 == 'b':
                        break
                    elif choice3 == 'q':
                        restrict = False
                    else:
                        print("Input error!")
            elif choice2 =='b':
                break
            elif choice2 =='q':
                restrict = False
            else:
                print("Input error!")
    elif choice == 'b':
        break
    elif choice == 'q':
        restrict = False
    else:
        print("Input error!")