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

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