python基础知识2

1. 封装与解构

a = 4
b = 5
print(a,b)
a,b = b,a
print(a,b)

#简单模式
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)

2. 线性结构

线性结构：列表、元组、字符串、bytes、bytearray

线性结构的特点：

可以for… in
可以len()获取长度
可以通过下标访问
可以切片
查询的时间复杂度为O(n)

非线性结构：
set、dict
元素(dict的key)要求可以hash，查询的时间复杂度为0(1)

# 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])

3. 时间相关操作

import 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')

4. 列表解析式

[返回值 for 元素 in 可迭代对象 if 条件]

1 2	print([i for i in range(10) if i > 3]) print([(x,y) for x in 'asf' for y in range(2)])

5. 生成器表达式

把列表解析器的[]换成() 就成为了生成器表达式，可以使用next()逐个取值。
内存占用少，计算速度“快”

1 2	lst = (i for i in range(10) if i > 3) next(lst)

生成器表达式，逐行取值，延迟计算。但是如果取值超出个数则会报错。

6. 集合表达式

把列表解析器的[]换成{} 就成为了生成器表达式。快速生成一个set。

1	{i for i in range(10) if i > 3}

7. 字典解析式

{返回值 for 元素 in 可迭代对象 if 条件}
{k:v 生成k 和 v}

1	{x:y for x in range(10) for y in [0]}

1	{x:0 for x in range(10)}

1	dict(zip(range(10),[0]*10))

1	list(reversed('str'))

1	''.join(list(reversed('str')))

8. 内建函数

id函数

a = '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函数

1
2
3

hash(a)

#列表,字典,集合是无法hash的，因为使用id查看内存地址时候是变化的，，

类型转换

#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

1 2	ipt = input('请输入一个字符或者数字，默认返回一个字符串') print(type(ipt))

打印函数

1
2
3

print('a','b',sep='\n')  

#sep = 改变打印元组之间的格式

长度计算

1	len('acffsd '*10)

类型确定

1 2	a = 2 isinstance(a,(str,int,list))

sorted(iter,[,key][,reverse])

1
2
3

print(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() 拉链函数

dict1 = {'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