引言

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

引言

本周启幕认知了库,并学习了Python中各类类型的变量和常用操作。并做到了较为周详的用户与商家购物分界面设计。

正文

模块:

Python有标准库和第3方库。第2方库须要安装本领动用。多量的库能够帮助大家更易于的实现复杂的操作。一般景色下,标准库被保留在了‘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的:后的数字是切块地方的后一个人。所以,在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')#某处插入

列表的修改1二分简便,例子:

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)

要想复制二个列表,有浅copy和深copy三种格局。浅copy只复制列表的第一层,第1层将只复制地址。深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()#判断为标题形式

字典

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

索引字典时选取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()#随便删除一个,不常用

找寻是,能够用事先的情势来寻找,不过还有1种安全的物色方法,例子:

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个字典的办法,不过存在非常的大的主题材料,所以一般不会使用,例子:

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个购物车程序,供给将商品音信存在文件里。展开程序后供给用户登录,用户输入要求贯彻,已购商品,余额记录,运转程序,输入工资,根据编号,购买商品,检验余额,够用扣款,不够提示,随时退出,打字与印刷已经买卖的商品和余额。商家入口要求贯彻,增加商品,修改价格。

流程图:

金沙注册送58 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中给变量赋值便是宣称,开头化变量(也正是开创1个相应数据类型的靶子,而那个数据类型正是类),变量的品种是在于其积存的数据。(下边代码中的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()转一下;可是足以和数字相乘,用于表示多个字符串复制;字符串不可能和浮点数直接结合,字符串能够和字符串直接相加;

二、输入函数用input(),暗中认可是字符串 总计字符串长度用len()

3、注释用#

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

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

陆、决断变量类型,type(变量)

本周开班认知了库,并学习了Python中各连串型的变量和常用操作。并成功了比较完美的用户与信用合作社购物分界面设计。

数据类型

Python3 中常用的数据类型:

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

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

可变数据类型是指一个ID地址中储存的数额是能够改换的。

不可变数据类型是指一个ID地址中积攒的数量无法转移。

其次有个别 调整流

1、not 非 and 与 or 或

二、range(初叶,截止,步长)  注意:循环不包涵‘结束’ 

③、import 函数 导入函数 from import是另一种导入形式,例如 from random
import * 可以在运用random函数时毫不加random.前缀

4、sys.exit()提前结束程序,需求import sys

正文

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

其叁有的 函数

1、def 函数名(入参):

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

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

四、分外管理 try 和except

常用的老大类型

金沙注册送58 2金沙注册送58 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长整型(表示相比长的整数(很大O科雷傲极小)),三.x的版本中就只有int整型

整型类型能发挥的数值仅仅与您的机械协理的(虚拟)内存大小有关,换句话说,Python能自在表明非常大的平头。

 

 金沙注册送58 4

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

第伍有的 列表

一、负数下标

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

二、利用切丝获得子列表

  spam[1:4]代表收获spam[1]到spam[3]的区间值作为2个新的切块,能够选择轻易方法

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

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

3、列表的长短

  使用len(spam)

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

5、列表的一连和复制

  使用+能够接连四个延续为三个列表

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

陆、列表元素的删减

  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贰、可变对象和不可变对目标

  可变即内部存款和储蓄器空间可变,不可变即内部存款和储蓄器空间不可变。可变的靶子的变量在传递时,传递的是引用地址(能够知晓为指针),所以拷贝的时候不是确实拷贝内部存款和储蓄器空间,仅仅是多了个变量指向一样的内部存款和储蓄器空间而已。对新的变量进行增加和删除都会潜移默化到原有变量,即浅拷贝。不可变对象,拷贝或透过新变量传递时,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方库须求安装技巧应用。大批量的库能够支持大家更易于的做到复杂的操作。一般景色下,标准库被保留在了‘lib/’目录下,第二方库被保存在了‘lib/site-packages’目录下。导入三个库卓殊简单,例子:

2.float(浮点数)

咱俩目前的把浮点数精通为带小数点的小数(作者还会开单章来讲说浮点数)

浮点数小说链接

第伍片段 元组

一、元组使用()进行区分,以逗号’,’作为最终3个达成,不然只有贰个要素时有希望会不被以为是元组类型

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

三、列表和元组的分别

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

import os

三.bool(布尔类型)

把 True 和 False 定义成关键字了,但它们的值仍然 一 和
0,它们得以和数字相加

 金沙注册送58 5

注意:

  • 1、Python能够而且为多少个变量赋值,如a, b = 1, 贰。
  • 2、三个变量能够透过赋值指向不相同档案的次序的对象。
  • 三、数值的除法 / 总是回到3个浮点数,要赢得整数使用 // 操作符( //
    是以舍去小数部分来取整的)。
  • 四、在混合总结时,Python会把整型转换来为浮点数。

Python还支持complex(复数),复数由实数部分和虚数部分组成,能够用a +
bj,大概complex(a,b)表示, 复数的实部a和虚部b都以浮点型。

第伍有的 字典和结构化数据

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

二、字典与列表

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

三、字典的检索和增加

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

  检查该键是还是不是存在于字典中,也可选取get()方法,其有七个参数,第叁个是取得其键的值,第一个是只要查找键战败,重回的私下认可值

肆、字典方法

  keys()方法——收取字典键

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

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

金沙注册送58 6金沙注册送58 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)) 

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

金沙注册送58 8金沙注册送58 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)

井字游戏

 柒、字典作为壹种数据类型,可以字典有嵌套字典

  每一种模块都有多数操作,一般景观是用模块名.操作名完毕有个别操作,例子:

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

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

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

 金沙注册送58 10

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

金沙注册送58 11

金沙注册送58 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 未有独自的字符类型,3个字符正是长度为一的字符串。

与 C 字符串分裂的是,Python
字符串不可能被改造。向2个索引地点赋值,譬喻word[0] = ‘m’会导致错误。

第捌有的 字符串操作

1、字符串字面量

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

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

  原始字符串r‘abc’:原始字符串职责‘’中的全体字符都以字符串的1有的,比如‘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””” 都能够起到注释代码的效果

  字符串下标切成片:字符串能够像列表同样接纳下标切丝抽取一些字符串,可是并未改观原来的字符串,只是新建了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():

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

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

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

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

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

 

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

3,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,) # 一个元素,需要在元素后添加逗号

作用:

一 对于一些数码大家不想被修改,能够行使元组;

二其余,元组的含义还在于,元组能够在炫目(和聚焦的成员)中当作键使用——而列表则不行;元组作为广大内建函数和格局的重回值存在。

变量类型:

4, 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中设有分化,它们得以相互转换,例子:

三.追加2个队列里的八个要素( extend)

         extend 方法可以在列表的结尾1回性追加另3个行列(可迭代对象,如
列表,字典,元组,字符串)中的多个值。

    extend
方法修改了被扩展的列表,而本来的连年操作(+)则否则,它会回去3个斩新的列表。

#列表
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剔除列表中钦命下标成分,暗许删除最终1个要素,并且重临该因素的值,借使列表为空或然索引值超过范围会报四个极度。

# 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] #还可以倒着取
 '十

 

 切成片—取八个要素(获得的是3个新的列表)

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() 方土耳其共和国(Türkiye Cumhuriyeti)语法:

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

  列表的修改十二分不难易行,例子:

 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中得以轻巧查询某些参数的地点和个数,例子:

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

Python 字典 setdefault() 方法和 get()
方法类似,重临钦赐键的值,尽管键不在字典中,将会加多键并将值设置为3个钦赐值,默感到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()“)

  更换列表的相继也十三分简便,例子:

1.删减查询到的键值对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分化,设计相对合理一些,不过有某个麻烦驾驭,学过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)

四..去除“最终1对键值对”(popitem())“

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

缘何是专擅删除呢?因为字典是严节的,未有所谓的“最后1项”或是此外顺序。在干活时倘若蒙受须求各样删除项的办事,用popitem()方法功用非常高。

一旦字典已经为空,却调用了此措施,就报出KeyError非凡。

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

 

  要想复制三个列表,有浅copy和深copy两种格局。浅copy只复制列表的第一层,第贰层将只复制地址。深copy则是一点壹滴在内部存款和储蓄器中创立2个均等的区域。例子:

改(‘=’,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中也提供了列表的集合方法,例子:

金沙注册送58 ,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()#大小写互换

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)#空格数

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

fromkeys()
方法用于创建三个新的字典,并以可迭代对象中的成分分别作为字典中的键,且具备键对应同二个值,默感觉None。

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

iterable–
用于创立新的字典的键的可迭代对象(字符串、列表、元祖、字典)。
value — 可选参数, 字典全数键对应同3个值的始发值,私下认可为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')#从右找某个字符第一次出现的位置

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

金沙注册送58 13金沙注册送58 14

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

延续串菜单

  字符和列表之间还足以并行调换,例子:

六 集合(set)

聚拢(set)是多个冬季的,把分化的成分(set
elements)组成联合产生汇聚(不另行的数额整合),它的要害效能如下:

去重:  把3个列表变成集结,就机关去重了(不可重复)

涉及测试:  测试两组数据此前的插花、差集、并集等涉及

集聚分类:可变集结、不可变集结

可变集结(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()加多1个行列(四个要素)

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,例子:

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

金沙注册送58 15

 

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

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

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

联合(并集)(|)

一齐(union)操作和(|)与聚焦其实等价的。

 金沙注册送58 16

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

  字典的充实和改变都以因此复制操作,程序会首先查询字典中是否有该KEY值,未有,则新建一条。有,则修改该条的值。例子:

交集(&)

错落符号的卓殊方法是intersection()。

金沙注册送58 17

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

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

 等价方法是difference()

 金沙注册送58 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()

金沙注册送58 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()#随便删除一个,不常用

 


  查找是,能够用事先的措施来搜寻,可是还有1种安全的追寻方法,例子:

 

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

金沙注册送58 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

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

 金沙注册送58 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])
    循环体

作业

编纂叁个购物车程序,须要将商品消息存在文件里。展开程序后供给用户登录,用户输入需求贯彻,已购商品,余额记录,运转程序,输入报酬,遵照编号,购买商品,检测余额,够用扣款,不够提醒,随时退出,打字与印刷已经购置的货物和余额。厂家入口须要贯彻,增加商品,修改价格。

流程图:

金沙注册送58 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地图