python数字和运算符空格_Python基础——运算符与数据结构（200315）

<34> rpartition():       ——根据指定字符对字符串进行分割，保留指定字符，从右边开始，只分三份

<35>split('对象'，'个数'):      ——根据指定字符对字符串进行分割，不保留指定字符，从左边开始，可设置分割个数

<36>rsplit('对象'，'个数'):     ——根据指定字符对字符串进行分割，不保留指定字符，从右边开始，可设置分割个数

1 test = 'klagjkjgsdajkjgcadajiiutu'

2 v = test.partition('a') #根据单个‘a’对字符串进行分割，从左边只找第一个，只分三份

3 print(v)4 #=> ('kl', 'a', 'gjkjgsdajkjgcadajiiutu')

5 v = test.rpartition('a') #根据单个‘a’对字符串进行分割，从右边只找第一个，只分三份

6 print(v)7 #=> ('klagjkjgsdajkjgcad', 'a', 'jiiutu')

8 v = test.split('a') #根据全部‘a’对字符串进行分割，分多段

9 print(v)10 #=> ['kl', 'gjkjgsd', 'jkjgc', 'd', 'jiiutu']

11 v = test.rsplit('a') #根据全部‘a’对字符串进行分割，分多段

12 print(v)13 #=>['kl', 'gjkjgsd', 'jkjgc', 'd', 'jiiutu']

<37> splitlines(self, keepends: bool = ...) -> List[str]: ...     ——对字符串进行分割，只能根据\n进行分割，True,False 表示是否保留换行符\n

1 test = 'dsafsdgdg\ngfdhghgh\ngdgfdhgh'

2 v =test.splitlines(False)3 print(v)4 #=> ['dsafsdgdg', 'gfdhghgh', 'gdgfdhgh']

<38> swapcase(self) -> str: ...     ——大小写转换

1 test = 'fsDG'

2 v =test.swapcase()3 print(v)4 #=> FSdg

<39> len():    ——判断字符串长度，也可判断列表长度

1 test = '你真棒！'

2 list = [11,22,33,44,55]3 v =len(test)4 print(v)5 #=> 4

6 print(len(list))7 #=> 5

<40> zfill(self, width: int) -> str: ...    ——居左只填充0，可设置宽度width

1 test = 'love'

2 v = test.zfill(20)3 print(v)4 #=> 0000000000000000love

<41> replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ..      ——替换，旧字符串替换新字符串，可设置替换个数

1 test = 'love you love you'

2 v =test.replace('o','m')3 print(v)4 #=> lmve ymu lmve ymu

5 test = 'love you love you'

6 v =test.replace('o','m',2) #可设置参数，进行替换个数的选择

7 print(v)8 #=> lmve ymu love you

3.列表(list)

列表(list)：列表由中括号括起，每个元素之间由逗号(,)分隔。如：li = [11,22,33,44,'我','老虎',]

列表中可以嵌套任何类型，数字、字符串、元组、列表、字典等等，可以无限嵌套。如：li = [[123,456,789],(1234,5678),{'一':1,'二':2}]

列表是有序的，列表元素可以被修改。

1)列表(list)基础操作

<1> 列表取值

1 li = [1,2,3,'sjlajg','你好',['are','you','ok']]2 #--—索引取值

3 print(li[3])4 #=>sjlajg

5 #——切片取值

6 print(li[2:5])7 #=>[3, 'sjlajg', '你好']

8 print(li[-4:-1])9 #=>[3, 'sjlajg', '你好']

<2> for / while 循环

1 li = [1,2,3,'sjlajg','你好',['are','you','ok']]2 #——for循环

3 for i inli:4 print(i) #遍历列表，将列表中的每一个元素取出

5 #——while 循环

6 a = 1

7 while a < 5:8 print(li[a])9 a += 1 #按条件遍历列表

<3> 修改列表

1 li = [1,2,3,'sjlajg','你好',['are','you','ok']]2 #——索引修改元素

3 li[1] = '我爱你'

4 print(li)5 #=>[1, '我爱你', 3, 'sjlajg', '你好', ['are', 'you', 'ok']]

6 #——切片修改元素

7 li[1:3] = [78,'你真棒']8 print(li)9 #=>[1, 78, '你真棒', 'sjlajg', '你好', ['are', 'you', 'ok']]

<4> 删除元素

1 li = [1,2,3,'sjlajg','你好',['are','you','ok']]2 #——del 删除

3 del li[4]4 print(li)5 #=>[1, 2, 3, 'sjlajg', ['are', 'you', 'ok']]

<5> in 和 not in 操作

1 #——in

2 li = [1,2,3,'sjlajg','你好',['are','you','ok']]3 v = '你好' inli4 print(v)5 #=>True

6 b = 100 not inli7 print(b)8 #=>True

<6> 列表嵌套取值操作

1 li = [1,2,3,'sjlajg','你好',['are','you',[120,666],'ok']]2 print(li[5][2][1])3 #=>666

<7> 字符串与列表相互转换

1 #——将字符串转换为列表

2 a = '我是英雄'

3 new_a = list(a) #字符串转列表，直接用list()转换，内部使用for循环

4 print(new_a)5 #=>['我', '是', '英', '雄']

6 #——将列表转换为字符串

7 #——<1>for循环，既有数字又有字符串

8 li = [12,3,5,'gf','你好']9 v = str(li) #str()整体作为一个字符串

10 print(v)11 #=>[12, 3, 5, 'gf', '你好']

12 s = ''

13 for i inli:14 s +=str(i)15 print(s)16 #=>1235gf你好

17 #——<2>join方法拼接，列表中元素只有字符串

18 li = ['hahg','sgb','年后']19 v = ''.join(li)20 print(v)21 #=>hahgsgb年后

2)列表(list)方法

<1> append(self, object)：在列表末尾添加一个元素，需要写参数；

1 li = [11,22,33,44]2 li.append(5) #参数，原来值最后追加

3 print(li)4 #=>[11, 22, 33, 44, 5]

<2> clear(self)：清空列表；

1 li = [11,22,33,44]2 li.clear()3 print(li)4 #=>[]

<3> copy(self)：拷贝，浅拷贝；

1 li = [11,22,33,44]2 v =li.copy()3 print(v)4 #=>[11, 22, 33, 44]

<4> count(self, objec) ：计算列表中元素出现的个数；

1 li = [11,22,33,44,55,66,44]2 v = li.count(44)3 print(v)4 #=>2

<5> extend(self, iterable)：扩展原来的列表，将可迭代对象(字符串、列表、元组……)一个一个添加到列表中；

1 li = [11,22,33,44]2 li.extend('我爱你')3 print(li)4 #=>[11, 22, 33, 44, '我', '爱', '你']

5 li1 = [1,23,88,99] #可用于列表的相加

6 li.extend(li1)7 print(li)8 #=>[11, 22, 33, 44, '我', '爱', '你', 1, 23, 88, 99]

<6> index(self, object, start:., stop: ) ：根据元素寻找索引，从左往右，只找第一个，可设置开始和结束位置；

1 li = [11,22,33,44,55,66,77,'我是','你',33]2 v = li.index('你')3 print(v)4 #=>8

5 b = li.index(33,4) #可以设置起始位置

6 print(b)7 #=>9

<7> insert(self, index, object)：在指定索引位置插入元素；

1 li = [11,22,33,44]2 li.insert(1,99) #第一个索引位置，第二个元素

3 print(li)4 #=>[11, 99, 22, 33, 44]

<8> pop(self, index.)：删除指定索引下标位置的元素，也可进行指定索引元素的提取,不填默认删除最后一个元素；

1 li = [11,22,33,44]2 v = li.pop(2)3 print(v) #提取元素

4 #=>33

5 print(li) #删除指定索引下标的元素

6 #=>[11, 22, 44]

<9> remove(self, object)：删除指定元素，从左往右，删除第一个出现的元素；

1 li = [11,22,33,44]2 li.remove(44)3 print(li)4 #=>[11, 22, 33]

<10> reverse(self)：反转列表，将列表顺序前后颠倒；

1 li = [11,22,33,44]2 li.reverse()3 print(li)4 #=>[44, 33, 22, 11]

<11> sort(self,key,reverse=False)：对列表进行排序，默认从小到大，reverse=True 从大到小；

1 li = [11,44,22,55,33]2 li.sort() #默认从小到大排序

3 print(li)4 #=>[11, 22, 33, 44, 55]

5 li1 = [11,44,22,55,33]6 li1.sort(reverse=True) #变为从大到小排序

7 print(li1)8 #=>[55, 44, 33, 22, 11]

4.元组(tuple)

元组(tuple)：元组由小括号括起，中间由逗号(，)分隔。如：tu = (11,22,33,44,55,66,)。

元组是有序的，一级元素不可被修改，不能被增加或删除。

一般写元组的时候，最后多加一个逗号。如：tu = (11,22,33,44,55,66,)

元组中可以嵌套任何类型，数字、字符串、元组、列表、字典等等，可以无限嵌套。如：tu = (1,2,3,'sjlajg','你好',('are','you',(120,666),'ok',),)。

1)元组(tuple)基础操作

<1> 元组取值

1 tu = (12,46,7,8,'wwe','爱的',)2 #--—索引取值

3 print(tu[3])4 #=>8

5 #——切片取值

6 print(tu[2:5])7 #=>(7, 8, 'wwe')

8 print(tu[-4:-1])9 #=>(7, 8, 'wwe')

<2> for 循环，可迭代对象

1 tu = (12,46,7,8,'wwe','爱的',)2 for i intu:3 print(i)

<3> 列表、元组、字符串的相互转换

1 #——元组转换为列表

2 tu = (12,46,7,8,'wwe','爱的',)3 li =list(tu)4 print(li)5 #=>[12, 46, 7, 8, 'wwe', '爱的']

6 #——列表转换为元组

7 li = [12,3,5,6,6]8 tu =tuple(li)9 print(tu)10 #=>(12, 3, 5, 6, 6)

11 #——字符串转换为元组

12 st = '我是你的苹果'

13 tu =tuple(st)14 print(tu)15 #=>('我', '是', '你', '的', '苹', '果')

16 #——元组转换为字符串

17 #——<1>for循环，既有数字又有字符串

18 tu = (12,3,5,'gf','你好')19 v = str(tu) #str()整体作为一个字符串

20 print(v)21 #=>(12, 3, 5, 'gf', '你好')

22 s = ''

23 for i intu:24 s +=str(i)25 print(s)26 #=>1235gf你好

27 #——<2>join方法拼接，元组中元素只有字符串

28 tu = ('hahg','sgb','年后')29 v = ''.join(tu)30 print(v)31 #=>hahgsgb年后

<4> 元组嵌套取值操作

1 tu = (1,2,3,'sjlajg','你好',('are','you',(120,666),'ok',))2 print(tu[5][2][1])3 #=>666

<5> 元组的一级元素不可修改、删除、增加，列表元素可修改

1 tu = (1,2,3,'sjlajg','你好',('are','you',[120,666],'ok',))2 tu[5][2][1] = '你真棒'

3 print(tu)4 #=>(1, 2, 3, 'sjlajg', '你好', ('are', 'you', [120, '你真棒'], 'ok'))

2)元组(tuple)方法

<1> count()：计算某个元素的个数；

1 tu = (11,22,33,44,55,44,)2 v = tu.count(44)3 print(v)4 #=>2

<2> index()：查找某个元素对应的索引下标,从左到右查找，找寻第一个；

1 tu = (11,22,33,44,55,44,)2 v = tu.index(55)3 print(v)4 #=>4

5.字典(dict)

字典(dict)：字典由大括号括起，键值对之间由英文冒号隔开，每个键值对之间由逗号(，)分隔；如：info = {'k1':10,'k2':True,'k3':[11,22,33],'K4':{'a1':110,'b1':[999,1000]},'k5':(12,23,34)}。

字典中可以嵌套任何类型，数字、字符串、元组、列表、字典等等,可以无限嵌套。

布尔值、列表、字典不能作为字典的键(key),字典的值(value)可以为任何类型数据。

字典是无序的，可以进行删除和增加功能。

1)字典(dict)基础操作

<1> 字典取值,通过键(key)取值(value)

1 #——索引方式找到指定元素，不能用切片方式寻找元素

2 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}3 print(info['k1'])4 #=>11

5 print(info['k4'][1])6 #=>55

7 print(info['k5'][2])8 #=>88

<2> 字典支持del删除操作

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 del info['k2']3 print(info)4 #=>{'k1': 11, 'k3': 33, 'k4': (44, 55), 'k5': [66, 77, 88]}

5 del info['k5'][1] #嵌套删除

6 print(info)7 #=>{'k1': 11, 'k3': 33, 'k4': (44, 55), 'k5': [66, 88]}

<3> for 循环

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 for i in info: #默认循环键(key0

3 print(i)4 #=>k1 k2 k3 k4 k5

5 for i in info.keys(): #循环键(key)

6 print(i)7 #=>k1 k2 k3 k4 k5

8 for i in info.values(): #循环值(value)

9 print(i)10 #=>11 22 33 (44, 55) [66, 77, 88]

11 for i,o in info.items(): #同时循环键(key)和值(value)

12 print(i,o)13 #=>k1 11 k2 22 k3 33 k4 (44, 55) k5 [66, 77, 88]

2)字典(dict)方法

<1>  clear(self)：清空字典

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 info.clear()3 print(info)4 #=>{}

<2> copy(self)：复制拷贝字典,浅拷贝

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 dic =info.copy()3 print(dic)4 #=>{'k1': 11, 'k2': 22, 'k3': 33, 'k4': (44, 55), 'k5': [66, 77, 88]}

<3> fromkeys(*args, **kwargs):根据序列，创建字典，并指定统一的值

1 dic = dict.fromkeys('一',1) #根据字符串，创建键(key)，1为值(value)

2 print(dic)3 #=>{'一': 1}

4 dic1 = dict.fromkeys(('k1','k2','k3',)) #根据元组，创建键(key)

5 print(dic1)6 #=>{'k1': None, 'k2': None, 'k3': None}

7 dic2 = dict.fromkeys(('k1','k2','k3',),111) #为键统一指定值

8 print(dic2)9 #=>{'k1': 111, 'k2': 111, 'k3': 111}

10 dic3 = dict.fromkeys(['k1','k2','k3'],111) #根据列表生成键值对

11 print(dic3)12 #=>{'k1': 111, 'k2': 111, 'k3': 111}

13 dic4 = dict.fromkeys('我',(111,222))14 print(dic4)15 #=>{'我': (111, 222)}

16 dic5 = dict.fromkeys('我是你',(111,222))17 print(dic5)18 #=>{'我': (111, 222), '是': (111, 222), '你': (111, 222)}

<4> get(self, *args, **kwargs)：根据key获取值，key不存在时，返回默认值(None)，可以指定任意值

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 v = info.get('你好') #没有“你好”的键(key),返回None

3 print(v)4 #=>None

5 v = info.get('k2') #有键'k2'，返回值22

6 print(v)7 #=>22

8 v = info.get('你好',666) #没有键“你好”,指定了返回值666，就返回666

9 print(v)10 #=>666

11 v = info.get('k2',666) #有键'k2'，返回'k2'相对应的值22

12 print(v)13 #=>22

<5> keys(self): 提取字典的键

<6> values(self): 提取字典的值

<7> items(self): 提取字典的键和值

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 for i in info.keys(): #循环键(key)

3 print(i)4 #=>k1 k2 k3 k4 k5

5 for i in info.values(): #循环值(value)

6 print(i)7 #=>11 22 33 (44, 55) [66, 77, 88]

8 for i,o in info.items(): #同时循环键(key)和值(value)

9 print(i,o)10 #=>k1 11 k2 22 k3 33 k4 (44, 55) k5 [66, 77, 88]

<8> pop(self, k, d=None)：删除指定键和对应的值，并且可以获取要删除的键和值

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 v = info.pop('k5')3 print(v)4 #=>[66, 77, 88]

5 print(info)6 #=>{'k1': 11, 'k2': 22, 'k3': 33, 'k4': (44, 55)}

<9> popitem(self): 随机删除一个键值对，也可进行获取其删除掉的键值对

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 v =info.popitem()3 print(info)4 #=>{'k1': 11, 'k2': 22, 'k3': 33, 'k4': (44, 55)}

5 print(v)6 #=>('k5', [66, 77, 88])

<10> setdefault(self, *args, **kwargs)：设置值，已存在，不设置，获取key对应的值；不存在，设置，获取当前key对应的值。可用于获取值或添加键和值

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 v = info.setdefault('k1')3 print(v)4 #=>11

5 print(info)6 #=》{'k1': 11, 'k2': 22, 'k3': 33, 'k4': (44, 55), 'k5': [66, 77, 88]}

7 v = info.setdefault('ok','are you')8 print(v)9 #=>are you

10 print(info)11 #=>{'k1': 11, 'k2': 22, 'k3': 33, 'k4': (44, 55), 'k5': [66, 77, 88], 'ok': 'are you'}

<11> update(self, E=None, **F)：更新字典

1 info = {'k1':11,'k2':22,'k3':33,'k4':(44,55),'k5':[66,77,88]}2 info.update({'k1':110,'are':'you ok'})3 print(info)4 #=>{'k1': 110, 'k2': 22, 'k3': 33, 'k4': (44, 55), 'k5': [66, 77, 88], 'are': 'you ok'}

5 info.update(k1=1234,k2=5678,k3=9090)6 print(info)7 #=>{'k1': 1234, 'k2': 5678, 'k3': 9090, 'k4': (44, 55), 'k5': [66, 77, 88], 'are': 'you ok'}

6.集合(set)

集合(set)：①由不同元素组成、②无序、③集合中元素必须是不可变类型。

集合(set)：集合由大括号括起，每个元素之间由逗号分隔：set = {1,2,3,4,5}。

1)集合(set)基础操作

<1> 集合中的元素必须不能重复、是无序的。(如果集合内有重复元素，会自动去重)

1 s = {11,22,33,44,55,55,66,33,77}2 print(s)3 #=>{33, 66, 11, 44, 77, 22, 55}

<2> 可以使用set()格式来生成集合，前提必须是可迭代对象。

1 s = set('hello')2 print(s)3 #=>{'e', 'o', 'l', 'h'}

4 s = set(['我','是','中','你','是'])5 print(s)6 #=>{'你', '我', '是', '中'}

<3> frozenset()：生成不可变集合(一旦创建不可被修改，可用于生成字典的键key)

1 s = frozenset('hello')2 print(s)3 #=>frozenset({'e', 'l', 'o', 'h'})

<4> 列表、集合去重，不改变顺序

1 li = ['你','爱','我','是','你']2 print(list(set(li)))3 #=>['爱', '你', '我', '是']

2)集合(set)方法

<1> add():添加一个元素

1 s = {11,22,33,44,55}2 s.add(3)3 print(s)4 #=>{33, 3, 11, 44, 22, 55}

5 s.add('是')6 print(s)7 #=>{33, 3, 11, 44, '是', 22, 55}

<2> clear():清空元素

1 s = {11,22,33,44,55}2 s.clear()3 print(s)4 #=>set()

<3> copy():复制拷贝，浅拷贝

1 s = {11,22,33,44,55}2 s1 =s.copy()3 print(s1)4 #=>{33, 22, 55, 11, 44}

<4> pop():随机删除元素

1 s = {11,22,33,44,55}2 s.pop()3 print(s)4 #=>{11, 44, 22, 55}

<5> remove():可以删除指定元素，删除不存在的元素会报错

1 s = {11,22,33,44,55,'123','567'}2 s.remove(33)3 print(s)4 #=>{11, 44, '567', '123', 22, 55}

5 s.remove('我是你')6 print(s)7 #=>会报错！！！

<6> discard():可以删除指定元素，删除不存在的元素不会报错

1 s = {11,22,33,44,55,'123','567'}2 s.discard(33)3 print(s)4 #=>{'123', 11, 44, '567', 22, 55}

5 s.discard('我是你')6 print(s)7 #=>{'123', 11, 44, '567', 22, 55} ===》不会报错！！

<7> intersection()/&:求元素的交集,相当于and

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 print(s1,s2)4 #=>{'王五', '黄八', '朱二', '张三', '李四', '刘六', '冯大'} {'喜欢', '黄八', '上树', '张三', '跳舞', '爱'}

5 print(s1.intersection(s2))6 #=>{'黄八', '张三'}

7 print(s1 &s2)8 #=>{'张三', '黄八'}

<8> union()/|:求元素的并集

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 print(s1.union(s2))4 #=>{'上树', '黄八', '冯大', '刘六', '朱二', '跳舞', '喜欢', '爱', '张三', '王五', '李四'}

5 print(s1 |s2)6 #=>{'上树', '黄八', '冯大', '刘六', '朱二', '跳舞', '喜欢', '爱', '张三', '王五', '李四'}

<9> difference()/-:求元素的差集

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 print(s1 -s2)4 #=>{'朱二', '李四', '冯大', '刘六', '王五'}

5 print(s2 -s1)6 #=>{'跳舞', '爱', '喜欢', '上树'}

7 print(s1.difference(s2))8 #=>{'王五', '冯大', '朱二', '李四', '刘六'}

<10> symmetric_difference()/^:求交叉补集,两个集合中去除相同元素，剩余所有元素的集合

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 print(s1.symmetric_difference(s2))4 #=>{'朱二', '上树', '喜欢', '王五', '跳舞', '冯大', '李四', '刘六', '爱'}

5 print(s1 ^s2)6 #=>{'朱二', '上树', '喜欢', '王五', '跳舞', '冯大', '李四', '刘六', '爱'}

<11> difference_update():求完差集后，将值赋给原始集合，原始结合发生变化

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 #s1 = s1 - s2

4 #print(s1)

5 ## =>{'朱二', '刘六', '王五', '冯大', '李四'}

6 s1.difference_update(s2)7 print(s1)8 #=>{'王五', '冯大', '李四', '刘六', '朱二'}

<12> isdisjoint():两个集合做交集，没有相同元素即为空集合则返回True

1 s1 = {'张三','李四','王五','刘六','朱二','冯大','黄八'}2 s2 = {'张三','爱','跳舞','黄八','喜欢','上树'}3 print(s1.isdisjoint(s2))4 #=>False # 交集有相同元素，则返回False

<13> issubset():判断一个集合是否是另一个集合的子集

<14> issuperset():判断一个集合是否是另一个集合的父集

1 s1 = {11,22,33,44,55}2 s2 = {1,2,3,4,5,22}3 s3 = {22,33}4 print(s1.issubset(s2)) #判断s1是不是s2的子集

5 #=>False

6 print(s3.issubset(s1)) #判断s3是不是s1的子集

7 #=>True

8 print(s1.issubset(s3)) #判断s1是不是s3的子集

9 #=》False

10 print(s1.issuperset(s3)) #判断s1是不是s3的父集

11 #=》True

<15> update():将另一个集合更新到一个集合

1 s1 = {11,22,33,44}2 s2 = {1,2,3,4,5,66,22}3 s1.update(s2)4 print(s1)5 #=>{33, 1, 2, 3, 4, 5, 66, 11, 44, 22}

案例

1.根据要求实现不同功能

1 name = 'aleX'

2

3 #a.移除 name 变量对应的值两边的空格，并输入移除后的内容

4 v =name.strip()5 print(v)6

7 #b.判断 name 变量对应的值是否以“al”开头，并输出结果

8 v = name.startswith('al')9 print(v)10

11 #c.判断 name 变量对应的值是否以“X”结尾，并输出结果

12 v = name.endswith('X')13 print(v)14

15 #d.将 name 变量对应的值中的“l”替换为"p"，并输出结果

16 v = name.replace('l','p')17 print(v)18

19 #e.将 name 变量对应的值根据“l”分割，并输出结果

20 v = name.split('l')21 print(v)22

23 #f.将 name 变量对应的值变大写，并输出结果

24 v =name.upper()25 print(v)26

27 #g.将 name 变量对应的值变小写，并输出结果

28 v =name.lower()29 print(v)30

31 #h.请输出 name 变量对应的值的第2个字符？

32 print(name[1])33

34 #i.请输出 name 变量对应的值的前3个字符？

35 print(name[0:3])36

37 #j.请输出 name 变量对应的值的后2个字符？

38 print(name[-2:])39

40 #k.请输出 name 变量对应的值中“e”所在索引位置

41 v = name.find('e')42 print(v)43

44 #l.获取子序列，仅不包含最后一个字符，如： oldboy 则获取oldbo ；root 则获取roo

45 print(name[0:-1])

2.将列表的每一个元素拼接成字符串， li = ['alex','eric','rain']

1 li = ['alex','eric','rain']2 i =''

3 v =i.join(li)4 print(v)5 #=>alexericrain

3.制作加法计算器

1 content = input('请输入内容：')2 v = content.split("+")3 answer =04 i =05 for i inv:6 m =int(i)7 answer +=m8 print(answer)9 #=>请输入内容：34+57+234+878

10 #=>1203

4.计算用户输入的内容中有几个十进制小数，几个字母？

1 1 content = input('请输入内容：')2 2 num =03 3 letter =04 4 for i incontent:5 5 ifi.isdecimal():6 6 num += 1

7 7 else:8 8 letter += 1

9 9 print('数字有：'+str(num) ,'字母有：'+str(letter))

5.制作表格  (循环提示用户输入：用户名、密码、邮箱(要求用户输入的长度不超过20个字符，如果超过则只有前20个字符有效))

1 begin_str = '用户名\t密码\t邮箱\n'

2 jh_str = ''

3 whileTrue:4 username = input('请输入姓名：')5 password = input('请输入密码：')6 email = input('请输入邮箱：')7 username += '\t'

8 password += '\t'

9 email += '\n'

10 jh_str += username + password +email11 all_str = begin_str +jh_str12 again = input('是否继续输入(是/否)：')13 if again == '否':14 break

15 excel = all_str.expandtabs(20)16 print(excel)17

18 '''=>请输入姓名：张三

19 请输入密码：123456

20 请输入邮箱：123456@qq.com

21 是否继续输入(是/否)：是

22 请输入姓名：李四

23 请输入密码：789987

24 请输入邮箱：789987@qq.com

25 是否继续输入(是/否)：否

26 用户名 密码 邮箱

27 张三 123456 123456@qq.com

28 李四 789987 789987@qq.com

29'''

6.输入一行字符串， 分别统计出其中英文字母、空格、数字和其它字符的个数。

1 deftj_num(str_zfc):　＃　定义一个统计字符函数2 shuzi =0　　　＃　数字3 ywen =0　　　＃　英文字母4 kge =0　　　＃　空格5 other =0　　＃　其他6 for i instr_zfc:　　　＃　遍历字符串中的每个字符7 ifi.isdecimal():　　＃　判断字符是否是数字8 shuzi += 1

9 elifi.isalpha():　　＃　判断字符是否是英文10 ywen += 1

11 elifi.isspace():　　＃　判断字符是否是空格12 kge += 1

13 else:　　　　　　　　＃　其他14 other += 1

15 print_gs = '字符串中含有英文字母：%d个 数字：%d个 空格：%d个 其它字符：%d个' %(ywen,shuzi,kge,other)16 returnprint_gs17 print('----------字符串字符种类统计----------')18 str_sr = input('输入字符串''\n''>>>')19 v =tj_num(str_sr)20 print(v)21 #----------字符串字符种类统计----------

22 #输入字符串

23 #>>>asdfghjkl;',./ 1234567890

24 #字符串中含有英文字母：9个 数字：10个 空格：1个 其它字符：5个

7.有如下值集合[11,22,33,44,55,66,77,88,99,00],将所有大于66的值保存至字典的第一个key中，将小于66值保存至第二个key的值中。

1 dic ={}2 li = [11,22,33,44,55,66,77,88,99,00]3 li1 =[]4 li2 =[]5 for i inli:6 if i > 66:7 li1.append(i)8 else:9 li2.append(i)10 dic.update(k1=li1,k2=li2)11 print(dic)12 #=>{'k1': [77, 88, 99], 'k2': [11, 22, 33, 44, 55, 66, 0]}

8. 26.有两个列表

1)l1 = [11,22,33]

2)l2 = [22,33,44]

①获取内容相同的元素

②获取l1中有，l2中没有的元素列表

③获取l2中有，l1中没有的元素列表

④获取l1和l2中内容都不同的元素

1 #方法一：

2 l1 = [11,22,33]3 l2 = [22,33,44]4 li =[]5 #获取相同元素

6 for i inl1:7 if i inl2:8 li.append(i)9 print(li)10 #l1中有，l2没有

11 for i inl1:12 if i not inl2:13 li.append(i)14 print(li)15 #l2中有，l1没有

16 for i inl2:17 if i not inl1:18 li.append(i)19 print(li)20 #l1和l2都不同

21 for i inl1:22 if i not inl2:23 li.append(i)24 for o inl2:25 if o not inl1:26 li.append(o)27 print(li)28 #方法二：

29 l1 = [11,22,33]30 l2 = [22,33,44]31 #获取相同元素,交集

32 li =list(set(l1).intersection(set(l2)))33 print(li)34 #l1中有，l2没有，差集

35 li =list(set(l1).difference(set(l2)))36 print(li)37 #l2中有，l1没有，差集

38 li =list(set(l2).difference(set(l1)))39 print(li)40 #l1和l2都不同，交叉补集

41 li =list(set(l1).symmetric_difference(set(l2)))42 print(li)