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

目录

1. 封装与解构
2. 线性结构
3. 时间相关操作
4. 列表解析式
5. 生成器表达式
6. 集合表达式
7. 字典解析式
8. 内建函数

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

线性结构的特点:

  1. 可以for... in
  2. 可以len()获取长度
  3. 可以通过下标访问
  4. 可以切片
  5. 查询的时间复杂度为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 条件]

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

5. 生成器表达式

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

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

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

6. 集合表达式

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

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

7. 字典解析式

{返回值 for 元素 in 可迭代对象 if 条件}
{k

生成k 和 v}

{x:y for x in range(10) for y in [0]}
{x:0 for x in range(10)}
dict(zip(range(10),[0]*10))
list(reversed('str'))
''.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函数

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

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

打印函数

print('a','b',sep='\n') #sep = 改变打印元组之间的格式

长度计算

len('acffsd '*10)

类型确定

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

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

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

本文作者:mykernel

本文链接:

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