字符串和常用数据结构
字符串
字符串是由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值