2019-04-19
test
00
请注意,本文编写于 1771 天前,最后修改于 1771 天前,其中某些信息可能已经过时。

目录

1. list
2. 元组
3. 字符串
4. bytes和bytearray
5. set
6. dict

本文主要是整理python的基本类型,包括列表、元组、字典、字符串、bytes和集合(set)的基本操作和应用。

1. list

python
### list:可变,可索引,有序(可索引),元素可重复,使用[]表示 lst = [1,3,'a',('a','b'),'mykernel'] #修改 lst[2] = 'good' print('1.',lst) #追加 lst.append('end str') print('2.',lst) #插入 lst.insert(3,'gogogog') print('3.',lst) #扩展新列表 lst2= ["new","list"] lst.extend(lst2) print('4.',lst) tup = ('a','b') lst.extend(tup) print('5.',lst) # + => list # * => list,重复 new_list = [1,2] old_list= [1] new1= new_list+old_list print('6.',new1) new2= new_list*3 print('7.',new2) #移除,移除找到的第一个,移除所有的如何写? new2.remove(1) print('8.',new2) new2.pop(3) #移除索引为3的 print('9.',new2) #清空 new2.clear() #反转 lst.reverse() print('9.',lst) #排序 l = [1,1,2,-100] l.sort() print('10.',l) ### 进阶 #列表复制,浅拷贝 lst = [1,2,3,4,11,'a',[1,2,4]] lst1 = lst lst2 = lst.copy() lst[6][1] = '1' print('11.',lst1,'\n ',lst2) #原引用里的值改变,新列表也会变 #深拷贝 import copy lst0 = [1,[2,3,4],5] lst5 = copy.deepcopy(lst0) lst0[1][1] = 21 print('12.',lst0,'\n ',lst5) #lst0 != lst5 #随机数 import random #从[0-9] 中随机挑选一个值 print('13,',random.randint(0,9)) print('14,',random.choice(range(10))) #打乱列表 lst6 = copy.deepcopy(lst) random.shuffle(lst6) print('15.',lst,'\n ',lst6)

求100以内的素数

python
# The first solution import math p1=[2,3,5,7] n = 100 for x in range(10,n): for i in range(2,math.ceil(math.sqrt(x))): if x % i == 0: break else: p1.append(x) print(p1) #The second solution #合数一定可以分解成几个质数的乘积 import math n = 100 lst = [] for x in range(2,n): for i in lst: if x % i ==0: break else: lst.append(x) print(lst) ## optimize code # 带flag判断,提高程序效率。 import math lst = [2] flag = False for x in range(2,100): #x=13 for i in p: #p=[2,3,5,7] if x % i ==0: # x%i != 0 flag = True break if i >= math.ceil(math.sqrt(x)): #i< math.ceil(math.sqrt(x)) flag = False break if not flag: #flag = false ==> true lst.append(x) print(lst)

打印杨辉三角( Pascal's triangle)

python
# The first solution # 下一行和上一行的关系 triangle = [[1],[1,1]] for i in range(2,6): cur = [1] pre = triangle[i-1] for j in range(len(pre)-1): cur.append(pre[j]+pre[j+1]) cur.append(1) triangle.append(cur) print(triangle) #The second solution triangle = [] n =6 for i in range(n): row = [1] triangle.append(row) if i == 0: continue for j in range(i-1): row.append(triangle[i-1][j]+triangle[i-1][j+1]) row.append(1) print(triangle) #Third option ,while n = 6 oldline = [] newline = [1] print(newline) length = 0 for i in range(1,n): oldline = newline.copy() oldline.append(0) newline.clear() offset = 0 while offset <= i: newline.append(oldline[offset-1]+ oldline[offset]) offset +=1 print(newline) #Third option ,for n = 6 oldline = [] newline = [1] print(newline) length = 0 for i in range(1,n): oldline = newline.copy() oldline.append(0) newline.clear() for j in range(i+1): newline.append(oldline[j-1]+ oldline[j]) print(newline) #Option 4 triangle = [] n = 6 for i in range(n): row = [1]*(i+1) triangle.append(row) if i == 0: continue for j in range(1,i//2+1): #n=3 开始 val = triangle[i-1][j-1] + triangle[i-1][j] row[j] = val if i !=2j: #奇数个数的中点跳过 row[-j-1] = val print(triangle)

2. 元组

python
# 元组有序(可索引),不可变,小括号()表示,可以重复,只读(不能增删改) ## 对比 list:有序(可索引),可变,使用[]表示,元素可重复 # 定义 print(tuple()) print((2,2)) print(tuple(range(1,7,2)))
python
t = (1,(2,),'a',[1,2],1,2,2,2,1,1,1) print('1,',(t.index(1))) #返回找到的第一个的索引 print('2,',t.count(1)) #返回value的个数 print('3,',len(t)) #长度 #命名元组 from collections import namedtuple point = namedtuple('_point',['x','y']) p = point(21,12) print('4,',p.x,p.y)

冒泡法排序

python
# 对列表[1,9,8,5,6,7,4,3,2]使用冒泡法进行排序,要求使用封装和解构来交换数据 lst = [1,9,8,5,6,7,4,3,2] for i in range(len(lst)): for j in range(8-i): if lst[j]>lst[j+1]: #靠前位置的值大于靠后位置的值,前位置获取小的值。 lst[j],lst[j+1]=lst[j+1],lst[j] print(lst)

3. 字符串

python
# 元组有序(可索引),不可变,小括号()表示,可以重复,只读(不能增删改) ## 对比 list:有序(可索引),可变,使用[]表示,元素可重复 ### 字符串是不可变的,有序,使用引号(单双,单双三)
python
str = "my name is mykernel" lst = [] for i in str: lst.append(i) print(lst) lst2 = list(str) print(lst2)
python
#其他相关操作 ## split print('1,','l love python'.split()) # split()的()中指定分隔符 # 默认使用空格作为分隔符 # maxsplit=# 可以指定分隔的次数。 print('2,','my name is mykernel'.split('m',maxsplit=1)) ##rsplit #分隔符可以是任意字符串。 print('3,','my name is mykernel'.rsplit('m',maxsplit=1)) #当不用maxsplit= 时候,split和rsplit效果一样,但是split效率更高。 ##splitlines l = """l love python i am mykernel """ print('4,',l.splitlines()) ##partition l = """l love python""" print('5,',l.partition(' ')) #partition() 不能不传入分隔符,只分隔一次,打印内容,为前半部分、分隔符和后半部分. print('#'*20,'大小','#'*20) #upper l = """l love python""" #转大写 l2= l.upper() print('5,',l2) #lower l3 = l2.lower() #转小写 print('6,',l3) print('#'*20,'替换','#'*20) #replace 替换 str = 'i love python' print('7,',str.replace('love python','am mykernel') ) #前边是旧的字符串,后边是新的字符串。 #控制替换的个数 str = 'i very very very love python ' print('8,',str.replace('very','非常',2)) #替换2个
python
print('#'*20,'去除','#'*20) #strip 去掉 str = ' mykernel love python \n' str2 = str.strip() #strip 可以加其他字符串,意思就是去掉两端可以匹配到的对应的字符串 print('9,',str2) #lstrip()只移除左侧部分; #rstrip()只移除右侧部分。 print('#'*20,'填充','#'*20) print('10,','mykernel'.ljust(30)) print('10,','mykernel'.rjust(30)) print('10,','mykernel'.center(30)) #一边15个。。。。 print('11,','mykernel'.ljust(30,'+')) print('11,','mykernel'.rjust(30,'#')) print('11,','mykernel'.center(30,'*')) #一边15个。。。。 print('#'*20,'查找','#'*20) #find() 查找返回找到的第一个的索引 str = 'i very very very love python ' print('12,',str.find('very')) print('12,',str.find('very',5)) print('12,',str.rfind('very',4)) print('12,',str.rfind('very',-20,-1)) #index(sub[, start[, end]]) #在指定的区间,从左到右。找到返回对应的索引值,没找到返回ValueError。 #rindex(sub[, start[, end]]) #在指定的区间,从右到左。找到返回对应的索引值,没找到返回ValueError。 #count 在指定的区间,从左到右,统计子字符串sub出现的次数 str = 'i very very very love python ' print('13,',str.count('very')) print('13,',str.count('very',5)) print('13,',str.count('very',5,11))
python
#判断 #startwith() str = 'i am mykernel,i very very very love python' print(str.startswith('am')) print(str.startswith('i')) ## 也可以指定范围进行匹配。 print(str.startswith('am',2,20)) #(2,20] #endswith() str = 'i am mykernel,i very very very love python' print(str.endswith('am')) print(str.endswith('python'))
python
print('#'*20,'拼接','#'*20) # + print('1,','i'+' love'+' python') # join print('2,',' '.join(['i'+' love'+' python'])) print('#'*20,'格式化','#'*20) s = 'i love %s' #%s为格式占位符,然后再其他地方可以将参数传入并替换该占位符。 s1 = s%('python',) #将python传入,替换占位符。 print('3,',s1) ##format字符串格式化 #a. format方法可以使用花括号作为占位符,传入的参数将替换花括号。 s = 'i love {}' #{}作为占位符 s1 = s.format('python') print('4,',s1) # format方法的参数可以为多个,如果不在括号里指定其位置一一对应引入。 s ='i love {}, i am {}' s1 = s.format('python','mykernel') #按照位置传入 print('5,',s1) # format方法可以在花括号里填入位置数字,其后的参数按照位置引入,从0号位置开始 s ='i love {1}, i am {0}' s1 = s.format('python','mykernel') print('6,',s1) s ='i love {0}, i am {0}' s1 = s.format('python','mykernel') print('7,',s1) #format方法可以用字符作为占位符的标志,方便识别。 s1='i love {language},i am {name}'.format(language='python',name='mykernel') print('8,',s1) #format方法的占位符可以混用,但是位置参数必须放在最前。 s1 = 'my name is {0},i love {language},i am {age}'.format('mykernel',language='pyrhon',age=18) print('9,',s1)

说明1:

占位符的个数大于参数个数的时候,会抛出异常IndexError。 占位符的个数小于参数个数的时候,若对应的占位符能匹配到值则不报错,匹配不到值会返回异常。 当占位符出现混用的情况时,位置参数不在最前会返回异常。 说明2:

通常使用2.6或之后的版本使用format方法,2.6之前使用printf style。 在format中,需要注意的是,在2.6版本中是不能省略大括号里面的数字或者关键字。 字符串对齐

python
print('{0}*{1}={2:<4}'.format(3,2,2*3)) #右边4个空格 print('{0}*{1}={2:>4}'.format(3,2,2*3)) print('{0}*{1}={2:<04}'.format(3,2,2*3)) print('{:^30}'.format('centered')) #左右各30个空格 print('{:*^30}'.format('centered'))
python
## 演变过程 print('{}'.format(1)) #右对齐 print('{:>8}'.format(1)) print('{:^{}}'.format(1,11)) #格式填充^、<、>分别是居中、左对齐、右对齐,后面带宽度

4. bytes和bytearray

python
# 元组有序(可索引),不可变,小括号()表示,可以重复,只读(不能增删改) ## 对比 list:有序(可索引),可变,使用[]表示,元素可重复 ### 字符串是不可变的,有序,使用引号(单双,单双三) #### bytes是不可变的字节序列,bytearray是可变的字节序列
python
# str -> bytes str = 'abc' bys = str.encode() print(bys) #bytes -> str str1 = bys.decode() print(str1) #生成bytearray bar = bytearray(1) bar1 = bytearray(b'123') print(bar,bar1) #bytearray的相关方法 b = bytearray() b.append(97) b.append(99) b.insert(1,98) b.extend([65,66,67]) b.extend(bytearray(b'aavv')) print(b) b.remove(66) print(b) b.pop() print(b) b.reverse() print(b) b.clear() print(b)

字符串转16进制

python
bytearray('abc'.encode()).hex()
'616263'

5. set

python
# 元组有序(可索引),不可变,小括号()表示,可以重复,只读(不能增删改) ## 对比 list:有序(可索引),可变,使用[]表示,元素可重复 ### 字符串是不可变的,有序,使用引号(单双,单双三) #### bytes是不可变的字节序列,bytearray是可变的字节序列 ##### set叫集合,元素可变(元素需要可hash)、无序(无法索引,可以迭代)、不重复(去重??)
python
#定义 s1 = {(1,),1,'1',b'1'} print('1,',s1) #增加元素,元素存在则什么都不做 s1.add('a') print('2,',s1) s1.update([1,2,3,4]) #update中为可迭代对象即可 print('3,',s1) s1.update('str 11') #注意字符串一个字符算一个元素 print('4,',s1) #删除 s1.remove(1) #移除的元素不存在 报错 print('5,',s1) s1.discard('1') #移除的元素不存在 不报错 print('6,',s1) print(s1.pop()) # -> item ,任意移除一个元素,s1为空报错 print('7,',s1) #清除 s1.clear() print('8,',s1) #其他 #1. set 不能修改 #2. set 非线性结构不能查询 #3. set 无序,但是可以for in 迭代,无法索引 #可以使用in 或者 not in 判断元素是否存在,效率极高。因为元素为hash存放
1, {1, b'1', '1', (1,)} 2, {1, (1,), 'a', b'1', '1'} 3, {1, 2, 3, 4, (1,), 'a', b'1', '1'} 4, {1, 2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'} 5, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'} 6, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'} 2 7, {3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'} 8, set()

集合的运算

交差并补

6. dict

python
# 元组有序(可索引),不可变,小括号()表示,可以重复,只读(不能增删改) ## 对比 list:有序(可索引),可变,使用[]表示,元素可重复 ### 字符串是不可变的,有序,使用引号(单双,单双三) #### bytes是不可变的字节序列,bytearray是可变的字节序列 ##### set叫集合,元素可变(元素需要可hash)、无序(无法索引,可以迭代)、不重复(去重??) ###### dict,k-v组合,可变,无序,key不能重复
python
d = {'k':'v','1':2,'aa':[1,2,3],'bb':(32,2)} print(d) #访问 print('1,',d['k']) print('2,',d.get('ss',6)) #6为设置的默认值(可省),k不存在则返回默认值 print('3,',d.setdefault('k',5)) #5为设置的默认值(可省),如果key不存在则添加kv对 print('1,',d) #添加 d['new'] = 44 #key存在就修改,不存在就添加 print('2,',d) d.update({'new1':1,"new2":2}) #添加一个对象,只能是字典 d.update(red=1) d.update((('red1',1),)) print('3,',d) #删除 d.pop('k') #key存在就删除并返回value,不存在返回默认值,无默认值报错 d.popitem() #随机删除一个kv对,dict为空则报错 print('4,',d) #清空 d.clear() print('5,',d)
{'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)} 1, v 2, 6 3, v 1, {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)} 2, {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44} 3, {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1, 'red1': 1} 4, {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1} 5, {}

遍历字典

python
d = {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)} #打印k for k in d.keys(): print(k) print('='*40) #打印value for v in d.values(): print(v) print('='*40) #遍历items for it in d.items(): print(it) print('='*40) for k,v in d.items(): print(k,v) #接轨
1 aa bb ======================================== 2 [1, 2, 3] (32, 2) ======================================== ('1', 2) ('aa', [1, 2, 3]) ('bb', (32, 2)) ======================================== 1 2 aa [1, 2, 3] bb (32, 2)

有序字典

python
from collections import OrderedDict od = OrderedDict() od['k'] = 'v' od
OrderedDict([('k', 'v')])

习题1. 用户输入一个数字,打印每一位数字及其重复的次数

python
str = "11gghhbsdsa" d = {} for i in str: d[i] = str.count(i) print(d)
{'1': 2, 'g': 2, 'h': 2, 'b': 1, 's': 2, 'd': 1, 'a': 1}

习题2. 数字重复统计: 1.随机产生100个整数

  1. 数字的范围[-1000,1000]
  2. 降序序输出所有不同的数字及其重复的次数
python
import random lst = random.choices(range(-50,51),k=100) d = dict(zip(lst,[0]*10)) for k in d.keys(): d[k] = lst.count(k) sorted(d.items(),key = lambda x:x[1],reverse=True)
[(20, 6), (-17, 4), (-30, 3), (41, 3), (-19, 2), (-1, 2), (-47, 2), (-9, 1)]

本文作者:mykernel

本文链接:

版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!