pythona = 4
b = 5
print(a,b)
a,b = b,a
print(a,b)
python#简单模式
lst = [1,3,(4,4)]
a,b,c = lst
print(a,b,c)
#进阶
a,b,(c,d) = lst
print(a,b,c,d)
tup= (1,2,3)
a,b,c = tup
print(a,b,c)
#_丢弃
#*批量收集
tup= (1,2,3,4,5,6,7,8)
a,b,c,*d,_ = tup
print(*d)
线性结构:列表、元组、字符串、bytes、bytearray
线性结构的特点:
非线性结构: set、dict 元素(dict的key)要求可以hash,查询的时间复杂度为0(1)
python# sequence[start:stop:step]
str = 'mykernel'
print(str[1])
print(str[:])
print(str[:-1])
print(str[:-1:2])
print(str[::-1]) #倒序打印
lst =list(str)
print(lst[::-1])
print(bytearray(b'www.mykernel.cn')[-10:-4:2])
pythonimport datetime
import time
#格式化
dt1 = datetime.datetime.strptime("21/11/19 14:33",'%d/%m/%y %H:%M')
dt2 = datetime.datetime.strptime("20/11/19 16:30",'%d/%m/%y %H:%M')
print(type(dt1))
#求时间差值
delta = dt1 - dt2
print(type(delta))
print(delta)
#将时间差换算为秒
delta_seconds = delta.total_seconds()
print(delta_seconds)
#sleep
time.sleep(2)
print('sleep 2s')
[返回值 for 元素 in 可迭代对象 if 条件]
pythonprint([i for i in range(10) if i > 3])
print([(x,y) for x in 'asf' for y in range(2)])
把列表解析器的[]换成() 就成为了生成器表达式,可以使用next()逐个取值。 内存占用少,计算速度“快”
pythonlst = (i for i in range(10) if i > 3)
next(lst)
生成器表达式,逐行取值,延迟计算。但是如果取值超出个数则会报错。
把列表解析器的[]换成{} 就成为了生成器表达式。快速生成一个set。
python{i for i in range(10) if i > 3}
{返回值 for 元素 in 可迭代对象 if 条件}
{k
python{x:y for x in range(10) for y in [0]}
python{x:0 for x in range(10)}
pythondict(zip(range(10),[0]*10))
pythonlist(reversed('str'))
python''.join(list(reversed('str')))
id函数
pythona = 'abc'
print(id(a))
b = 'abc'
print(id(b))
#数字,字符串这种常量,在python中的位置是不变的,无论被谁引用,其引用的地址是一样的。
def add(a,b):
return a + b
print('add function:',id(add))
lst = [1,2,3]
lst1 = [1,2,3]
print('list:',id(lst))
print('list1:',id(lst1))
#函数、字典、列表等类型在内存中的位置是变化的。每次定义所分配的内存地址不一样。
hash函数
pythonhash(a)
#列表,字典,集合是无法hash的,因为使用id查看内存地址时候是变化的,,
类型转换
python#1.字符串转列表
str = "acd"
str_list = list(str)
print('str==>list:',str_list)
#2. “字符串列表”转字符串
lst = ['a','v','k']
list_str = ''.join(lst)
print('list==>str:',list_str)
#3. 字符串转元组
lst = 'accd'
str_tup = tuple(lst)
print('str==>tup:',str_tup)
#4. 字符串转字典的k,v取默认值
lst = 'accd'
print(dict)
str_dv = dict(zip(lst,[0]*len(lst)))
print('str==>dict[k]:',str_dv)
#元组转列表
t = ('a', 'c', 'c', 'd')
print(list(t))
#列表转元组
lst = ['a', 'c', 'c', 'd']
print(tuple(lst))
#列表转set,元组转set 去重。。
t = (1,1,1,1)
print(set(t))
#含有二元组的列表转字典
str = 'mykernel'
lst = [i for i in enumerate(str)]
d = {}
for i in lst:
d[i[0]] = i[1]
print(d)
# 字典的kv 互换
print('v<==>k:',dict(zip(d.values(),d.keys())))
lst = [1,1,1,2]
print(set(lst))
#typt 查看对象的类型
print('type :',type(type))
输入函数input
pythonipt = input('请输入一个字符或者数字,默认返回一个字符串')
print(type(ipt))
打印函数
pythonprint('a','b',sep='\n')
#sep = 改变打印元组之间的格式
长度计算
pythonlen('acffsd '*10)
类型确定
pythona = 2
isinstance(a,(str,int,list))
sorted(iter,[,key][,reverse])
pythonprint(sorted({'c':1, 'b':2, 'a':1}))
print([i for i in reversed(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1]))])
print(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1],reverse=True))
reversed(seq) 返回一个迭代器
enumerate(seq,start=0) 枚举
iter(iter) next(iterator) 生成一个迭代器和取迭代器里的元素
zip() 拉链函数
pythondict1 = {'name':'pxr','age':'20'}
ops = {'age':int}
info = {k:ops.get(k,lambda x:x)(v) for k,v in dict1.items()}
#lambda
#字典解析式
#get
info
本文作者:mykernel
本文链接:
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!