变量类型,让繁琐工作自动化学习笔记

引言

NO.2:自学python之路,no.2python之路

引言

本周启幕认识了库,并学习了Python中各类类型的变量和常用操作。并成功了比较完美的用户与集团购物分界面设计。

正文

模块:

Python有标准库和第二方库。第二方库要求安装本领利用。多量的库可以帮助大家更易于的成就复杂的操作。1般意况下,标准库被保留在了‘lib/’目录下,第一方库被保存在了‘lib/site-packages’目录下。导入3个库非凡简单,例子:

import os

每一种模块都有许多操作,一般情形是用模块名.操作名完结有些操作,例子:

os.system('dir')#读取目录下的文件列表,但不保存

变量类型:

整型(int),Python 3.X中整型唯有int型,而在Python
二.X中整型分为int,和long,变量的类型不需定义,与Matlab中好像,但项目不可随便改造。查看变量类型,例子:

x = 3
type(x)

任何项目与C++中好像,所以不再赘言。

虚数型,在Python中j表示虚数。

比特型(bytes),Python 二.X中比特型与字符型未有不一致,而在Python
3.X中设有差异,它们得以相互转变,例子:

x = '我爱中国'
y = x.encode()#转换为比特型
print(y)
z = y.decode())#转换为字符型
print(z)

在常常行使Python中,字典与列表是最常使用的变量。上面将详细介绍字典与列表的选拔形式。

列表:

列表的定义,例子:

province = ['Beijin','Hebei','Shanghai','Henan']

列表的切成丝与Matlab有相似之处,但持有光辉差别,Python的:后的数字是切成片地方的后一人。所以,在Python中[1:2]=[1],例子:

province = ['Beijin','Hebei','Shanghai','Henan']
print(province[0:2])#切片(顾头不顾尾)

Python还是能从右数来成功切条,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
print(province[-1])#从右数
print(province[-2:])#最后的值省略

 列表的扩充有二种办法,1种是终极追加,还有一种是某处插入。例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province.append('Shannxi')#最后追加
province.insert(1,'Xinjiang')#某处插入

列表的改造10分简约,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province[1] = 'Beijing'#改变某处

列表的删减有多数措施,del是Python中通用的删除方法,其余还有删除某些与删除某处参数的不二法门,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
del province[2]#删除某处
province.remove('Beijing')#删除某个
province.pop()#删除最后一个(默认),或括号中的位置

除此以外,Python还为列表提供了成都百货上千功效。Python中得以轻易查询有些参数的职位和个数,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province.index('Shanghai')#寻找位置
province.count('Shanghai')#寻找个数

退换列表的相继也十分粗略,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province.reverse()#反转序列
province.sort()#排序序列(符号,数字,大写,小写(ASCII))

Python中列表的复制与Matlab不一致,设计相对合理一些,然而有一些麻烦精晓,学过C++中指针的能够绝对轻松精晓1些。普通的赋值操作,只是将列表的地址复制,壹旦中间列表中的值产生更换,两者中的值都会转移,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province_copy = province#复制地址,改变后一起变化
province.append('Xinjiang')
print(province)
print(province_copy)

要想复制多个列表,有浅copy和深copy三种方法。浅copy只复制列表的首先层,第3层将只复制地址。深copy则是一心在内部存储器中树立四个1如既往的区域。例子:

province = ['Beijin',['Hebei','Shijiazhuang'],'Shanghai','Henan']
province_copy = province.copy()#浅copy
import copy
province_copy = copy.copy(province)#浅copy
province_copy = list(province)#浅copy
province_copy = copy.deepcopy(province)#深copy

Python中也提供了列表的统一方法,例子:

province = ['Beijin','Hebei','Shanghai','Henan']
province_new = ['Xinjiang','Dongbei']
province.extend(province_new)#并入后面

列表的飞跃循环方法是用以下格式,[::x]切开中x为步距,例子如下:

province = ['Beijin','Hebei','Shanghai','Henan']
for i in province[::2]:#切片
    循环体

当列表中贮存的音讯不想被更动时,就能够用元组,元组的定义与列表大概同样,只是用‘()’代替了[]。元组无法改改,只好切成块。例子:

province = ('Beijin','Hebei','Shanghai','Henan')

字符:

字符中对字母大小写变化的操作许多,能够有以下三种方法,例子:

x = 'l love china'
x.capitalize()#首字母大写
x.upper()#全变大写
x.lower()#全变小写
x.title()#变为标题形式
x.swapcase()#大小写互换

在Python中还足以轻便的对字符举行修改,例子:

names = 'Xiaohong Xiaohuang'
names.replace('o','O',1)#旧字符,新字符,替换个数
tran = str.maketrans('aox','123')#设置替换密文
names.translate(tran)#替换加密
names.center(50,'-')#50个字符,将name居中,不的够用-填充
names.ljust(50,'*')#50个字符,将name居左,不的够用*填充
names.rjust(50,'*')#50个字符,将name居右,不的够用*填充
names.zfill(50)#50个字符,将name居右,不的够用0填充
names = '  Xiaohong'
names.lstrip()#去掉左边空格,然后回车
names = '  Xiaohong   '
names.strip()#去掉左右空格,然后回车
names = 'Xiaohong\tXiaohuang'#\t与下面结合,控制空格的数量
names.expandtabs(tabsize=30)#空格数

除开,还提供了询问功效,例子:

names = 'xiaohei'
names.find('i')#从左找某个字符第一次出现的位置
names.rfind('i')#从右找某个字符第一次出现的位置

字符和列表之间还可以相互转变,例子:

names = 'Xiaohong Xiaohuang Xiaozhang Xiaoli'
names.split()#按空格分成列表
names = 'Xiaohong
Xiaohuang
Xiaozhang
Xiaoli'
names.splitlines()#按回车分成列表
names = ['Xiaohong','Xiaohuang','Xiaozhang','Xiaoli']
'+'.join(names)#用+连接列表成字符

Python还为字符提供了无数肯定,这个功能繁多以is发轫,例子:

names = ('xiaohong hei')
names.endswith('hei')#判断以什么结尾
names.isalnum()#判断为阿拉伯数字
names.isalpha()#判断为纯英文
names.isdigit()#判断为整数
names.isidentifier()#判断为合法标识符(变量名)
names.islower()#判断为小写
names.istitle()#判断为标题形式

字典

字典也是常用的1种工具,字典是接纳‘{}’定义的,字典中的数据是严节的,字典能够与体系与字典嵌套。

索引字典时行使KEY,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
print(info['2012020202'])

字典的加码和退换都是由此复制操作,程序会首先查询字典中是还是不是有该KEY值,未有,则新建一条。有,则修改该条的值。例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info['2012020201'] = '蛤蛤'#修改
info['2012020204'] = '拉拉'#增加

字典的删减能够应用Python中通用的删除方法,或许字典中提供的情势,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
del info['2012020203']#删除
info.pop('2012020203')#删除
info.popitem()#随便删除一个,不常用

查究是,能够用事先的点子来探索,不过还有壹种安全的寻觅方法,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info.get('2012020202')

看清有个别KEY是或不是在字典中,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
'2012020202' in info

字典也得以统一,合并时,将会用新的字典中覆盖旧的字典,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info_new = {
    '2012020202':'王凯',
    '2012020206':'彭浩',
    }
info.update(info_new)#合并更新

Python也提供了新建1个字典的法门,可是存在十分的大的主题素材,所以1般不会动用,例子:

info_new = dict.fromkeys([1,2,3],[1,{'name':'X',2}])#初始化字典
info_new[3][1][‘name’] = Y

当修改Python新建的字典时,例子中只改了[3][1]中的‘name’为‘Y’不过足以窥见字典中的全部‘name’都产生了‘Y’。所以,符合规律情形下很难使用。

字典能够转为列表,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info.items()

数以万计字典的操作与单级字典差异十分的小,修改略有差别。例子:

province = {
    '华北':{
        '北京':['直辖市','很大'],
        '河北':['石家庄','漂亮'],
        },
    '东北':{
        '黑龙江':['哈尔滨','很棒'],
        '辽宁':['沈阳','厉害'],
        },
    }
province['华北']['北京'][1] = '首都'#修改
province.setdefault('西北',{'陕西':['西安','省会']})#取西北如果有,返回,没有新建

字典的循环格式与列表类似,格式如下,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
for i in info:#高效循环
    print(i,info[i])
    循环体

作业

编写3个购物车程序,要求将商品音信存在文件里。展开程序后需求用户登入,用户输入需求完毕,已购商品,余额记录,运转程序,输入报酬,依照编号,购买商品,检查测试余额,够用扣款,不够提示,随时退出,打字与印刷已经购置的货品和余额。厂家入口需求实现,增多商品,修改价格。

流程图:

亚洲必赢官网 1

主程序:

#购物车程序
'''
商品信息存在文件里
1.打印商品列表
用户入口
已购商品,余额记录
启动程序,输入工资
根据编号,购买商品
检测余额,够用扣款,不够提醒
随时退出,打印已经购买的商品和余额
商家入口
添加商品,修改价格
'''
import getpass

title = '''
---------------------------
-     欢迎光临本超市      -
---------------------------
'''
print(title)

#读取商品数据
goods = open('商品.txt')
read_flag = True
goods_list = []
while read_flag:#按行处理
    goods_line = goods.readline()
    if goods_line == '':
        read_flag = False
    else:
        goods_list.append(goods_line.split())
goods.close()

#读取用户信息
info = open('用户信息.txt')
read_flag = True
info_user = []
while read_flag:
    info_line = info.readline()
    if info_line == '':
        read_flag = False
    else:
        info_user.append(info_line.split())
info.close()

#用户登陆
success_flag = False
for count in range(0,6):
    account = input('请输入用户名:')
    password = getpass.getpass('请输入密码:')
    for i in range(0,len(info_user)):
        if account == info_user[i][0] and password == info_user[i][1]:
            success_flag = True
            user_number = i
            break
    if success_flag:
        print('尊敬的%s登陆成功!'%info_user[user_number][2])
        break
    else:
        print('用户名或密码错误!')
else:
    print('输入密码次数超过6次,请重新开启软件尝试!')
    exit()

#进入入口
info_write = []
if info_user[user_number][3] == '0':
    #普通用户
    if info_user[user_number][4] == '0':
        #初次登陆
        balance = input('您是第一次登陆,请输入充值金额:')
        if balance.isdigit():
            balance = int(balance)
            info_user[user_number][4] = '1'
            info_user[user_number][5] = str(balance)
        else:
            print('充值错误,退出系统!')
            exit()
    #非初次登陆
    for i in range(0,len(goods_list)):
        goods = '{number}.物品名:{name} 价格:{price}'.format(number = i + 1,
                                                               name = goods_list[i][0],
                                                               price = goods_list[i][1])
        print(goods)
    print('%s.充值'%(len(goods_list)+1))
    buy_list = []
    balance = int(info_user[user_number][5])
    while True:
        buy_number = input('请输入你所需要的商品序号[按q退出购买]:')
        if buy_number == 'q':
            buy_list = ' '.join(buy_list)
            print('本次购物购买了:{list}'.format(list = buy_list))
            #更新信息
            info_user[user_number][5] = str(balance)
            info = open('用户信息.txt','w')
            for i in range(0,len(info_user)):
                info.write(' '.join(info_user[i])+'\n')
            info.close()
            exit()
        elif buy_number.isdigit():
            buy_number = int(buy_number)-1
            if buy_number > len(goods_list) or buy_number < 0:
                print('请输入正确的商品码!')
            elif buy_number == len(goods_list):
                money = input('请输入充值金额:')
                if money.isdigit():
                    balance += int(money)
                    info_user[user_number][5] = str(balance)
                else:
                    print('充值金额错误')
            else:
                if balance < int(goods_list[buy_number][1]):
                    print('你的余额不够购买这件商品!')
                else:
                    balance = balance - int(goods_list[buy_number][1])
                    buy_list.append(goods_list[buy_number][0])
                    print('购买成功!还剩%s圆'%balance)#
        else:
            print('输入错误')
elif info_user[user_number][3] == '1':
    #商家用户
    for i in range(0,len(goods_list)):
        goods = '{number}.物品名:{name} 价格:{price}'.format(number = i + 1,
                                                               name = goods_list[i][0],
                                                               price = goods_list[i][1])
        print(goods)
    print('%s.添加物品'%(len(goods_list)+1))
    add_list = []
    while True:
        buy_number = input('请输入你需要修改商品价格的序号[按q退出购买]:')
        if buy_number == 'q':
            add_list = ' '.join(add_list)
            print('本次共添加了:{list}'.format(list = add_list))
            #更新信息
            info = open('商品.txt','w')
            for i in range(0,len(goods_list)):
                info.write(' '.join(goods_list[i])+'\n')
            info.close()
            exit()
        elif buy_number.isdigit():
            buy_number = int(buy_number)-1
            if buy_number > len(goods_list) or buy_number < 0:
                print('请输入正确的商品码!')
            elif buy_number == len(goods_list):
                goods_name = input('请输入商品名称:')
                goods_price = input('请输入商品价格:')
                if goods_price.isdigit():
                    add_list.append(goods_name)
                    goods_list.append([goods_name,goods_price])
                else:
                    print('商品价格信息错误!')
            else:
                goods_price = input('请输入商品价格:')
                if goods_price.isdigit():
                    goods_list[buy_number][1] = goods_price
                else:
                    print('商品价格信息错误!')
        else:
            print('输入错误')
else:
    print('用户数据错误!请管理员维护!!')

讯息记录文件:

商品.txt

手机 1000
电脑 8000
耳机 500
泡面 3
娃娃 10000

用户音讯.txt

customer 123456 凯凯王 0 0 0
business 123456 卖力头 1 0 0

 

引言
本周上马认识了库,并学习了Python中各系列型的变量和常用操作。并做到了相比全面包车型客车用户与市4购…

Python里的变量 —门牌

 

Python在动用变量以前毫无定义它的连串,可是必须注解以及开始化该变量。

Python中给变量赋值就是宣称,开端化变量(也正是创建一个对应数据类型的靶子,而这一个数据类型正是类),变量的体系是在于其储存的数额。(下边代码中的a变量,其项目类型随着赋值的类型不相同而改动)

#type(a)返回a的数据类型
a=1
print(type(a),'整型')

a=1.1
print(type(a),'浮点型')

a=True
print(type(a),'布尔类型')

a=''
print(type(a),'字符串类型')

a=['床前明月光','地上鞋两双']
print(type(a),'列表')

a=(123,123)
print(type(a),'元组')

a={'好诗':'举头望明月,低头思故乡','好湿':'床前明月光,地上鞋两双'}
print(type(a),'字典')

a={12345,'上山打老虎'}
print(type(a),'集合')


# <class 'int'> 整型
# <class 'float'> 浮点型
# <class 'bool'> 布尔类型
# <class 'str'> 字符串类型
# <class 'list'> 列表
# <class 'tuple'> 元组
# <class 'dict'> 字典
# <class 'set'> 集合

 

第三片段 基本语法

一、字符串不能一向和数字相加,要用str()转一下;然而能够和数字相乘,用于表示两个字符串复制;字符串不可能和浮点数间接结合,字符串能够和字符串直接相加;

二、输入函数用input(),默许是字符串 总括字符串长度用len()

3、注释用#

四、类型调换,int()整型,str()字符串类型,float()浮点类型

5、**是求指数值 //是整除 /是除法

6、判别变量类型,type(变量)

本周伊始认识了库,并学习了Python中各连串型的变量和常用操作。并成功了较为完美的用户与厂家购物分界面设计。

数据类型

Python叁 中常用的数据类型:

  • 不可变数据类型
  • Number(数字)
  • String(字符串)
  • Tuple(元组)
  • 可变数据类型
  • List(列表)
  • Dictionary(字典)
  • Sets(集合)

数据类型类型可分为:可变数据类型,不可变数据类型。

可变数据类型是指1个ID地址中蕴藏的数量是足以改变的。

不可变数据类型是指2个ID地址中蕴藏的多少不得以转移。

其次某些 调控流

1、not 非 and 与 or 或

二、range(起先,甘休,步长)  注意:循环不包蕴‘截止’ 

三、import 函数 导入函数 from import是另壹种导入方式,举例 from random
import * 能够在使用random函数时绝不加random.前缀

肆、sys.exit()提前停止程序,须要import sys

正文

壹 ,Number(数字)—-不可变数据类型

其叁局部 函数

1、def 函数名(入参):

贰、关键字 print(‘hello’,end=”) 连接字符
print(‘cats’,’dogs’,’mice’,sep=’,’)用 ‘,’代替‘ ’

三、要想在函数中期维修改全局变量,要求在全局变量前拉长global关键字

4、相当处理 try 和except

常用的卓殊类型

亚洲必赢官网 2亚洲必赢官网 3

 1 1、NameError:尝试访问一个未申明的变量
 2 >>>  v
 3 NameError: name 'v' is not defined
 4 
 5 2、ZeroDivisionError:除数为0
 6 >>> v = 1/0
 7 ZeroDivisionError: int division or modulo by zero
 8 
 9 3、SyntaxError:语法错误
10 >>> int int
11 SyntaxError: invalid syntax (<pyshell#14>, line 1)
12 
13 4、IndexError:索引超出范围
14 >>> List = [2]
15 >>> List[3]
16 Traceback (most recent call last):
17   File "<pyshell#18>", line 1, in <module>
18        List[3]
19 IndexError: list index out of range
20 
21 5、KeyError:字典关键字不存在
22 >>> Dic = {'1':'yes', '2':'no'}
23 >>> Dic['3']
24 Traceback (most recent call last):
25   File "<pyshell#20>", line 1, in <module>
26         Dic['3']
27 KeyError: '3'
28 
29 6、IOError:输入输出错误
30 >>> f = open('abc')
31 IOError: [Errno 2] No such file or directory: 'abc'
32 
33 7、AttributeError:访问未知对象属性
34 >>> class Worker:
35  def Work():
36       print("I am working")
37 >>> w = Worker()
38 >>> w.a
39 Traceback (most recent call last):
40   File "<pyshell#51>", line 1, in <module>
41         w.a
42 AttributeError: 'Worker' object has no attribute 'a'
43 
44 8、ValueError:数值错误
45 >>> int('d')
46 Traceback (most recent call last):
47   File "<pyshell#54>", line 1, in <module>
48         int('d')
49 ValueError: invalid literal for int() with base 10: 'd'
50 
51 9、TypeError:类型错误
52 >>> iStr = '22'
53 >>> iVal = 22
54 >>> obj = iStr + iVal;
55 Traceback (most recent call last):
56      File "<pyshell#68>", line 1, in <module>
57        obj = iStr + iVal;
58 TypeError: Can't convert 'int' object to str implicitly
59 
60 10、AssertionError:断言错误
61 >>> assert 1 != 1
62 Traceback (most recent call last):
63      File "<pyshell#70>", line 1, in <module>
64         assert 1 != 1
65 AssertionError

View Code

模块:

1.int(整型)

int类型就是整数

Python的二.x的版本中还留存Long长整型(表示相比长的平头(相比大OCR-V相比较小)),三.x的版本中就唯有int整型

整型类型能发挥的数值仅仅与您的机械补助的(虚拟)内部存款和储蓄器大小有关,换句话说,Python能自在表明相当大的平头。

 

 亚洲必赢官网 4

(嘿嘿,本身去总计对不对)

第五片段 列表

一、负数下标

平头-1下标指的是列表的结尾八个下标,-二指的是列表的倒数第四个下标

2、利用切块获得子列表

  spam[1:4]表示收获spam[1]到spam[3]的区间值作为1个新的切条,可以利用轻巧方法

  spam[:4]代表收获spam[0]到spam[3]的区间值作为叁个新的切成丝,省略的值获得是0

  spam[1:]代表收获spam[1]到spam最终二个要素的区间值作为3个新的切成丝,省略的值赚取是列表的长度

三、列表的尺寸

  使用len(spam)

四、列表能够向数组那样实行赋值

伍、列表的接连和复制

  使用+能够接连不断八个两次三番为1个列表

  使用[‘a’,’b’,’c’]*n能够复制n个列表为叁个列表

6、列表成分的删除

  del spam[3]

七、列表的决断

1 in 'howdy' in ['hello','howdy']
2 >> True
3 not in
4 >> False

 

变量类型,让繁琐工作自动化学习笔记。八、多种赋值

1 cat = ['fat','black','loud']
2 size,color,disposition = cat

  等号左边的变量数目和列表长度必须严俊相等,否则会报ValueError

玖、加强赋值

  类似于C中+=,*=,/=,-=,%=

  加强赋值一样能够用于列表中,功用相当于于对以成分为单位的操作

10、方法

  类似于C++中类的分子方法

 1     spam.index('hello') 取出'hello'在列表中的下标索引,重复值返回第一次出现的下标索引
 2 
 3     spam.append('yes') 在列表尾部追加一个元素
 4 
 5     spam.insert(1,'no') 在指定spam[1]之前插入一个元素
 6 
 7     spam.remove('hello') 删除指定元素,如果有多个重复元素存在,删除第一个元素,后面的元素不删除。
 8 
 9     spam.sort() 对数字按照由小到大排列,对字符串按照ASCII字符顺序排列
10 
11     spam.sort(reverse=True) 对字符串按照ASCII字符顺序逆序排列,对数字按照由大到小排列
12 
13     spam.sort(key=str.lower) 对表项全部按照小写字母进行排列
14 
15     spam.sort(1,2,3,'hello','no') -----WRONG,不能对既有数字又有字符串的列表进行排序,因为不知道按照那个原则进行排序

11、续行字符’\’,在行末使用

1二、可变对象和不可变对指标

  可变即内部存款和储蓄器空间可变,不可变即内部存款和储蓄器空间不可变。可变的目的的变量在传递时,传递的是援引地址(能够明白为指针),所以拷贝的时候不是实在拷贝内部存款和储蓄器空间,仅仅是多了个变量指向同样的内部存储器空间而已。对新的变量实行增加和删除都会影响到原始变量,即浅拷贝。不可变对象,拷贝或透过新变量传递时,一旦爆发修改,会新生成二个跟原先对象属于分裂内部存储器空间的新对象值。元组(tuple)、数值型(number)、字符串(string)均属于不可变对象,而字典型(dictionary)和列表型(list)的靶子是可变对象。

13、引用

  在变量必须保留可变数据类型的值时,例如列表或字典,Python就动用引用。对于不可变的数据类型的值,例如字符串、整型或元组,Python变量就保存值本身。

1四、传递引用

  当函数被调用时,参数的值被复制给变元。对于列表和字典,那表示变元得到的是引用的正片。

15、copy模块的copy()和deepcopy()函数

  使用copy.copy()来幸免引用传递带来的劳顿,假诺被复制的列表或字典中带有列表或字典,使用copy.deepcopy()

1 import copy
2 samp = ['A', 'B', 'C', 'D']
3 cheese = copy.copy(samp)
4 cheese[1] = 42
5 print(samp)

 1陆、列表和字符串的共同点

  列表和字符串都得以流传len(),都有下标和切成条,用于for循环,连接或复制,并与in和not
in操作符一同行使。

  Python有标准库和第3方库。第3方库必要设置本事使用。多量的库能够扶助我们更便于的成就复杂的操作。一般景色下,标准库被保留在了‘lib/’目录下,第壹方库被封存在了‘lib/site-packages’目录下。导入2个库非凡简单,例子:

2.float(浮点数)

笔者们权且的把浮点数掌握为带小数点的小数(小编还会开单章来说说浮点数)

浮点数小说链接

第四部分 元组

1、元组使用()实行区分,以逗号’,’作为最终三个了却,不然只有叁个因素时有望会不被以为是元组类型

贰、列表和元组之间的品种调换 使用list() tuple()举办类型转变

三、列表和元组的分别

  列表是足以修改的,他们得以增多值、删除值和修改值。元组是不得以修改的,他们向来不能够更动。而且元组使用的是括号,而列表使用的方括号。

import os

三.bool(布尔类型)

把 True 和 False 定义成最首要字了,但它们的值仍旧 一 和
0,它们得以和数字相加

 亚洲必赢官网 5

注意:

  • 1、Python可以而且为多少个变量赋值,如a, b = 壹, 贰。
  • 贰、1个变量能够通过赋值指向分歧种类的指标。
  • 三、数值的除法 / 总是回到1个浮点数,要获取整数使用 // 操作符( //
    是以舍去小数部分来取整的)。
  • 4、在混合计算时,Python会把整型调换成为浮点数。

Python还援助complex(复数),复数由实数部分和虚数部分构成,能够用a +
bj,或然complex(a,b)表示, 复数的实部a和虚部b都以浮点型。

第伍部分 字典和结构化数据

一、字典是广大值的重组,但不像列表的下标,字典的目录能够动用过多不等的数据类型,不只是整数。字典的目录被叫作“键”,键及其关联的值称为“键-值”对,字典使用花括号{}包裹。

二、字典与列表

  字典也得以应用数字作为键;不像列表,字典中的表项时不排序的。同样的五个列表其顺序也亟须是一律的,而字典则未必;因为字典是不排序的,所以不可能开始展览列表这样的切成块操作。

3、字典的探究和丰硕

  查找键值是不是位于字典中,不过使用in操作,字典键值对的增进然则使用普通的赋值操作举行。

  检查该键是还是不是存在于字典中,也可利用get()方法,其有多个参数,第七个是获取其键的值,第3个是一旦查找键败北,重回的暗中同意值

四、字典方法

  keys()方法——抽出字典键

  values()方法—-抽出字典值

  items()方法—–抽取字典键值对

亚洲必赢官网 6亚洲必赢官网 7

 1 spam = {'color': 'red', 'age': '42'}
 2 for i in spam.keys():
 3     print(i)
 4 for i in spam.values():
 5     print(i)
 6 for i in spam.items():
 7     print(i)
 8 
 9 
10 age
11 color
12 42
13 red
14 ('age', '42')
15 ('color', 'red')

Python dictionary

  能够将keys()和values()再次来到的值存款和储蓄为列表,例如list(spam.keys())

  也得以使用多种赋值的技能,在for循环军长key和value对号落座

1 for k, v in spam.items():
2     print('key:' + k + 'value:' + str(v))

  setdefault()方法—设置字典键对应的默许值

  假如未有暗中认可值,将艺术设置的值设置成功,如若已有暗中认可值,则保持原状。

   spam.setdefault(‘color’, ‘black’) 

 5、美丽打字与印刷

  使用 import
pprint 能够服从字典的体裁打字与印刷出来,例如 pprint.pprint(myDict) ,倘诺想将打字与印刷的结果转为字符串而不是一贯出口在荧屏上能够运用 print(pprint.pformat(myDict)) 

陆、字典实战——棋盘井字游戏

亚洲必赢官网 8亚洲必赢官网 9

 1 theBoard = {'top-L': ' ', 'top-M': ' ', 'top-R': ' ',
 2             'mid-L': ' ', 'mid-M': ' ', 'mid-R': ' ',
 3             'low-L': ' ', 'low-M': ' ', 'low-R': ' '}
 4 def showBoard(board):
 5     print(board['top-L'] + '|' + board['top-M'] + '|' + board['top-R'])
 6     print('-+-+-')
 7     print(board['mid-L'] + '|' + board['mid-M'] + '|' + board['mid-R'])
 8     print('-+-+-')
 9     print(board['low-L'] + '|' + board['low-M'] + '|' + board['low-R'])
10 
11 
12 turn = 'X'
13 for i in range(9):
14     showBoard(theBoard)
15     print('the turn for' + turn + 'move in which space ?')
16     move = input()
17     theBoard[move] = turn
18     if turn == 'X':
19         turn = 'O'
20     else:
21         turn = 'X'
22 showBoard(theBoard)

井字游戏

 7、字典作为1种数据类型,能够字典有嵌套字典

  每一个模块都有好多操作,一般情形是用模块名.操作名达成有些操作,例子:

二,String(字符串)—-不可变数据类型

字符串是以单引号 ' or双引号
" or三引号 '''括起来的随意文本(用来括起文本的单引号,双引号,三引号并不是文件里的字符),例如:’追求喜欢的女孩’,“有机遇要追求”,‘’’未有机会,成立机会也要追求‘‘’

当有属于文本中的单引号  ’
,就供给用双引号把文本括起来;当有属于文本中的双引号 
“,就须要用三引号把文本括起来。(当引号为文本时要用引号多的把引号少的括起来)

 亚洲必赢官网 10

3引号能够把多行字符串括起来

亚洲必赢官网 11

亚洲必赢官网 12

动用反斜杠 \
转义特殊字符,尽管您不想让反斜杠爆发转义,能够在字符串后边增加三个r,表示原始字符串:

>>>print('L\ove')
L
ove
>>> print(r'L\ove')
L\ove
>>> 

字符串的操作

[ ],[ : ],[ : :
]经过索引能够开始展览切开操作,和列表同样(在列表时会详细讲)

加号 (+) 是字符串的连接符, 星号 (*)
表示复制当前字符串,紧跟的数字为复制的次数。

str = 'I Love'
print((str+'You ')*4)

#输出 I LoveYou I LoveYou I LoveYou I LoveYou 

注意

Python 未有单身的字符类型,1个字符正是长度为一的字符串。

与 C 字符串不一致的是,Python
字符串无法被更换。向2个目录地方赋值,比如word[0] = ‘m’会招致错误。

第九有个别 字符串操作

1、字符串字面量

  双引号“that’s a cat
”:双引号同样能够代表字符串,并且在双引号中增多单引号作纯字符串使用;

  转移字符‘\’:转移字符能够讲单引号转为普通字符,从而得以避免引起语义错误;

  原始字符串r‘abc’:原始字符串义务‘’中的全部字符都是字符串的壹有的,例如‘that
is carol\’s cat
’中的转移字符‘\’也被认为是字符串的一局地据此打字与印刷为 that is
carol\’s cat 

  三重引号”’:使用print打字与印刷多行字符串时,能够应用三重分号将字符串打字与印刷出来,例如

 print('''Dear Alice, 
I like you very much ..... ''') 

Dear Alice, 
I like you very much ..... 

  多行注释:代码中动用 ”’Python”’ 和 “””Python””” 都可以起到注释代码的功力

  字符串下标切块:字符串能够像列表一样使用下标切条收取1些字符串,可是并不曾改观原先的字符串,只是新建了3个字符串,例如

 1 sapm = 'hello world'
 2 >>>spam[0]
 3 'H'
 4 >>>spam[4]
 5 'o'
 6 >>>spam[-1]
 7 'd'
 8 >>>spam[0:5]
 9 'hello'
10 >>>spam[:5]
11 'hello'
12 >>>spam[6:]
13 'world'

  字符串in和not in操作符:能够利用in或许not
in决断二个字符串是还是不是在另四个字符串中设有,重返值为布尔型。

2、字符串方法

  字符串方法upper()、lower()、isupper()、islower():

  isX字符串方法:

  is阿尔法()再次来到TRUE,即使字符串只含有字母,并且非空;

  isalnum()再次来到TRUE,纵然字符串值包涵字母和数字,并且非空;

  isdecimal()重回TRUE,假使字符串包罗数字字符,并且非空;

  isspace()重回TRUE,如果字符串值蕴涵空格,制表符和换行,并且非空;

  istitle()重回TRUE,假设字符串仅包蕴以大写字母起首后边都是小写字母的单词;

  字符串方法startswith()、endswith():

  字符串方法join()、split():

  join()连接字符串 

>>','.joini['my','name','is']
>>my,name,is

  split()分离字符串

1 >>'myABCnameABCisABC'.split('ABC')
2 >>['my','name','is']
3 
4 >>'My name is '.split('m')
5 >>['My na','e is']

  split(‘\n’)以换行实行分割字符串

  字符串对齐方法rjust()、ljust()、center():

  左右对齐和居中,当中第一个参数是填写参数,能够选取填充字符;

  字符串删除空白字符方法strip()、rstrip()、lstrip():

  删除两边,左边和左手的空白字符,第四个参数启用时钦命须求删除的钦定字符串

  字符串拷贝粘贴方法pyperclip():

1 '''
2   该模块需要单独安装  
3 '''
4 >>import pyperclip
5 >>pyperclip.copy('Hello World!')
6 >>pyperclip.paste()
7 >>'Hello World!'

 

os.system('dir')#读取目录下的文件列表,但不保存

三,tuple(元组)—-不可变数据类型

元组被称之为只读列表,即数据足以被询问,但不能够被改换,所以,列表的切成条操作同样适用于元组。

元组写在小括号 () 里,成分之间用逗号隔开分离。

 同四个元组中,成分得以是例外的(成分得认为随机档次)

虽说tuple的要素不可改造,但它的成分得以为可变数据类型,比如list列表。(今后不知情无妨,在前面解释可变与不可变数据类型中会有详尽表达)

tup =([11,22,33], ['无边落木萧萧下', 44])
a=tup[1]
b=[11,22,33]
print(id(a))
print(id(tuple[1]))
print(id(b))
#输出结果
#31469064
#31469064
#31927176

布局包蕴 0 个或 壹 个因素的元组相比较独特,所以有一对附加的语法规则:

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号

作用:

一 对此有个别数目大家不想被涂改,能够利用元组;

2此外,元组的意义还在于,元组可以在光彩夺目(和汇集的积极分子)中当作键使用——而列表则不行;元组作为众多内建函数和措施的重返值存在。

变量类型:

肆, List(列表)—-可变数据类型

列表(list)是使用应用中括号 [ ]
来分析列表。

通过列表能够对数据达成最便宜的存款和储蓄、修改等操作

  整型(int),Python 三.X中整型唯有int型,而在Python
二.X中整型分为int,和long,变量的项目不需定义,与Matlab中接近,但品种不可随便变动。查看变量类型,例子:

概念列表

a = ['锦','瑟','无','端','五','十','弦']  # 定义一个列表
a=list(('锦','瑟','无','端','五','十','弦'))#强制转换

 同三个列表中,成分得以是见仁见智的(成分得以为随机档次)

通过下标访问列表中的成分,下标从0开始计数

 

x = 3
type(x)

 增(append,insert, extend

 

  别的类型与C++中近乎,所以不再赘言。

1.insert 艺术用于将指标插入到列表中

 

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a.insert(0,'就是这')
print(a)
# ['就是这', '锦', '瑟', '无', '端', '五', '十', '弦']

 

  虚数型,在Python中j表示虚数。

二.append方法则用于在列表末尾追加新的目的

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a.append('最后面')
print(a)
# ['锦', '瑟', '无', '端', '五', '十', '弦', '最后面']

  比特型(bytes),Python 二.X中比特型与字符型未有分别,而在Python
3.X中存在分裂,它们得以互相转变,例子:

三.追加多少个行列里的八个要素( extend)

         extend 方法能够在列表的末梢3次性追加另叁个种类(可迭代对象,如
列表,字典,元组,字符串)中的多少个值。

    extend
方法修改了被扩展的列表,而原有的连天操作(+)则不然,它会再次来到2个簇新的列表。

#列表
a = ['锦', '瑟', '无', '端', '五', '十', '弦']
b = ['一', '弦', '一', '柱', '思', '华', '年']
a.extend(b)  #只是对a进行扩展,无返回值(不会产生新的列表)
print(a)  # ['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']
b.extend(b)
print(b)  # ['一', '弦', '一', '柱', '思', '华', '年', '一', '弦', '一', '柱', '思', '华', '年'] 

#字典
a = ['一', '弦', '一', '柱', '思', '华', '年']
b = {'字典':123,'键':456}  # 可迭代对象是字典(默认是键)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', '字典', '键']

#元组
a = ['一', '弦', '一', '柱', '思', '华', '年']
b=(1,2,3,4)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', 1, 2, 3, 4]

#字符串
a = ['一', '弦', '一', '柱', '思', '华', '年']
b='abcd'
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '华', '年', 'a', 'b', 'c', 'd']
x = '我爱中国'
y = x.encode()#转换为比特型
print(y)
z = y.decode())#转换为字符型
print(z)

 删(remove,del,pop)

  在通常使用Python中,字典与列表是最常使用的变量。下边将详细介绍字典与列表的行使方法。

壹.remove去除以值钦定的因素

a = ['锦', '瑟', '无', '端', '五', '十', '弦'] # 定义一个列表
a.remove('瑟')  # 删除元素'瑟',当要删除的元素有多个相同时,删最前面那个(就是下标最小的那个,这个函数检索列表是从下标0开始的)
print(a)
# ['锦', '无', '端', '五', '十']

列表:

二.del删减以下标钦命的因素or整个列表

a = ['锦', '瑟', '无', '端', '五', '十', '弦'] # 定义一个列表
del a[0]   # 删除以下标指定的元素
print(a)
# ['无', '端', '五', '十']
del a    # 删除整个列表

  列表的定义,例子:

3.pop去除列表中钦点下标成分,暗许删除最后2个因素,并且重回该因素的值,借使列表为空或许索引值高出范围会报多少个百般。

# a.pop([index=-1])
a = ['一', '弦', '一', '柱', '思', '华', '年'] # 定义一个列表
b=a.pop()   # 默认下标为-1  index=-1 删除最后一个元素  
print(b)  # a.pop()会返回被删除的元素
# 弦
print(a) # ['一', '弦', '一', '柱', '思', '华'] 
a.pop(0)
print(a) # ['弦', '一', '柱', '思', '华']
province = ['Beijin','Hebei','Shanghai','Henan']

 改(重新赋值)

注意:列表可以重新赋值,元组不得以

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表
a[0]=0
print(a)
# [0, '瑟', '无', '端', '五', '十', '弦']
a[1]='1'
print(a)
# [0, '1', '无', '端', '五', '十', '弦']
a[2:4]=2,3
print(a)
# [0, '1', 2, 3, '五', '十', '弦']
a[4::2]=4,7
print(a)
# [0, '1', 2, 3, 4, '十', 7]

 

  列表的切块与Matlab有相似之处,但有所光辉分化,Python的:后的数字是切成片地方的后1个人。所以,在Python中[1:2]=[1]亚洲必赢官网 ,,例子:

查(切片,index)

province = ['Beijin','Hebei','Shanghai','Henan']
print(province[0:2])#切片(顾头不顾尾)

1.切块操作(列表的切丝,字符串,元组的切成丝操作都以一样的)

切开—取二个成分

a = ['锦','瑟','无','端','五','十','弦'] # 定义一个列表

>>> a[0]
'锦'
>>> a[6]
'弦'
>>> a[-1]
 '弦'
>>> a[-2] #还可以倒着取
 '十

 

 切成条—取多少个成分(获得的是三个新的列表)

a = ['锦', '瑟', '无', '端', '五', '十', '弦']  # 定义一个列表

# a[起始下标:结束下标:移动的方向和步幅]

b = a[0:6]
print(b)
# ['锦', '瑟', '无', '端', '五', '十']
# a[0:6]取头不取尾
b = a[0:]
print(b)
# ['锦', '瑟', '无', '端', '五', '十', '弦']
# a[0:]才可以去到尾
b = a[:]
print(b)
# ['锦', '瑟', '无', '端', '五', '十', '弦']
# b = a[:]从头取到尾

# 当a[::]的的二个 : 没有时,我们就默认其步幅为1。
# 步幅: 步幅为1时是“走一步“取一个。例如,'锦'走一步是'瑟'
#      步幅为2时时“走两步”取一个。例如,'锦'走两步是'无'
# 方向:步幅为正数时(顺着取),是由左向右走;步幅为负数时(倒着取),是由右向左走

b = a[0:6:2]
print(b)
# ['锦', '无', '五']
# 步幅为2
b = a[0:-1:2]
print(b)
# ['锦', '无', '五']
b = a[6:1:-1]
print(b)
# ['弦', '十', '五', '端', '无']
# 步幅为-2
b = a[-1:1:-2]
print(b)
# ['弦', '五', '无']

  Python还是能从右数来形成切丝,例子:

二.靠成分找下标 (index)

  该办法能够幸免遍历列表来找成分下标。

       Python 列表 index()
方法用于从列表中搜索某些对象第一个相配项的目录地点,假如那几个指标不在列表中会报多少个可怜。

  index() 方英语法:

a.index(value, start, stop)

    value– 钦定检索的目的。
    start — 可选参数,初阶索引,默以为0。(可独立钦赐)
    stop — 可选参数,截止索引,暗中认可为元祖的长度。(可独自钦定)

a = ['一', '弦', '一', '柱', '思', '华', '年', '一', '弦', '一', '柱', '思', '华', '年']
b = a.index('一')
print(b)  # 0
b = a.index('一',1)
print(b)  # 2
b = a.index('弦',0,0)
print(b)
# b = a.index('弦',0,0)
# ValueError: '弦' is not in list
province = ['Beijin','Hebei','Shanghai','Henan']
print(province[-1])#从右数
print(province[-2:])#最后的值省略

其他

   列表的增加有二种方法,1种是最后追加,还有一种是某处插入。例子:

1.统计( count)

       count 方法总计有些成分在列表中冒出的次数

a = ['锦', '瑟', '无', '端', '五', '十', '弦', '弦', '弦']  # 定义一个列表
b = a.count('弦')  # 统计'弦'在列表a中出现的次数
print(b)  # 3
province = ['Beijin','Hebei','Shanghai','Henan']
province.append('Shannxi')#最后追加
province.insert(1,'Xinjiang')#某处插入

2.翻转(reverse)

       reverse 方法将列表中的成分反向存放。

       该格局只是对列表操作,无重回值(不会发出新的列表)

a = ['一', '弦', '一', '柱', '思', '华', '年']
a.reverse()
print(a)  # ['年', '华', '思', '柱', '一', '弦', '一']

  列表的退换11分粗略,例子:

 3.复制(copy())

因为列表的因素得以是可变和不可变数据类型,所以就关系到了深浅复制

a=['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']
b=a.copy()
print(b) # ['锦', '瑟', '无', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '华', '年']

 

province = ['Beijin','Hebei','Shanghai','Henan']
province[1] = 'Beijing'#改变某处

5,Dictionary(字典)—-可变数据类型

 字典是python中绝无仅有的投射类型,选拔键值对(key-value)的方式储存数据。

python对key实行哈希函数运算,依据计算的结果决定value的积存地点,所以字典是冬日存储的,且key必须是可哈希的。

可哈希代表key必须是不可变类型,如:数字、字符串、元组。

 

dic1={'name':'BarkingPig',(1,):[1,2,3],2:13}
dic2=dict((('name','BarkingPig'),((1,),[1,2,3]),(2,13)))

  列表的去除有无数艺术,del是Python中通用的删减方法,其余还有删除某些与删除某处参数的法子,例子:

增(‘=’,setdefault())

province = ['Beijin','Hebei','Shanghai','Henan']
del province[2]#删除某处
province.remove('Beijing')#删除某个
province.pop()#删除最后一个(默认),或括号中的位置

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川'}
dic[3] = '飞流直下三千尺'
print(dic)
#{1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'}

  其它,Python还为列表提供了过多效果。Python中能够轻便查询某些参数的地点和个数,例子:

二.增加查询键值对(setdefault())

Python 字典 setdefault() 方法和 get()
方法类似,重临钦定键的值,即使键不在字典中,将会加多键并将值设置为三个内定值,默认为None。

而 get() 不会增加键。

dic.setdefault(key[,default=None])

key — 字典中要探索的键。
default — 可选参数,尽管钦定键的值不存在时,再次回到该值,默认为 None

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川'}
dic.setdefault(3)
dic.setdefault(4,'疑是银河落九天')
print(dic)
#{1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: None, 4: '疑是银河落九天'}
province = ['Beijin','Hebei','Shanghai','Henan']
province.index('Shanghai')#寻找位置
province.count('Shanghai')#寻找个数

删(del,pop(),clear(),popitem()“)

  更改列表的逐条也不行简约,例子:

一.去除查询到的键值对or整个字典(del)

剔除全体字典

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
del dic
print(dic)
# NameError: name 'dic' is not defined

删除键对应键值对

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
del dic[1]
print(dic)
# {2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
province = ['Beijin','Hebei','Shanghai','Henan']
province.reverse()#反转序列
province.sort()#排序序列(符号,数字,大写,小写(ASCII))

二刨除指定键值对(pop())

pop() 方法删除给定键所对应的键/值对,并重回被删去的值。给定键假设不在字典中,则必须设置多少个default值,不然会报错,此时回到的就是default值。

dic.pop(key[,default])

    key: 要删除的键/值对所对应的键
    default:
可选参数,给定键不在字典中时必须安装,否者会报错(未有暗中认可值),此时回去default值。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
a=dic.pop(4,True)
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} 疑是银河落九天
a=dic.pop(5,True)
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} True

  Python中列表的复制与Matlab分歧,设计相对合理1些,可是有少数麻烦驾驭,学过C++中指针的能够相对轻便驾驭1些。普通的赋值操作,只是将列表的地址复制,一旦中间列表中的值爆发变动,两者中的值都会改换,例子:

3.置空(clear())

clear() 方法用于删除字典内享有因素(就是把字典置空,不删除字典)。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
dic.clear()
print(dic) # {}
province = ['Beijin','Hebei','Shanghai','Henan']
province_copy = province#复制地址,改变后一起变化
province.append('Xinjiang')
print(province)
print(province_copy)

4..去除“最终一对键值对”(popitem())“

popitem() 方法随机重回并删除字典中的一个键/值对(1般删除末尾对)。

缘何是自由删除呢?因为字典是冬季的,未有所谓的“最后1项”或是别的顺序。在办事时壹旦遇上须要各种删除项的办事,用popitem()方法效用极高。

设若字典已经为空,却调用了此方法,就报出KeyError分外。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
a=dic.popitem()
print(dic,a) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺'} (4, '疑是银河落九天')

 

  要想复制1个列表,有浅copy和深copy三种艺术。浅copy只复制列表的首先层,第二层将只复制地址。深copy则是截然在内部存款和储蓄器中成立贰个等同的区域。例子:

改(‘=’,update())

province = ['Beijin',['Hebei','Shijiazhuang'],'Shanghai','Henan']
province_copy = province.copy()#浅copy
import copy
province_copy = copy.copy(province)#浅copy
province_copy = list(province)#浅copy
province_copy = copy.deepcopy(province)#深copy

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川',3:'飞流直下三千尺',4:'疑是银河落九天'}
dic[1]='黄河之水天上来'
print(dic) #{1: '黄河之水天上来', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}

 

  Python中也提供了列表的联合方法,例子:

2.改,扩展(update())

update()
方法用于立异字典中的键/值对,能够修改存在的键对应的值,也足以增加新的键/值对到字典中

dic= {1: '日照香炉生紫烟', 'two':'遥看瀑布挂前川' }
dic.update(two='黄河之水天上来')  # 修改键对应的值,键为数字时不适用
print(dic) # {1: '日照香炉生紫烟', 'two': '黄河之水天上来'}
dic1={3:'飞流直下三千尺',4:'疑是银河落九天'}
dic.update(dic1)  # 扩展字典
print(dic) # {1: '日照香炉生紫烟', 'two': '黄河之水天上来', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
province = ['Beijin','Hebei','Shanghai','Henan']
province_new = ['Xinjiang','Dongbei']
province.extend(province_new)#并入后面

查(‘=’,get(),keys(),values(),items(),in/not in,sorted())

  列表的一点也不慢循环方法是用于下格式,[::x]切开中x为步距,例子如下:

1.‘=’

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
a=dic[1]
print(a) # 日照香炉生紫烟
province = ['Beijin','Hebei','Shanghai','Henan']
for i in province[::2]:#切片
    循环体

2.键找值(get())

get() ,再次来到钦赐键的值,借使键不在字典中,重返三个钦定值,默感到None。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
a=dic.get(1)
print(a) # 日照香炉生紫烟

  当列表中存款和储蓄的新闻不想被改成时,就足以用元组,元组的概念与列表大约1模同样,只是用‘()’取代了[]。元组无法修改,只好切成片。例子:

3.全部键列表(keys())

keys()
方法以列表格局(并非一向的列表,若要重临列表值还需调用list函数)再次回到字典中的全数的键。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.keys()) # dict_keys([1, 2, 3, 4]) #并非直接的列表
a=list(dic.keys()) 
print(a)  # [1, 2, 3, 4]
province = ('Beijin','Hebei','Shanghai','Henan')

4.拥有值列表(values())

values()
方法以列表情势(并非一贯的列表,若要再次来到列表值还需调用list函数)重临字典中的全数值。

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.values()) # dict_values(['日照香炉生紫烟', '遥看瀑布挂前川', '飞流直下三千尺', '疑是银河落九天']) #并非直接的列表
a=list(dic.values())
print(a)  # ['日照香炉生紫烟', '遥看瀑布挂前川', '飞流直下三千尺', '疑是银河落九天']

 

字符:

伍.全部键值对列表(items())

items()
方法以列表格局(并非一向的列表,若要重返列表值还需调用list函数)重回全部的键值对(壹对键值对组合的元组)

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(dic.items())  # dict_items([(1, '日照香炉生紫烟'), (2, '遥看瀑布挂前川'), (3, '飞流直下三千尺'), (4, '疑是银河落九天')]) # 并非直接的列表
a=list(dic.items())
print(a)  # [(1, '日照香炉生紫烟'), (2, '遥看瀑布挂前川'), (3, '飞流直下三千尺'), (4, '疑是银河落九天')]

  字符中对字母大小写变化的操作大多,能够有以下三种办法,例子:

陆.in/not in(是或不是存在)

in
操作符用于判定键(key)是或不是存在于字典(D)中,即便键在字典中回到True,不然再次回到False。

not in 则相反

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(1 in dic) # True
print(1 not in dic) # False
x = 'l love china'
x.capitalize()#首字母大写
x.upper()#全变大写
x.lower()#全变小写
x.title()#变为标题形式
x.swapcase()#大小写互换

7.全数键列表(sorted())

 再次来到一个静止的含有字典全部key的列表

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
print(sorted(dic)) # [1, 2, 3, 4]

  在Python中还足以轻巧的对字符实行改换,例子:

别的骚操作(dict.fromkeys(),copy() )

names = 'Xiaohong Xiaohuang'
names.replace('o','O',1)#旧字符,新字符,替换个数
tran = str.maketrans('aox','123')#设置替换密文
names.translate(tran)#替换加密
names.center(50,'-')#50个字符,将name居中,不的够用-填充
names.ljust(50,'*')#50个字符,将name居左,不的够用*填充
names.rjust(50,'*')#50个字符,将name居右,不的够用*填充
names.zfill(50)#50个字符,将name居右,不的够用0填充
names = '  Xiaohong'
names.lstrip()#去掉左边空格,然后回车
names = '  Xiaohong   '
names.strip()#去掉左右空格,然后回车
names = 'Xiaohong\tXiaohuang'#\t与下面结合,控制空格的数量
names.expandtabs(tabsize=30)#空格数

1.可迭代对象做键(dict.fromkeys())

fromkeys()
方法用于创设叁个新的字典,并以可迭代对象中的成分分别作为字典中的键,且有着键对应同二个值,默感到None。

dic.fromkeys(iterable[,value=None])

iterable–
用于创制新的字典的键的可迭代对象(字符串、列表、元祖、字典)。
value — 可选参数, 字典全数键对应同三个值的起来值,默感觉None

str = "12" # 字符串
dic = {1:'one',2:'two'} # 字典
a=dict.fromkeys(str,'字符串')
print(a) # {'1': '字符串', '2': '字符串'}
a=dict.fromkeys(dic,'字典')
print(a) # {1: '字典', 2: '字典'} #字典是还是用键做新键

  除却,还提供了询问功效,例子:

2.复制(copy())

dic.copy() 对字典 dic
举行浅复制,重返三个和dic有雷同键值对的新字典。(因为字典的值value能够是可变和不可变数据类型,所以就涉及到了深浅复制)

dic = {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
d=dic.copy()
print(d) # {1: '日照香炉生紫烟', 2: '遥看瀑布挂前川', 3: '飞流直下三千尺', 4: '疑是银河落九天'}
names = 'xiaohei'
names.find('i')#从左找某个字符第一次出现的位置
names.rfind('i')#从右找某个字符第一次出现的位置

叁.字典的嵌套(多级菜单)

亚洲必赢官网 13亚洲必赢官网 14

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车站': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

文山会江离单

  字符和列表之间还足以互相转变,例子:

六 集合(set)

汇合(set)是一个严节的,把不一致的成分(set
elements)组成联合变成汇集(不重复的数码整合),它的重点职能如下:

去重:  把1个列表形成集合,就机关去重了(不可重复)

提到测试:  测试两组数据在此以前的滥竽充数、差集、并集等关系

相会分类:可变集合、不可变集合

可变集合(set):可增加和删除成分,非可哈希的(可变数据类型),无法用作字典的键,也不可能做别的集合的要素

不可变集合(frozenset):不可增多,不可删除成分,可哈希的(不可变数据类型),能用作字典的键,也能做其它集合的要素

list=['一', '弦', '一', '柱', '思', '华', '年']
set=set(list)
print(set)  # {'弦', '华', '思', '柱', '年', '一'}   去重,无序
names = 'Xiaohong Xiaohuang Xiaozhang Xiaoli'
names.split()#按空格分成列表
names = 'Xiaohong
Xiaohuang
Xiaozhang
Xiaoli'
names.splitlines()#按回车分成列表
names = ['Xiaohong','Xiaohuang','Xiaozhang','Xiaoli']
'+'.join(names)#用+连接列表成字符

创办集合

汇聚的工厂方法set()和frozenset()创设

set1={'一', '弦', '一', '柱', '思', '华', '年'}
print(type(set1))  # <class 'set'>

set2=set('一弦一柱思华年')
print(type(set2))  # <class 'set'>

set3=frozenset('一弦一柱思华年')
print(type(set3)) # <class 'frozenset'>   不可添加,不可删除元素,可哈希的(不可变数据类型)

  Python还为字符提供了多数论断,那一个效应诸多以is初始,例子:

增(add,update)

.add()增加单个成分(能够再一次增加一样的值,不过没用,集合去重的)

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.add('诗............')
print(set1)  # {'柱', '诗............', '弦', '华', '思', '一', '年'}  #增加一个元素,可以重复添加相同的值,但是没用,集合去重的

.update()增多二个行列(七个要素)

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.update('弓弦')
print(set1)  # {'柱', '诗............', '弦', '华', '思', '弓', '一', '年'} #重复添加相同的值,但是没用,集合去重的
names = ('xiaohong hei')
names.endswith('hei')#判断以什么结尾
names.isalnum()#判断为阿拉伯数字
names.isalpha()#判断为纯英文
names.isdigit()#判断为整数
names.isidentifier()#判断为合法标识符(变量名)
names.islower()#判断为小写
names.istitle()#判断为标题形式

删(remove,discard,pop,del)

.remove()  删除元素,间接要刨除钦点成分就足以 ,但元素不设有时报错  

.discard()  删除成分,直接要去除钦命成分就能够 ,成分不存在时不报错 

.pop()   随机删除3个元素,因为集合是冬季的

del 删除集合本身

set1={'一', '弦', '一', '柱', '思', '华', '年'}
set1.remove('一')
print(set1)  # {'思', '年', '弦', '柱', '华'}
set1.discard('思')
print(set1)  # {'年', '弦', '柱', '华'}
del set1


set1.pop()
print(set1)  # {'弦', '柱', '华'}

字典:

是因为汇集本人是冬天的,所以无法为集聚成立索引或切块操作,只好循环遍历或选择in、not
in来访问或决断集合成分

set1={'一', '弦', '一', '柱', '思', '华', '年'}
if '一' in set1:
    print('在里面')
if '不存在的' not in set1:
    print('不存在的')
for s in set1:
    print(s)

#打印结果
# 在里面
# 不存在的
# 柱
# 弦
# 一
# 思
# 年
# 华

  字典也是常用的一种工具,字典是选用‘{}’定义的,字典中的数据是冬季的,字典可以与系列与字典嵌套。

 集合之间的涉及

  索引字典时行使KEY,例子:

聚集等价与不等价(==, !=);子集、超集;

亚洲必赢官网 15

 

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
s4={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
print(s1==s4)  # 集合等价(==)两个集合之间,所有元素完全相等。不等价(!=)两集合之间,存在不相等的元素
print(s3<s2)

s二是s3的子集('<‘表示的是真子集),s叁是s2的超集

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
print(info['2012020202'])

联合(并集)(|)

联合(union)操作和(|)与聚集其实等价的。

 亚洲必赢官网 16

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
print(s1|s2)  # {'托尼.斯塔克', '灭霸', '卡魔拉', '美国队长', '乌木喉', '星爵'}
print(s1.union(s2))  # {'托尼.斯塔克', '灭霸', '卡魔拉', '美国队长', '乌木喉', '星爵'}

  字典的增加和修改都以经过复制操作,程序会率先查询字典中是或不是有该KEY值,未有,则新建一条。有,则修改该条的值。例子:

交集(&)

错落符号的对等方法是intersection()。

亚洲必赢官网 17

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3=s1&s2
print(s3)  # {'卡魔拉'}
s3=s1.intersection(s2)
print(s3)  # {'卡魔拉'}
info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info['2012020201'] = '蛤蛤'#修改
info['2012020204'] = '拉拉'#增加

查集(补集,包涵:相等补集,相对补集)(-)

 等价方法是difference()

 亚洲必赢官网 18

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
s4=s2-s1
print(s4)
#{'美国队长', '星爵', '托尼.斯塔克'}
s5=s1-s2
print(s5)
#{'乌木喉', '灭霸'}
s6=s1.difference(s2)
print(s6)
# {'乌木喉', '灭霸'} 等价于 s1-s2
s7=s2.difference(s1)
print(s7)
# {'美国队长', '星爵', '托尼·斯塔克'} 等价于 s2-s1
s8=s2-s3
print(s8)
# {'星爵', '卡魔拉'}
s9=s3-s2
print(s9)
# set() 空集合
s10=s2.intersection(s3)
print(s10)
# {'美国队长', '托尼.斯塔克'}  intersection()函数不适用于绝对补集
s11=s3.difference(s2)
print(s11)
# set() 空集合

  字典的删除能够选用Python中通用的去除方法,或然字典中提供的不二等秘书技,例子:

对称差集(^)

(ab交接相对于ab并集的补集)获得的成分属于a,b但不相同时属于a和b.其等价方法symmetric_difference()

亚洲必赢官网 19

s1={'灭霸','卡魔拉','乌木喉'}  # 灭霸战队
s2={'美国队长','托尼.斯塔克','星爵','卡魔拉'}  # 复仇者联盟阵营
s3={'美国队长','托尼.斯塔克'}  # 妇联
print(s1^s1)  # set()
print(s1^s2)  # {'星爵', '灭霸', '托尼.斯塔克', '美国队长', '乌木喉'}
print(s2^s3)  # {'星爵', '卡魔拉'}
print(s1.symmetric_difference(s2))  # {'星爵', '灭霸', '托尼.斯塔克', '美国队长', '乌木喉'}  等价于s1^s2
info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
del info['2012020203']#删除
info.pop('2012020203')#删除
info.popitem()#随便删除一个,不常用

 


  查找是,能够用事先的格局来搜索,不过还有壹种安全的检索方法,例子:

 

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info.get('2012020202')

来来来,常用的数据类型大约就这一个,之后就商量它们背后那3个不可告人的…….

  决断有些KEY是或不是在字典中,例子:

变量,数据,内部存款和储蓄器3者的关联(不是三角恋哈)

a='黄河之水天上来,你说奇怪不奇怪'     # id(),是获取数据在内存上的储存地址
print(id('黄河之水天上来,你说奇怪不奇怪'))  # 34507248
print(id(a))  # 34507248

print(id(2*3))  # 1509649584     
print(id(6))    # # 1509649584

亚洲必赢官网 20

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
'2012020202' in info

 

  字典也能够统一,合并时,将会用新的字典中覆盖旧的字典,例子:

可变数据类型与不可变数据类型的爱恨情愁…不对是上辈子今生

a = ['托尼·斯塔克', '马克系列', '反浩克装甲', '血边战衣']
# 而不可变数据类型则是每一次引用内存地址都是不变的
# 可变数据类型的内存地址引用一次改改变一次
print(id(a))  # 32076360
print(id(['托尼·斯塔克', '马克系列', '反浩克装甲', '血边战衣']))  # 31274056

print(id(a[0]))  # 32006192
print(id('托尼·斯塔克'))  # 32006192

print(id(a[1]))  # 6719984
print(id('马克系列'))  # 6719984

print(id(a[2]))  # 31383040
print(id('反浩克装甲'))  # 31383040

print(id(a[3]))  # 31994216
print(id('血边战衣'))  # 31994216

或然多少迷糊是吧………….啥也不说了,直接上海教室(图里说)

 亚洲必赢官网 21

可变数据类型与不可变数据。每回引用可变数据类型时,其内部存款和储蓄器地址都会转移,当引用不可变数据是,其内部存款和储蓄器地址都以和率先次引用时同样的。

那几个意况的是Python的内部存款和储蓄器回收机制导致的。

可变数据类型每当引用可变数据类型数据后,**Python会立刻回收刚才引用可变数据类型数据分配出去内存,这样就招致下次再引用该可变数据类型数据又要重新分配内存空间给该多少。**

不可变数据类型先是次引用不可变数据类型数据是,**Python就会分配二个内部存款和储蓄器空间给该不可变数据类型数据,第三次引用之后的每贰遍引用都会找到这一个内部存款和储蓄器空间来取多少,**

        当这几个不可变数据类型数据不在被引述时,其内部存款和储蓄器空间才会被回收。

 

提起底问个难题,Python干嘛要分可变数据类型和不可变数据类型,没事干吃饱了撑的?

欢迎评论留言,西红柿,鸡蛋都砸过来吧。

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info_new = {
    '2012020202':'王凯',
    '2012020206':'彭浩',
    }
info.update(info_new)#合并更新

  Python也提供了新建1个字典的章程,不过存在非常的大的主题材料,所以壹般不会使用,例子:

info_new = dict.fromkeys([1,2,3],[1,{'name':'X',2}])#初始化字典
info_new[3][1][‘name’] = Y

  当修改Python新建的字典时,例子中只改了[3][1]中的‘name’为‘Y’不过足以窥见字典中的全体‘name’都成为了‘Y’。所以,符合规律情状下很难使用。

  字典能够转为列表,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
info.items()

  多级字典的操作与单级字典差别非常小,修改略有不一致。例子:

province = {
    '华北':{
        '北京':['直辖市','很大'],
        '河北':['石家庄','漂亮'],
        },
    '东北':{
        '黑龙江':['哈尔滨','很棒'],
        '辽宁':['沈阳','厉害'],
        },
    }
province['华北']['北京'][1] = '首都'#修改
province.setdefault('西北',{'陕西':['西安','省会']})#取西北如果有,返回,没有新建

  字典的循环格式与列表类似,格式如下,例子:

info = {
    '2012020201':'随便',
    '2012020202':'呵呵',
    '2012020203':'不知'
    }
for i in info:#高效循环
    print(i,info[i])
    循环体

作业

编辑3个购物车程序,须要将商品新闻存在文件里。张开程序后供给用户登入,用户输入要求贯彻,已购商品,余额记录,运转程序,输入薪俸,遵照编号,购买商品,质量评定余额,够用扣款,不够提示,随时退出,打字与印刷已经购买出卖的物品和余额。商家入口须求贯彻,增多商品,修改价格。

流程图:

亚洲必赢官网 22

主程序:

#购物车程序
'''
商品信息存在文件里
1.打印商品列表
用户入口
已购商品,余额记录
启动程序,输入工资
根据编号,购买商品
检测余额,够用扣款,不够提醒
随时退出,打印已经购买的商品和余额
商家入口
添加商品,修改价格
'''
import getpass

title = '''
---------------------------
-     欢迎光临本超市      -
---------------------------
'''
print(title)

#读取商品数据
goods = open('商品.txt')
read_flag = True
goods_list = []
while read_flag:#按行处理
    goods_line = goods.readline()
    if goods_line == '':
        read_flag = False
    else:
        goods_list.append(goods_line.split())
goods.close()

#读取用户信息
info = open('用户信息.txt')
read_flag = True
info_user = []
while read_flag:
    info_line = info.readline()
    if info_line == '':
        read_flag = False
    else:
        info_user.append(info_line.split())
info.close()

#用户登陆
success_flag = False
for count in range(0,6):
    account = input('请输入用户名:')
    password = getpass.getpass('请输入密码:')
    for i in range(0,len(info_user)):
        if account == info_user[i][0] and password == info_user[i][1]:
            success_flag = True
            user_number = i
            break
    if success_flag:
        print('尊敬的%s登陆成功!'%info_user[user_number][2])
        break
    else:
        print('用户名或密码错误!')
else:
    print('输入密码次数超过6次,请重新开启软件尝试!')
    exit()

#进入入口
info_write = []
if info_user[user_number][3] == '0':
    #普通用户
    if info_user[user_number][4] == '0':
        #初次登陆
        balance = input('您是第一次登陆,请输入充值金额:')
        if balance.isdigit():
            balance = int(balance)
            info_user[user_number][4] = '1'
            info_user[user_number][5] = str(balance)
        else:
            print('充值错误,退出系统!')
            exit()
    #非初次登陆
    for i in range(0,len(goods_list)):
        goods = '{number}.物品名:{name} 价格:{price}'.format(number = i + 1,
                                                               name = goods_list[i][0],
                                                               price = goods_list[i][1])
        print(goods)
    print('%s.充值'%(len(goods_list)+1))
    buy_list = []
    balance = int(info_user[user_number][5])
    while True:
        buy_number = input('请输入你所需要的商品序号[按q退出购买]:')
        if buy_number == 'q':
            buy_list = ' '.join(buy_list)
            print('本次购物购买了:{list}'.format(list = buy_list))
            #更新信息
            info_user[user_number][5] = str(balance)
            info = open('用户信息.txt','w')
            for i in range(0,len(info_user)):
                info.write(' '.join(info_user[i])+'\n')
            info.close()
            exit()
        elif buy_number.isdigit():
            buy_number = int(buy_number)-1
            if buy_number > len(goods_list) or buy_number < 0:
                print('请输入正确的商品码!')
            elif buy_number == len(goods_list):
                money = input('请输入充值金额:')
                if money.isdigit():
                    balance += int(money)
                    info_user[user_number][5] = str(balance)
                else:
                    print('充值金额错误')
            else:
                if balance < int(goods_list[buy_number][1]):
                    print('你的余额不够购买这件商品!')
                else:
                    balance = balance - int(goods_list[buy_number][1])
                    buy_list.append(goods_list[buy_number][0])
                    print('购买成功!还剩%s圆'%balance)#
        else:
            print('输入错误')
elif info_user[user_number][3] == '1':
    #商家用户
    for i in range(0,len(goods_list)):
        goods = '{number}.物品名:{name} 价格:{price}'.format(number = i + 1,
                                                               name = goods_list[i][0],
                                                               price = goods_list[i][1])
        print(goods)
    print('%s.添加物品'%(len(goods_list)+1))
    add_list = []
    while True:
        buy_number = input('请输入你需要修改商品价格的序号[按q退出购买]:')
        if buy_number == 'q':
            add_list = ' '.join(add_list)
            print('本次共添加了:{list}'.format(list = add_list))
            #更新信息
            info = open('商品.txt','w')
            for i in range(0,len(goods_list)):
                info.write(' '.join(goods_list[i])+'\n')
            info.close()
            exit()
        elif buy_number.isdigit():
            buy_number = int(buy_number)-1
            if buy_number > len(goods_list) or buy_number < 0:
                print('请输入正确的商品码!')
            elif buy_number == len(goods_list):
                goods_name = input('请输入商品名称:')
                goods_price = input('请输入商品价格:')
                if goods_price.isdigit():
                    add_list.append(goods_name)
                    goods_list.append([goods_name,goods_price])
                else:
                    print('商品价格信息错误!')
            else:
                goods_price = input('请输入商品价格:')
                if goods_price.isdigit():
                    goods_list[buy_number][1] = goods_price
                else:
                    print('商品价格信息错误!')
        else:
            print('输入错误')
else:
    print('用户数据错误!请管理员维护!!')

音讯记录文件:

商品.txt

手机 1000
电脑 8000
耳机 500
泡面 3
娃娃 10000

用户音信.txt

customer 123456 凯凯王 0 0 0
business 123456 卖力头 1 0 0

 

网站地图xml地图