print('-----------数据类型：列表、字典、元组、集合----------')
'''列表（list）、字典（dictionary）、元组（tuple）和集合（set）都可以看成能存储多少个数据的容器。前两者经常被使用，后两者被使用的机会相对要少一些
list[]是具有顺序的一组对象，其中的元素不需要是同类型，可以是数字、字符串甚至一个列表；
字典{}中每个元素由2个部分组成，前半部分为键（key），后半部分为值（value），键与值用冒号（:）分隔

元组()的定义和使用方法与列表类似，区别在于定义列表用的是[]，而定义元组用的是()，此外元组中的元素不可修改
集合{}是一个无序的不重复的序列，集合中不会有重复的元素，集合中的元素没有索引值，集合用{}来定义，也可以用set()函数来创建集合

'''




'''
列表示例：list=[1,'2',3.0,'文本',[6]]
字典示例：dic= {'李白': 85, '王维': 95, '孟浩然': 75, '王昌龄': 65, '王之涣': 55}
元组示例：tuple=('a','b','c')
集合示例：={'a','b','c'}

'''



print('---------------------------列表----------------------------------')


'''list是具有顺序的一组对象，其中的元素不需要是同类型，可以是数字、字符串甚至一个列表'''
列表=[1,'2',3.0,'文本',[6]]
print(列表)   #[1, '2', 3.0, '文本', [6]]


print('---')

#提取list中的元素
print(列表[3])       #文本  取列表中索引值是3的元素
print(列表[-1])   #[6]    取列表中倒数第一个元素

#修改list中指定元素的值
列表[0]=0
print(列表)   #[0, '2', 3.0, '文本', [6]]

#两个list之间相加可以拼合
list1=[1,2,3]

list2=['w','h','h']
list3=list1+list2
print(list3)    #[1, 2, 3, 'w', 'h', 'h']

print('---')
#判断某个元素是否在list当中
list1=[1,2,3]
print(1 in list1)   #True

#max()与min()函数可以读取list中最大与最小的元素（仅支持数字）
list1=[1,2,3]
print(max(list1))   #3

#删除list中指定的元素
list1=[1,2,3]
#del(list1[0])  #2种方法都都行
del list1[0]
print(list1)    #[2, 3]


#append()函数可以给列表添加元素
a=[1]
a.append(2)
print(a)    #[1, 2]

print('---')

#可以给range()设置一个步长(第三个参数）
for i in range(1,10,3):
        print(i)
'''
1
4
7'''
print('---')

#列表的切片操作也可以指定步长
buchang1=[1,2,3,6,7,90,0]
print(buchang1[2:6:2])      #索引值2开始到索引值6之前，每隔2个元素取1个
#[3, 7]


print('---')
#列表中的元素可以被替换
liebiao12=[1,2,3]
liebiao12[0]='替换成字符串'
print(liebiao12)    #['替换成字符串', 2, 3]
print('---')

#要替换的内容甚至可以设置成变量
thbl=233
liebiao12[2]=thbl
print(liebiao12)    #['替换成字符串', 2, 233]

print('---')
#列表的长度也可以为0，留空即可
liebiao13=[]
print(liebiao13)    #[]
print(len(liebiao13))   #0

print('---')


#将列表转换为字符串
liebiao12=['1','2','3']
print(''.join(liebiao12))   #123

'''
.list类对象的常用方法“
.append()  向list列表末尾添加元素
.extemd()   与append()类似，如果对两个list操作，会将两个list拼在一起生成新的list，而append会将整个list作为一个元素加入另一个list当中
.count(x)  统计x在列表中出现了多少次
.index (x)    找出列表中第一个出现的x并返回其下下标
.insert(i,x)       将x插入到列表中的指定位置(i)
.pop(i)        删除当前列表中下标为i的元素，如果没写参数，但就默认删除最后一个
.remove(x)     删除列表中第一个出现的x
.reverse()     倒置列表，使列表中的元素顺序与原来相反
.sort()     对列表进行排序，默认从小到大（不填写参数），如果填入【True】参数，则是从大到小，假如无法排序，比如因为列表中包含字符串和数字，会报错
.sorted()   同样也是排序，但不影响list本身的值
'''

#可以使用help()查看该对象的所有方法和属性
#help(list)
'''
Help on class list in module builtins:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |  
 |  append(self, object, /)
 |      Append object to the end of the list.
 |  
 |  clear(self, /)
 |      Remove all items from list.
 |  
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |      
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |      
 |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
 |      order of two equal elements is maintained).
 |      
 |      If a key function is given, apply it once to each list item and sort them,
 |      ascending or descending, according to their function values.
 |      
 |      The reverse flag can be set to sort in descending order.
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  __class_getitem__(...) from builtins.type
 |      See PEP 585
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None'''

print('---')


#除了.reverse()可以倒置列表，也可以通过切片功能实现列表元素的反向排列
liebiao123=[1,2,3,4,5,6,7,8,9]
#【-1】的位置是设置步长，步长设置为负数，代表从后往前每1个元素提取1次
print(liebiao123[::-1]) #[9, 8, 7, 6, 5, 4, 3, 2, 1]
print(liebiao123[::-2]) #[9, 7, 5, 3, 1]    #从后往前没2个元素提取第1个

'''上面的代码只是修改了输出的结果，下面的reverse()直接对对象本身进行修改'''

print(liebiao123)      #[1, 2, 3, 4, 5, 6, 7, 8, 9]

liebiao123.reverse()
print(liebiao123)   #[9, 8, 7, 6, 5, 4, 3, 2, 1]
#需要注意的是，reverse()会直接对列表造成修改，而切片则不会

print('-------')

#range()也可以设置一个负数的步长
for i in range(10,0,-1):    #注意前面的参数是10，后面的参数是0，否则没有返回结果
    print(i)

'''
10
9
8
7
6
5
4
3
2
1'''



#字符串对象也可以通过切片的方法倒置
daozhi='三千里路云和月'
print(daozhi[::-1]) #月和云路里千三
print(daozhi[::-2]) #月云里三

print('---')
#字符串与列表都属于“序列”，因此都可以使用切片、下标、in、len()等功能
xulie1='xulie'
print(xulie1[1])    #u  #取字符串中索引值为1的元素

print(xulie1*3) #xuliexuliexulie

print('---')
#虽然都是序列，字符串与列表的主要区别在于，列表元素可以被替换修改，而字符串不能
# 另外列表可以包含多种类型的元素，而字符串只能是字符串

#要修改字符串，只能生成一个新的字符串变量
s1='abc123abc'
s2=s1[:2]+'-'+s1[-3:]
print(s2)   #ab-abc

s3=s1.replace('a','q')  #将a替换成q
print(s3)   #qbc123qbc
print(s1.count('a'))    #2  #统计s1字符串中a字母出现的次数
print(s1.find('123'))   #3  #查找s1中第一个【123】字符串出现的位置，如果不存在会返回【-1】

#find方法还可以设置查找范围，第二个参数设置查找的起点，第三个参数设置查找的终点
print(s1.find('a',1,12))    #6

print('---')

#查找s1中第二个a出现的位置
a2=s1.find('a')
print(a2)   #0

a2=s1.find('a',a2+1)    #
print(a2)   #6

print('---')
#查找s1中所有的a
aa=s1.find('a')
while aa!=-1:
    print(aa)
    aa=s1.find('a',aa+1)
'''
0
6'''

#rfind()可以查找s1中最后一个字幕a
print(s1.rfind('a'))    #6

print('---')

#.strip()可以返回字符串的副本，但移除该字符串的前导与末尾，默认移除空白符
kongbai=' www空白wwwqqq 1'
print(kongbai)  # www空白wwwqqq 1
print(kongbai.strip())  #www空白wwwqqq 1

如果为strip()加入参数，则是指定移除字符串头尾的指定字符串
kongbai='www空白wwwqqq 1'
print(kongbai.strip('w'))   #空白wwwqqq 1
#要替换字符串内所有的空格，直接使用replace()即可

#与strip()类似的有lstrip()和rstrip()，功能分别是去掉左边开头的空格和结尾的空格

#.lower()可以将字符串内的大写字母转换成小写字母
zimu1='ZIMU'
print(zimu1.lower())    #zimu

#.upper()可以将字符串内的小写字母转换成大写字母
zimu2='zimu'
print(zimu2.upper())    #ZIMU

#.swapcase()可以将字符串内的大小写颠倒，大写变小写，小写变大写
zimu3='123qazWSX'
print(zimu3.swapcase()) #123QAZwsx

#.title 可以将每个单词（连续的字母串）的开头第一个字母转换为大写
zimu6='hello world aww'
print(zimu6.title())    #Hello World Aww

#.capitalize()  将句首第一个字母转换成大写
print(zimu6.capitalize())   #Hello world aww

#.split()   可以根据指定的字符将字符串进行拆分
s6='hhhh1hhhh1hhh1'
print(s6.split('1'))    #['hhhh', 'hhhh', 'hhh', '']
#如果指定的分隔符连续出现了两次，那么列表中会出现空的元素
print(s6.split('hh'))   #['', '', '1', '', '1', 'h1']

#.join() 可以将列表拼合成字符串，或者说相互转换,
list1=['1','2','3']
list2='&'.join(list1)   #1&2&3
print(list2)

'''使用.join()方法将列表转换成字符串时，要是列表包含数字，则会报错
list1=[1,2,3]

网上找到的案例1：
L = [1,2,3,4,5]
print(','.join(L))
以上写法会报错，TypeError: sequence item 0: expected str instance, int found
原因：list包含数字，不能直接转化成字符串
修改成  print(','.join(str(n) for n in L)) 就可以了

网上找到的案例2：
a = ['1','2','3',1]
print(' '.join(a))

Traceback (most recent call last):
  File "C:/Users/Administrator/Desktop/onetest.py", line 188, in <module>
    print(' '.join(a))
TypeError: sequence item 3: expected str instance, int found

解决方法：
print(" ".join('%s' %id for id in list1))

'''


pinhe=['高','歌','一','曲']
print(pinhe)    #['高', '歌', '一', '曲']
pinhe1='+'.join(pinhe)
print(pinhe1)   #高+歌+一+曲
pinhe2=''.join(pinhe)
print(pinhe2)   #高歌一曲






print('---------------------------字典------------------------------')
'''字典{}中每个元素由2个部分组成，前半部分为键（key），后半部分为值（value），键与值用冒号（:）分隔
可以通过字典中某个元素的键，提取对应元素的值'''
dic={'李':0,'灵':1,"杰":2}
print(dic['灵']) #1

#遍历字典，提取字典中每个元素的键与值
dic={'李':0,'灵':1,"杰":2}
for i in dic:
    print(i+':'+str(dic[i]))    #每次循环，提取一个键+冒号再加上文本化的值
'''
李:0
灵:1
杰:2'''

print('---')
#另一种遍历字典的方法是用字典的items()函数
dic={'li':0,'ling':1,'jie':2}
a=dic.items()
print(a)    #dict_items([('li', 0), ('ling', 1), ('jie', 2)])

#向字典中添加或修改一组键值
dic['键']='值'    #添加
print(dic)  #{'li': 0, 'ling': 1, 'jie': 2, '键': '值'}

dic['键']='修改后的值'    #修改
print(dic)  #{'li': 0, 'ling': 1, 'jie': 2, '键': '修改后的值'}


#检查字典中是否存在某一个键
print('ling' in dic)    #True

#将字典中所有的键以列表的形式输出
print(dic.keys())   #dict_keys(['li', 'ling', 'jie', '键'])




print('-------------------元组--------------------')
'''元组()的定义和使用方法与列表类似，区别在于定义列表用的是[]，而定义元组用的是()，
此外元组中的元素不可修改，也无法向元祖中添加项目'''
tuple=('a','b','c')
print(tuple)    #('a', 'b', 'c')
print(tuple[0:2])   #('a', 'b')


print('------------------集合-----------------------')
'''集合{}是一个无序的不重复的序列，集合中不会有重复的元素，集合中的元素没有索引值，集合用{}来定义，也可以用set()函数来创建集合'''
set={'a','b','c'}
print(set)  #{'c', 'a', 'b'}


'''集合创建之后，无法修改，但是可以添加新项目
使用add()方法可以添加单个项目
使用update()方法可以添加多个项目'''

set={1,2,3}
set.add(6)  #{1, 2, 3, 6}
print(set)

set2={1,2,3}
set2.update('9','0','7')
print(set2) #{1, 2, 3, '0', '9', '7'}


#使用set()函数来创建集合，或者说将列表转换成集合
#书中这样写但报错
'''a=['2','3','3']
print(set(a))

a = ['李白', '李白', '王维', '孟浩然', '王昌龄', '王之涣']
print(set(a))
#理论上输出结果是： {'李白', '王维', '王之涣', '孟浩然', '王昌龄'}，注意去除了重复值
'''