一： 什么是数据
在接触数据之前我们已经知道了变量，那么什么是变量呢 又该如何声明变量呢
变量是用来存储值的所在处
声明变量 name="王妃"
在这个变量中共包含三个部分：
（1）变量的名称 name （2）变量的值 “王妃” （3）赋值符 =
在这个示例中 变量的值“王妃”我们就可以把它称为数据，说白了数据就是我们所要储存的一个值
二：数据类型的概念
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他
三.数据类型
计算机是可以做计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种
1.Int(数字) 用于计算
a=10 b=a b=666 print(a) ---->10 print(b) ---->666
Numbr类型转换
var1=3.14 var2=5 var3=int(var1) var4=float(var2) print(var3,var4) ---->3 5.0
int数字转换成二进制的最小位数:bit_length()
x=10 print(x.bit_length())
int和字符串之间的转换
x=5 数字转换成字符串 print(str(x))
print('x')
s='hello,world' #字符串转化为数字
res=int(s)
print(res)
int和bool的转换
字符串和bool值
2.字符串(String) 主要用于存储少量的数据以便进行操作
定义：在单引号 双引号 三引号内由一串字符组成--->以单引号'或双引号"括起来的任意文本，比如'abc'，"123"等等
注意：''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比
如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
作用：主要用来描述信息 比如：一个人的个人信息（姓名 性别 国籍 住址等等）
msg = 'Hello World!' msg2 = "Hello Python"
字符串的操作：
* 重复输出字符串 print('hello'*2) --->hellohello [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表 print('helloworld'[2:]) --->lloworld in 成员运算符 - 如果字符串中包含给定的字符返回 True print('el' in 'hello') --->True % 格式字符串(占位符) print('%s 是一门编程语言'%'python') --->python是一门编程语言 # + 字符串拼接 a='123' b='abc' c='789' d1=a+b+c print(d1) --->123abc789 # +效率低,占内存多，该用join d2=''.join([a,b,c]) print(d2) --->123abc789
python字符串内置方法
# string.capitalize() 把字符串的第一个字符大写 # string.center(width) 返回内容是原字符串居中,并使用空格填充至长度为 width 的新字符串 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 # string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' # string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. # string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False # string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False # string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. # string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False # string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False # string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 # string.lower() 转换 string 中所有大写字符为小写. # string.lstrip() 截掉 string 左边的空格 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 # max(str) 返回字符串 str 中最大的字母。 # min(str) 返回字符串 str 中最小的字母。 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找. # string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始. # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. # string.rstrip() 删除 string 字符串末尾的空格. # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 # string.splitlines(num=string.count(' ')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() # string.swapcase() 翻转 string 中的大小写 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 # string.upper() 转换 string 中的小写字母为大写
fromat方法
3.字节类型(Bytes)
# a=bytes('hello','utf8') # a=bytes('中国','utf8') a=bytes('中国','utf8') b=bytes('hello','gbk') # print(a) #b'xe4xb8xadxe5x9bxbd' print(b) #b'hello' print(ord('h')) #其十进制 unicode 值为: 104 print(ord('中'))#其十进制 unicode 值为:20013 # h e l l o # 104 101 108 108 111 编码后结果:与ASCII表对应 # 中 国 # xd6xd0 xb9xfa gbk编码后的字节结果 #xe4 xb8 xad xe5 x9b xbd utf8编码后的字节结果 # 228 184 173 229 155 189 a[:]切片取 c=a.decode('utf8') d=b.decode('gbk') #c=a.decode('gbk') :很明显报错 print(c) #中国 print(d) #hello
注意：对于 ASCII 字符串，因为无论哪种编码对应的结果都是一样的，所以可以直接使用 b'xxxx' 赋值创建 bytes 实例，但对于非 ASCII 编码的字符则不能通过这 种方式创建 bytes 实例，需要指明编码方式
b1=b'123'
print(type(b1))
# b2=b'中国' #报错
# 所以得这样:
b2=bytes('中国','utf8')
print(b2)#b'xe4xb8xadxe5x9bxbd'
4.布尔值 用于判断，也可以作为if的条件
一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写）
print(True) print(4>2) print(bool([3,4])) print(True+1)
与或非操作：
bool(1 and 0) bool(1 and 1) bool(1 or 0) bool(not 0)
布尔值经常用在条件判断中:
age=18 if age>18:#bool(age>18) print('old') else: print('young')
5.LIst（列表）
上面我们了解了字符串和整型两个数据类型，但是，我如果想把某个班所有的名字存起来，该怎么办呢？
这时有的童鞋就会说简单啦，不是了解了变量存储了吗，我就用变量存储呗，但是一个班有几十位同学，每一位同学都得定义一个变量不嫌累吗，消耗大，效率低。
又有童鞋说，我用个大字符串不可以吗，没问题，你的确存起来了，但是，你对这个数据的操作（增删改查）将变得非常艰难，不是吗，我想知道张三的位置，你怎么办？
在这种需求下，编程语言有了一个重要的数据类型－－－－列表（list）
列表的定义：
列表（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。
相关操作：
1.查
names_class2=['张三','李四','王五','赵六'] # print(names_class2[2]) # print(names_class2[0:3]) # print(names_class2[0:7]) # print(names_class2[-1]) # print(names_class2[2:3]) # print(names_class2[0:3:1]) # print(names_class2[3:0:-1]) # print(names_class2[:])
2.增（append，insert，extend）
insert 方法用于将对象插入到列表中，而append方法则用于在列表末尾追加新的对象
names_class2.append('xuyaping') names_class2.insert(2,'alvin') print(names_class2)
3.改（重新赋值）
names_class2=['张三','李四','王五','赵六'] names_class2[3]='赵七' names_class2[0:2]=['wusir','alvin'] print(names_class2)
4.删 （remove，del，pop）
names_class2.remove('hello Python') #remove删除指定元素
names_class2.clear() #清空整个列表 del names_class2[0] # 删除列表指定索引的元素 del names_class2 #删除整个列表 names_class2.pop()#注意,pop有返回值,返回的是所要删除的元素
列表的其他方法：
count： 统计某个元素在列表中出现的次数
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 2 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] >>> x.count(1) 2 >>> x.count([1,2]) 1
estend：可以在列表的末尾一次性追加另一个序列中的多个值。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6]
注意：
extend 方法修改了被扩展的列表，而原始的连接操作（+）它会返回一个全新的列表。
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6] >>> >>> a + b [1, 2, 3, 4, 5, 6, 4, 5, 6] >>> a [1, 2, 3, 4, 5, 6]
Index：用于从列表中找出某个值第一个匹配项的索引位置
names_class2.index('李四')
reverse： 将列表中的元素反向存放
names_class2.reverse() print(names_class2)
sort :用于在原位置对列表进行排序。
x = [4, 6, 2, 1, 7, 9] x.sort()#x.sort(reverse=True)
6.tuple(元祖)
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。
元组写在小括号()里，元素之间用逗号隔开。
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号
作用：
1 对于一些数据我们不想被修改，可以使用元组；
2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。
字典
# product_list=[
# ('book',100),
# ('Mac Pro',9000),
# ('watch',500),
# ('coffee',30),
# ('Python',106),]
#
# saving=input('input your saving:')
# shopping_car=[]
#
# if saving.isdigit():
# saving=int(saving)
# while True:
# for i,v in enumerate(product_list):
# print(i,v)
# user_choice=input('选择购买商品编号[退出:q]:')
#
# if user_choice.isdigit():
# user_choice=int(user_choice)
# if user_choice<len(product_list) and user_choice>=0:
# product_item=product_list[user_choice]
# if product_item[1]<saving:
# saving-=product_item[1]
# shopping_car.append(product_item)
# print('您当前的余额为%s'%saving)
# else:
# print('编号错误')
# elif user_choice=='q':
# print('---------您已经购买如下商品-----------')
# for i in shopping_car:
# print(i)
# print('您的余额为%s'%saving)
# break
#
# else:
# print('invalid choice')
7.(Dictionary)字典 关系类型数据储存在字典中
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决 定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
优点：二分查找查询 储存大量的关系型数据
特点：无序的 只针对3.5之前的python版本(包括3.5) 没有索引 通过key来查找
创建字典：
dic1={'name':'ying','age':30,'sex':'male'}
dic2=dict((('name','ying7'),))
print(dic1)<br>
print(dic2)<br># {'name':'ying7'}
相关操作：
增：
dic3={} dic3['name']='ying' dic3['age']=30 print(dic3)#{'name': 'ying', 'age': 30} a=dic3.setdefault('name','zhang') #如果有就用原来的 没有就添加新的 b=dic3.setdefault('ages',30) print(a,b) # ying 30 print(dic3) # {'name':'ying','age':30,'ages':40}
查：
dic3={'name': 'ying', 'age': 30}
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
print(dic3.items()) # dict_items([('name','ying'),('age',30)])
print(dic3.keys()) # dict_keys(['name','age'])
print(dic3.values()) # dict_values(['ying',18])
print('name' in dic3) # True
print(list(dic3.values())) # ['ying',30]
改：
dic3={'name': 'ying', 'age': 30}
dic3['name']='steven'
dic4={'sex':'male','hobby':'run','age':40}
dic3.update(dic4) #把dic4的内容(键值对)更新到dic3中 没有就添加 有就覆盖
print(dic3) #{'name': 'steven','sex':'male','hobby':'run','age':40}
删：
dic4={'name': 'ying', 'age': 30,'class':5}
# dic4.clear()
# print(dic4) # {}
del dic4['name']
print(dic4) #{'age':30,'class':5}
a=dic4.popitem() #随机删除 以元祖的形式返回键值对
print(a,dic4) # ('class',5) {'age':30}
# print(dic4.pop('age')) # 30
# print(dic4)
# del dic4
# print(dic4)
其他相关操作及方法：
dict.fromkeys
d1=dict.fromkeys(['host1','host2','host3'],'Mac') print(d1) # {'host1': 'Mac', 'host2': 'Mac', 'host3': 'Mac'} d1['host1']='xiaomi' print(d1) # {'host1': 'xiaomi', 'host2': 'Mac', 'host3': 'Mac'} ####### d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei']) print(d2) # {'host1': ['Mac', 'huawei'], 'host2': ['Mac', 'huawei'], 'host3': ['Mac', 'huawei']} d2['host1'][0]='xiaomi' print(d2) # {'host1': ['xiaomi', 'huawei'], 'host2': ['xiaomi', 'huawei'], 'host3': [xiaomi', 'huawei']}
dic.copy() 对字典 dic 进行浅复制，返回一个和d有相同键值对的新字典
字典的嵌套
av_catalog = { "欧美":{ "www.youporn.com": ["很多免费的,世界最大的","质量一般"], "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"], "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"], "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"] }, "日韩":{ "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"] }, "大陆":{ "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"] } } av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来" print(av_catalog["大陆"]["1024"]) #ouput ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
sorted(dict) : 返回一个有序的包含字典所有key的列表
dic={5:'555',2:'222',4:'444'}
print(sorted(dic)) # [2,4,5]
字典的遍历
dic5={'name': 'ying', 'age': 30}
for i in dic5:
print(i,dic5[i])
# ---> name ying
# age 30
for items in dic5.items():
print(items)
# ---> ('name','ying')
# ('age',30)
for keys,values in dic5.items():
print(keys,values)
# ---> name ying
# age 30
8.集合(set)
集合的概念及作用
把不同的元素组成一起形成集合，是python基本的数据类型。集合本身是可变数据类型，但是其子元素是不可变数据类型且集合是一个无序的，不重复的数据组合，它的主要有俩大作用：
1.去重，把一个列表变成集合，就自动去重了 2.关系运算，测试两组数据之前的交集、差集、并集等关系
集合的分类：可变集合、不可变集合
集合的创建
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...} 或者 set(value)
实例：
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
结果： {'orange', 'banana', 'pear', 'apple'} # 由结果可知集合中的元素是不重复的这也是集合的俩大作用之一去重功能
相关操作：
添加：
s.add( x )将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'}
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )，x 可以有多个，用逗号分开。
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao")) >>>
thisset.update({1,3}) >>>
print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>>
thisset.update([1,4],[5,6]) >>>
print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} >>>
移除元素
语法格式如下：
s.remove( x )将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao")) >>>
thisset.remove("Taobao") >>>
print(thisset) {'Google', 'Runoob'} >>>
thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Facebook' >>>
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao")) >>>
thisset.discard("Facebook") # 不存在不会发生错误 >>>
print(thisset) {'Taobao', 'Google', 'Runoob'}
我们也可以设置随机删除集合中的一个元素，语法格式如下：
s.pop()
脚本模式实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
输出结果：
$ python3 test.py Runoob
多次执行测试结果都不一样。然而在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao", "Facebook")) >>>
thisset.pop() 'Facebook' >>>
print(thisset) {'Google', 'Taobao', 'Runoob'} >>>
计算集合元素个数
语法格式如下：
len(s)
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao"))
len(thisset) 3
清空集合
语法格式如下：
s.clear() 清空集合 s。
实例(Python 3.0+)
thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset) set()
集合的关系运算：(详情参考下表)
集合内置方法完整列表
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 删除集合中的元素，该元素在指定的集合中不存在。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
1.in与not in
2 等价与不等价
3.子集与超集
s=set('alvinyuan') s1=set('alvin') print('v' in s) print(s1<s)
4.联合（|）
联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。
s1=set('alvin') s2=set('yuan') s3=s1|s2 print(s3) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
5.交集（&）
与集合and等价，交集符号的等价方法是intersection()
s1=set('alvin') s2=set('yuan') s3=s1&s2 print(s3) #{'n', 'a'} print(s1.intersection(s2)) #{'n', 'a'}
6.差集（-）
等价方法是difference()
s1=set('alvin') s2=set('yuan') s3=s1-s2 print(s3) #{'v', 'i', 'l'} print(s1.difference(s2)) #{'v', 'i', 'l'}
7.对称差集.（^）
对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()
s1=set('alvin') s2=set('yuan') s3=s1^s2 print(s3) #{'l', 'v', 'y', 'u', 'i'} print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}
应用：
'''最简单的去重方式''' lis = [1,2,3,4,1,2,3,4] print list(set(lis)) #[1, 2, 3, 4]