Python--列表-，元组，字典的介绍

补充1

关于字符串切片,就是取出字符串中的单个字符

s='hello world'
print(s[0])    根据字符的索引值，来取出单个字符，从0 开始，
print(s[1])
print(s[0:5])  指定范围取值，从0到5的值，取头不取尾，
print(s[0:5:2])在0到5的范围内，按照步长2取值，没个一个字符取一个值，
结果为
h
e
hello
hlo
--------------------------------------------------------------------
补充2

变量的解压

s='hello'
a,b,c,d,e=s        把每个单个字符都绑定一个变量
print(a,b,c,d,e)
print(b)           如果支取某个，就指定那个变量名，
结果 
h e l l o
e

-------------------------------------------------------------------------
补充3
关于for和while循环
需要涉及到break和continue的区别了。

break： 只能跳出当前循环，当前这一套循环就结束了。
continue： 跳出当次循环，然后呢还会去继续下一次别的循环。

for循环

for i in range(10):
    print(i)
结果
0
1
2
3
4
5
6
7
8
9
从0到9 一次循环打印，直到9结束

for i in range(0,10,3):
    print(i)
0
3
6
9
指定步长为3，打印，每隔3个

列表

1.定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特性：
1.可存放多个值
2.可修改指定索引位置对应的值，可变
3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

关于表格的创建的3种方式：
list_1=[1,2,3]

list_test=list('abc')
print(list_test)

list_test=list(['lhf',12,'ok'])
print(list_test)
2. 列表的常用操作
索引
切片
追加
删除
长度
循环
包含
--------------------------------------------------------------------------------------------------------

列表元素去重

n1=['a','b',1,2,1]
n2=[]
for i in n1 :
    if i not in n1 :
        n2.append(i)
print(n2)


list_1=list(set(n1))
list_1.sort(key=n1.index)  --------------sort是排序，根据n1的列表排序
print(list_1)
-----------------------------------------------------------------------------------------------------------

1.1切片，，根据索引值求值

name=['alex','egon',1 ,[3,4]]
print(name[0])                 索引0的位置的值
print(name[0:2])               从0到2的值
print(name[0:3:2])             步长为2的，每隔一个数求值
结果
alex
['alex', 'egon']
['alex', 1]
-----------------------------------------------------------------------------
2.追加
name=['alex','egon',1 ,[3,4]]
name.append('ccc')
print(name)        -------------------------从列表的最后开始追加
结果
['alex', 'egon', 1, [3, 4], 'ccc']
-----------------------------------------------------------------------------
3.插入

name=['alex','egon',1 ,[3,4]]
name.insert(1,'ddddd')
print(name)    ---------------------插入，指定一个索引，插入到索引值前
结果
['alex', 'ddddd', 'egon', 1, [3, 4]]
------------------------------------------------------------------------------
4.删除

name=['alex','egon',1 ,[3,4]]
name.pop()
print(name)                   --------如果不加参数，从列表的最后一个值开始删除，

结果
['alex', 'egon', 1]

name=['alex','egon',1 ,[3,4]]
name.pop(1)-------------------指定一个索引，删除索引位置的值
print(name)
结果
['alex', 1, [3, 4]]
----------------------------------------------------------------------------------
5.关于队列和堆栈
队列---先进先出
堆栈---先进后出

队列

先进1
append   的追加方式，默认从最后加

a=[]
a.append('p1')
a.append('p2')
a.append('p3')
print(a)

结果-------['p1', 'p2', 'p3']-----先进来得，排在最前面

先进2
insert   的追加方式，需要指定索引位置

a=[]
a.insert(0,'p1')
a.insert(1,'p2')
a.insert(2,'p3')
print(a)


先出

a=['p1', 'p2', 'p3']
a.pop(0)           ---指定0的索引位置弹出  p1弹出
a.pop(1)           ---指定1的索引位置弹出  p2弹出
a.pop(2)           ---指定2的索引位置弹出  p3弹出
print(a)

--------------------------------------------------
堆栈
先进后出
append 追加
pop    弹出，不加参数，默认从列表的最后弹出，
-------------------------------------------------------------------
5.del 删除 列表元素

a=['p1', 'p2', 'p3']
del a[1]
print(a)

结果----['p1', 'p3']   -------del 的删除列表的格式，del a[1]，del后面加上列表名字，跟上索引位置
---------------------------------------------------------------------------------------------
6.列表长度

a=['p1', 'p2', 'p3']
print(len(a))

结果   3  ，
---------------------------------------------------------------------------------------------
7.成员运算
in  ，判断元素是否在列表里

a=['p1', 'p2', 'p3']
print('p4' in a )
结果   False    -----p4不在a的列表里，

关于字符串里，单个字符的判断
v='dfdfdf'
print('f' in v)     --------判断f 是否在字符串v内，在，返回Ture，
-------------------------------------------------------------------------------
8.求出列表内某个元素的索引值

a=['p1', 'p2', 'p3']
print(a.index('p2'))----返回  1
-----------------------------------------------------------------------------
9.计算列表里某个元素数量

a=['p1', 'p2', 'p3','p3']
print(a.count('p3'))    -----------返回2 ，2各p3
----------------------------------------------------------------------------------
10.加入新的列表
a=['p1', 'p2', 'p3','p3']
a.extend([1,2,3])
print(a)
结果    ['p1', 'p2', 'p3', 'p3', 1, 2, 3]   ----extend是把新表里的每个元素加到原来的列表里
-------------------------------------------------------------------------------------
11.append，追加

a=['p1', 'p2', 'p3','p3']
a.append([1,2,3])
print(a)   结果    ['p1', 'p2', 'p3', 'p3', [1, 2, 3]]，，append是把整个列表加到原来的列表里，整体作为列表的一个元素
------------------------------------------------------------------------------------------------------------------
12.指定删除  remove

a=['p1', 'p2', 'p3','p3']
a.remove('p1')
print(a)             ------指定删除某个元素
13.排序   sort

a=['p1', 'p6', 'p9','p3']
a.sort()
print(a)          -------从小到大排序，，，

a=['p1', 'p6', 'p9','p3']
a.sort(reverse=True)      reverse是反转的意思
print(a)          ------从大到小排序

---------------------------------------------------------------------
13.按原来的列表倒着排序

a=['p1', 'p6', 'p9','p3']
a.reverse()
print(a)
结果['p3', 'p9', 'p6', 'p1']
------------------------------------------------------------------------------------------
14.清空列表  clear
a=['p1', 'p6', 'p9','p3']
a.clear()
print(a)
结果  []     清空列表，，
-------------------------------------------------------------------------------------
15.遍历出列表的每个元素

a=['p1', 'p6', 'p9','p3']
for i in range(len(a)) :
    print(a[i])

结果--
p1
p6
p9
p3

元组的操作

定义：与列表类似，只不过［］改成（）
特性：

1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组常用操作

索引
切片
循环
长度
包含

1.计算元组里的每个元素个数  count

t=('p1', 'p6', 'p9','p3')
print(t.count('p9'))  ---结果  为1  ，代表只有1个p9元素，  
--------------------------------------------------------------
2.输出值的索引  index 

t=('p1', 'p6', 'p9','p3')
print(t.index('p9'))   ---结果  2  代表p9的索引为2，
-----------------------------------------------------------------

3.元组的元素输出，切片  
t=('p1', 'p6', 'p9','p3')
print(t[1])
print(t[3])    ----利用索引，

指定范围取值
t=('p1', 'p6', 'p9','p3')
print(t[1:3])   ---利用索引，也可以指定步长
print(t[3])
结果
('p6',)
p3
---------------------------------------------------------------------
4.求出元组的长度，  确定元素是否在元组内
t=('p1', 'p6', 'p9','p3')
print(len(t))     ---输出元组长度
print('p1' in t)  ---身份确认
结果
4
True
----------------------------------------------------------------------------
5.关于元组元素的改动  ，元素里的列表元素可以改动，其他的都不能动

t=('p1', 'p6', 'p9','p3',[1,2])
t[4][0]=('a')      -------------指定元组里列表的元素改为‘a’,是可以改的，其他不能改动，否则报错
print(t)
结果('p1', 'p6', 'p9', 'p3', ['a', 2])

--------------------------------------------------------------------------------


字典

dict={'key1':'value','key2':'value2'}
print(dict)
结果
{'key1': 'value', 'key2': 'value2'}
字典的有key,和value 组成，两者一一对应，
key必须是不可变的，是hash类型，数字，元组，字符串是可以作为key的，
value是可变的，

可以用hash()的方法，判断哪些可以作为key

print(hash('a'))
print(hash(2))
t=(1,2,3)
print(hash(t))

结果                ------不报错，都可以用作字典的key,
7486283456454968218
2
2528502973977326415

----------------------------------------------------------------------------------------------
字典没有索引，是无序的，通过key来取值，

1.通过key改值value

dict={'key1':'value','key2':'value2'}
dict['key1']='value3'                 ----------通过key1的建，赋给新的值value3,
print(dict)
结果
{'key1': 'value3', 'key2': 'value2'}
-------------------------------------------------------------------------------------------------
2.输出字典的key

dict={'key1':'value','key2':'value2'}

print(dict.keys())
结果   dict_keys(['key1', 'key2'])---不是列表
-----------------------------------------------------------------------------------

3.输出字典的value
dict={'key1':'value','key2':'value2'}

print(dict.values())

结果：dict_values(['value', 'value2'])--不是列表
--------------------------------------------------------------------------------------

4.遍历出字典的key 键，value，值，---------不通过索引的方式，输出key 和value
dict={'key1':'value','key2':'value2'}

for i in dict :
    print(i,dict[i])
结果
key1 value
key2 value2
----------------------------------------------------------------------
5.get的使用

dict={'key1':'value','key2':'value2'}

print(dict.get('b'))   ----即使‘b’不在dict的字典里用get的方法也不会报错
结果   None

如果不用get

dict={'key1':'value','key2':'value2'}

print(dict.('b'))

 
结果  直接报错
print(dict.('b'))
               ^
SyntaxError: invalid syntax
-----------------------------------------------------------------

总结
for，循环，对有索引的，有序的，可以遍历每个元素，适合列表，元组，字符串，

字典的查询速度快，没有索引，通过key，直接找到value，字典里存放的就是hash表，

比较容器类型  
10000个用户信息，存在不同的类型容器里，查询速度，占用的内存空间是不一样的，
列表：通过索引取值，索引存放在内存里，没增加一个值，就扩大内存，
元组：不可变的，更省空间，
字典：字典里的hash表，比列表还大，但优化了查询速度，不用找无用的值，直接找 key ,
-----------------------------------------------------------------
字典的嵌套

-----------------------------------------------------------------------
关于布尔值
True  False
每个数据类型都自带布尔值，0，None,空，为 False，其余都是True  ,

while 1 :              ---1 为True.
    cmd = input('>>: ')
    if not cmd :       ---cmd 输入为空，就是什么都不输入，直接回车，就是False ,not cmd 就是真，就继续输入，如果输入
        continue
    print('ok')

------------------------------------------------------------------------------------------------------------
集合

定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
特性：
1.集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

取连个列表中相同的值
l1=[1,2,3,4]
l2=[1,5,6,3]
l3=[]
for i in l1 :
    if i in l2 :
        l3.append(i)
print(l3)
结果
[1, 3]    ----------这是在做关系运算，

集合的作用就是做关系运算，两个集合之间的关系运算
set  集合，包含的元素没有重复的，，元素必须是不可变的，元组可以，列表不行，  
集合也是无序的， 没有可以，没有索引
集合不能取值，
只能做两个集合之间的运算，没有取单个值的需求，可以用for循环遍历每个元素，

------
集合的关系运算
1.交集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 & s2)
结果
{1, 'a', 'b'}

2.求两个集合的所有元素，并集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 | s2)         ------用  |   表示
结果
{1, 2, 'alex', 'b', 3, 'a'}   ---去掉重复的部分的所有

3.输出s1不包含在s2的值，，反之，s2-s1,
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 - s2)     ---减去相同的部分
结果
{2, 'alex'}
4.对称差集，两个集合自己独有的值，
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1 ^ s2)        --------  ^  上肩号，在连个集合里都没有重复的值
结果{2, 3, 'alex'}
----------------------------------------------------------------------

用方法调用：
1.s1集合中没有s2 的值，相当于 s1 - s2
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.difference(s2))
结果
{2, 'alex'}
2.  交集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.intersection(s2))
结果
'b', 1, 'a'}
3.并集
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.union(s2))
3.对称差集  ，除去两者集合相同的部分
s1={'alex',1,'a',2,'b'}
s2={1,'a',3,'b'}
print(s1.symmetric_difference(s2))
结果
{2, 3, 'alex'}
---------------------------------------------------------------------------
5.把s1的值并给s2,  updata  

s1={'alex',1,2}
s2={1,'a','b'}
s1.update(s2)
print(s1)   -----{1, 2, 'b', 'a', 'alex'}    s2还是存在的
------------------------------------------------------------------------
6.添加元素   add

s1={'alex',1,2}
s2={1,'a','b'}
s1.add('aa')
print(s1)   ----{1, 2, 'alex', 'aa'}    
------------------------------------------------------------------------------
7. 删除集合元素    discard
s1={'alex',1,2}
s2={1,'a','b'}
s1.discard(2)    -----------指定删除的元素  ，，如果删除集合里没有的，是不会报错的
print(s1)    ---------{1, 'alex'}

---------------------------------------------
8.删除集合元素    remove

s1={'alex',1,2}
s2={1,'a','b'}
s1.discard(3)    ------------指定删除，如果删除集合里没有的，会报错
print(s1）
-------------------------------------------------
9.删除集合元素      pop   

s1={'alex',1,2}
s2={1,'a','b'}
s1.pop()        ----   不能指定元素，随机删除元素，有返回值
print(s1)

------------------------------------------------------------------
10.  issubset,确定是否值子集
     issupperset .确定是否是超级父集
     isdijoint ,确定是否有交集

---------------------------------------------------------------------
 11.关于字符串格式化

res="name%s"   %'egon'     
name的位置可以添加任意内容， 
%s   可以跟数字和字符串
%d   只能跟数字

---------------------------------------------------------------------------


---------------------------------------------------------------------------------