python菜鸟学习Day5（字符串，列表，元组，集合，字典）

字符串和常用数据结构

字符串

字符串是由0个或多个字符串联起来组成的有限序列，用单引号或双引号包围起来。也可以用个双引号或单引号包围。用三个双引号或单引号开头的字符串可以折行

str1 = 'hello world!!!'
str2 = "hello world!!!"
str3 = '''
		hello
		world
		!!!'''
str4 = """
		hello
		world
		!!!"""
print(str1,str2,str3,str4,end='\n')

在字符串中\代表转义，就是\以及后面的字符不再是字符原来的含义，而是赋予它一定的意义。（假如单引号包围的字符串中包含单引号，就会被截断出错，所以需要转义字符）例如 \n 表示换行，而不是原来的反斜杠和n，\表示反斜杠，'表示单引号，

str1 =' hello world!!!'
str2 = '\n\'hello world\'\n'
print(str1)
print(str2)

如果字符串不需要\表示转义，要按照字符串中字符原原本本的输出，在字符串前面加个r。

str1 =r' hello world!!!'
str2 = r'\n\'hello world\'\n'
print(str1)
print(str2)

字符串的运算符

运算符	含义
+	字符串顺序拼接
*	后跟数字n，表示字符串重复n次
in，not in	字符串是否包含另一个字符串
[::]	字符串切片，start=0,end=length,space(间隔) =1
+	字符串顺序拼接

str1 = '123abcdefghijk '
str1_repeat = str1*3
str1_contat = str1 + str1_repeat
str1_in = 'def' in str1 
str1_not_in = 'def' in str1 
str1_one = str1[2]
str1_two = str1[:2]
str1_three = str1[:2:2]
str1_four = str1[::2]
str1_five = str1[2:]
str1_six = str1[2:6:2]
print(str1, str1_repeat, str1_contat, str1_in, str1_not_in, str1_one, str1_two, str1_three, str1_four, str1_five, str1_six)

字符串的内置方法

方法	含义	实例	输出
大小写处理
len()	字符串长度	len(‘abc efg’)	7
upper()	字符串全转为大写	‘abc efg’.upper()	‘ABC EFG’
lower()	字符串全转为小写	‘ABC EFG’.upper()	‘abc efg’
swapcase()	字符串大小写互换	‘abc EFG’.swapcase()	‘ABC efg’
.title()	每个单词首字母大写	‘abc EFG’.title()	‘Abc Efg’
capitalize	首字母大写		‘abc EFG’.capitalize ()
字符判断
startswith(‘a’,[start,end])	是否已‘a’为起始	‘abc efg’.startswith(‘ab’)	True
endswith(‘a’)	是否以‘a’结束字符	abc efg’.endswith(‘ab’)	False
isalnum()	是否以字符数字组成	‘abc 78 ’.alnum()	Flase(包含空格)
isalpha()	是否以字符组成	‘abc 78 ’.isalpha()	False
isdigit()	是否以数字组成	‘abc 78 ’.isdigit()	False
字符替换
replace(old,new,[times=all])	将old字符替换成new字符，重复times次	‘hello world’.replace(‘l’,‘xx’,2)	‘hexxxxo world’
去空格
strip([chars])	去重字符串左右两端指定字符，默认空格，能删除中间部分的字符	‘ hello wor ld ’.strip()	‘hello wor ld’
lstrip([chars])	去重字符串左端指定字符	‘ hello wor ld ’.strip()	‘hello wor ld ’
rstrip([chars])	去重字符串右端指定字符	‘ hello wor ld ’.strip()	‘ hello wor ld’
字符查找
find(str, beg=0, end=len(string))	查钊字符str,找到返回第一次匹配str首字母下标，没有返回-1	‘ hello wor ld ’.find(‘xx’)	-1
index(str, beg=0, end=len(string))	同find，找不到会报错	‘ hello wor ld ’.index((‘xx’)	报错
rindex(str, beg=0, end=len(string))	从右面开始查找	‘hello wor ld’.rindex(‘l’)	10
rfind(str, beg=0,end=len(string))	从右面开始查找	‘hello wor ld’.rfind(‘l’)	10
分组
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串	‘hello world ’.split(’ ')	[‘hello’,‘world’]
计数
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数	‘hello world’.count(‘l’)	3

列表

列表常用操作
lst_one = [‘hello’, ‘world’],lst_two = [‘i’,‘am’,‘coming’]

操作	含义	结果
lst_one * 2	lst_one 元素重复n次	[‘hello’, ‘world’,‘hello’, ‘world’]
lst_one + lst_two	列表拼接	[‘hello’, ‘world’,‘i’,‘am’,‘coming’]
lst_one[:2:]	列表切片	[‘hello’, ‘world’]
len(lst_one)	列表元素个数	2
‘hello’ in lst_one	列表包含	True
lst_one.index(‘world’)	列表元素个数	1
lst_one.append(‘yes’)	列表末尾添加元素	[‘hello’, ‘world’,‘yes’]
lst_one.insert(1,‘yes’)	列表指定位置插入	[‘hello’,‘yes’, ‘world’]
lst_one.remove(‘hello’)	列表删除指定元素	[‘world’]
lst_one.pop([index=-1])	列表删除指定位置的元素	[‘hello’]
lst_one.sort()	列表排序,直接作用在原列表	[‘hello’, ‘world’]
sorted(lst_one,reverse=True)	列表排序,生成新的列表	[‘world’，‘hello’,]

列表生成

1 用列表的生成表达式语法生成列表获取数据,用这种语法生成列表，列表元素已经生成，占用较多内存空间。
lst = [x2 for x in range(1,1000)]
lst = [x+y for x in range(100) for y in range(100)]
2 用生成器对象获取数据，而不是列表，不占用额外空间，调用的时候产生数据
gene = (x2 for x in range(1,1000))
print(sys.getsizeof(gene)) # 此时gene是生成器对象，不占用存储数据的空间
for val in gene: #调用生成器对象生产数据
prin(val)
3 python中还有另外一种生成器生成方式，用关键词yield将普通函数转换成生成器函数。

def febi(n):
	a,b = 0,1
	for _ in range(n)
		a,b = b,a+b
		yield a
def main(n):
	for val in febi(n):
		print(val) 
if __name__ == '__main__':
    main()

元组（tuple）

元组也是一种容器，可以存储多个数据，不同于列表的是，元组中的元素不能改变
#创建元组
tuple_one =(‘我’, ‘爱你’, True, ‘祖国’)
#取元组元素
tuple_one[2] #‘爱你’
#元组转列表
lst_one = list(tuple_one)
tuple_one = tuple(lst_one )

有了列表，为甚么还有元组，元组在那些地方应用？？
元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
元组在创建时间和占用的空间上面都优于列表。

集合

类似于数学意义上的集合，无序（不能通过下标调用元素），无重复。
#创建集合
set_one = set((“Google”, “Runoob”, “Taobao”))
set_two = set(‘我爱你中国’)
#(‘我’,‘爱’,‘你’,‘中’,‘国’)
set_three = {“Google”, “Runoob”, “Taobao”}
创建空集合是，只能用set(),因为{}是创建空字典。

集合操作
set_one = {“Google”, “Runoob”, “Taobao”, “Taobao”}
#元素个数等于3
len(set_one)
#添加元素
set_one.add(‘jingdong’)
#添加多个元素
set_one.update({1,3})
set_one.update([1,3])
set_one.update([1,3],[‘suning’,‘dangdang’])
#删除元素
set_one.remove(4) #如果元素不存在，会抛出异常
set_one.discard(4) #删除元素，不存在也不会抛出异常。
集合的成员、交集、并集、差集等运算。

集合的交集、并集、差集、对称差运算
#交集
set1 & set2
set1.intersection(set2)
#并集
set1 | set2
set1.union(set2)
#差集
set1 - set2
set1.difference(set2)
#两个集合中不重复的元素集合。
set1 ^ set2
set1.symmetric_difference(set2)
#判断子集和超集
set2 <= set1
set2.issubset(set1)

字典

字典有key,value键值对构成，键和值通过冒号分开。可以通过key搜索value（key不重复）。整个字典包括在花括号({})中.
dict_one = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
dict_two = {num: num ** 2 for num in range(1, 10)}

dict_one [‘lilei’] #如果key不在字典中会抛出异常
if ‘lilei’ in dict_one #判断key在不在字典中
dict_one .update(‘冷面’=67, ‘方启鹤’=85) #添加元素
dict_one[‘lilei’] = ‘9527’ #添加元素
dict_one.popitem() #随机删除一个键值对
dict_one.pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值
dict_one.get() #返回指定键的值，如果值不在字典中返回default值