python参数顺序 元组 字典_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=[]

fori inl1 :

ifi inl2 :

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 只能跟数字

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