【澳门葡京备用网址】变量类型,Python编制程序急忙上手

引言

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

引言

本周开班认识了库,并学习了Python中各类别型的变量和常用操作。并成功了较为完美的用户与合营社购物界面设计。

正文

模块:

Python有标准库和第一方库。第一方库必要安装才能运用。多量的库能够帮助我们更易于的成就复杂的操作。①般景观下,标准库被保留在了‘lib/’目录下,第三方库被保存在了‘lib/site-packages’目录下。导入一个库非常简单,例子:

import os

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

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

变量类型:

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

x = 3
type(x)

另外项目与C++中好像,所以不再赘述。

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

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

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

【澳门葡京备用网址】变量类型,Python编制程序急忙上手。在普通使用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:])#最后的值省略

 列表的扩充有三种办法,一种是最后追加,还有一种是某处插入。例子:

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++中指针的能够相对不难了然1些。普通的赋值操作,只是将列表的地方复制,一旦中间列表中的值产生转移,两者中的值都会改变,例子:

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

要想复制三个列表,有浅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()#判断为标题形式

字典

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

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

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

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

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

字典的去除能够动用Python中通用的删减方法,也许字典中提供的方法,例子:

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

搜寻是,能够用事先的点子来寻找,可是还有一种安全的探寻方法,例子:

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

认清有个别KEY是还是不是在字典中,例子:

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

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

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

Python也提供了新建三个字典的主意,不过存在一点都不小的难点,所以一般不会采取,例子:

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

作业

编写制定多少个购物车程序,要求将商品消息存在文件里。打开程序后要求用户登六,用户输入须要达成,已购商品,余额记录,运行程序,输入薪俸,依据编号,购买商品,检查评定余额,够用扣款,不够提醒,随时退出,打字与印刷已经购买的货色和余额。卖家入口须求贯彻,添加商品,修改价格。

流程图:

澳门葡京备用网址 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中各系列型的变量和常用操作。并成功了较为完善的用户与集团购物界面设计。

数据类型

Python三 中常用的数据类型:

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

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

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

不可变数据类型是指三个ID地址中贮存的数额不得以变更。

其次局地 控制流

1、not 非 and 与 or 或

二、range(早先,结束,步长)  注意:循环不包涵‘截至’ 

三、import 函数 导入函数 from import是另一种导入格局,举例 from random
import * 能够在使用random函数时毫不加random.前缀

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

正文

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

其三片段 函数

1、def 函数名(入参):

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

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

肆、非凡处理 try 和except

常用的不胜类型

澳门葡京备用网址 2澳门葡京备用网址 3

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

View Code

模块:

1.int(整型)

int类型正是整数

Python的二.x的本子中还设有Long长整型(表示相比较长的整数(相比大O卡宴相比小)),三.x的本子中就唯有int整型

整型类型能发挥的数值仅仅与您的机械扶助的(虚拟)内存大小有关,换句话说,Python能轻松表明不小的平头。

 

 澳门葡京备用网址 4

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

第伍有的 列表

一、负数下标

平头-一下标指的是列表的末段三个下标,-2指的是列表的倒数第三个下标

二、利用切片取得子列表

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

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

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

3、列表的长短

  使用len(spam)

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

5、列表的接连和复制

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

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

6、列表成分的去除

  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旦发生修改,会新生成3个跟原来对象属于差别内部存款和储蓄器空间的新对象值。元组(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)

 16、列表和字符串的共同点

  列表和字符串都能够流传len(),都有下标和切片,用于for循环,连接或复制,并与in和not
in操作符壹起使用。

  Python有标准库和第三方库。第3方库须要安装才能应用。多量的库能够扶助大家更易于的成就复杂的操作。一般景况下,标准库被保留在了‘lib/’目录下,第2方库被保存在了‘lib/site-packages’目录下。导入二个库卓殊简单,例子:

2.float(浮点数)

我们近日的把浮点数明白为带小数点的小数(笔者还会开单章来说说浮点数)

浮点数小说链接

第肆部分 元组

一、元组使用()举办区分,以逗号’,’作为最后一个终了,不然唯有3个成分时有希望会不被认为是元组类型

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

3、列表和元组的区分

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

import os

三.bool(布尔类型)

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

 澳门葡京备用网址 5

注意:

  • 1、Python能够而且为八个变量赋值,如a, b = 1, 二。
  • 二、叁个变量能够因而赋值指向分化类其他目的。
  • 3、数值的除法 / 总是回到1个浮点数,要赢得整数使用 // 操作符( //
    是以舍去小数部分来取整的)。
  • 4、在混合计算时,Python会把整型转换到为浮点数。

Python还协理complex(复数),复数由实数部分和虚数部分构成,能够用a +
bj,也许complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

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

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

二、字典与列表

  字典也足以选用数字作为键;不像列表,字典中的表项时不排序的。相同的六个列表其顺序也亟须是同样的,而字典则未必;因为字典是不排序的,所以无法拓展列表那样的切片操作。

叁、字典的搜寻和增进

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

  检查该键是或不是存在于字典中,也可采取get()方法,其有八个参数,第肆个是获取其键的值,第二个是如果查找键战败,再次回到的私下认可值

四、字典方法

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

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

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

澳门葡京备用网址 6澳门葡京备用网址 7

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

Python dictionary

  能够将keys()和values()重回的值存款和储蓄为列表,例如list(spam.keys())

  也得以接纳多重赋值的技术,在for循环中校key和value对号落座

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

  setdefault()方法—设置字典键对应的暗中认可值

  假使未有默许值,将艺术设置的值设置成功,要是已有暗中认可值,则保持原状。

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

 伍、美丽打字与印刷

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

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

澳门葡京备用网址 8澳门葡京备用网址 9

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

井字游戏

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

  每一个模块都有诸多操作,一般境况是用模块名.操作名达成有些操作,例子:

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

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

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

 澳门葡京备用网址 10

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

澳门葡京备用网址 11

澳门葡京备用网址 12

选拔反斜杠 \
转义特殊字符,若是你不想让反斜杠爆发转义,能够在字符串前边添加1个r,表示原始字符串:

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

字符串的操作

[ ],[ : ],[ : :
]因而索引能够拓展切开操作,和列表一样(在列表时会详细讲)

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

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

#输出 I LoveYou I LoveYou I LoveYou I LoveYou 

注意

Python 未有独自的字符类型,叁个字符正是长度为壹的字符串。

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

第十有的 字符串操作

壹、字符串字面量

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

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

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

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

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

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

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

  字符串下标切片:字符串能够像列表一样选取下标切片取出一些字符串,可是并从未变动原先的字符串,只是新建了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判断三个字符串是不是在另多个字符串中留存,重返值为布尔型。

贰、字符串方法

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

  isX字符串方法:

  is阿尔法()再次回到TRUE,假设字符串只包涵字母,并且非空;

  isalnum()再次回到TRUE,借使字符串值包涵字母和数字,并且非空;

  isdecimal()再次来到TRUE,若是字符串包涵数字字符,并且非空;

  isspace()再次回到TRUE,固然字符串值包括空格,制表符和换行,并且非空;

  istitle()重临TRUE,假如字符串仅包括以大写字母开始前边都以小写字母的单词;

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

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

  join()连接字符串 

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

  split()分离字符串

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

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

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

  左右对齐和居中,其中第贰个参数是填充参数,能够选拔填充字符;

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

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

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

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

 

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

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

作用:

壹 对此部分数额大家不想被改动,能够利用元组;

二其余,元组的含义还在于,元组能够在炫耀(和聚集的成员)中当作键使用——而列表则格外;元组作为广大内建函数和艺术的重临值存在。

变量类型:

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

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

透过列表能够对数据完成最方便的仓库储存、修改等操作

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

概念列表

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

 同3个列表中,成分得以是见仁见智的(成分得以为专擅档次)

由此下标访问列表中的成分,下标从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 方法能够在列表的结尾贰遍性追加另3个行列(可迭代对象,如
列表,字典,元组,字符串)中的多个值。

    extend
方法修改了被增加的列表,而原有的接连操作(+)则不然,它会再次来到四个崭新的列表。

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

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

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

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

 删(remove,del,pop)

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

一.remove剔除以值钦赐的因素

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

列表:

贰.del刨除以下标钦命的成分or整个列表

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

  列表的概念,例子:

三.pop剔除列表中钦赐下标成分,暗许删除最终三个成分,并且重回该因素的值,要是列表为空只怕索引值超出范围会报三个丰富。

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

 改(重新赋值)

专注:列表能够另行赋值,元组不得以

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

 

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

查(切片,index)

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

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()
方法用于从列表中找出有些对象第1个匹配项的目录地方,倘使那么些指标不在列表中会报一个那多少个。

  index() 方斯洛伐克语法:

a.index(value, start, stop)

    value– 钦定检索的对象。
    start — 可选参数,开首索引,暗中认可为0。(可独自钦赐)
    stop — 可选参数,甘休索引,暗许为元祖的长度。(可单独钦定)

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

其他

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

1.统计( 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'#改变某处

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

 字典是python中绝无仅有的映照类型,采纳键值对(key-value)的款型储存数据。

python对key进行哈希函数运算,依照测算的结果决定value的贮存地方,所以字典是冬辰存款和储蓄的,且key必须是可哈希的。

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

 

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

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

增(‘=’,setdefault())

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

1.‘=’

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

  其余,Python还为列表提供了不可胜数功力。Python中能够轻松查询有些参数的任务和个数,例子:

2.添加询问键值对(setdefault())

Python 字典 setdefault() 方法和 get()
方法类似,重返内定键的值,固然键不在字典中,将会添加键并将值设置为叁个点名值,默认为None。

而 get() 不会添加键。

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

key — 字典中要寻找的键。
default — 可选参数,假设钦点键的值不设有时,重临该值,暗中同意为 None

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

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

  改变列表的种种也要命简短,例子:

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

去除全体字典

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

删除键对应键值对

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

二刨除钦点键值对(pop())

pop() 方法删除给定键所对应的键/值对,并赶回被删去的值。给定键就算不在字典中,则必须安装二个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)

四..刨除“最终一对键值对”(popitem())“

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

为何是任意删除呢?因为字典是冬日的,未有所谓的“最终1项”或是别的顺序。在办事时假诺境遇须要各样删除项的办事,用popitem()方法效用很高。

一经字典已经为空,却调用了此办法,就报出KeyError卓殊。

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

 

  要想复制一个列表,有浅copy和深copy二种艺术。浅copy只复制列表的率先层,第三层将只复制地址。深copy则是一心在内部存款和储蓄器中国建工业总会公司立一个相同的区域。例子:

改(‘=’,update())

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

1.‘=’

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

 

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

2.改,扩展(update())

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

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

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

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

1.‘=’

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

2.键找值(get())

get() ,重返指定键的值,若是键不在字典中,再次来到叁个点名值,暗许为None。

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

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

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

keys()
方法以列表情势(并非直接的列表,若要再次来到列表值还需调用list函数)重回字典中的全体的键。

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

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

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

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

 

字符:

5.全体键值对列表(items())

items()
方法以列表情势(并非一向的列表,若要再次来到列表值还需调用list函数)重临全数的键值对(1对键值对组合的元组)

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

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

陆.in/not in(是还是不是留存)

in
操作符用于判断键(key)是还是不是存在于字典(D)中,假设键在字典中回到True,不然再次回到False。

not in 则相反

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

柒.全部键列表(sorted())

 重返多个平稳的包括字典全部key的列表

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

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

其它骚操作(dict.fromkeys(),copy() )

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

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

fromkeys()
方法用于创制一个新的字典,并以可迭代对象中的成分分别作为字典中的键,且全体键对应同3个值,默许为None。

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

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

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

  除了这一个之外,还提供了询问作用,例子:

2.复制(copy())

dic.copy() 对字典 dic
举办浅复制,重临贰个和dic有相同键值对的新字典。(因为字典的值value能够是可变和不可变数据类型,所以就事关到了深浅复制)

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

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

澳门葡京备用网址 13澳门葡京备用网址 14

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

二种菜单

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

六 集合(set)

汇集(set)是一个冬日的,把分裂的要素(set
elements)组成联合形成汇聚(不另行的数量整合),它的重大功效如下:

去重:  把贰个列表变成集合,就活动去重了(不可重复)

涉嫌测试:  测试两组数据以前的混杂、差集、并集等关系

聚拢分类:可变集合、不可变集合

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

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

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

创立集合

聚拢的厂子方法set()和frozenset()创设

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

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

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

  Python还为字符提供了无数论断,那么些意义大多以is伊始,例子:

增(add,update)

澳门葡京备用网址 ,.add()添加单个成分(能够重复添加相同的值,不过没用,集合去重的)

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

.update()添加多个行列(多少个因素)

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

删(remove,discard,pop,del)

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

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

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

del 删除集合自个儿

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


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

字典:

出于汇集本人是冬季的,所以无法为汇聚成立索引或切片操作,只好循环遍历或使用in、not
in来访问或判断集合成分

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

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

  字典也是常用的一种工具,字典是利用‘{}’定义的,字典中的数据是严节的,字典能够与类别与字典嵌套。

 集合之间的涉及

  索引字典时选取KEY,例子:

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

澳门葡京备用网址 15

 

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

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

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

联合(并集)(|)

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

 澳门葡京备用网址 16

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

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

交集(&)

错落符号的非凡方法是intersection()。

澳门葡京备用网址 17

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

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

 等价方法是difference()

 澳门葡京备用网址 18

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

  字典的删减能够选取Python中通用的删减方法,可能字典中提供的艺术,例子:

对称差集(^)

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

澳门葡京备用网址 19

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

 


  查找是,能够用事先的章程来探寻,然而还有一种安全的追寻方法,例子:

 

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

来来来,常用的数据类型大约就那个,之后就探究它们背后那多少个不可告人的…….

  判断有个别KEY是或不是在字典中,例子:

变量,数据,内存3者的涉及(不是三角恋哈)

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

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

澳门葡京备用网址 20

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

 

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

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

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

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

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

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

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

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

 澳门葡京备用网址 21

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

以此场合包车型客车是Python的内部存款和储蓄器回收机制导致的。

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

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

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

 

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

迎接评论留言,番茄,鸡蛋都砸过来吧。

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

  Python也提供了新建三个字典的方法,不过存在相当的大的标题,所以壹般不会利用,例子:

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

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

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

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

  多级字典的操作与单级字典差距十分小,修改略有不一致。例子:

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

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

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

作业

编写制定一个购物车程序,要求将商品消息存在文件里。打开程序后须要用户登陆,用户输入须求贯彻,已购商品,余额记录,运维程序,输入薪资,依据编号,购买商品,检测余额,够用扣款,不够提示,随时退出,打字与印刷已经购销的货色和余额。商行入口必要贯彻,添加商品,修改价格。

流程图:

澳门葡京备用网址 22

主程序:

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

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

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

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

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

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

音信记录文件:

商品.txt

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

用户消息.txt

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

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website