基础知识拾遗--字符串&元组&列表&字典&collectons序列&集合

############字符串

创建字符串

str1 = 'abc'  
print(str1)  ##abc

str2 = str('efg')
print(str2)  ##efg
######上面两种创建方法等同

"" '' 在python中单引号和双引号效果一样
'''
''' 注释
'''
''' 段落

字符串格式化
字符串是%s ;整数是%d；浮点数%f

print("you information: age %d,sex %s,record %0.2f"%(28,'Male',87.5))

字符串常用功能
移除空白 .strip() 去除前后的内容
分割 split
长度 len(obj)
索引 obj[2]
切片 obj[1:10]

每个字符串有如下功能

'''
name = 'eric'
result = name.capitalize()  ##首字母大写
print(result)     ##  Eric
'''
'''
name = 'eric'
result = name.center(20,'*')   ###居中，并以* 填充左右。20表示宽度。填充字符加上字符串一起20个
print(result)       ######********eric********
'''
'''
name = 'sfsdfsdfsfisjfisdnisdng'
result = name.count('d')  ###找子系列出现的次数
result1 = name.count('s',0,2)  ###找子系列出现的次数,从第0到第2的位置.字符串的编号从0开始  范围是0<=a<2
print(result)  ##4
print(result1) ##1
'''
'''
name = '李杰'
result = name.encode('gbk')  ###编码变更
print(result)  #b'xc0xeexbdxdc'
'''
'''
name = 'alex'
result = name.endswith('e')  ##是否是以某个子系列结尾的
print(result)  #  false
'''

'''
name = 'alex'
result = name.endswith('e')  ##是否是以某个子系列结尾的
result1 = name.endswith('x',0,4)  #  0<=a<3
print(result)  #  false
print(result1)  #  true
'''

'''
name = 'a   lex'
result = name.expandtabs()  ##tab 换成空格， 一个tab算8个空格；结果有待探讨
print(result)   ###a   lex
print(len(result))  ##7
'''
'''
name = 'alex'
result = name.find('a')  ##找a字符在字符串alex 在第几个位置，还可以设置起始和结束位置;找不到返回-1
result1 = name.index('a')  ##找a字符在字符串alex 在第几个位置，还可以设置起始和结束位置；找不到，就程序报错
print(result)   ###0
print(result1)   ###0
'''
'''
name = 'alex {0} as {1}'
result = name.format('sb','eric')  ##格式化，sb 以参数的形式传到上的{0}中
print(result)  ###alex sb as eric

name = 'alex {name} as {id}'
result = name.format(name='sb',id='eric')  ##格式化，动态传参数
print(result)  ###alex sb as eric
'''
'''
li = ['s','b','a','l','e','x']
result = "".join(li)   ###将li 列表拼接
result1 = "_".join(li) ##将li 以下划线拼接
print(result)  ##sbalex
print(result1) ##s_b_a_l_e_x
'''

###ljust  rjust  ##和center类似

###lstrip  ##去掉左边

###
'''
name = 'alexissb'
result = name.partition('is')  ##以is 做分割
result1 = name.replace('a','o')  ## 做字符的替换，可以加数字，替换几个
print(result)  ##('alex', 'is', 'sb')
print(result1)  ##('alex', 'is', 'sb')
'''

###rfind   从左往右找。凡是加r的方法，是从左往右执行
###swapcase  大小写全部转换
###titile  所有单词的 第一个字母变大写
####upper ###小写转为大写

###列表

'''
li1 = list([1,2,3,4])
print(li1)
li2 = [1,2,3,4]
print(li2)
###创建列表的两种方式
'''

'''
li1 = list([1,2,3,4])
li1.insert(0,'alex')  ##insert  插入;具体在哪个位置插入
print(li1) ###['alex', 1, 2, 3, 4]
'''
'''
li1 = list([1,2,3,4])
li1.extend([11,22])  ##extend  扩展，自动放到最后
print(li1) ##[1, 2, 3, 4, 11, 22]
'''
'''
li1 = list([1,2,3,4,8,5])
li1.append(10)  ##append  追加，在最后追加一个字符
print(li1) ##[1, 2, 3, 4, 8, 5, 10]
'''
'''
li1 = list([1,2,3,4])
ret = li1.pop(0)  ##pop  pop() 具体显示去掉哪个元素；去掉的元素的值可以获取
print(li1) ## [2, 3, 4]
print(ret) # 1
'''
'''
li1 = list([1,2,'a','b'])
li1.remove('b')  ##去掉某个值，函数中写的具体的元素的值
print(li1) ###[1, 2, 'a']
'''
'''
li1 = list([1,2,3,4])
li1.reverse()  ## 翻转
print(li1) ###[4, 3, 2, 1]
'''
'''
li1 = list([1,2,3,4,8,5])
li1.sort()  ##排序
print(li1) ###[1, 2, 3, 4, 5, 8]
'''

###元组

##元组有的功能，列表一定有，列表有的功能，元组不一定有

'''
tu1 = (11,22,33,44,)
tu2 = tuple((11,22,33,44,))  ###接受的参数是一个序列
tu3 = tuple([11,22,33,44,])
li1 = [11,22,33]
tu4 = tuple(li1)    ###实现列表和元组的转换

print(tu1)
#print(tu2)

###count
##index

###字典

###字典是无序的序列

'''
dic1 = {'k1':'v1','k2':'v2'}
dic2 = dict(k1='v1',k2='v2')

print(dic1)  ##{'k2': 'v2', 'k1': 'v1'}
print(dic2) ##{'k2': 'v2', 'k1': 'v1'}
'''
##clear 清空所有的元素
'''
dic2 = dict(k1='v1',k2='v2')
dic3 = dic2.fromkeys(['k1','k2','k3'],'v1') ###获取key 值，重新得到一个字典
print(dic3)
'''
'''
dic = dict(k1='v1',k2='v2')
#print(dic['k1'])
#print(dic['k2'])
#print(dic['k3'])  ###报错 KeyError: 'k3'

print(dic.get('k1'))
print(dic.get('k2'))
print(dic.get('k3','alex'))  ##alex, 当值不存在时，设置值为alex
'''
'''
dic = dict(k1='v1',k2='v2')
print(dic.keys())   ##获取所有的keys  dict_keys(['k1', 'k2'])
print(dic.values()) ##或者所有的values dict_values(['v1', 'v2'])
print(dic.items())  ##或者所有的keys和values对 dict_items([('k1', 'v1'), ('k2', 'v2')])
for k in dic.keys():  ###循环获取所有的keys k1
    print(k)                               #k2
for v in dic.values():    ###循环获取所有的values v1
    print(v)                                      #v2
for k,v in dic.items():   ##循环获取所有的keys和values对 k1 v1
    print(k,v)                                        ### k2 v2
'''

###pop 去掉一个
'''
dic = dict(k1='v1',k2='v2')
print(dic.pop('k1'))  ##具体取走了什么 v1
print(dic)      ###取走之后的字典结果 {'k2': 'v2'}
'''
'''
dic = dict(k1='v1',k2='v2')
print(dic.popitem())  ###r任意删除一对
print(dic)
'''
'''
dic = dict(k1='v1',k2='v2')
print(dic.update({'k3':'123'}))
print(dic) ### {'k2': 'v2', 'k3': '123', 'k1': 'v1'}
'''
'''

###练习题

有一个数字的集合11,22,33,44,55,66,77,88,99。
将所有大于66的值保存到字典的第一个key中，将小于66的值保存至第二个key中
即 {'k1':大于66，'k2’:小于66}
实现方法一：
将要实现的元素，拆分为最简单，一个一个实现。
定义一个字典、定义两个列表值作为字典的values，再通过逻辑得到values的具体值

补充的：各种集合的打印方法

'''
s1 = 'alexabc'
for  i in s1:
    print(i)
'''
'''
all_list = [11,22,33,44,55,66,77,88,99]
for i in all_list:
    print(i)
'''
'''
tu1 = (11,22,33)
for i in tu1:
    print(i)
'''
dic1 = {'k1':'v1','k2':'v2'}
for k in dic1.keys():
    print(k)
for v in dic1.values():
    print(v)
for k,v in dic1.items():
    print(k,v)

all_list = [11,22,33,44,55,66,77,88,99]
dic = {}
li1 = []
li2 = []
for i in all_list:
    if i>66:
        li1.append(i)
    else:
        li2.append(i)
dic['k1'] = li1
dic['k2'] = li2
print(dic)

实现方法二：

原理：定义一个字典，通过逻辑判断生成value 值。 用到了列表的追加

all_list = [11,22,33,44,55,66,77,88,99]
dic = {}
for i in all_list:
    if i>66:
        if 'k1' in dic.keys():
            dic['k1'].append(i)
        else:
            dic['k1'] = [i,]
    else:
        if 'k2' in dic.keys():
            dic['k2'].append(i)
        else:
            dic['k2'] = [i,]
print(dic)   ######{'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99]}

####集合

set 是一个无序，并且不重复的元素集合
类似于hash值

#!/usr/bin/env python
'''
s1 = set()
s1.add('alex')
print(s1)   ###结果 {'alex'}
'''
###访问速度快
###原生解决了重复问题
#  ##作用之一：爬虫
##add 添加
##clear 清除元素
###copy  浅拷贝
###discard
##intersection  取交集，新创建一个set
##intersection_update 取交集，修改原来set

##isdisjoint  如果没有交集 返回true
###issubset  是否是子集
##issuperset  是否是父集

###
###union  并集
##update 更新
#symmetric_difference         差集，创建新对象
##symmetric_difference_update  差集，改变原来


'''
s2 = set(['alex','eric','tony','alex'])
print(s2)   ##{'eric', 'alex', 'tony'}
ret = s2.difference(['alex','eric'])  ##生成一个新的集合
print(s2)  ##{'eric', 'alex', 'tony'}   ##旧的集合不改变
print(ret)  # {'tony'}
'''
'''
s2 = set(['alex','eric','tony','alex'])
print(s2)     #           {'tony', 'eric', 'alex'}
ret = s2.difference_update(['alex','eric'])  ##在旧集合的基础上直接修改，得到结果。或者说删除当前set中所有包含在参数集合里的元素
print(s2)   #    {'tony'}
print(ret)  # None
'''
'''
s2 = set(['alex','eric','tony','alex'])
ret = s2.pop()
print(s2)   ## {'alex', 'tony'}
print(ret)  ## eric
'''
'''
s2 = set(['alex','eric','tony','alex'])
ret1 = s2.remove('tony')
print(s2)   ## {'eric', 'alex'}
print(ret1) ###  None
'''
###pop() remove()执行后，旧set 都会改变。pop去掉的值会赋给新的变量。而remove不会




###数据更新
'''
old = set(old_dict.keys())
new = set(new_dict.keys())

交集
update_set = old.intersection(new)

差集
delete_set = old.difference(new)   ###这种方法好像在数学上没有这个概念
add_set = new.difference(old)
上面两种实现方法和下面的实现效果一样。下面的更绕
delete_set = old.symmetric_difference(update_set)  ###这种方法和数学上的并集有些不同
add_set = new.symmetric_difference(update_set)
'''
'''
s1 = set([11,22,33])
s2 = set([22,44])
ret1 = s1.difference(s2)
####从字面意思来看是S1集合中的元素和s2中的元素比较有哪些不同的，不同的就留下来。
ret2 = s1.symmetric_difference(s2)
###从字面意思来说是对称的不同；从程序的角度来说，是s1中的元素循环和s2中元素比较，不同的留下，s2中的元素循环和s1中的元素比较，不同的留下。
print(ret1)  ###结果 {33, 11}
print(ret2)  ###结果 {33, 11, 44}
'''

###collections 序列

由于之前的字典、元组、列表等或多或少存在一些缺点

比如：

字典是无序的
列表的元素类型未知

collections 序列就是为了解决上面的问题而生

###collections 之counter

counter（计数器） 是对字典类型的补充，用于追踪值得出现次数
counter 类继承dict的类（功能） ps：具备字典的所有功能 + 自己的功能

dict 有的方法 items() keys() values()
counter 继承了dict的类 同样有上面的方法 额外有一个方法 elements() 取所有的元素

#!/usr/bin/env python
import  collections
obj = collections.Counter('fdsfsfsfdfsdfsvrodo')
print(obj)   ########Counter({'f': 6, 's': 5, 'd': 4, 'o': 2, 'r': 1, 'v': 1})
print(obj.most_common(4))   ####获取排名前4多的情况   [('f', 6), ('s', 5), ('d', 4), ('o', 2)]

#for item in obj.elements(): ##所有元素
#    print(item)   ###fdsfsfsfdfsdfsvrodo

for k,v in obj.items():
    print(k,v)

'''
结果
d 4
s 5
o 2
r 1
f 6
v 1
'''