【4858.com】让繁琐工作自动化学习笔记,数据类型

By admin in 4858.com on 2019年4月5日

引言

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

引言

本周上马认识了库,并就学了Python中各类类型的变量和常用操作。并形成了相比完美的用户与专营商购物界面设计。

正文

模块:

Python有标准库和第壹方库。第二方库供给设置才能使用。大批量的库能够扶助大家更易于的实现复杂的操作。一般景观下,标准库被保留在了‘lib/’目录下,第3方库被封存在了‘lib/site-packages’目录下。导入三个库极度简单,例子:

import os

每一个模块都有无数操作,1般情状是用模块名.操作名实现某个操作,例子:

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

变量类型:

整型(int),Python 叁.X中整型只有int型,而在Python
二.X中整型分为int,和long,变量的花色不需定义,与Matlab中近乎,但项目不可随意变更。查看变量类型,例子:

x = 3
type(x)

任何种类与C++中近乎,所以不再赘述。

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

比特型(bytes),Python 2.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')#某处插入

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

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

列表的删除有过多艺术,del是Python中通用的去除方法,其它还有删除有个别与删除某处参数的法子,例子:

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

除此以外,Python还为列表提供了广大功力。Python中得以轻松查询有个别参数的岗位和个数,例子:

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

变动列表的次第也很是大致,例子:

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

Python中列表的复制与Matlab不相同,设计相对合理一些,但是有有个别麻烦知晓,学过C++中指针的可以相对简单理解一些。普通的赋值操作,只是将列表的地方复制,一旦中间列表中的值产生变动,两者中的值都会转移,例子:

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

要想复制1个列表,有浅copy和深copy二种方法。浅copy只复制列表的第三层,第二层将只复制地址。深copy则是一心在内部存储器中确立一个如出1辙的区域。例子:

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

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

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

列表的短平快循环方法是用来下格式,[::x]切开中x为步距,例子如下:

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

当列表中蕴藏的音信不想被转移时,就足以用元组,元组的定义与列表大约等同,只是用‘()’代替了[]。元组无法改改,只好切片。例子:

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

字符:

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

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

在Python中还足以轻松的对字符进行改动,例子:

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

除了那么些之外,还提供了查询成效,例子:

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

字符和列表之间仍是可以够相互转换,例子:

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

Python还为字符提供了众多论断,这么些效应大多以is起头,例子:

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

字典

字典也是常用的1种工具,字典是使用‘{}’定义的,字典中的数据是冬天的,字典能够与种类与字典嵌套。

索引字典时利用KEY,例子:

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

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

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

字典的删除能够行使Python中通用的去除方法,大概字典中提供的法子,例子:

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

检索是,能够用事先的主意来寻找,不过还有1种安全的搜寻方法,例子:

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

判定某些KEY是不是在字典中,例子:

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

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

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

作业

编写二个购物行车路程序,须求将商品新闻存在文件里。打开程序后要求用户登陆,用户输入需求实现,已购商品,余额记录,运转程序,输入薪酬,依照编号,购买商品,检验余额,够用扣款,不够提醒,随时退出,打字与印刷已经购买销售的货色和余额。专营商入口须求贯彻,添加商品,修改价格。

流程图:

4858.com 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'> 集合

 

先是有的 基本语法

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

2、输入函数用input(),暗中同意是字符串 总括字符串长度用len()

3、注释用#

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

4858.com,5、**是求指数值 //是整除 /是除法

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

本周启幕认识了库,并就学了Python中各种类型的变量和常用操作。并成功了较为完善的用户与商行购物界面设计。

数据类型

Python三 中常用的数据类型:

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

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

可变数据类型是指3个ID地址中存款和储蓄的数目是足以变动的。

不可变数据类型是指一个ID地址中储存的数量不得以转移。

第贰有的 控制流

1、not 非 and 与 or 或

②、range(初叶,甘休,步长)  注意:循环不包蕴‘截止’ 

3、import 函数 导入函数 from import是另1种导入格局,举例 from random
import * 能够在动用random函数时不要加random.前缀

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

正文

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

其叁部分 函数

1、def 函数名(入参):

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

三、要想在函数中期维修改全局变量,供给在全局变量前增进global关键字

四、至极处理 try 和except

常用的十二分类型

4858.com 24858.com 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类型正是整数

【4858.com】让繁琐工作自动化学习笔记,数据类型。Python的贰.x的本子中还留存Long长整型(表示比较长的整数(相比大O奥德赛比较小)),叁.x的版本中就唯有int整型

整型类型能表明的数值仅仅与你的机器帮助的(虚拟)内部存款和储蓄器大小有关,换句话说,Python能轻轻松松表明相当大的平头。

 

 4858.com 4

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

第5部分 列表

一、负数下标

平头-一下标指的是列表的尾声贰个下标,-贰指的是列表的尾数第一个下标

二、利用切片取得子列表

  spam[1:4]意味着收获spam[1]到spam[3]的区间值作为2个新的切片,能够使用简易方法

  spam[:4]表示收获spam[0]到spam[3]的区间值作为3个新的切片,省略的值取得是0

  spam[1:]表示收获spam[1]到spam最后三个要素的区间值作为3个新的切片,省略的值取得是列表的长度

3、列表的长度

  使用len(spam)

四、列表可以向数组那样进行赋值

5、列表的总是和复制

  使用+能够三番五次七个接二连三为二个列表

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

陆、列表成分的删除

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

  可变即内部存款和储蓄器空间可变,不可变即内部存款和储蓄器空间不可变。可变的靶子的变量在传递时,传递的是援引地址(能够知晓为指针),所以拷贝的时候不是真的拷贝内部存款和储蓄器空间,仅仅是多了个变量指向相同的内部存款和储蓄器空间而已。对新的变量举办增加和删除都会潜移默化到原来变量,即浅拷贝。不可变对象,拷贝或通过新变量传递时,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操作符1起行使。

  Python有标准库和第三方库。第3方库需要安装才能使用。多量的库能够协助大家更易于的到位复杂的操作。1般景况下,标准库被封存在了‘lib/’目录下,第壹方库被保存在了‘lib/site-packages’目录下。导入二个库卓殊简单,例子:

2.float(浮点数)

我们一时的把浮点数精晓为带小数点的小数(小编还会开单章来说说浮点数)

浮点数随笔链接

第伍片段 元组

一、元组使用()举行区分,以逗号’,’作为最终2个竣事,不然唯有四个要素时有望会不被认为是元组类型

2、列表和元组之间的类型转换 使用list() tuple()举办类型转换

3、列表和元组的区分

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

import os

3.bool(布尔类型)

把 True 和 False 定义成主要字了,但它们的值依旧 壹 和
0,它们得以和数字相加

 4858.com 5

注意:

  • 一、Python能够而且为多少个变量赋值,如a, b = 1, 2。
  • 二、3个变量能够通过赋值指向差异体系的对象。
  • 3、数值的除法 / 总是回到二个浮点数,要赢得整数使用 // 操作符( //
    是以舍去小数部分来取整的)。
  • 肆、在混合总括时,Python会把整型转换来为浮点数。

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

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

一、字典是不少值的组成,但不像列表的下标,字典的目录能够动用过多两样的数据类型,不只是整数。字典的目录被称之为“键”,键及其涉及的值称为“键-值”对,字典使用花括号{}包裹。

二、字典与列表

  字典也得以采用数字作为键;不像列表,字典中的表项时不排序的。相同的三个列表其顺序也不能够不是如出1辙的,而字典则未必;因为字典是不排序的,所以无法拓展列表那样的切片操作。

叁、字典的搜寻和拉长

  查找键值是还是不是位于字典中,可是使用in操作,字典键值对的丰硕唯独使用普通的赋值操作实行。

  检查该键是或不是留存于字典中,也可选择get()方法,其有五个参数,第1个是获得其键的值,第贰个是即使查找键失利,重回的暗中同意值

四、字典方法

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

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

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

4858.com 64858.com 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’) 

 五、漂亮打字与印刷

  使用 import
pprint 可以遵从字典的体裁打字与印刷出来,例如 pprint.pprint(myDict) ,借使想将打字与印刷的结果转为字符串而不是直接出口在荧屏上能够使用 print(pprint.pformat(myDict)) 

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

4858.com 84858.com 9

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

井字游戏

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

  各类模块都有好多操作,一般情况是用模块名.操作名达成有个别操作,例子:

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

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

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

 4858.com 10

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

4858.com 11

4858.com 12

行使反斜杠 \
转义特殊字符,假如您不想让反斜杠爆发转义,能够在字符串前边添加叁个r,表示原始字符串:

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

字符串的操作

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

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

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

#输出 I LoveYou I LoveYou I LoveYou I LoveYou 

注意

Python 未有单独的字符类型,三个字符便是长度为1的字符串。

与 C 字符串差别的是,Python
字符串不可能被转移。向3个目录地方赋值,比如word[0] = ‘m’会导致错误。

第10有的 字符串操作

一、字符串字面量

  双引号“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””” 都能够起到注释代码的效应

  字符串下标切片:字符串可以像列表壹样接纳下标切片取出1些字符串,不过并从未变动原来的字符串,只是新建了一个字符串,例如

 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判断3个字符串是还是不是在另八个字符串中设有,再次回到值为布尔型。

二、字符串方法

  字符串方法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')#读取目录下的文件列表,但不保存

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

元组被叫作只读列表,即数据可以被询问,但无法被修改,所以,列表的切片操作同样适用于元组。

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

 同3个元组中,成分得以是见仁见智的(成分得以为随机档次)

即便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 个或 1 个因素的元组相比较特殊,所以有局部极度的语法规则:

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

作用:

壹 对于部分数目大家不想被改动,能够接纳元组;

2其它,元组的含义还在于,元组能够在炫耀(和集合的成员)中当作键使用——而列表则相当;元组作为众多内建函数和办法的重回值存在。

变量类型:

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

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

透过列表能够对数码完毕最有利于的蕴藏、修改等操作

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

概念列表

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

 同一个列表中,成分得以是例外的(成分得以为随机档次)

通过下标访问列表中的成分,下标从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中存在不一致,它们得以并行转换,例子:

三.追加一个队列里的多少个要素( extend)

         extend 方法能够在列表的最终一遍性追加另叁个行列(可迭代对象,如
列表,字典,元组,字符串)中的七个值。

    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刨除列表中钦定下标成分,暗中认可删除最后一个因素,并且再次回到该因素的值,要是列表为空或许索引值超出范围会报2个百般。

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

 改(重新赋值)

专注:列表能够重复赋值,元组不得以

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

 

  列表的切片与Matlab有相似之处,但装有光辉不一致,Python的:后的数字是切片地点的后一人。所以,在Python中[1:2]=[1],例子:

查(切片,index)

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

1.切开操作(列表的切片,字符串,元组的切片操作都以如出壹辙的)

切开—取三个要素

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

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

 

 切片—取四个因素(获得的是叁个新的列表)

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

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

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

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

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

  Python还足以从右数来成功切片,例子:

二.靠成分找下标 (index)

  该方法能够制止遍历列表来找成分下标。

       Python 列表 index()
方法用于从列表中找出某些对象第2个相称项的目录地方,即使那么些目的不在列表中会报三个尤其。

  index() 方克罗地亚(Croatia)语法:

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.统计( 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()
方法类似,重回内定键的值,假使键不在字典中,将会添加键并将值设置为一个点名值,暗中认可为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() 方法删除给定键所对应的键/值对,并赶回被删去的值。给定键要是不在字典中,则必须安装2个default值,不然会报错,此时重回的就是default值。

dic.pop(key[,default])

    key: 要删除的键/值对所对应的键
    default:
可选参数,给定键不在字典中时务必设置,否者会报错(未有暗中同意值),此时赶回default值。

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

  Python中列表的复制与Matlab分化,设计相对合理1些,可是有几许难以明白,学过C++中指针的能够相对简单掌握壹些。普通的赋值操作,只是将列表的地点复制,一旦中间列表中的值发生变动,两者中的值都会转移,例子:

3.置空(clear())

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

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

4..剔除“最终壹对键值对”(popitem())“

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

为啥是轻易删除呢?因为字典是冬季的,未有所谓的“最终一项”或是别的顺序。在劳作时壹旦遇上需求各种删除项的干活,用popitem()方法作用很高。

如若字典已经为空,却调用了此办法,就报出KeyError非常。

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

 

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

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

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) # 日照香炉生紫烟

  当列表中存款和储蓄的音讯不想被改变时,就足以用元组,元组的定义与列表大致同壹,只是用‘()’代替了[]。元组不可能改改,只能切片。例子:

三.全数键列表(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')

四.有所值列表(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()
方法用于创制1个新的字典,并以可迭代对象中的成分分别作为字典中的键,且全部键对应同一个值,暗许为None。

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

iterable–
用于创建新的字典的键的可迭代对象(字符串、列表、元祖、字典)。
value — 可选参数, 字典全部键对应同一个值的始发值,暗中认可为None

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

  除此而外,还提供了查询作用,例子:

2.复制(copy())

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

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

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

4858.com 134858.com 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)

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

  字典也是常用的1种工具,字典是行使‘{}’定义的,字典中的数据是冬季的,字典能够与连串与字典嵌套。

 集合之间的涉及

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

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

4858.com 15

 

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

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

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

联合(并集)(|)

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

 4858.com 16

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

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

交集(&)

混合符号的对等方法是intersection()。

4858.com 17

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

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

 等价方法是difference()

 4858.com 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()

4858.com 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')

来来来,常用的数据类型大致就这个,之后就谈谈它们背后那三个不可告人的…….

  判断某些KEY是还是不是在字典中,例子:

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

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

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

4858.com 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

恐怕有点迷糊是吧………….啥也不说了,直接上海教室(图里说)

 4858.com 21

可变数据类型与不可变数据。每趟引用可变数据类型时,其内部存款和储蓄器地址都会改变,当引用不可变数据是,其内部存款和储蓄器地址都以和第一遍引用时1样的。

以此情景的是Python的内部存储器回收机制导致的。

可变数据类型每当引用可变数据类型数据后,**Python会立时回收刚才引用可变数据类型数据分配出去内存,那样就导致下次再引用该可变数据类型数据又要重新分配内部存款和储蓄器空间给该数量。**

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

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

 

终极问个难题,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])
    循环体

作业

编纂四个购物车程序,须求将商品新闻存在文件里。打开程序后须要用户登6,用户输入须要实现,已购商品,余额记录,运营程序,输入工资,依照编号,购买商品,检验余额,够用扣款,不够提示,随时退出,打字与印刷已经购置的货色和余额。商家入口供给实现,添加商品,修改价格。

流程图:

4858.com 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地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有