数据类型,变量类型

引言

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

引言

本周开班认知了库,并就学了Python中各体系型的变量和常用操作。并实现了相比周全的用户与厂家购物分界面设计。

正文

模块:

Python有标准库和第二方库。第二方库须求设置才具动用。大批量的库能够协理大家更易于的成就复杂的操作。一般景观下,标准库被保留在了‘lib/’目录下,第一方库被封存在了‘lib/site-packages’目录下。导入四个库分外简单,例子:

import os

每一种模块都有成都百货上千操作,一般情形是用模块名.操作名达成有个别操作,例子:

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

变量类型:

整型(int),Python 三.X中整型唯有int型,而在Python
贰.X中整型分为int,和long,变量的门类不需定义,与Matlab中就像,但品种不可轻巧变动。查看变量类型,例子:

x = 3
type(x)

别的品类与C++中就像是,所以不再赘言。

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

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

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

在经常行使Python中,字典与列表是最常使用的变量。上边将详细介绍字典与列表的选拔办法。

列表:

列表的定义,例子:

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

列表的切成块与Matlab有相似之处,但持有光辉不一样,Python的:后的数字是切块地点的后1人。所以,在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种是最后追加,还有1种是某处插入。例子:

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

列表的修改12分轻松易行,例子:

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++中指针的能够相对轻易明白一些。普通的赋值操作,只是将列表的地址复制,一旦中间列表中的值产生改动,两者中的值都会转移,例子:

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

要想复制1个列表,有浅copy和深copy三种形式。浅copy只复制列表的首先层,第1层将只复制地址。深copy则是全然在内部存款和储蓄器中创制一个一致的区域。例子:

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()#判断为标题形式

字典

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

索引字典时选取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也提供了新建3个字典的秘籍,但是存在相当的大的难题,所以一般不会使用,例子:

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()

1种类字典的操作与单级字典差距十分的小,修改略有区别。例子:

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中各连串型的变量和常用操作。并成功了较为完善的用户与百货店购…

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'> 集合

 

首先片段 基本语法

1、字符串不可能直接和数字相加,要用str()转一下;不过足以和数字相乘,用于表示七个字符串复制;字符串不可能和浮点数直接结合,字符串能够和字符串直接相加;

2、输入函数用input(),暗许是字符串 计算字符串长度用len()

3、注释用#

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

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

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

本周早先认知了库,并就学了Python中各体系型的变量和常用操作。并完结了相比全面包车型客车用户与公司购物界面设计。

数据类型

Python三 中常用的数据类型:

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

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

可变数据类型是指2个ID地址中贮存的数目是能够退换的。

不可变数据类型是指一个ID地址中贮存的多少不可能更改。

第一有的 调控流

1、not 非 and 与 or 或

二、range(初步,甘休,步长)  注意:循环不包罗‘甘休’ 

叁、import 函数 导入函数 from import是另1种导入方式,比方 from random
import * 能够在选用random函数时绝不加random.前缀

四、sys.exit()提前结束程序,必要import sys

正文

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

其三部分 函数

1、def 函数名(入参):

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

叁、要想在函数中期维修改全局变量,须求在全局变量前增加global关键字

四、相当管理 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长整型(表示比较长的整数(一点都不小OHighlander非常的小)),三.x的本子中就只有int整型

整型类型能发挥的数值仅仅与你的机器援助的(虚拟)内部存款和储蓄器大小有关,换句话说,Python能自在表达十分大的整数。

数据类型,变量类型。 

 美高梅开户网址 4

(嘿嘿,本人去总结对不对)

第6有的 列表

一、负数下标

平头-1下标指的是列表的末段三个下标,-二指的是列表的尾数第一个下标

二、利用切成块取得子列表

  spam[1:4]代表收获spam[1]到spam[3]的区间值作为贰个新的切成块,能够动用简单方法

  spam[:4]意味着收获spam[0]到spam[3]的区间值作为二个新的切成丝,省略的值获得是0

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

三、列表的长短

  使用len(spam)

四、列表能够向数组那样举办赋值

五、列表的连天和复制

  使用+能够接连不断八个连续为叁个列表

美高梅开户网址,  使用[‘a’,’b’,’c’]*n能够复制n个列表为1个列表

陆、列表成分的删减

  del spam[3]

7、列表的判别

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,不能对既有数字又有字符串的列表进行排序,因为不知道按照那个原则进行排序

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

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

  可变即内部存储器空间可变,不可变即内部存款和储蓄器空间不可变。可变的目的的变量在传递时,传递的是引用地址(能够知晓为指针),所以拷贝的时候不是当真拷贝内部存储器空间,仅仅是多了个变量指向一样的内部存款和储蓄器空间而已。对新的变量实行增加和删除都会潜移默化到原始变量,即浅拷贝。不可变对象,拷贝或通过新变量传递时,一旦发生修改,会新生成2个跟原来对象属于不一致内部存款和储蓄器空间的新对象值。元组(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有标准库和第一方库。第壹方库须要设置才具选拔。多量的库能够扶持大家更易于的完结复杂的操作。一般意况下,规范库被封存在了‘lib/’目录下,第三方库被保留在了‘lib/site-packages’目录下。导入多少个库卓殊轻易,例子:

2.float(浮点数)

大家临时的把浮点数精晓为带小数点的小数(笔者还会开单章来讲说浮点数)

浮点数随笔链接

第陆部分 元组

1、元组使用()进行区分,以逗号’,’作为最后叁个截止,不然唯有三个成分时有非常的大可能率会不被以为是元组类型

二、列表和元组之间的类别调换 使用list() tuple()进行类型转变

3、列表和元组的差别

  列表是足以修改的,他们能够增多值、删除值和改换值。元组是不得以修改的,他们一贯不可能退换。而且元组使用的是括号,而列表使用的方括号。

import os

三.bool(布尔类型)

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

 美高梅开户网址 5

注意:

  • 壹、Python能够同时为多个变量赋值,如a, b = 一, 2。
  • 二、多少个变量能够透过赋值指向不一样等级次序的对象。
  • 三、数值的除法 / 总是回到2个浮点数,要拿走整数使用 // 操作符( //
    是以舍去小数部分来取整的)。
  • 四、在混合总计时,Python会把整型调换到为浮点数。

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

第四某个 字典和结构化数据

壹、字典是许多值的组成,但不像列表的下标,字典的目录能够选用过多分裂的数据类型,不只是整数。字典的目录被称之为“键”,键及其关联的值称为“键-值”对,字典使用花括号{}包裹。

2、字典与列表

  字典也能够动用数字作为键;不像列表,字典中的表项时不排序的。一样的三个列表其顺序也务必是千篇1律的,而字典则未必;因为字典是不排序的,所以不能够张开列表这样的切丝操作。

3、字典的查找和增进

  查找键值是或不是位于字典中,然而使用in操作,字典键值对的丰盛只是使用普通的赋值操作进行。

  检查该键是还是不是留存于字典中,也可利用get()方法,其有八个参数,第一个是获得其键的值,第二个是只要查找键战败,再次来到的私下认可值

四、字典方法

  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)

井字游戏

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

  各个模块都有无数操作,一般情状是用模块名.操作名完成某个操作,例子:

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

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

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

 美高梅开户网址 10

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

美高梅开户网址 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 未有单身的字符类型,二个字符正是长度为一的字符串。

与 C 字符串差异的是,Python
字符串不可能被转移。向2个目录地点赋值,比方word[0] = ‘m’会形成错误。

第拾片段 字符串操作

一、字符串字面量

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

  转移字符‘\’:转移字符能够讲单引号转为一般字符,从而得防止止引起语义错误;

  原始字符串r‘abc’:原始字符串职分‘’中的全体字符都以字符串的一片段,比方‘that
is carol\’s cat
’中的转移字符‘\’也被感觉是字符串的1某个据此打字与印刷为 that is
carol\’s cat 

  三重引号”’:使用print打字与印刷多行字符串时,可以接纳三重分号将字符串打印出来,举例

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

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

  多行注释:代码中使用 ”’Python”’ 和 “””Python””” 都能够起到注释代码的效用

  字符串下标切成片:字符串可以像列表同样选拔下标切条抽取一些字符串,但是并从未改造原来的字符串,只是新建了二个字符串,比如

 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推断叁个字符串是还是不是在另四个字符串中存在,再次回到值为布尔型。

二、字符串方法

  字符串方法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():

  删除两边,右侧和左手的空白字符,第2个参数启用时钦点须要删除的钦定字符串

  字符串拷贝粘贴方法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,) # 一个元素,需要在元素后添加逗号

作用:

1 对于部分数量我们不想被修改,能够接纳元组;

二其它,元组的含义还在于,元组能够在炫丽(和集结的分子)中当作键使用——而列表则丰硕;元组作为广大内建函数和章程的再次来到值存在。

变量类型:

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

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

通过列表可以对数据实现最有益的储存、修改等操作

  整型(int),Python 三.X中整型唯有int型,而在Python
二.X中整型分为int,和long,变量的品种不需定义,与Matlab中就像,但品种不可随意退换。查看变量类型,例子:

概念列表

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

 同1个列表中,成分得以是差别的(成分得以为随便档期的顺序)

经过下标访问列表中的成分,下标从0发轫计数

 

x = 3
type(x)

 增(append,insert, extend

 

  其余类型与C++中类似,所以不再赘述。

一.insert 方式用于将目的插入到列表中

 

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

 

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

二.append方法则用来在列表末尾追加新的对象

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

  比特型(bytes),Python 贰.X中比特型与字符型未有不相同,而在Python
三.X中设有区别,它们得以并行调换,例子:

3.追加三个系列里的多少个因素( extend)

         extend 方法能够在列表的末段2回性追加另贰个种类(可迭代对象,如
列表,字典,元组,字符串)中的四个值。

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

#列表
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    # 删除整个列表

  列表的概念,例子:

三.pop刨除列表中钦定下标元素,暗许删除最后叁个成分,并且重临该因素的值,要是列表为空可能索引值超越范围会报二个格外。

# 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的:后的数字是切成丝地方的后一个人。所以,在Python中[1:2]=[1],例子:

查(切片,index)

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

一.切开操作(列表的切成条,字符串,元组的切成块操作都以平等的)

切开—取2个因素

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

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

 

 切成片—取多少个成分(得到的是1个新的列表)

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() 方立陶宛(Lithuania)语法:

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)  # ['年', '华', '思', '柱', '一', '弦', '一']

  列表的修改1二分轻易易行,例子:

 3.复制(copy())

因为列表的成分得以是可变和不可变数据类型,所以就涉嫌到了深浅复制

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

 

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

伍,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中能够轻易查询有些参数的任务和个数,例子:

2.增添查询键值对(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() 方法删除给定键所对应的键/值对,并回到被去除的值。给定键即使不在字典中,则必须设置1个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不相同,设计相对合理一些,可是有少数麻烦知晓,学过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)

肆..剔除“最后一对键值对”(popitem())“

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

为啥是随意删除呢?因为字典是九冬的,未有所谓的“最终一项”或是其余顺序。在职业时如若蒙受供给各样删除项的办事,用popitem()方法作用极高。

假设字典已经为空,却调用了此措施,就报出KeyError至极。

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

 

  要想复制三个列表,有浅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) # 日照香炉生紫烟

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

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)  # ['日照香炉生紫烟', '遥看瀑布挂前川', '飞流直下三千尺', '疑是银河落九天']

 

字符:

5.全体键值对列表(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()#大小写互换

七.全数键列表(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
实行浅复制,再次来到3个和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)组成联合产生集聚(不重复的数码整合),它的主要性职能如下:

去重:  把一个列表产生集结,就自行去重了(不可重复)

事关测试:  测试两组数据从前的插花、差集、并集等关乎

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

可变集结(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()   随机删除三个因素,因为集合是冬季的

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的子集('<‘表示的是真子集),s3是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是不是在字典中,例子:

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

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

 

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

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

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也提供了新建一个字典的措施,可是存在相当的大的标题,所以一般不会使用,例子:

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])
    循环体

作业

编排五个购物车程序,须求将商品音讯存在文件里。展开程序后供给用户登入,用户输入必要贯彻,已购商品,余额记录,运维程序,输入薪金,依据编号,购买商品,检查实验余额,够用扣款,不够提示,随时退出,打字与印刷已经买卖的货物和余额。厂家入口必要贯彻,增添商品,修改价格。

流程图:

美高梅开户网址 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地图