Dayday up ---- python Day2

模块

　　模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py

　　python的库分为标准库和第三方库，标准库即python自带的库，第三方库一般存放在同级目录或者python安装目录lib/site-packages下

　　以下是使用模块的例子:  

　　sys

import sys　　　　　　　　　　　　    #导入sys模块   引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法
print("命令行参数如下:")
for i in sys.argv:　　　　　　　 　　#sys.argv 打印所有的位置参数
    print(i)
print("路径为:", sys.path, '\n')　　#sys.path 打印python的全局环境变量,查找所需模块的路径的列表

　　os

#!/usr/bin/env python

import os　　　　　　　　　　　　　　　#导入os模块
os.system("free -m")　　　　　　　　 #调用系统命令，直接输出到屏幕

　　更多：

cmd_free = os.system("free -m")  # 如果定义为变量，print变量是执行命令的状态
print("\n-->", cmd_free) 　　　　  # 输出结果以及结果状态

--> 0　　　　　　　　  # 输出状态结果为0，表示成功，失败为1或者其他

cmd_free2 = os.popen("free -m").read()　　  # 不加read打印保存的内存地址，即存在内存中的对象 ,执行命令保存结果到内存
print(cmd_free2)  # 输出内容

os.mkdir("aa")
创建目录
os.rmdir("aa")
删除目录

 

.pyc 预编译编码文件

　　.pyc 文件是由.py文件经过编译后生成的字节码文件，其加载速度相对于之前的.py文件有所提高，而且还可以实现源码隐藏，以及一定程度上的反编译。

　　在import 别的.py文件的时候，那个.py文件会被存一份pyc加速下次装载，而主文件因为只需要装载一次所以不需要存.pyc

 

数据类型

　　可以用type()来查看数据类型

1、数字

　　int(整型)

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

　　　　

>>> type(222)
<class 'int'>

　　

　　long(长整型)

　　　　 python2里面当整数值特别大的时候自动会切换为长整型，而python3里面没有长整型的概念就是不管数值多大都是int整型

>>> type(2**64)
<type 'long'>

　　float(浮点数)

　　　　浮点数的表现形式是小数，但不能说浮点数就是小数

>>> type(5.55)
<class 'float'>

　　complex(复数)

　　　　一般用在量子力学

2、布尔值

　　真或假 True或False　　1或0

3、字符串

>>> type(True)
<class 'bool'>

 

数据运算

1、算数运算

　　　加 +

>>> 30+80
110

　　　减 -

>>> 80-30
50

　　　乘 *

>>> 30*80
2400

　　　除 /

>>> 8/2
4.0

　　　取模 % 即取除法的余数

>>> 9%4　　#9除以4余1
1

　　　幂 **

>>> 2**4
16

　　　取整除

>>> 9//4　　#9除以4的整数部分是2
2

 

2、比较运算　　

　　　等于 ==

>>> 2.0==2
True　　　　　　　　#如果成立返回true 不成立返回false

　　　不等于 !=

>>> 2.0!=2
False

　　　大于>

>>> 30>10
True

　　　小于<

>>> a=40
>>> b=50
>>> a < b
True

　　　大于等于>=

>>> a=40
>>> b=50
>>> b>=a
True

　　　小于等于<=

>>> a=40
>>> b=50
>>> a<=b
True

3、赋值运算　

　　　=   简单的赋值运算符，例如变量赋值

>>> a=40
>>> b=50
>>> c=a+b
>>> c
90

　　　+= 加法赋值运算符

>>> a +=1
>>> a = a+1　　　　# 等效于 a+=1, 意思是a每次都在之前的值之上加1

　　　-= 减法赋值运算符

>>> a -=c
>>> a = a-c　　　　# 等效于 a-=c, 意思是a每次都在之前的值之上减c

　　　*= 乘法赋值运算符

>>> a *=c
>>> a = a*c　　　　# 等效于 a*=c, 意思是a每次都在之前的值之上乘c

　　　/= 除法赋值运算符

>>> a /=c
>>> a = a/c　　　　# 等效于 a/=c, 意思是a每次都在之前的值之上除c

　　　%= 取模赋值运算符

>>> c = 9
>>> a = 4
>>> c = c % a　　　#等效于 c%=a, 意思是c每次都在之前的值之上进行与a取模运算
>>> c
1
>>>

　　　**=幂赋值运算符

>>> a = 2
>>> c = 3
>>> c = c ** a　　 #等效于 c**=a ,意思是c在每次都在之前的值上与a进行幂运算
>>> c
9
>>>

　　　//=取整除赋值运算符　　　 

>>> c=9
>>> a=2
>>> c = c//a　　　　#等效于 c//=a ,意思是c在每次都在之前的值上与a进行取整除运算
>>> c 
4 
>>>　　

4、逻辑运算

　　　and　布尔"与"

>>> a = 10
>>> b = 20
>>> c = 50
>>> c > b and b > a　　　　# and两边都得成立
True
>>>

　　　or 　布尔"或"

>>> a = 10
>>> b = 20
>>> c = 50
>>> c < a or c > b　　　　　# or 一边成立即可
True
>>>

　　　not　布尔"非"

>>> a = 10
>>> b = 20
>>> c = 50
>>> not(c > b and b > a)　　#not 与后边的结果相反
False
>>>

5、成员运算

　　　in 例如: a in b 指a在b序列中

>>> b = "nihao"
>>> a = "n"
>>> a in b　　　　　# "n" 字符串在 "nihao"中
True
>>>

　　　not in 例如: a not in b 指a不在b序列中

>>> b = "nihao"
>>> a = "t"
>>> a not in b
True
>>>

6、身份运算　　　

　　　is 判断两个标识符是不是引用一个对象

>>> flag = True
>>> flag is True
True
>>>

　　　is not 判断两个标识符是不是引用不同的对象

>>> flag = True
>>> flag is not False
True
>>>

7、位运算 二进制运算

　　　&　按位与运算符

>>> a = 60
>>> b = 13
>>> a & b
12
>>>

　　　| 　按位或运算符

>>> a = 60
>>> b = 13
>>> a | b
61
>>>

　　　^ 　按位异或运算符

>>> a = 60
>>> b = 13
>>> a ^ b
49

　　~ 　　按位取反运算符

>>> a = 60
>>> b = 13
>>> ~a
-61
>>>

　　<<　　左移动运算符

>>> a = 60
>>> b = 13
>>> a<<2
240
>>>

　　>>　　右移动运算符

>>> a = 60
>>> b = 13
>>> a>>2
15
>>>

　　运算过程如下：

    128 64  32  16  8   4    2   1

a:    0   0   1   1   1   1   0   0    = 60
b:    0   0   0   0   1   1   0   1    = 13

与:    0   0   0   0   1   1   0   0    = 12

或:    0   0   1   1   1   1   0   1    = 61

异或:    0   0   1   1   0   0   0   1    = 49

a取反:    1   1   0   0   0   0   1   1    195-256 = -61

a左移2:    1   1   1   1   0   0   0   0    = 240

a右移2:    0   0   0   0   1   1   1   1    = 15

 

 

列表、元组

1、列表list,用[]

例如：names = ['aa', 'bb', 'cc']

通过names[num]下标访问列表中的元素，下标从0开始计数

>>> names = ['aa', 'bb', 'cc']
>>> names[0]　　　　#从0开始取第一位
'aa'
>>> names[-1]　　　 #[-1]表示最后一位
'cc'
>>> names[-2]　　　 #[-2]表示最后后两位
'bb'

切片,取列表中的一段数据

>>> names = ['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
>>> names[0:3]　　　#[0:3]表示前三位，取头不取尾
['aa', 'bb', 'cc']
>>> names[:3]　　　 #和[0:3]相等
['aa', 'bb', 'cc']
>>> names[-3:]　　　#取最后三个元素
['dd', 'ee', 'ff'
>>> names[2:5]        #取第二个到第5个元素
['cc', 'dd', 'ee']
>>> names[:-3]         #取0到倒数第三个元素
['aa', 'bb', 'cc']
>>> names[::2]         #从头到尾一个元素隔一个取一个
['aa', 'cc', 'ee']
>>> names[0:4:3]     #从0到第四位隔2个取一个    
['aa', 'dd']

list操作

增(不能批量插入)

>>> names.append("hahaha")　　#在列表最后一个元素追加
>>> names
['aa', 'bb', 'cc', 'dd', 'ee', 'ff', 'hahaha']
>>> names.insert(3,"nihao")         #在索引为3即第4个位置插入
>>> names
['aa', 'bb', 'cc', 'nihao', 'dd', 'ee', 'ff', 'hahaha']

删

>>> names.remove("ee")     #删除叫"ee"的元素,如果有多个"ee"，那会删除从左往右的第一个元素
>>> names
['aa', 'bb', 'cc', 'nihao', 'dd', 'ff', 'hahaha']
>>> del names[1]                #删除索引为1的元素
>>> names
['aa', 'cc', 'nihao', 'dd', 'ff', 'hahaha']
>>> names.pop()                  #()内不指定删除最后一个元素
'hahaha'
>>> names.pop(1)                #()内指定索引则删除相应的元素    
'cc'
>>> names
['aa', 'nihao', 'dd', 'ff']

改

>>> names[0]="my"　　　　#根据索引修改，把第一个位置的数改为"my"
>>> names
['my', 'nihao', 'dd', 'ff']

查

　　

>>> names
['my', '123', '#', 'aa', 'ff', 'dd', 'nihao', 'my']
>>> names.index("nihao")　　　　#取出"nihao"元素对应的索引，如果有多个相同的元素，那么取从左往右的第一个
1
>>> names.count("my")　　　　　　#统计列表中有多少个名字为"my"的元素
2
>>> names.reverse()　　　　　　　#反转列表
>>> names
['my', '123', '#', 'aa', 'ff', 'dd', 'nihao', 'my']
>>> names.sort()　　　　　　　　　#将列表排序,顺序为特殊字符、数字、大写、小写
>>> names
['#', '123', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names2 = ["A", "B", "C", "D"]　　#定义names2列表
>>> names.extend(names2)　　　　　　　#将name2合并到name列表中
>>> names
['#', '123', 'aa', 'dd', 'ff', 'my', 'my', 'nihao', 'A', 'B', 'C', 'D']
>>> del names2　　　　　　　　　#删除names2列表或删除变量
>>> names.clear()　　　　　　　 #清空列表
>>> names
[]

２、浅copy

１、
>>> names = ['#', '123', 'A', 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names2=names.copy()
>>> names2
['#', '123', 'A', 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names[2]='a'
>>> names
['#', '123', 'a', 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names2
['#', '123', 'A', 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']　　　#names改变了，names2不变

２、加上子列表
>>> names=['#', '123', 'A', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names2=names.copy()
>>> names2
['#', '123', 'A', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names[3][1]='LL'
>>> names2
['#', '123', 'A', ['ll', 'LL', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names
['#', '123', 'A', ['ll', 'LL', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']　　#子列表值一起改变

　　第二个列表是第一个列表的引用，只是第一个层的copy，把子列表看成一个整体，指向同一块内存地址，而第一层是开辟一块新的内存地址

３、深copy---完全独立　　

>>> import copy　　　　　　　　　　　#导入copy模块
>>> names2=copy.deepcopy(names) 　#names2 深copy names
>>> names2
['#', '123', 'A', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names[2]='a'
>>> names2
['#', '123', 'A', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names
['#', '123', 'a', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names[3][0]='LL'
>>> names
['#', '123', 'a', ['LL', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']
>>> names2
['#', '123', 'A', ['ll', 'yy', 'ly'], 'B', 'C', 'D', 'aa', 'dd', 'ff', 'my', 'my', 'nihao']

　　各自开辟新的内存地址

４、元组tuple,用(),又名只读列表,不能修改

它只有2个方法，一个是count,一个是index

>>> names3=("ni","zai","na","li","ni")
>>> names3.count("ni")　#统计为"ni"的元素有多少个　　　
2
>>> names3.index("li")　#取出"li"的下标，即索引
3

５、字典　无序，可以层层嵌套　

格式:　key:value 　key尽量不要写中文，key必须唯一

info = {
    "name": "ll",
    "age": "22",
    "teacher": "Mr.li"
}

print(info["name"])      #输出key为name的value，必须确定有这个key
print(info.get("haha"))  #输出key为name的value，可以不确定有这个key
print(info.get("age"))
print("teacher" in info)   #判断teacher这个key是否在字典中

info["address"]="jiangxi"   #新增一条数据，如果字典中存在address这个key的话则修改这条数据
print(info)

#del info    #删除字典
#del info["age"]     #删除字典中key为age的这条数据
#print(info)

#info.pop("age")  #第二种删除数据方式

#info.popitem()   #随机删除
#print(info)

print(info.values())   #打印所有的value
print(info.keys())

print(info.setdefault("nihao"))   #取不到数据就新增key为"nihao",取得到就返回
b = {
    "a": "A",
    "b": "B",
    "c": "C"
}
info.update(b)
print(info)
test = dict.fromkeys([1,2,3],"test")　　　#初始化一个新的字典，创建key为1,2,3，value都为test
print(test)
test[2] = "test1"
print(test)

info.clear()   #清空info字典

　遍历字典

info = {
    "name": "ll",
    "age": "22",
    "teacher": "Mr.li"
}
for i in info:
    print(i)　　　　#只会打印key
    print(i,info[i])　　#同时打印value，需要通过i去取


for key,val in info.items():　　　#或者先把字典转换成列表，再从列表中取
    print(key,val)

　　

字符串的常用操作　　

age = "22"
print(age.isdigit())   #字符串是否为数字


names = ["Aa", "Bb", "Cc", "Dd"]
for num,name in enumerate(names):  #用于遍历序列中的元素以及下标
    print(num,name)
# 0 Aa
# 1 Bb
# 2 Cc
# 3 Dd

company = "fengnian"
print(company.capitalize())   #把字符串首字母改为大写
#Fengnian

print(company.count("n"))   #统计company中"n"字符串有多少个
# 3

print(company.center(50,"-"))  #显示一共50个字符，包括变量company中，剩余字符用"-"表示,把company放在中间位置
#  ---------------------fengnian---------------------

print(company.endswith("an"))      #判断"Fengnian"是否以an结尾
#  True

company = "feng\tnian"
print(company)
print(company.expandtabs(tabsize=30))
#expandtabs 把字符串中的tab符号('\t')转为空格，tab 符号('\t')默认的空格数是8，tabsize指定tab符号转为空格的字符数

#  feng	nian
#  feng                          nian

company = "fengnian"

print(company[company.find("ng"):])   #将字符串切片,将字符串"ng"以后的字符串打印出来

company = "nihao hahahaha"
company2 = "123abc"
print(company.isalnum())        # 字符串中是否包含阿拉伯数字
# False
print(company2.isalnum())
# True

company = "fengnian"
company2 = "123abc"
print(company.isalpha())   # 字符串是否只包含字母
# True
print(company2.isalpha())
# False

day = "90"
day2 = "90aaaa"
print(day.isdecimal())    # 字符串是否只包含十进制字符
print(day2.isdecimal())
Company = "Fengnian Day"
print(Company.isidentifier())   #判断是不是一个合法的标识符，或者变量名是否合法
print(Company.islower())   #判断字符串是否全部为小写

print(Company.isupper())   #判断字符串是否全部为大写

print(Company.isnumeric())  #判断是否为数字，不能为小数

print(Company.istitle())   #判断字符串每个首字母是否大写

print(Company.isspace())  #判断字符串是否由空格组成，或者说只包含空格

print(Company.isprintable())   #判断是否可以打印


print('+'.join(['1', '2', '3']))    # 将列表中的字符串用+组合起来生成新的字符串
# 1+2+3

print(company.ljust(50,"*"))   
#显示一共50个字符，包括变量company中，剩余字符用"-"表示,在company后面开始填补不够的字符串

print(Company.lower())   #看字符串中是否都是小写，如果是直接打印，如果不是把它转换成小写再打印
# fengnian day
print(Company.upper())   #看字符串中是大写，如果是直接打印，如果不是把它转换成大写再打印
# FENGNIAN DAY

print(Company.strip())   #用于除去字符串头尾指定的字符串，如果不指定默认是除掉空格
print(Company.lstrip())   #用于除去字符串左边指定的字符串,默认去掉左边的空格
print(Company.rstrip())   #用于除去字符串右边指定的字符串,默认去掉右边的空格

p = str.maketrans("abcdef","123456")   #创建字符映射的转换表,两个字符串的长度必须相同，一一对应
print("yan".translate(p))   #translate,根据表翻译字符串

print("ccb".replace('c','C',1))
#替换字符串,replace()中第一个字符串指旧的被替换的,第二个是要替换的新的字符串,第三个可选，指可以替换的次数,不写则表示所有替换

print("lylyly".rfind('y'))    #返回y在字符串中最后一次出现的位置,如果没有匹配项则返回-1
print("lylyly".rfind('y', 3, 6))  #3 开始查找的位置,6 结束查找的位置,默认为字符串的长度

Company = "Fengnian Day \ hahahah"
print(Company.split("\\"))     # 按\(需要转义)分隔来建立列表,不写默认以空格作为分隔符

print(Company.swapcase())   #字符串中的每个字符,大写变小写,小写变大写

print(Company.title())  #把字符串中独立的字符首字母改为大写

　　

购物车实例:

需求:

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

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

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

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

product_list = [
    ('iphone',6888),
    ('ipad',3500),
    ('iwatch',500),
    ('macbook',600)
]

shopping_list = []
salary = input("please input your salary:")
pro_flag = True
if salary.isdigit():
    salary = int(salary)
    while pro_flag:
        for index,item in enumerate(product_list):
            print(index,item)
        user_choice = input("请输入您要购买的商品编号:")
        if user_choice.isdigit():
            user_choice = int(user_choice)
            if user_choice < len(product_list) and user_choice >= 0:
                p_item = product_list[user_choice]
                if p_item[1] < salary:
                    shopping_list.append(p_item)
                    salary -= p_item[1]
                    print("added %s in your shopping list" % p_item[0])
                    print("your balance \033[31;1m%s\033[0m" % salary)
                else:
                    print("your balance only have \033[31;1m%s\033[0m " % salary)
                    for i in shopping_list:
                        print(i)
                    pro_flag = False
            else:
                print("you input product is not exit")
        elif user_choice == 'q':
            print("-------商品列表-------")
            for i in shopping_list:
                print(i)
            print("your balance have \033[31;1m%s\033[0m " % salary)
            pro_flag = False
        else:
            print("你输入的商品编号不对，请重新输入:")
else:
   print("工资输入错误，请重新输入~~~")

 

三级菜单实例:　

　　

要求: 

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

2、可返回上一级

3、可随时退出程序

 

MapDict = {
    "北京": {
        "朝阳区": {
            "青年路": "朝阳大悦城",
            "望京": "望京soho",
            "常营": "长楹天街"
        },
        "西城区": {
            "大栅栏" : "大观楼影院",
            "天坛": "恐龙公园"
        }
    },
    "广东": {
        "深圳": {
            "宝安区": "宝安机场",
        },
        "广州": {
            "番禹区": "长隆水上"
        }
    }
}
while True:
    for i in MapDict:
        print(i)

    choice = input("输入地名进入,输入q退出----->")
    if choice in MapDict:
        while True:
            for i2 in MapDict[choice]:
                print(i2)
            choice2 = input("输入地名进入.输入b返回上一层----->")
            if choice2 in MapDict[choice]:
                while True:
                    for i3 in MapDict[choice][choice2]:
                        print(i3)
                    choice3 = input("输入地名进入,输入b返回上一层---->")
                    if choice3 in MapDict[choice][choice2]:
                        for i4 in MapDict[choice][choice2][choice3].split():
                            print(i4)
                        choice4 = input("选择b返回.输入b返回上一层---->")
                        if choice4 == "b":
                            pass
                    if choice3 == 'b':
                        break
            if choice2 == "b":
                break
    if choice == "q":
        break